From fc0cdb8226f66fa5056b9677252d5c66bb4303b5 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Thu, 14 Mar 2019 18:10:36 +1300
Subject: [PATCH 01/60] Start building non-worst case benches

---
 .../benches/bench_block_processing.rs         | 231 +++++++++++-------
 .../testing_beacon_block_builder.rs           |  15 +-
 2 files changed, 152 insertions(+), 94 deletions(-)

diff --git a/eth2/state_processing/benches/bench_block_processing.rs b/eth2/state_processing/benches/bench_block_processing.rs
index 128b1051b2..a315717b20 100644
--- a/eth2/state_processing/benches/bench_block_processing.rs
+++ b/eth2/state_processing/benches/bench_block_processing.rs
@@ -17,6 +17,8 @@ use types::*;
 pub fn bench_block_processing_n_validators(c: &mut Criterion, validator_count: usize) {
     let spec = ChainSpec::foundation();
 
+    let bench_builder = BlockBenchingBuilder::new(validator_count, &spec);
+
     let (mut state, keypairs) = build_state(validator_count, &spec);
     let block = build_block(&mut state, &keypairs, &spec);
 
@@ -94,105 +96,160 @@ fn build_state(validator_count: usize, spec: &ChainSpec) -> (BeaconState, Vec<Ke
     builder.build()
 }
 
-fn build_block(state: &mut BeaconState, keypairs: &[Keypair], spec: &ChainSpec) -> BeaconBlock {
-    let mut builder = TestingBeaconBlockBuilder::new(spec);
+pub struct BlockBenchingBuilder {
+    pub state_builder: TestingBeaconStateBuilder,
+    pub block_builder: TestingBeaconBlockBuilder,
 
-    builder.set_slot(state.slot);
+    pub num_validators: usize,
+    pub num_proposer_slashings: usize,
+    pub num_attester_slashings: usize,
+    pub num_indices_per_slashable_vote: usize,
+    pub num_attestations: usize,
+    pub num_deposits: usize,
+    pub num_exits: usize,
+    pub num_transfers: usize,
+}
 
-    let proposer_index = state.get_beacon_proposer_index(state.slot, spec).unwrap();
-    let keypair = &keypairs[proposer_index];
+impl BlockBenchingBuilder {
+    pub fn new(num_validators: usize, spec: &ChainSpec) -> Self {
+        let mut state_builder =
+            TestingBeaconStateBuilder::from_default_keypairs_file_if_exists(num_validators, &spec);
+        let mut block_builder = TestingBeaconBlockBuilder::new(spec);
 
-    builder.set_randao_reveal(&keypair.sk, &state.fork, spec);
-
-    // Used as a stream of validator indices for use in slashings, exits, etc.
-    let mut validators_iter = (0..keypairs.len() as u64).into_iter();
-
-    // Insert the maximum possible number of `ProposerSlashing` objects.
-    debug!(
-        "Inserting {} proposer slashings...",
-        spec.max_proposer_slashings
-    );
-    for _ in 0..spec.max_proposer_slashings {
-        let validator_index = validators_iter.next().expect("Insufficient validators.");
-
-        builder.insert_proposer_slashing(
-            validator_index,
-            &keypairs[validator_index as usize].sk,
-            &state.fork,
-            spec,
-        );
+        Self {
+            state_builder,
+            block_builder,
+            num_validators: 0,
+            num_proposer_slashings: 0,
+            num_attester_slashings: 0,
+            num_indices_per_slashable_vote: spec.max_indices_per_slashable_vote as usize,
+            num_attestations: 0,
+            num_deposits: 0,
+            num_exits: 0,
+            num_transfers: 0
+        }
     }
 
-    // Insert the maximum possible number of `AttesterSlashing` objects
-    debug!(
-        "Inserting {} attester slashings...",
-        spec.max_attester_slashings
-    );
-    for _ in 0..spec.max_attester_slashings {
-        let mut attesters: Vec<u64> = vec![];
-        let mut secret_keys: Vec<&SecretKey> = vec![];
+    pub fn maximize_block_operations(&mut self, spec: &ChainSpec) {
+        self.num_proposer_slashings = spec.max_proposer_slashings as usize;
+        self.num_attester_slashings = spec.max_attester_slashings as usize;
+        self.num_indices_per_slashable_vote = spec.max_indices_per_slashable_vote as usize;
+        self.num_attestations = spec.max_attestations as usize;
+        self.num_deposits = spec.max_deposits as usize;
+        self.num_exits = spec.max_voluntary_exits as usize;
+        self.num_transfers = spec.max_transfers as usize;
+    }
 
-        for _ in 0..spec.max_indices_per_slashable_vote {
+    pub fn set_slot(&mut self, slot: Slot, spec: &ChainSpec) {
+        self.state_builder.teleport_to_slot(slot, &spec);
+    }
+
+    pub fn build_caches(&mut self, spec: &ChainSpec) {
+        // Builds all caches; benches will not contain shuffling/committee building times.
+        self.state_builder.build_caches(&spec).unwrap();
+    }
+
+    pub fn build(self, spec: &ChainSpec) -> (BeaconBlock, BeaconState) {
+        let (mut state, keypairs) = self.state_builder.build();
+        let builder = &mut self.block_builder;
+
+        builder.set_slot(state.slot);
+
+        let proposer_index = state.get_beacon_proposer_index(state.slot, spec).unwrap();
+        let keypair = &keypairs[proposer_index];
+
+        builder.set_randao_reveal(&keypair.sk, &state.fork, spec);
+
+        // Used as a stream of validator indices for use in slashings, exits, etc.
+        let mut validators_iter = (0..keypairs.len() as u64).into_iter();
+
+        // Insert `ProposerSlashing` objects.
+        debug!(
+            "Inserting {} proposer slashings...",
+            self.num_proposer_slashings
+        );
+        for _ in 0..self.num_proposer_slashings {
             let validator_index = validators_iter.next().expect("Insufficient validators.");
 
-            attesters.push(validator_index);
-            secret_keys.push(&keypairs[validator_index as usize].sk);
+            builder.insert_proposer_slashing(
+                validator_index,
+                &keypairs[validator_index as usize].sk,
+                &state.fork,
+                spec,
+            );
         }
 
-        builder.insert_attester_slashing(&attesters, &secret_keys, &state.fork, spec);
-    }
-
-    // Insert the maximum possible number of `Attestation` objects.
-    debug!("Inserting {} attestations...", spec.max_attestations);
-    let all_secret_keys: Vec<&SecretKey> = keypairs.iter().map(|keypair| &keypair.sk).collect();
-    builder
-        .fill_with_attestations(state, &all_secret_keys, spec)
-        .unwrap();
-
-    // Insert the maximum possible number of `Deposit` objects.
-    debug!("Inserting {} deposits...", spec.max_deposits);
-    for i in 0..spec.max_deposits {
-        builder.insert_deposit(32_000_000_000, state.deposit_index + i, state, spec);
-    }
-
-    // Insert the maximum possible number of `Exit` objects.
-    debug!("Inserting {} exits...", spec.max_voluntary_exits);
-    for _ in 0..spec.max_voluntary_exits {
-        let validator_index = validators_iter.next().expect("Insufficient validators.");
-
-        builder.insert_exit(
-            state,
-            validator_index,
-            &keypairs[validator_index as usize].sk,
-            spec,
+        // Insert `AttesterSlashing` objects
+        debug!(
+            "Inserting {} attester slashings...",
+            self.num_attester_slashings
         );
+        for _ in 0..self.num_attester_slashings {
+            let mut attesters: Vec<u64> = vec![];
+            let mut secret_keys: Vec<&SecretKey> = vec![];
+
+            for _ in 0..self.num_indices_per_slashable_vote {
+                let validator_index = validators_iter.next().expect("Insufficient validators.");
+
+                attesters.push(validator_index);
+                secret_keys.push(&keypairs[validator_index as usize].sk);
+            }
+
+            builder.insert_attester_slashing(&attesters, &secret_keys, &state.fork, spec);
+        }
+
+        // Insert `Attestation` objects.
+        debug!("Inserting {} attestations...", self.num_attestations);
+        let all_secret_keys: Vec<&SecretKey> = keypairs.iter().map(|keypair| &keypair.sk).collect();
+        builder
+            .insert_attestations(&state, &all_secret_keys, self.num_attestations as usize, spec)
+            .unwrap();
+
+        // Insert `Deposit` objects.
+        debug!("Inserting {} deposits...", self.num_deposits);
+        for i in 0..self.num_deposits {
+            builder.insert_deposit(32_000_000_000, state.deposit_index + (i as u64), &state, spec);
+        }
+
+        // Insert the maximum possible number of `Exit` objects.
+        debug!("Inserting {} exits...", self.num_exits);
+        for _ in 0..self.num_exits {
+            let validator_index = validators_iter.next().expect("Insufficient validators.");
+
+            builder.insert_exit(
+                &state,
+                validator_index,
+                &keypairs[validator_index as usize].sk,
+                spec,
+            );
+        }
+
+        // Insert the maximum possible number of `Transfer` objects.
+        debug!("Inserting {} transfers...", self.num_transfers);
+        for _ in 0..self.num_transfers {
+            let validator_index = validators_iter.next().expect("Insufficient validators.");
+
+            // Manually set the validator to be withdrawn.
+            state.validator_registry[validator_index as usize].withdrawable_epoch =
+                state.previous_epoch(spec);
+
+            builder.insert_transfer(
+                &state,
+                validator_index,
+                validator_index,
+                1,
+                keypairs[validator_index as usize].clone(),
+                spec,
+            );
+        }
+
+        let mut block = builder.build(&keypair.sk, &state.fork, spec);
+
+        // Set the eth1 data to be different from the state.
+        block.eth1_data.block_hash = Hash256::from_slice(&vec![42; 32]);
+
+        (block, state)
     }
-
-    // Insert the maximum possible number of `Transfer` objects.
-    debug!("Inserting {} transfers...", spec.max_transfers);
-    for _ in 0..spec.max_transfers {
-        let validator_index = validators_iter.next().expect("Insufficient validators.");
-
-        // Manually set the validator to be withdrawn.
-        state.validator_registry[validator_index as usize].withdrawable_epoch =
-            state.previous_epoch(spec);
-
-        builder.insert_transfer(
-            state,
-            validator_index,
-            validator_index,
-            1,
-            keypairs[validator_index as usize].clone(),
-            spec,
-        );
-    }
-
-    let mut block = builder.build(&keypair.sk, &state.fork, spec);
-
-    // Set the eth1 data to be different from the state.
-    block.eth1_data.block_hash = Hash256::from_slice(&vec![42; 32]);
-
-    block
 }
 
 /// Run the detailed benchmarking suite on the given `BeaconState`.
diff --git a/eth2/types/src/test_utils/testing_beacon_block_builder.rs b/eth2/types/src/test_utils/testing_beacon_block_builder.rs
index 97e395e1f5..ecb42e27b8 100644
--- a/eth2/types/src/test_utils/testing_beacon_block_builder.rs
+++ b/eth2/types/src/test_utils/testing_beacon_block_builder.rs
@@ -74,19 +74,20 @@ impl TestingBeaconBlockBuilder {
         self.block.body.attester_slashings.push(attester_slashing);
     }
 
-    /// Fills the block with `MAX_ATTESTATIONS` attestations.
+    /// Fills the block with `num_attestations` attestations.
     ///
     /// It will first go and get each committee that is able to include an attestation in this
-    /// block. If there are enough committees, it will produce an attestation for each. If there
-    /// are _not_ enough committees, it will start splitting the committees in half until it
+    /// block. If there _are_ enough committees, it will produce an attestation for each. If there
+    /// _are not_ enough committees, it will start splitting the committees in half until it
     /// achieves the target. It will then produce separate attestations for each split committee.
     ///
     /// Note: the signed messages of the split committees will be identical -- it would be possible
     /// to aggregate these split attestations.
-    pub fn fill_with_attestations(
+    pub fn insert_attestations(
         &mut self,
         state: &BeaconState,
         secret_keys: &[&SecretKey],
+        num_attestations: usize,
         spec: &ChainSpec,
     ) -> Result<(), BeaconStateError> {
         let mut slot = self.block.slot - spec.min_attestation_inclusion_delay;
@@ -110,7 +111,7 @@ impl TestingBeaconBlockBuilder {
             }
 
             for (committee, shard) in state.get_crosslink_committees_at_slot(slot, spec)? {
-                if attestations_added >= spec.max_attestations {
+                if attestations_added >= num_attestations {
                     break;
                 }
 
@@ -125,12 +126,12 @@ impl TestingBeaconBlockBuilder {
         // Loop through all the committees, splitting each one in half until we have
         // `MAX_ATTESTATIONS` committees.
         loop {
-            if committees.len() >= spec.max_attestations as usize {
+            if committees.len() >= num_attestations as usize {
                 break;
             }
 
             for index in 0..committees.len() {
-                if committees.len() >= spec.max_attestations as usize {
+                if committees.len() >= num_attestations as usize {
                     break;
                 }
 

From 2535f47f132006480b0f5dc85d2a92f6e6ddd066 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Thu, 14 Mar 2019 16:44:56 +1100
Subject: [PATCH 02/60] Add builder for benches

Also adds a "sane" case for block processing
---
 .../benches/bench_block_processing.rs         | 243 +-----------------
 eth2/state_processing/benches/benches.rs      |  94 ++++++-
 .../benches/block_benching_builder.rs         | 175 +++++++++++++
 .../testing_beacon_block_builder.rs           |   2 +-
 4 files changed, 266 insertions(+), 248 deletions(-)
 create mode 100644 eth2/state_processing/benches/block_benching_builder.rs

diff --git a/eth2/state_processing/benches/bench_block_processing.rs b/eth2/state_processing/benches/bench_block_processing.rs
index a315717b20..2ee08c96a0 100644
--- a/eth2/state_processing/benches/bench_block_processing.rs
+++ b/eth2/state_processing/benches/bench_block_processing.rs
@@ -1,6 +1,5 @@
 use criterion::Criterion;
 use criterion::{black_box, Benchmark};
-use log::debug;
 use ssz::TreeHash;
 use state_processing::{
     per_block_processing,
@@ -10,252 +9,12 @@ use state_processing::{
         verify_block_signature,
     },
 };
-use types::test_utils::{TestingBeaconBlockBuilder, TestingBeaconStateBuilder};
 use types::*;
 
-/// Run the benchmarking suite on a foundation spec with 16,384 validators.
-pub fn bench_block_processing_n_validators(c: &mut Criterion, validator_count: usize) {
-    let spec = ChainSpec::foundation();
-
-    let bench_builder = BlockBenchingBuilder::new(validator_count, &spec);
-
-    let (mut state, keypairs) = build_state(validator_count, &spec);
-    let block = build_block(&mut state, &keypairs, &spec);
-
-    assert_eq!(
-        block.body.proposer_slashings.len(),
-        spec.max_proposer_slashings as usize,
-        "The block should have the maximum possible proposer slashings"
-    );
-
-    assert_eq!(
-        block.body.attester_slashings.len(),
-        spec.max_attester_slashings as usize,
-        "The block should have the maximum possible attester slashings"
-    );
-
-    for attester_slashing in &block.body.attester_slashings {
-        let len_1 = attester_slashing
-            .slashable_attestation_1
-            .validator_indices
-            .len();
-        let len_2 = attester_slashing
-            .slashable_attestation_1
-            .validator_indices
-            .len();
-        assert!(
-            (len_1 == len_2) && (len_2 == spec.max_indices_per_slashable_vote as usize),
-            "Each attester slashing should have the maximum possible validator indices"
-        );
-    }
-
-    assert_eq!(
-        block.body.attestations.len(),
-        spec.max_attestations as usize,
-        "The block should have the maximum possible attestations."
-    );
-
-    assert_eq!(
-        block.body.deposits.len(),
-        spec.max_deposits as usize,
-        "The block should have the maximum possible deposits."
-    );
-
-    assert_eq!(
-        block.body.voluntary_exits.len(),
-        spec.max_voluntary_exits as usize,
-        "The block should have the maximum possible voluntary exits."
-    );
-
-    assert_eq!(
-        block.body.transfers.len(),
-        spec.max_transfers as usize,
-        "The block should have the maximum possible transfers."
-    );
-
-    bench_block_processing(
-        c,
-        &block,
-        &state,
-        &spec,
-        &format!("{}_validators", validator_count),
-    );
-}
-
-fn build_state(validator_count: usize, spec: &ChainSpec) -> (BeaconState, Vec<Keypair>) {
-    let mut builder =
-        TestingBeaconStateBuilder::from_default_keypairs_file_if_exists(validator_count, &spec);
-
-    // Set the state to be just before an epoch transition.
-    let target_slot = (spec.genesis_epoch + 4).end_slot(spec.slots_per_epoch);
-    builder.teleport_to_slot(target_slot, &spec);
-
-    // Builds all caches; benches will not contain shuffling/committee building times.
-    builder.build_caches(&spec).unwrap();
-
-    builder.build()
-}
-
-pub struct BlockBenchingBuilder {
-    pub state_builder: TestingBeaconStateBuilder,
-    pub block_builder: TestingBeaconBlockBuilder,
-
-    pub num_validators: usize,
-    pub num_proposer_slashings: usize,
-    pub num_attester_slashings: usize,
-    pub num_indices_per_slashable_vote: usize,
-    pub num_attestations: usize,
-    pub num_deposits: usize,
-    pub num_exits: usize,
-    pub num_transfers: usize,
-}
-
-impl BlockBenchingBuilder {
-    pub fn new(num_validators: usize, spec: &ChainSpec) -> Self {
-        let mut state_builder =
-            TestingBeaconStateBuilder::from_default_keypairs_file_if_exists(num_validators, &spec);
-        let mut block_builder = TestingBeaconBlockBuilder::new(spec);
-
-        Self {
-            state_builder,
-            block_builder,
-            num_validators: 0,
-            num_proposer_slashings: 0,
-            num_attester_slashings: 0,
-            num_indices_per_slashable_vote: spec.max_indices_per_slashable_vote as usize,
-            num_attestations: 0,
-            num_deposits: 0,
-            num_exits: 0,
-            num_transfers: 0
-        }
-    }
-
-    pub fn maximize_block_operations(&mut self, spec: &ChainSpec) {
-        self.num_proposer_slashings = spec.max_proposer_slashings as usize;
-        self.num_attester_slashings = spec.max_attester_slashings as usize;
-        self.num_indices_per_slashable_vote = spec.max_indices_per_slashable_vote as usize;
-        self.num_attestations = spec.max_attestations as usize;
-        self.num_deposits = spec.max_deposits as usize;
-        self.num_exits = spec.max_voluntary_exits as usize;
-        self.num_transfers = spec.max_transfers as usize;
-    }
-
-    pub fn set_slot(&mut self, slot: Slot, spec: &ChainSpec) {
-        self.state_builder.teleport_to_slot(slot, &spec);
-    }
-
-    pub fn build_caches(&mut self, spec: &ChainSpec) {
-        // Builds all caches; benches will not contain shuffling/committee building times.
-        self.state_builder.build_caches(&spec).unwrap();
-    }
-
-    pub fn build(self, spec: &ChainSpec) -> (BeaconBlock, BeaconState) {
-        let (mut state, keypairs) = self.state_builder.build();
-        let builder = &mut self.block_builder;
-
-        builder.set_slot(state.slot);
-
-        let proposer_index = state.get_beacon_proposer_index(state.slot, spec).unwrap();
-        let keypair = &keypairs[proposer_index];
-
-        builder.set_randao_reveal(&keypair.sk, &state.fork, spec);
-
-        // Used as a stream of validator indices for use in slashings, exits, etc.
-        let mut validators_iter = (0..keypairs.len() as u64).into_iter();
-
-        // Insert `ProposerSlashing` objects.
-        debug!(
-            "Inserting {} proposer slashings...",
-            self.num_proposer_slashings
-        );
-        for _ in 0..self.num_proposer_slashings {
-            let validator_index = validators_iter.next().expect("Insufficient validators.");
-
-            builder.insert_proposer_slashing(
-                validator_index,
-                &keypairs[validator_index as usize].sk,
-                &state.fork,
-                spec,
-            );
-        }
-
-        // Insert `AttesterSlashing` objects
-        debug!(
-            "Inserting {} attester slashings...",
-            self.num_attester_slashings
-        );
-        for _ in 0..self.num_attester_slashings {
-            let mut attesters: Vec<u64> = vec![];
-            let mut secret_keys: Vec<&SecretKey> = vec![];
-
-            for _ in 0..self.num_indices_per_slashable_vote {
-                let validator_index = validators_iter.next().expect("Insufficient validators.");
-
-                attesters.push(validator_index);
-                secret_keys.push(&keypairs[validator_index as usize].sk);
-            }
-
-            builder.insert_attester_slashing(&attesters, &secret_keys, &state.fork, spec);
-        }
-
-        // Insert `Attestation` objects.
-        debug!("Inserting {} attestations...", self.num_attestations);
-        let all_secret_keys: Vec<&SecretKey> = keypairs.iter().map(|keypair| &keypair.sk).collect();
-        builder
-            .insert_attestations(&state, &all_secret_keys, self.num_attestations as usize, spec)
-            .unwrap();
-
-        // Insert `Deposit` objects.
-        debug!("Inserting {} deposits...", self.num_deposits);
-        for i in 0..self.num_deposits {
-            builder.insert_deposit(32_000_000_000, state.deposit_index + (i as u64), &state, spec);
-        }
-
-        // Insert the maximum possible number of `Exit` objects.
-        debug!("Inserting {} exits...", self.num_exits);
-        for _ in 0..self.num_exits {
-            let validator_index = validators_iter.next().expect("Insufficient validators.");
-
-            builder.insert_exit(
-                &state,
-                validator_index,
-                &keypairs[validator_index as usize].sk,
-                spec,
-            );
-        }
-
-        // Insert the maximum possible number of `Transfer` objects.
-        debug!("Inserting {} transfers...", self.num_transfers);
-        for _ in 0..self.num_transfers {
-            let validator_index = validators_iter.next().expect("Insufficient validators.");
-
-            // Manually set the validator to be withdrawn.
-            state.validator_registry[validator_index as usize].withdrawable_epoch =
-                state.previous_epoch(spec);
-
-            builder.insert_transfer(
-                &state,
-                validator_index,
-                validator_index,
-                1,
-                keypairs[validator_index as usize].clone(),
-                spec,
-            );
-        }
-
-        let mut block = builder.build(&keypair.sk, &state.fork, spec);
-
-        // Set the eth1 data to be different from the state.
-        block.eth1_data.block_hash = Hash256::from_slice(&vec![42; 32]);
-
-        (block, state)
-    }
-}
-
 /// Run the detailed benchmarking suite on the given `BeaconState`.
 ///
 /// `desc` will be added to the title of each bench.
-fn bench_block_processing(
+pub fn bench_block_processing(
     c: &mut Criterion,
     initial_block: &BeaconBlock,
     initial_state: &BeaconState,
diff --git a/eth2/state_processing/benches/benches.rs b/eth2/state_processing/benches/benches.rs
index af384b00a2..685858c78c 100644
--- a/eth2/state_processing/benches/benches.rs
+++ b/eth2/state_processing/benches/benches.rs
@@ -1,23 +1,107 @@
+use block_benching_builder::BlockBenchingBuilder;
 use criterion::Criterion;
 use criterion::{criterion_group, criterion_main};
 use env_logger::{Builder, Env};
+use log::info;
+use types::*;
 
 mod bench_block_processing;
 mod bench_epoch_processing;
+mod block_benching_builder;
 
 pub const VALIDATOR_COUNT: usize = 16_384;
 
 // `LOG_LEVEL == "debug"` gives logs, but they're very noisy and slow down benching.
-pub const LOG_LEVEL: &str = "";
+pub const LOG_LEVEL: &str = "info";
 
-pub fn state_processing(c: &mut Criterion) {
+/// Build a worst-case block and benchmark processing it.
+pub fn block_processing_worst_case(c: &mut Criterion) {
     if LOG_LEVEL != "" {
         Builder::from_env(Env::default().default_filter_or(LOG_LEVEL)).init();
     }
+    info!(
+        "Building worst case block bench with {} validators",
+        VALIDATOR_COUNT
+    );
 
-    bench_epoch_processing::bench_epoch_processing_n_validators(c, VALIDATOR_COUNT);
-    bench_block_processing::bench_block_processing_n_validators(c, VALIDATOR_COUNT);
+    // Use the specifications from the Eth2.0 spec.
+    let spec = ChainSpec::foundation();
+
+    // Create a builder for configuring the block and state for benching.
+    let mut bench_builder = BlockBenchingBuilder::new(VALIDATOR_COUNT, &spec);
+
+    // Set the number of included operations to be maximum (e.g., `MAX_ATTESTATIONS`, etc.)
+    bench_builder.maximize_block_operations(&spec);
+
+    // Set the state and block to be in the last slot of the 4th epoch.
+    let last_slot_of_epoch = (spec.genesis_epoch + 4).end_slot(spec.slots_per_epoch);
+    bench_builder.set_slot(last_slot_of_epoch, &spec);
+
+    // Build all the state caches so the build times aren't included in the benches.
+    bench_builder.build_caches(&spec);
+
+    // Generate the block and state.
+    let (block, state) = bench_builder.build(&spec);
+
+    // Run the benches.
+    bench_block_processing::bench_block_processing(
+        c,
+        &block,
+        &state,
+        &spec,
+        &format!("{}_validators/worst_case", VALIDATOR_COUNT),
+    );
 }
 
-criterion_group!(benches, state_processing);
+/// Build a reasonable-case block and benchmark processing it.
+pub fn block_processing_reasonable_case(c: &mut Criterion) {
+    info!(
+        "Building reasonable case block bench with {} validators",
+        VALIDATOR_COUNT
+    );
+
+    // Use the specifications from the Eth2.0 spec.
+    let spec = ChainSpec::foundation();
+
+    // Create a builder for configuring the block and state for benching.
+    let mut bench_builder = BlockBenchingBuilder::new(VALIDATOR_COUNT, &spec);
+
+    // Set the number of included operations to what we might expect normally.
+    bench_builder.num_proposer_slashings = 0;
+    bench_builder.num_attester_slashings = 0;
+    bench_builder.num_attestations = (spec.shard_count / spec.slots_per_epoch) as usize;
+    bench_builder.num_deposits = 2;
+    bench_builder.num_exits = 2;
+    bench_builder.num_transfers = 2;
+
+    // Set the state and block to be in the last slot of the 4th epoch.
+    let last_slot_of_epoch = (spec.genesis_epoch + 4).end_slot(spec.slots_per_epoch);
+    bench_builder.set_slot(last_slot_of_epoch, &spec);
+
+    // Build all the state caches so the build times aren't included in the benches.
+    bench_builder.build_caches(&spec);
+
+    // Generate the block and state.
+    let (block, state) = bench_builder.build(&spec);
+
+    // Run the benches.
+    bench_block_processing::bench_block_processing(
+        c,
+        &block,
+        &state,
+        &spec,
+        &format!("{}_validators/reasonable_case", VALIDATOR_COUNT),
+    );
+}
+
+pub fn state_processing(c: &mut Criterion) {
+    bench_epoch_processing::bench_epoch_processing_n_validators(c, VALIDATOR_COUNT);
+}
+
+criterion_group!(
+    benches,
+    block_processing_reasonable_case,
+    block_processing_worst_case,
+    state_processing
+);
 criterion_main!(benches);
diff --git a/eth2/state_processing/benches/block_benching_builder.rs b/eth2/state_processing/benches/block_benching_builder.rs
new file mode 100644
index 0000000000..b993851d7b
--- /dev/null
+++ b/eth2/state_processing/benches/block_benching_builder.rs
@@ -0,0 +1,175 @@
+use log::info;
+use types::test_utils::{TestingBeaconBlockBuilder, TestingBeaconStateBuilder};
+use types::*;
+
+pub struct BlockBenchingBuilder {
+    pub state_builder: TestingBeaconStateBuilder,
+    pub block_builder: TestingBeaconBlockBuilder,
+
+    pub num_validators: usize,
+    pub num_proposer_slashings: usize,
+    pub num_attester_slashings: usize,
+    pub num_indices_per_slashable_vote: usize,
+    pub num_attestations: usize,
+    pub num_deposits: usize,
+    pub num_exits: usize,
+    pub num_transfers: usize,
+}
+
+impl BlockBenchingBuilder {
+    pub fn new(num_validators: usize, spec: &ChainSpec) -> Self {
+        let state_builder =
+            TestingBeaconStateBuilder::from_default_keypairs_file_if_exists(num_validators, &spec);
+        let block_builder = TestingBeaconBlockBuilder::new(spec);
+
+        Self {
+            state_builder,
+            block_builder,
+            num_validators: 0,
+            num_proposer_slashings: 0,
+            num_attester_slashings: 0,
+            num_indices_per_slashable_vote: spec.max_indices_per_slashable_vote as usize,
+            num_attestations: 0,
+            num_deposits: 0,
+            num_exits: 0,
+            num_transfers: 0,
+        }
+    }
+
+    pub fn maximize_block_operations(&mut self, spec: &ChainSpec) {
+        self.num_proposer_slashings = spec.max_proposer_slashings as usize;
+        self.num_attester_slashings = spec.max_attester_slashings as usize;
+        self.num_indices_per_slashable_vote = spec.max_indices_per_slashable_vote as usize;
+        self.num_attestations = spec.max_attestations as usize;
+        self.num_deposits = spec.max_deposits as usize;
+        self.num_exits = spec.max_voluntary_exits as usize;
+        self.num_transfers = spec.max_transfers as usize;
+    }
+
+    pub fn set_slot(&mut self, slot: Slot, spec: &ChainSpec) {
+        self.state_builder.teleport_to_slot(slot, &spec);
+    }
+
+    pub fn build_caches(&mut self, spec: &ChainSpec) {
+        // Builds all caches; benches will not contain shuffling/committee building times.
+        self.state_builder.build_caches(&spec).unwrap();
+    }
+
+    pub fn build(mut self, spec: &ChainSpec) -> (BeaconBlock, BeaconState) {
+        let (mut state, keypairs) = self.state_builder.build();
+        let builder = &mut self.block_builder;
+
+        builder.set_slot(state.slot);
+
+        let proposer_index = state.get_beacon_proposer_index(state.slot, spec).unwrap();
+        let keypair = &keypairs[proposer_index];
+
+        builder.set_randao_reveal(&keypair.sk, &state.fork, spec);
+
+        // Used as a stream of validator indices for use in slashings, exits, etc.
+        let mut validators_iter = (0..keypairs.len() as u64).into_iter();
+
+        // Insert `ProposerSlashing` objects.
+        for _ in 0..self.num_proposer_slashings {
+            let validator_index = validators_iter.next().expect("Insufficient validators.");
+
+            builder.insert_proposer_slashing(
+                validator_index,
+                &keypairs[validator_index as usize].sk,
+                &state.fork,
+                spec,
+            );
+        }
+        info!(
+            "Inserted {} proposer slashings.",
+            builder.block.body.proposer_slashings.len()
+        );
+
+        // Insert `AttesterSlashing` objects
+        for _ in 0..self.num_attester_slashings {
+            let mut attesters: Vec<u64> = vec![];
+            let mut secret_keys: Vec<&SecretKey> = vec![];
+
+            for _ in 0..self.num_indices_per_slashable_vote {
+                let validator_index = validators_iter.next().expect("Insufficient validators.");
+
+                attesters.push(validator_index);
+                secret_keys.push(&keypairs[validator_index as usize].sk);
+            }
+
+            builder.insert_attester_slashing(&attesters, &secret_keys, &state.fork, spec);
+        }
+        info!(
+            "Inserted {} attester slashings.",
+            builder.block.body.attester_slashings.len()
+        );
+
+        // Insert `Attestation` objects.
+        let all_secret_keys: Vec<&SecretKey> = keypairs.iter().map(|keypair| &keypair.sk).collect();
+        builder
+            .insert_attestations(
+                &state,
+                &all_secret_keys,
+                self.num_attestations as usize,
+                spec,
+            )
+            .unwrap();
+        info!(
+            "Inserted {} attestations.",
+            builder.block.body.attestations.len()
+        );
+
+        // Insert `Deposit` objects.
+        for i in 0..self.num_deposits {
+            builder.insert_deposit(
+                32_000_000_000,
+                state.deposit_index + (i as u64),
+                &state,
+                spec,
+            );
+        }
+        info!("Inserted {} deposits.", builder.block.body.deposits.len());
+
+        // Insert the maximum possible number of `Exit` objects.
+        for _ in 0..self.num_exits {
+            let validator_index = validators_iter.next().expect("Insufficient validators.");
+
+            builder.insert_exit(
+                &state,
+                validator_index,
+                &keypairs[validator_index as usize].sk,
+                spec,
+            );
+        }
+        info!(
+            "Inserted {} exits.",
+            builder.block.body.voluntary_exits.len()
+        );
+
+        // Insert the maximum possible number of `Transfer` objects.
+        for _ in 0..self.num_transfers {
+            let validator_index = validators_iter.next().expect("Insufficient validators.");
+
+            // Manually set the validator to be withdrawn.
+            state.validator_registry[validator_index as usize].withdrawable_epoch =
+                state.previous_epoch(spec);
+
+            builder.insert_transfer(
+                &state,
+                validator_index,
+                validator_index,
+                1,
+                keypairs[validator_index as usize].clone(),
+                spec,
+            );
+        }
+        info!("Inserted {} transfers.", builder.block.body.transfers.len());
+
+        let mut block = self.block_builder.build(&keypair.sk, &state.fork, spec);
+
+        // Set the eth1 data to be different from the state.
+        block.eth1_data.block_hash = Hash256::from_slice(&vec![42; 32]);
+
+        (block, state)
+    }
+}
diff --git a/eth2/types/src/test_utils/testing_beacon_block_builder.rs b/eth2/types/src/test_utils/testing_beacon_block_builder.rs
index ecb42e27b8..58633b5cee 100644
--- a/eth2/types/src/test_utils/testing_beacon_block_builder.rs
+++ b/eth2/types/src/test_utils/testing_beacon_block_builder.rs
@@ -12,7 +12,7 @@ use ssz::{SignedRoot, TreeHash};
 ///
 /// This struct should **never be used for production purposes.**
 pub struct TestingBeaconBlockBuilder {
-    block: BeaconBlock,
+    pub block: BeaconBlock,
 }
 
 impl TestingBeaconBlockBuilder {

From 4fd8551e8b6a541720bb93cce85dcca302fa021b Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Thu, 14 Mar 2019 17:49:39 +1100
Subject: [PATCH 03/60] Update loglevel, comments in benches

---
 eth2/state_processing/benches/benches.rs | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/eth2/state_processing/benches/benches.rs b/eth2/state_processing/benches/benches.rs
index 685858c78c..0cf797147f 100644
--- a/eth2/state_processing/benches/benches.rs
+++ b/eth2/state_processing/benches/benches.rs
@@ -11,7 +11,7 @@ mod block_benching_builder;
 
 pub const VALIDATOR_COUNT: usize = 16_384;
 
-// `LOG_LEVEL == "debug"` gives logs, but they're very noisy and slow down benching.
+// `LOG_LEVEL == "info"` gives handy messages.
 pub const LOG_LEVEL: &str = "info";
 
 /// Build a worst-case block and benchmark processing it.
@@ -40,10 +40,8 @@ pub fn block_processing_worst_case(c: &mut Criterion) {
     // Build all the state caches so the build times aren't included in the benches.
     bench_builder.build_caches(&spec);
 
-    // Generate the block and state.
+    // Generate the block and state then run benches.
     let (block, state) = bench_builder.build(&spec);
-
-    // Run the benches.
     bench_block_processing::bench_block_processing(
         c,
         &block,
@@ -81,10 +79,8 @@ pub fn block_processing_reasonable_case(c: &mut Criterion) {
     // Build all the state caches so the build times aren't included in the benches.
     bench_builder.build_caches(&spec);
 
-    // Generate the block and state.
+    // Generate the block and state then run benches.
     let (block, state) = bench_builder.build(&spec);
-
-    // Run the benches.
     bench_block_processing::bench_block_processing(
         c,
         &block,

From 96d96ba9ba55c927a1e3228aa8af89b9aac6b097 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Thu, 14 Mar 2019 20:54:30 +1100
Subject: [PATCH 04/60] Remove assertion in benches

---
 .../state_processing/benches/bench_epoch_processing.rs | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/eth2/state_processing/benches/bench_epoch_processing.rs b/eth2/state_processing/benches/bench_epoch_processing.rs
index 49b4f4371c..cc77012962 100644
--- a/eth2/state_processing/benches/bench_epoch_processing.rs
+++ b/eth2/state_processing/benches/bench_epoch_processing.rs
@@ -48,16 +48,6 @@ pub fn bench_epoch_processing_n_validators(c: &mut Criterion, validator_count: u
         "The state should have an attestation for each committee."
     );
 
-    // Assert that each attestation in the state has full participation.
-    let committee_size = validator_count / committees_per_epoch as usize;
-    for a in &state.latest_attestations {
-        assert_eq!(
-            a.aggregation_bitfield.num_set_bits(),
-            committee_size,
-            "Each attestation in the state should have full participation"
-        );
-    }
-
     // Assert that we will run the first arm of process_rewards_and_penalities
     let epochs_since_finality = state.next_epoch(&spec) - state.finalized_epoch;
     assert_eq!(

From 81543971142c32c90cd9ecfc7085004aa22ec17b Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Thu, 14 Mar 2019 20:54:44 +1100
Subject: [PATCH 05/60] Set map initial cacacity in epoch cache builder

This should help reduce reallocations
---
 eth2/types/src/beacon_state/epoch_cache.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/eth2/types/src/beacon_state/epoch_cache.rs b/eth2/types/src/beacon_state/epoch_cache.rs
index bbc991646e..e6bacd351f 100644
--- a/eth2/types/src/beacon_state/epoch_cache.rs
+++ b/eth2/types/src/beacon_state/epoch_cache.rs
@@ -33,12 +33,13 @@ impl EpochCache {
     ) -> Result<EpochCache, Error> {
         let mut epoch_committees: Vec<CrosslinkCommittees> =
             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.slots_per_epoch), false, spec)?;
 
+        let mut attestation_duty_map: AttestationDutyMap = HashMap::with_capacity(shuffling.len());
+
         for (epoch_committeess_index, slot) in epoch.slot_iter(spec.slots_per_epoch).enumerate() {
             let slot_committees = state.calculate_crosslink_committees_at_slot(
                 slot,

From 902b80a579315499cd61925076d19e454483ce3d Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Thu, 14 Mar 2019 22:16:21 +1100
Subject: [PATCH 06/60] Optimise epoch building

---
 eth2/types/src/beacon_state.rs             | 35 +++++--------
 eth2/types/src/beacon_state/epoch_cache.rs | 60 ++++++++++------------
 eth2/types/src/validator_registry.rs       | 22 ++++----
 3 files changed, 51 insertions(+), 66 deletions(-)

diff --git a/eth2/types/src/beacon_state.rs b/eth2/types/src/beacon_state.rs
index a1dd8983c9..2463f4701c 100644
--- a/eth2/types/src/beacon_state.rs
+++ b/eth2/types/src/beacon_state.rs
@@ -537,8 +537,8 @@ impl BeaconState {
         let cache = self.cache(relative_epoch)?;
 
         let (committee_slot_index, committee_index) = cache
-            .shard_committee_index_map
-            .get(&attestation_data.shard)
+            .shard_committee_indices
+            .get(attestation_data.shard as usize)
             .ok_or_else(|| Error::ShardOutOfBounds)?;
         let (committee, shard) = &cache.committees[*committee_slot_index][*committee_index];
 
@@ -787,7 +787,6 @@ impl BeaconState {
         &self,
         slot: Slot,
         registry_change: bool,
-
         spec: &ChainSpec,
     ) -> Result<Vec<Vec<usize>>, Error> {
         let (_committees_per_epoch, seed, shuffling_epoch, _shuffling_start_shard) =
@@ -810,7 +809,6 @@ impl BeaconState {
     ) -> Result<Vec<Vec<usize>>, Error> {
         let active_validator_indices =
             get_active_validator_indices(&self.validator_registry, epoch);
-
         if active_validator_indices.is_empty() {
             error!("get_shuffling: no validators.");
             return Err(Error::InsufficientValidators);
@@ -912,22 +910,18 @@ impl BeaconState {
         }
     }
 
-    /// Return the list of ``(committee, shard)`` tuples for the ``slot``.
+    /// Return the ordered list of shards tuples for the `slot`.
     ///
     /// Note: There are two possible shufflings for crosslink committees for a
     /// `slot` in the next epoch: with and without a `registry_change`
     ///
-    /// Note: does not utilize the cache, `get_crosslink_committees_at_slot` is an equivalent
-    /// function which uses the cache.
-    ///
     /// Spec v0.4.0
-    pub(crate) fn calculate_crosslink_committees_at_slot(
+    pub(crate) fn get_shards_for_slot(
         &self,
         slot: Slot,
         registry_change: bool,
-        shuffling: Vec<Vec<usize>>,
         spec: &ChainSpec,
-    ) -> Result<Vec<(Vec<usize>, u64)>, Error> {
+    ) -> Result<Vec<u64>, Error> {
         let (committees_per_epoch, _seed, _shuffling_epoch, shuffling_start_shard) =
             self.get_committee_params_at_slot(slot, registry_change, spec)?;
 
@@ -936,15 +930,12 @@ impl BeaconState {
         let slot_start_shard =
             (shuffling_start_shard + committees_per_slot * offset) % spec.shard_count;
 
-        let mut crosslinks_at_slot = vec![];
+        let mut shards_at_slot = vec![];
         for i in 0..committees_per_slot {
-            let tuple = (
-                shuffling[(committees_per_slot * offset + i) as usize].clone(),
-                (slot_start_shard + i) % spec.shard_count,
-            );
-            crosslinks_at_slot.push(tuple)
+            shards_at_slot.push((slot_start_shard + i) % spec.shard_count)
         }
-        Ok(crosslinks_at_slot)
+
+        Ok(shards_at_slot)
     }
 
     /// Returns the `slot`, `shard` and `committee_index` for which a validator must produce an
@@ -962,10 +953,10 @@ impl BeaconState {
     ) -> Result<Option<(Slot, u64, u64)>, Error> {
         let cache = self.cache(RelativeEpoch::Current)?;
 
-        Ok(cache
-            .attestation_duty_map
-            .get(&(validator_index as u64))
-            .and_then(|tuple| Some(*tuple)))
+        Ok(*cache
+            .attestation_duties
+            .get(validator_index)
+            .ok_or_else(|| Error::UnknownValidator)?)
     }
 
     /// Process the slashings.
diff --git a/eth2/types/src/beacon_state/epoch_cache.rs b/eth2/types/src/beacon_state/epoch_cache.rs
index e6bacd351f..f9bc0d2e77 100644
--- a/eth2/types/src/beacon_state/epoch_cache.rs
+++ b/eth2/types/src/beacon_state/epoch_cache.rs
@@ -1,8 +1,6 @@
-use super::{AttestationDutyMap, BeaconState, CrosslinkCommittees, Error, ShardCommitteeIndexMap};
+use super::{AttestationDuty, BeaconState, CrosslinkCommittees, Error};
 use crate::{ChainSpec, Epoch};
-use log::trace;
 use serde_derive::Serialize;
-use std::collections::HashMap;
 
 #[derive(Debug, PartialEq, Clone, Serialize)]
 pub struct EpochCache {
@@ -11,21 +9,23 @@ pub struct EpochCache {
     /// The crosslink committees for an epoch.
     pub committees: Vec<CrosslinkCommittees>,
     /// Maps validator index to a slot, shard and committee index for attestation.
-    pub attestation_duty_map: AttestationDutyMap,
+    pub attestation_duties: Vec<Option<AttestationDuty>>,
     /// Maps a shard to an index of `self.committees`.
-    pub shard_committee_index_map: ShardCommitteeIndexMap,
+    pub shard_committee_indices: Vec<(usize, usize)>,
 }
 
 impl EpochCache {
+    /// Return a new, completely empty cache.
     pub fn empty() -> EpochCache {
         EpochCache {
             initialized: false,
             committees: vec![],
-            attestation_duty_map: AttestationDutyMap::new(),
-            shard_committee_index_map: ShardCommitteeIndexMap::new(),
+            attestation_duties: vec![],
+            shard_committee_indices: vec![],
         }
     }
 
+    /// Return a new, fully initialized cache.
     pub fn initialized(
         state: &BeaconState,
         epoch: Epoch,
@@ -33,42 +33,36 @@ impl EpochCache {
     ) -> Result<EpochCache, Error> {
         let mut epoch_committees: Vec<CrosslinkCommittees> =
             Vec::with_capacity(spec.slots_per_epoch as usize);
-        let mut shard_committee_index_map: ShardCommitteeIndexMap = HashMap::new();
 
-        let shuffling =
+        let mut attestation_duties = vec![None; state.validator_registry.len()];
+
+        let mut shard_committee_indices = vec![(0, 0); spec.shard_count as usize];
+
+        let mut shuffling =
             state.get_shuffling_for_slot(epoch.start_slot(spec.slots_per_epoch), false, spec)?;
 
-        let mut attestation_duty_map: AttestationDutyMap = HashMap::with_capacity(shuffling.len());
+        for (epoch_committees_index, slot) in epoch.slot_iter(spec.slots_per_epoch).enumerate() {
+            let mut slot_committees: Vec<(Vec<usize>, u64)> = vec![];
 
-        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,
-                shuffling.clone(),
-                spec,
-            )?;
+            let shards = state.get_shards_for_slot(slot, false, spec)?;
+            for shard in shards {
+                let committee = shuffling.remove(0);
+                slot_committees.push((committee, shard));
+            }
 
             for (slot_committees_index, (committee, shard)) in slot_committees.iter().enumerate() {
-                // Empty committees are not permitted.
                 if committee.is_empty() {
                     return Err(Error::InsufficientValidators);
                 }
 
-                trace!(
-                    "shard: {}, epoch_i: {}, slot_i: {}",
-                    shard,
-                    epoch_committeess_index,
-                    slot_committees_index
-                );
-
-                shard_committee_index_map
-                    .insert(*shard, (epoch_committeess_index, slot_committees_index));
+                // Store the slot and committee index for this shard.
+                shard_committee_indices[*shard as usize] =
+                    (epoch_committees_index, slot_committees_index);
 
+                // For each validator, store their attestation duties.
                 for (committee_index, validator_index) in committee.iter().enumerate() {
-                    attestation_duty_map.insert(
-                        *validator_index as u64,
-                        (slot, *shard, committee_index as u64),
-                    );
+                    attestation_duties[*validator_index] =
+                        Some((slot, *shard, committee_index as u64))
                 }
             }
 
@@ -78,8 +72,8 @@ impl EpochCache {
         Ok(EpochCache {
             initialized: true,
             committees: epoch_committees,
-            attestation_duty_map,
-            shard_committee_index_map,
+            attestation_duties,
+            shard_committee_indices,
         })
     }
 }
diff --git a/eth2/types/src/validator_registry.rs b/eth2/types/src/validator_registry.rs
index 7b55e78cb0..db35ae9936 100644
--- a/eth2/types/src/validator_registry.rs
+++ b/eth2/types/src/validator_registry.rs
@@ -7,17 +7,17 @@ use crate::Epoch;
 ///
 /// Spec v0.4.0
 pub fn get_active_validator_indices(validators: &[Validator], epoch: Epoch) -> Vec<usize> {
-    validators
-        .iter()
-        .enumerate()
-        .filter_map(|(index, validator)| {
-            if validator.is_active_at(epoch) {
-                Some(index)
-            } else {
-                None
-            }
-        })
-        .collect::<Vec<_>>()
+    let mut active = Vec::with_capacity(validators.len());
+
+    for (index, validator) in validators.iter().enumerate() {
+        if validator.is_active_at(epoch) {
+            active.push(index)
+        }
+    }
+
+    active.shrink_to_fit();
+
+    active
 }
 
 #[cfg(test)]

From 236b97476ae110c608678f34de16a85d990186b6 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Fri, 15 Mar 2019 13:31:30 +1100
Subject: [PATCH 07/60] Marge fixes to test_harness, add serdehex crate

---
 Cargo.toml                                    |  1 +
 .../src/test_utils/epoch_map.rs               |  4 +-
 eth2/state_processing/Cargo.toml              |  3 +
 eth2/types/src/attestation.rs                 | 15 ++++-
 eth2/types/src/attestation_data.rs            |  3 +-
 eth2/types/src/attester_slashing.rs           |  4 +-
 eth2/types/src/beacon_block.rs                | 15 ++++-
 eth2/types/src/beacon_block_body.rs           |  6 +-
 eth2/types/src/beacon_state.rs                | 28 ++++-----
 eth2/types/src/beacon_state/epoch_cache.rs    | 14 +----
 eth2/types/src/beacon_state/pubkey_cache.rs   | 11 +---
 eth2/types/src/chain_spec.rs                  | 32 ++++++----
 eth2/types/src/crosslink.rs                   | 14 ++++-
 eth2/types/src/eth1_data.rs                   |  6 +-
 eth2/types/src/eth1_data_vote.rs              |  6 +-
 eth2/types/src/fork.rs                        | 33 ++++++++---
 eth2/types/src/pending_attestation.rs         |  4 +-
 eth2/types/src/proposal.rs                    | 15 ++++-
 eth2/types/src/proposer_slashing.rs           |  4 +-
 eth2/types/src/slashable_attestation.rs       | 15 ++++-
 eth2/types/src/test_utils/test_random.rs      | 14 +++++
 eth2/types/src/transfer.rs                    | 15 ++++-
 eth2/types/src/voluntary_exit.rs              | 15 ++++-
 eth2/utils/bls/Cargo.toml                     |  1 +
 eth2/utils/bls/src/aggregate_signature.rs     | 16 ++++-
 eth2/utils/bls/src/public_key.rs              | 13 ++--
 eth2/utils/boolean-bitfield/Cargo.toml        |  1 +
 eth2/utils/boolean-bitfield/src/lib.rs        | 19 +++++-
 eth2/utils/serde_hex/Cargo.toml               |  9 +++
 eth2/utils/serde_hex/src/lib.rs               | 59 +++++++++++++++++++
 eth2/utils/ssz/src/impl_decode.rs             | 27 +++++++++
 eth2/utils/ssz/src/impl_encode.rs             | 25 ++++++++
 32 files changed, 355 insertions(+), 92 deletions(-)
 create mode 100644 eth2/utils/serde_hex/Cargo.toml
 create mode 100644 eth2/utils/serde_hex/src/lib.rs

diff --git a/Cargo.toml b/Cargo.toml
index c5aae7f43f..d149030b66 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -11,6 +11,7 @@ members = [
 	"eth2/utils/honey-badger-split",
 	"eth2/utils/merkle_proof",
 	"eth2/utils/int_to_bytes",
+	"eth2/utils/serde_hex",
 	"eth2/utils/slot_clock",
 	"eth2/utils/ssz",
 	"eth2/utils/ssz_derive",
diff --git a/eth2/block_proposer/src/test_utils/epoch_map.rs b/eth2/block_proposer/src/test_utils/epoch_map.rs
index 6658c75265..c06c376c68 100644
--- a/eth2/block_proposer/src/test_utils/epoch_map.rs
+++ b/eth2/block_proposer/src/test_utils/epoch_map.rs
@@ -28,8 +28,8 @@ impl DutiesReader for EpochMap {
 
     fn fork(&self) -> Result<Fork, DutiesReaderError> {
         Ok(Fork {
-            previous_version: 0,
-            current_version: 0,
+            previous_version: [0; 4],
+            current_version: [0; 4],
             epoch: Epoch::new(0),
         })
     }
diff --git a/eth2/state_processing/Cargo.toml b/eth2/state_processing/Cargo.toml
index f6692b259e..4e37fce0c2 100644
--- a/eth2/state_processing/Cargo.toml
+++ b/eth2/state_processing/Cargo.toml
@@ -11,6 +11,9 @@ harness = false
 [dev-dependencies]
 criterion = "0.2"
 env_logger = "0.6.0"
+serde = "1.0"
+serde_derive = "1.0"
+serde_yaml = "0.8"
 
 [dependencies]
 bls = { path = "../utils/bls" }
diff --git a/eth2/types/src/attestation.rs b/eth2/types/src/attestation.rs
index dcc4c1fda8..4b3c2e89cc 100644
--- a/eth2/types/src/attestation.rs
+++ b/eth2/types/src/attestation.rs
@@ -1,7 +1,7 @@
 use super::{AggregateSignature, AttestationData, Bitfield};
 use crate::test_utils::TestRandom;
 use rand::RngCore;
-use serde_derive::Serialize;
+use serde_derive::{Deserialize, Serialize};
 use ssz::TreeHash;
 use ssz_derive::{Decode, Encode, SignedRoot, TreeHash};
 use test_random_derive::TestRandom;
@@ -9,7 +9,18 @@ use test_random_derive::TestRandom;
 /// Details an attestation that can be slashable.
 ///
 /// Spec v0.4.0
-#[derive(Debug, Clone, PartialEq, Serialize, Encode, Decode, TreeHash, TestRandom, SignedRoot)]
+#[derive(
+    Debug,
+    Clone,
+    PartialEq,
+    Serialize,
+    Deserialize,
+    Encode,
+    Decode,
+    TreeHash,
+    TestRandom,
+    SignedRoot,
+)]
 pub struct Attestation {
     pub aggregation_bitfield: Bitfield,
     pub data: AttestationData,
diff --git a/eth2/types/src/attestation_data.rs b/eth2/types/src/attestation_data.rs
index 6e3cb3891e..791ba00d27 100644
--- a/eth2/types/src/attestation_data.rs
+++ b/eth2/types/src/attestation_data.rs
@@ -1,7 +1,7 @@
 use crate::test_utils::TestRandom;
 use crate::{Crosslink, Epoch, Hash256, Slot};
 use rand::RngCore;
-use serde_derive::Serialize;
+use serde_derive::{Deserialize, Serialize};
 use ssz::TreeHash;
 use ssz_derive::{Decode, Encode, SignedRoot, TreeHash};
 use test_random_derive::TestRandom;
@@ -15,6 +15,7 @@ use test_random_derive::TestRandom;
     PartialEq,
     Default,
     Serialize,
+    Deserialize,
     Hash,
     Encode,
     Decode,
diff --git a/eth2/types/src/attester_slashing.rs b/eth2/types/src/attester_slashing.rs
index f437d41f24..195c0fdccd 100644
--- a/eth2/types/src/attester_slashing.rs
+++ b/eth2/types/src/attester_slashing.rs
@@ -1,13 +1,13 @@
 use crate::{test_utils::TestRandom, SlashableAttestation};
 use rand::RngCore;
-use serde_derive::Serialize;
+use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode, TreeHash};
 use test_random_derive::TestRandom;
 
 /// Two conflicting attestations.
 ///
 /// Spec v0.4.0
-#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode, TreeHash, TestRandom)]
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom)]
 pub struct AttesterSlashing {
     pub slashable_attestation_1: SlashableAttestation,
     pub slashable_attestation_2: SlashableAttestation,
diff --git a/eth2/types/src/beacon_block.rs b/eth2/types/src/beacon_block.rs
index 615d9f9288..56f77c8d25 100644
--- a/eth2/types/src/beacon_block.rs
+++ b/eth2/types/src/beacon_block.rs
@@ -2,7 +2,7 @@ use crate::test_utils::TestRandom;
 use crate::{BeaconBlockBody, ChainSpec, Eth1Data, Hash256, Proposal, Slot};
 use bls::Signature;
 use rand::RngCore;
-use serde_derive::Serialize;
+use serde_derive::{Deserialize, Serialize};
 use ssz::{SignedRoot, TreeHash};
 use ssz_derive::{Decode, Encode, SignedRoot, TreeHash};
 use test_random_derive::TestRandom;
@@ -10,7 +10,18 @@ use test_random_derive::TestRandom;
 /// A block of the `BeaconChain`.
 ///
 /// Spec v0.4.0
-#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode, TreeHash, TestRandom, SignedRoot)]
+#[derive(
+    Debug,
+    PartialEq,
+    Clone,
+    Serialize,
+    Deserialize,
+    Encode,
+    Decode,
+    TreeHash,
+    TestRandom,
+    SignedRoot,
+)]
 pub struct BeaconBlock {
     pub slot: Slot,
     pub parent_root: Hash256,
diff --git a/eth2/types/src/beacon_block_body.rs b/eth2/types/src/beacon_block_body.rs
index 70ce24dbe8..ce8020fec0 100644
--- a/eth2/types/src/beacon_block_body.rs
+++ b/eth2/types/src/beacon_block_body.rs
@@ -1,14 +1,16 @@
 use super::{Attestation, AttesterSlashing, Deposit, ProposerSlashing, Transfer, VoluntaryExit};
 use crate::test_utils::TestRandom;
 use rand::RngCore;
-use serde_derive::Serialize;
+use serde_derive::{Deserialize, 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)]
+#[derive(
+    Debug, PartialEq, Clone, Default, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom,
+)]
 pub struct BeaconBlockBody {
     pub proposer_slashings: Vec<ProposerSlashing>,
     pub attester_slashings: Vec<AttesterSlashing>,
diff --git a/eth2/types/src/beacon_state.rs b/eth2/types/src/beacon_state.rs
index 2463f4701c..2644b3e73d 100644
--- a/eth2/types/src/beacon_state.rs
+++ b/eth2/types/src/beacon_state.rs
@@ -7,7 +7,7 @@ use int_to_bytes::int_to_bytes32;
 use log::{debug, error, trace};
 use pubkey_cache::PubkeyCache;
 use rand::RngCore;
-use serde_derive::Serialize;
+use serde_derive::{Deserialize, Serialize};
 use ssz::{hash, Decodable, DecodeError, Encodable, SignedRoot, SszStream, TreeHash};
 use std::collections::HashMap;
 use swap_or_not_shuffle::shuffle_list;
@@ -72,7 +72,7 @@ macro_rules! safe_sub_assign {
     };
 }
 
-#[derive(Debug, PartialEq, Clone, Default, Serialize)]
+#[derive(Debug, PartialEq, Clone, Default, Serialize, Deserialize)]
 pub struct BeaconState {
     // Misc
     pub slot: Slot,
@@ -114,7 +114,9 @@ pub struct BeaconState {
 
     // Caching (not in the spec)
     pub cache_index_offset: usize,
+    #[serde(default)]
     pub caches: Vec<EpochCache>,
+    #[serde(default)]
     pub pubkey_cache: PubkeyCache,
 }
 
@@ -137,11 +139,7 @@ impl BeaconState {
              */
             slot: spec.genesis_slot,
             genesis_time,
-            fork: Fork {
-                previous_version: spec.genesis_fork_version,
-                current_version: spec.genesis_fork_version,
-                epoch: spec.genesis_epoch,
-            },
+            fork: Fork::genesis(spec),
 
             /*
              * Validator registry
@@ -193,8 +191,8 @@ impl BeaconState {
              * Caching (not in spec)
              */
             cache_index_offset: 0,
-            caches: vec![EpochCache::empty(); CACHED_EPOCHS],
-            pubkey_cache: PubkeyCache::empty(),
+            caches: vec![EpochCache::default(); CACHED_EPOCHS],
+            pubkey_cache: PubkeyCache::default(),
         }
     }
 
@@ -276,7 +274,7 @@ impl BeaconState {
     /// Removes the specified cache and sets it to uninitialized.
     pub fn drop_cache(&mut self, relative_epoch: RelativeEpoch) {
         let previous_cache_index = self.cache_index(relative_epoch);
-        self.caches[previous_cache_index] = EpochCache::empty();
+        self.caches[previous_cache_index] = EpochCache::default();
     }
 
     /// Returns the index of `self.caches` for some `RelativeEpoch`.
@@ -324,7 +322,7 @@ impl BeaconState {
 
     /// Completely drops the `pubkey_cache`, replacing it with a new, empty cache.
     pub fn drop_pubkey_cache(&mut self) {
-        self.pubkey_cache = PubkeyCache::empty()
+        self.pubkey_cache = PubkeyCache::default()
     }
 
     /// If a validator pubkey exists in the validator registry, returns `Some(i)`, otherwise
@@ -1227,8 +1225,8 @@ impl Decodable for BeaconState {
                 eth1_data_votes,
                 deposit_index,
                 cache_index_offset: 0,
-                caches: vec![EpochCache::empty(); CACHED_EPOCHS],
-                pubkey_cache: PubkeyCache::empty(),
+                caches: vec![EpochCache::default(); CACHED_EPOCHS],
+                pubkey_cache: PubkeyCache::default(),
             },
             i,
         ))
@@ -1298,8 +1296,8 @@ impl<T: RngCore> TestRandom<T> for BeaconState {
             eth1_data_votes: <_>::random_for_test(rng),
             deposit_index: <_>::random_for_test(rng),
             cache_index_offset: 0,
-            caches: vec![EpochCache::empty(); CACHED_EPOCHS],
-            pubkey_cache: PubkeyCache::empty(),
+            caches: vec![EpochCache::default(); CACHED_EPOCHS],
+            pubkey_cache: PubkeyCache::default(),
         }
     }
 }
diff --git a/eth2/types/src/beacon_state/epoch_cache.rs b/eth2/types/src/beacon_state/epoch_cache.rs
index f9bc0d2e77..ddcca0a9a0 100644
--- a/eth2/types/src/beacon_state/epoch_cache.rs
+++ b/eth2/types/src/beacon_state/epoch_cache.rs
@@ -1,8 +1,8 @@
 use super::{AttestationDuty, BeaconState, CrosslinkCommittees, Error};
 use crate::{ChainSpec, Epoch};
-use serde_derive::Serialize;
+use serde_derive::{Deserialize, Serialize};
 
-#[derive(Debug, PartialEq, Clone, Serialize)]
+#[derive(Debug, Default, PartialEq, Clone, Serialize, Deserialize)]
 pub struct EpochCache {
     /// True if this cache has been initialized.
     pub initialized: bool,
@@ -15,16 +15,6 @@ pub struct EpochCache {
 }
 
 impl EpochCache {
-    /// Return a new, completely empty cache.
-    pub fn empty() -> EpochCache {
-        EpochCache {
-            initialized: false,
-            committees: vec![],
-            attestation_duties: vec![],
-            shard_committee_indices: vec![],
-        }
-    }
-
     /// Return a new, fully initialized cache.
     pub fn initialized(
         state: &BeaconState,
diff --git a/eth2/types/src/beacon_state/pubkey_cache.rs b/eth2/types/src/beacon_state/pubkey_cache.rs
index c051475792..340bdb3119 100644
--- a/eth2/types/src/beacon_state/pubkey_cache.rs
+++ b/eth2/types/src/beacon_state/pubkey_cache.rs
@@ -1,22 +1,15 @@
 use crate::*;
-use serde_derive::Serialize;
+use serde_derive::{Deserialize, Serialize};
 use std::collections::HashMap;
 
 type ValidatorIndex = usize;
 
-#[derive(Debug, PartialEq, Clone, Default, Serialize)]
+#[derive(Debug, PartialEq, Clone, Default, Serialize, Deserialize)]
 pub struct PubkeyCache {
     map: HashMap<PublicKey, ValidatorIndex>,
 }
 
 impl PubkeyCache {
-    /// Instantiates a new, empty cache.
-    pub fn empty() -> Self {
-        Self {
-            map: HashMap::new(),
-        }
-    }
-
     /// Returns the number of validator indices already in the map.
     pub fn len(&self) -> ValidatorIndex {
         self.map.len()
diff --git a/eth2/types/src/chain_spec.rs b/eth2/types/src/chain_spec.rs
index 789bb6c0cc..108516695d 100644
--- a/eth2/types/src/chain_spec.rs
+++ b/eth2/types/src/chain_spec.rs
@@ -1,5 +1,7 @@
 use crate::{Address, Epoch, Fork, Hash256, Slot};
 use bls::Signature;
+use int_to_bytes::int_to_bytes4;
+use serde_derive::Deserialize;
 
 const GWEI: u64 = 1_000_000_000;
 
@@ -15,7 +17,8 @@ pub enum Domain {
 /// Holds all the "constants" for a BeaconChain.
 ///
 /// Spec v0.4.0
-#[derive(PartialEq, Debug, Clone)]
+#[derive(PartialEq, Debug, Clone, Deserialize)]
+#[serde(default)]
 pub struct ChainSpec {
     /*
      * Misc
@@ -45,7 +48,7 @@ pub struct ChainSpec {
     /*
      * Initial Values
      */
-    pub genesis_fork_version: u64,
+    pub genesis_fork_version: u32,
     pub genesis_slot: Slot,
     pub genesis_epoch: Epoch,
     pub genesis_start_shard: u64,
@@ -100,12 +103,12 @@ pub struct ChainSpec {
      *
      * Use `ChainSpec::get_domain(..)` to access these values.
      */
-    domain_deposit: u64,
-    domain_attestation: u64,
-    domain_proposal: u64,
-    domain_exit: u64,
-    domain_randao: u64,
-    domain_transfer: u64,
+    domain_deposit: u32,
+    domain_attestation: u32,
+    domain_proposal: u32,
+    domain_exit: u32,
+    domain_randao: u32,
+    domain_transfer: u32,
 }
 
 impl ChainSpec {
@@ -135,8 +138,11 @@ impl ChainSpec {
             Domain::Transfer => self.domain_transfer,
         };
 
-        let fork_version = fork.get_fork_version(epoch);
-        fork_version * u64::pow(2, 32) + domain_constant
+        let mut fork_and_domain = [0; 8];
+        fork_and_domain.copy_from_slice(&fork.get_fork_version(epoch));
+        fork_and_domain.copy_from_slice(&int_to_bytes4(domain_constant));
+
+        u64::from_le_bytes(fork_and_domain)
     }
 
     /// Returns a `ChainSpec` compatible with the Ethereum Foundation specification.
@@ -254,6 +260,12 @@ impl ChainSpec {
     }
 }
 
+impl Default for ChainSpec {
+    fn default() -> Self {
+        Self::foundation()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/eth2/types/src/crosslink.rs b/eth2/types/src/crosslink.rs
index 5db5e20a60..dfa0311eff 100644
--- a/eth2/types/src/crosslink.rs
+++ b/eth2/types/src/crosslink.rs
@@ -1,7 +1,7 @@
 use crate::test_utils::TestRandom;
 use crate::{Epoch, Hash256};
 use rand::RngCore;
-use serde_derive::Serialize;
+use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode, TreeHash};
 use test_random_derive::TestRandom;
 
@@ -9,7 +9,17 @@ use test_random_derive::TestRandom;
 ///
 /// Spec v0.4.0
 #[derive(
-    Debug, Clone, PartialEq, Default, Serialize, Hash, Encode, Decode, TreeHash, TestRandom,
+    Debug,
+    Clone,
+    PartialEq,
+    Default,
+    Serialize,
+    Deserialize,
+    Hash,
+    Encode,
+    Decode,
+    TreeHash,
+    TestRandom,
 )]
 pub struct Crosslink {
     pub epoch: Epoch,
diff --git a/eth2/types/src/eth1_data.rs b/eth2/types/src/eth1_data.rs
index c4b2b1894f..0f1dbfec59 100644
--- a/eth2/types/src/eth1_data.rs
+++ b/eth2/types/src/eth1_data.rs
@@ -1,14 +1,16 @@
 use super::Hash256;
 use crate::test_utils::TestRandom;
 use rand::RngCore;
-use serde_derive::Serialize;
+use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode, TreeHash};
 use test_random_derive::TestRandom;
 
 /// Contains data obtained from the Eth1 chain.
 ///
 /// Spec v0.4.0
-#[derive(Debug, PartialEq, Clone, Default, Serialize, Encode, Decode, TreeHash, TestRandom)]
+#[derive(
+    Debug, PartialEq, Clone, Default, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom,
+)]
 pub struct Eth1Data {
     pub deposit_root: Hash256,
     pub block_hash: Hash256,
diff --git a/eth2/types/src/eth1_data_vote.rs b/eth2/types/src/eth1_data_vote.rs
index 4788833bd3..d709608d5f 100644
--- a/eth2/types/src/eth1_data_vote.rs
+++ b/eth2/types/src/eth1_data_vote.rs
@@ -1,14 +1,16 @@
 use super::Eth1Data;
 use crate::test_utils::TestRandom;
 use rand::RngCore;
-use serde_derive::Serialize;
+use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode, TreeHash};
 use test_random_derive::TestRandom;
 
 /// A summation of votes for some `Eth1Data`.
 ///
 /// Spec v0.4.0
-#[derive(Debug, PartialEq, Clone, Default, Serialize, Encode, Decode, TreeHash, TestRandom)]
+#[derive(
+    Debug, PartialEq, Clone, Default, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom,
+)]
 pub struct Eth1DataVote {
     pub eth1_data: Eth1Data,
     pub vote_count: u64,
diff --git a/eth2/types/src/fork.rs b/eth2/types/src/fork.rs
index f3b62f5a8d..f0e3d10467 100644
--- a/eth2/types/src/fork.rs
+++ b/eth2/types/src/fork.rs
@@ -1,24 +1,41 @@
-use crate::{test_utils::TestRandom, Epoch};
+use crate::{test_utils::TestRandom, ChainSpec, Epoch};
+use int_to_bytes::int_to_bytes4;
 use rand::RngCore;
-use serde_derive::Serialize;
+use serde_derive::{Deserialize, 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)]
+/// Spec v0.5.0
+#[derive(
+    Debug, Clone, PartialEq, Default, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom,
+)]
 pub struct Fork {
-    pub previous_version: u64,
-    pub current_version: u64,
+    pub previous_version: [u8; 4],
+    pub current_version: [u8; 4],
     pub epoch: Epoch,
 }
 
 impl Fork {
+    /// Initialize the `Fork` from the genesis parameters in the `spec`.
+    ///
+    /// Spec v0.5.0
+    pub fn genesis(spec: &ChainSpec) -> Self {
+        let mut current_version: [u8; 4] = [0; 4];
+        current_version.copy_from_slice(&int_to_bytes4(spec.genesis_fork_version));
+
+        Self {
+            previous_version: current_version,
+            current_version,
+            epoch: spec.genesis_epoch,
+        }
+    }
+
     /// Return the fork version of the given ``epoch``.
     ///
-    /// Spec v0.4.0
-    pub fn get_fork_version(&self, epoch: Epoch) -> u64 {
+    /// Spec v0.5.0
+    pub fn get_fork_version(&self, epoch: Epoch) -> [u8; 4] {
         if epoch < self.epoch {
             return self.previous_version;
         }
diff --git a/eth2/types/src/pending_attestation.rs b/eth2/types/src/pending_attestation.rs
index 68dd1c3451..70907c29df 100644
--- a/eth2/types/src/pending_attestation.rs
+++ b/eth2/types/src/pending_attestation.rs
@@ -1,14 +1,14 @@
 use crate::test_utils::TestRandom;
 use crate::{AttestationData, Bitfield, Slot};
 use rand::RngCore;
-use serde_derive::Serialize;
+use serde_derive::{Deserialize, 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)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom)]
 pub struct PendingAttestation {
     pub aggregation_bitfield: Bitfield,
     pub data: AttestationData,
diff --git a/eth2/types/src/proposal.rs b/eth2/types/src/proposal.rs
index 59d6370e1d..36fba5603e 100644
--- a/eth2/types/src/proposal.rs
+++ b/eth2/types/src/proposal.rs
@@ -2,7 +2,7 @@ use crate::test_utils::TestRandom;
 use crate::{Hash256, Slot};
 use bls::Signature;
 use rand::RngCore;
-use serde_derive::Serialize;
+use serde_derive::{Deserialize, Serialize};
 use ssz::TreeHash;
 use ssz_derive::{Decode, Encode, SignedRoot, TreeHash};
 use test_random_derive::TestRandom;
@@ -10,7 +10,18 @@ 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)]
+#[derive(
+    Debug,
+    PartialEq,
+    Clone,
+    Serialize,
+    Deserialize,
+    Encode,
+    Decode,
+    TreeHash,
+    TestRandom,
+    SignedRoot,
+)]
 pub struct Proposal {
     pub slot: Slot,
     /// Shard number (spec.beacon_chain_shard_number for beacon chain)
diff --git a/eth2/types/src/proposer_slashing.rs b/eth2/types/src/proposer_slashing.rs
index 26c3d67a77..bc5b8665ef 100644
--- a/eth2/types/src/proposer_slashing.rs
+++ b/eth2/types/src/proposer_slashing.rs
@@ -1,14 +1,14 @@
 use super::Proposal;
 use crate::test_utils::TestRandom;
 use rand::RngCore;
-use serde_derive::Serialize;
+use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode, TreeHash};
 use test_random_derive::TestRandom;
 
 /// Two conflicting proposals from the same proposer (validator).
 ///
 /// Spec v0.4.0
-#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode, TreeHash, TestRandom)]
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom)]
 pub struct ProposerSlashing {
     pub proposer_index: u64,
     pub proposal_1: Proposal,
diff --git a/eth2/types/src/slashable_attestation.rs b/eth2/types/src/slashable_attestation.rs
index 56c9dfc2f6..bc9b2769a4 100644
--- a/eth2/types/src/slashable_attestation.rs
+++ b/eth2/types/src/slashable_attestation.rs
@@ -1,6 +1,6 @@
 use crate::{test_utils::TestRandom, AggregateSignature, AttestationData, Bitfield, ChainSpec};
 use rand::RngCore;
-use serde_derive::Serialize;
+use serde_derive::{Deserialize, Serialize};
 use ssz::TreeHash;
 use ssz_derive::{Decode, Encode, SignedRoot, TreeHash};
 use test_random_derive::TestRandom;
@@ -10,7 +10,18 @@ use test_random_derive::TestRandom;
 /// To be included in an `AttesterSlashing`.
 ///
 /// Spec v0.4.0
-#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode, TreeHash, TestRandom, SignedRoot)]
+#[derive(
+    Debug,
+    PartialEq,
+    Clone,
+    Serialize,
+    Deserialize,
+    Encode,
+    Decode,
+    TreeHash,
+    TestRandom,
+    SignedRoot,
+)]
 pub struct SlashableAttestation {
     /// Lists validator registry indices, not committee indices.
     pub validator_indices: Vec<u64>,
diff --git a/eth2/types/src/test_utils/test_random.rs b/eth2/types/src/test_utils/test_random.rs
index 3b172463e4..cb7abe3a42 100644
--- a/eth2/types/src/test_utils/test_random.rs
+++ b/eth2/types/src/test_utils/test_random.rs
@@ -51,3 +51,17 @@ where
         ]
     }
 }
+
+macro_rules! impl_test_random_for_u8_array {
+    ($len: expr) => {
+        impl<T: RngCore> TestRandom<T> for [u8; $len] {
+            fn random_for_test(rng: &mut T) -> Self {
+                let mut bytes = [0; $len];
+                rng.fill_bytes(&mut bytes);
+                bytes
+            }
+        }
+    };
+}
+
+impl_test_random_for_u8_array!(4);
diff --git a/eth2/types/src/transfer.rs b/eth2/types/src/transfer.rs
index af3b18ef42..a46e24e241 100644
--- a/eth2/types/src/transfer.rs
+++ b/eth2/types/src/transfer.rs
@@ -2,7 +2,7 @@ use super::Slot;
 use crate::test_utils::TestRandom;
 use bls::{PublicKey, Signature};
 use rand::RngCore;
-use serde_derive::Serialize;
+use serde_derive::{Deserialize, Serialize};
 use ssz::TreeHash;
 use ssz_derive::{Decode, Encode, SignedRoot, TreeHash};
 use test_random_derive::TestRandom;
@@ -10,7 +10,18 @@ use test_random_derive::TestRandom;
 /// The data submitted to the deposit contract.
 ///
 /// Spec v0.4.0
-#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode, TreeHash, TestRandom, SignedRoot)]
+#[derive(
+    Debug,
+    PartialEq,
+    Clone,
+    Serialize,
+    Deserialize,
+    Encode,
+    Decode,
+    TreeHash,
+    TestRandom,
+    SignedRoot,
+)]
 pub struct Transfer {
     pub from: u64,
     pub to: u64,
diff --git a/eth2/types/src/voluntary_exit.rs b/eth2/types/src/voluntary_exit.rs
index 38630a0575..5fdfcdd82f 100644
--- a/eth2/types/src/voluntary_exit.rs
+++ b/eth2/types/src/voluntary_exit.rs
@@ -1,7 +1,7 @@
 use crate::{test_utils::TestRandom, Epoch};
 use bls::Signature;
 use rand::RngCore;
-use serde_derive::Serialize;
+use serde_derive::{Deserialize, Serialize};
 use ssz::TreeHash;
 use ssz_derive::{Decode, Encode, SignedRoot, TreeHash};
 use test_random_derive::TestRandom;
@@ -9,7 +9,18 @@ use test_random_derive::TestRandom;
 /// An exit voluntarily submitted a validator who wishes to withdraw.
 ///
 /// Spec v0.4.0
-#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode, TreeHash, TestRandom, SignedRoot)]
+#[derive(
+    Debug,
+    PartialEq,
+    Clone,
+    Serialize,
+    Deserialize,
+    Encode,
+    Decode,
+    TreeHash,
+    TestRandom,
+    SignedRoot,
+)]
 pub struct VoluntaryExit {
     pub epoch: Epoch,
     pub validator_index: u64,
diff --git a/eth2/utils/bls/Cargo.toml b/eth2/utils/bls/Cargo.toml
index 2466605b0c..4230a06eae 100644
--- a/eth2/utils/bls/Cargo.toml
+++ b/eth2/utils/bls/Cargo.toml
@@ -10,4 +10,5 @@ hashing = { path = "../hashing" }
 hex = "0.3"
 serde = "1.0"
 serde_derive = "1.0"
+serde_hex = { path = "../serde_hex" }
 ssz = { path = "../ssz" }
diff --git a/eth2/utils/bls/src/aggregate_signature.rs b/eth2/utils/bls/src/aggregate_signature.rs
index 9c5ed03750..7b80d3bbfd 100644
--- a/eth2/utils/bls/src/aggregate_signature.rs
+++ b/eth2/utils/bls/src/aggregate_signature.rs
@@ -2,7 +2,9 @@ use super::{AggregatePublicKey, Signature};
 use bls_aggregates::{
     AggregatePublicKey as RawAggregatePublicKey, AggregateSignature as RawAggregateSignature,
 };
+use serde::de::{Deserialize, Deserializer};
 use serde::ser::{Serialize, Serializer};
+use serde_hex::{encode as hex_encode, PrefixedHexVisitor};
 use ssz::{
     decode_ssz_list, hash, ssz_encode, Decodable, DecodeError, Encodable, SszStream, TreeHash,
 };
@@ -82,7 +84,19 @@ impl Serialize for AggregateSignature {
     where
         S: Serializer,
     {
-        serializer.serialize_bytes(&ssz_encode(self))
+        serializer.serialize_str(&hex_encode(ssz_encode(self)))
+    }
+}
+
+impl<'de> Deserialize<'de> for AggregateSignature {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let bytes = deserializer.deserialize_str(PrefixedHexVisitor)?;
+        let (obj, _) = <_>::ssz_decode(&bytes[..], 0)
+            .map_err(|e| serde::de::Error::custom(format!("invalid ssz ({:?})", e)))?;
+        Ok(obj)
     }
 }
 
diff --git a/eth2/utils/bls/src/public_key.rs b/eth2/utils/bls/src/public_key.rs
index c85760bbf0..5a348f530d 100644
--- a/eth2/utils/bls/src/public_key.rs
+++ b/eth2/utils/bls/src/public_key.rs
@@ -1,9 +1,8 @@
-use super::serde_vistors::HexVisitor;
 use super::SecretKey;
 use bls_aggregates::PublicKey as RawPublicKey;
-use hex::encode as hex_encode;
 use serde::de::{Deserialize, Deserializer};
 use serde::ser::{Serialize, Serializer};
+use serde_hex::{encode as hex_encode, PrefixedHexVisitor};
 use ssz::{
     decode_ssz_list, hash, ssz_encode, Decodable, DecodeError, Encodable, SszStream, TreeHash,
 };
@@ -81,7 +80,7 @@ impl Serialize for PublicKey {
     where
         S: Serializer,
     {
-        serializer.serialize_str(&hex_encode(ssz_encode(self)))
+        serializer.serialize_str(&hex_encode(self.as_raw().as_bytes()))
     }
 }
 
@@ -90,10 +89,10 @@ impl<'de> Deserialize<'de> for PublicKey {
     where
         D: Deserializer<'de>,
     {
-        let bytes = deserializer.deserialize_str(HexVisitor)?;
-        let (pubkey, _) = <_>::ssz_decode(&bytes[..], 0)
-            .map_err(|e| serde::de::Error::custom(format!("invalid ssz ({:?})", e)))?;
-        Ok(pubkey)
+        let bytes = deserializer.deserialize_str(PrefixedHexVisitor)?;
+        let obj = PublicKey::from_bytes(&bytes[..])
+            .map_err(|e| serde::de::Error::custom(format!("invalid pubkey ({:?})", e)))?;
+        Ok(obj)
     }
 }
 
diff --git a/eth2/utils/boolean-bitfield/Cargo.toml b/eth2/utils/boolean-bitfield/Cargo.toml
index d94b9f7b14..cf037c5d70 100644
--- a/eth2/utils/boolean-bitfield/Cargo.toml
+++ b/eth2/utils/boolean-bitfield/Cargo.toml
@@ -5,6 +5,7 @@ authors = ["Paul Hauner <paul@paulhauner.com>"]
 edition = "2018"
 
 [dependencies]
+serde_hex = { path = "../serde_hex" }
 ssz = { path = "../ssz" }
 bit-vec = "0.5.0"
 serde = "1.0"
diff --git a/eth2/utils/boolean-bitfield/src/lib.rs b/eth2/utils/boolean-bitfield/src/lib.rs
index a0fce1f0a4..443cd06dad 100644
--- a/eth2/utils/boolean-bitfield/src/lib.rs
+++ b/eth2/utils/boolean-bitfield/src/lib.rs
@@ -3,7 +3,10 @@ extern crate ssz;
 
 use bit_vec::BitVec;
 
+use serde::de::{Deserialize, Deserializer};
 use serde::ser::{Serialize, Serializer};
+use serde_hex::{encode, PrefixedHexVisitor};
+use ssz::Decodable;
 use std::cmp;
 use std::default;
 
@@ -178,11 +181,25 @@ impl ssz::Decodable for BooleanBitfield {
 }
 
 impl Serialize for BooleanBitfield {
+    /// Serde serialization is compliant the Ethereum YAML test format.
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
-        serializer.serialize_bytes(&ssz::ssz_encode(self))
+        serializer.serialize_str(&encode(&ssz::ssz_encode(self)))
+    }
+}
+
+impl<'de> Deserialize<'de> for BooleanBitfield {
+    /// Serde serialization is compliant the Ethereum YAML test format.
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let bytes = deserializer.deserialize_str(PrefixedHexVisitor)?;
+        let (bitfield, _) = <_>::ssz_decode(&bytes[..], 0)
+            .map_err(|e| serde::de::Error::custom(format!("invalid ssz ({:?})", e)))?;
+        Ok(bitfield)
     }
 }
 
diff --git a/eth2/utils/serde_hex/Cargo.toml b/eth2/utils/serde_hex/Cargo.toml
new file mode 100644
index 0000000000..b28194dd6f
--- /dev/null
+++ b/eth2/utils/serde_hex/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "serde_hex"
+version = "0.1.0"
+authors = ["Paul Hauner <paul@paulhauner.com>"]
+edition = "2018"
+
+[dependencies]
+serde = "1.0"
+hex = "0.3"
diff --git a/eth2/utils/serde_hex/src/lib.rs b/eth2/utils/serde_hex/src/lib.rs
new file mode 100644
index 0000000000..3be20d93f9
--- /dev/null
+++ b/eth2/utils/serde_hex/src/lib.rs
@@ -0,0 +1,59 @@
+use hex;
+use hex::ToHex;
+use serde::de::{self, Visitor};
+use std::fmt;
+
+pub fn encode<T: AsRef<[u8]>>(data: T) -> String {
+    let mut hex = String::with_capacity(data.as_ref().len() * 2);
+
+    // Writing to a string never errors, so we can unwrap here.
+    data.write_hex(&mut hex).unwrap();
+
+    let mut s = "0x".to_string();
+
+    s.push_str(hex.as_str());
+
+    s
+}
+
+pub struct PrefixedHexVisitor;
+
+impl<'de> Visitor<'de> for PrefixedHexVisitor {
+    type Value = Vec<u8>;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str("a hex string with 0x prefix")
+    }
+
+    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        if value.starts_with("0x") {
+            Ok(hex::decode(&value[2..])
+                .map_err(|e| de::Error::custom(format!("invalid hex ({:?})", e)))?)
+        } else {
+            Err(de::Error::custom("missing 0x prefix"))
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn encoding() {
+        let bytes = vec![0, 255];
+        let hex = encode(&bytes);
+        assert_eq!(hex.as_str(), "0x00ff");
+
+        let bytes = vec![];
+        let hex = encode(&bytes);
+        assert_eq!(hex.as_str(), "0x");
+
+        let bytes = vec![1, 2, 3];
+        let hex = encode(&bytes);
+        assert_eq!(hex.as_str(), "0x010203");
+    }
+}
diff --git a/eth2/utils/ssz/src/impl_decode.rs b/eth2/utils/ssz/src/impl_decode.rs
index b13cbeb5de..152e367606 100644
--- a/eth2/utils/ssz/src/impl_decode.rs
+++ b/eth2/utils/ssz/src/impl_decode.rs
@@ -24,11 +24,30 @@ macro_rules! impl_decodable_for_uint {
     };
 }
 
+macro_rules! impl_decodable_for_u8_array {
+    ($len: expr) => {
+        impl Decodable for [u8; $len] {
+            fn ssz_decode(bytes: &[u8], index: usize) -> Result<(Self, usize), DecodeError> {
+                if index + $len > bytes.len() {
+                    Err(DecodeError::TooShort)
+                } else {
+                    let mut array: [u8; $len] = [0; $len];
+                    array.copy_from_slice(&bytes[index..index + $len]);
+
+                    Ok((array, index + $len))
+                }
+            }
+        }
+    };
+}
+
 impl_decodable_for_uint!(u16, 16);
 impl_decodable_for_uint!(u32, 32);
 impl_decodable_for_uint!(u64, 64);
 impl_decodable_for_uint!(usize, 64);
 
+impl_decodable_for_u8_array!(4);
+
 impl Decodable for u8 {
     fn ssz_decode(bytes: &[u8], index: usize) -> Result<(Self, usize), DecodeError> {
         if index >= bytes.len() {
@@ -246,4 +265,12 @@ mod tests {
         let result: Result<(bool, usize), DecodeError> = decode_ssz(&ssz, 0);
         assert_eq!(result, Err(DecodeError::Invalid));
     }
+
+    #[test]
+    fn test_decode_u8_array() {
+        let ssz = vec![0, 1, 2, 3];
+        let (result, index): ([u8; 4], usize) = decode_ssz(&ssz, 0).unwrap();
+        assert_eq!(index, 4);
+        assert_eq!(result, [0, 1, 2, 3]);
+    }
 }
diff --git a/eth2/utils/ssz/src/impl_encode.rs b/eth2/utils/ssz/src/impl_encode.rs
index bb1ec42d5d..b7d008ccfb 100644
--- a/eth2/utils/ssz/src/impl_encode.rs
+++ b/eth2/utils/ssz/src/impl_encode.rs
@@ -40,12 +40,25 @@ macro_rules! impl_encodable_for_uint {
     };
 }
 
+macro_rules! impl_encodable_for_u8_array {
+    ($len: expr) => {
+        impl Encodable for [u8; $len] {
+            fn ssz_append(&self, s: &mut SszStream) {
+                let bytes: Vec<u8> = self.iter().cloned().collect();
+                s.append_encoded_raw(&bytes);
+            }
+        }
+    };
+}
+
 impl_encodable_for_uint!(u8, 8);
 impl_encodable_for_uint!(u16, 16);
 impl_encodable_for_uint!(u32, 32);
 impl_encodable_for_uint!(u64, 64);
 impl_encodable_for_uint!(usize, 64);
 
+impl_encodable_for_u8_array!(4);
+
 impl Encodable for bool {
     fn ssz_append(&self, s: &mut SszStream) {
         let byte = if *self { 0b1000_0000 } else { 0b0000_0000 };
@@ -77,6 +90,7 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::ssz_encode;
 
     #[test]
     fn test_ssz_encode_h256() {
@@ -226,4 +240,15 @@ mod tests {
         ssz.append(&x);
         assert_eq!(ssz.drain(), vec![0b1000_0000]);
     }
+
+    #[test]
+    fn test_ssz_encode_u8_array() {
+        let x: [u8; 4] = [0, 1, 7, 8];
+        let ssz = ssz_encode(&x);
+        assert_eq!(ssz, vec![0, 1, 7, 8]);
+
+        let x: [u8; 4] = [255, 255, 255, 255];
+        let ssz = ssz_encode(&x);
+        assert_eq!(ssz, vec![255, 255, 255, 255]);
+    }
 }

From ef86948259c11ba2129982dd53e0619ed2cdedd1 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Fri, 15 Mar 2019 13:32:23 +1100
Subject: [PATCH 08/60] Add bones of YAML state test parsing.

Is incomplete, need to update all our types to v0.5.0 first
---
 eth2/state_processing/specs/example.yml | 347 ++++++++++++++++++++++++
 eth2/state_processing/tests/tests.rs    |  42 +++
 2 files changed, 389 insertions(+)
 create mode 100644 eth2/state_processing/specs/example.yml
 create mode 100644 eth2/state_processing/tests/tests.rs

diff --git a/eth2/state_processing/specs/example.yml b/eth2/state_processing/specs/example.yml
new file mode 100644
index 0000000000..95b749bc45
--- /dev/null
+++ b/eth2/state_processing/specs/example.yml
@@ -0,0 +1,347 @@
+title: Sanity tests
+summary: Basic sanity checks from phase 0 spec pythonization. All tests are run with
+  `verify_signatures` as set to False.
+test_suite: beacon_state
+fork: tchaikovsky
+version: v0.5.0
+test_cases:
+- name: test_empty_block_transition
+  config: {SHARD_COUNT: 8, TARGET_COMMITTEE_SIZE: 4, MAX_BALANCE_CHURN_QUOTIENT: 32,
+    MAX_INDICES_PER_SLASHABLE_VOTE: 4096, MAX_EXIT_DEQUEUES_PER_EPOCH: 4, SHUFFLE_ROUND_COUNT: 90,
+    DEPOSIT_CONTRACT_TREE_DEPTH: 32, MIN_DEPOSIT_AMOUNT: 1000000000, MAX_DEPOSIT_AMOUNT: 32000000000,
+    FORK_CHOICE_BALANCE_INCREMENT: 1000000000, EJECTION_BALANCE: 16000000000, GENESIS_FORK_VERSION: 0,
+    GENESIS_SLOT: 4294967296, GENESIS_EPOCH: 536870912, GENESIS_START_SHARD: 0, BLS_WITHDRAWAL_PREFIX_BYTE: 0,
+    SECONDS_PER_SLOT: 6, MIN_ATTESTATION_INCLUSION_DELAY: 2, SLOTS_PER_EPOCH: 8, MIN_SEED_LOOKAHEAD: 1,
+    ACTIVATION_EXIT_DELAY: 4, EPOCHS_PER_ETH1_VOTING_PERIOD: 16, SLOTS_PER_HISTORICAL_ROOT: 64,
+    MIN_VALIDATOR_WITHDRAWABILITY_DELAY: 256, PERSISTENT_COMMITTEE_PERIOD: 2048, LATEST_RANDAO_MIXES_LENGTH: 64,
+    LATEST_ACTIVE_INDEX_ROOTS_LENGTH: 64, LATEST_SLASHED_EXIT_LENGTH: 64, BASE_REWARD_QUOTIENT: 32,
+    WHISTLEBLOWER_REWARD_QUOTIENT: 512, ATTESTATION_INCLUSION_REWARD_QUOTIENT: 8,
+    INACTIVITY_PENALTY_QUOTIENT: 16777216, MIN_PENALTY_QUOTIENT: 32, MAX_PROPOSER_SLASHINGS: 16,
+    MAX_ATTESTER_SLASHINGS: 1, MAX_ATTESTATIONS: 128, MAX_DEPOSITS: 16, MAX_VOLUNTARY_EXITS: 16,
+    MAX_TRANSFERS: 16, DOMAIN_BEACON_BLOCK: 0, DOMAIN_RANDAO: 1, DOMAIN_ATTESTATION: 2,
+    DOMAIN_DEPOSIT: 3, DOMAIN_VOLUNTARY_EXIT: 4, DOMAIN_TRANSFER: 5}
+  verify_signatures: false
+  initial_state:
+    slot: 4294967296
+    genesis_time: 0
+    fork: {previous_version: 0, current_version: 0, epoch: 536870912}
+    validator_registry:
+    - {pubkey: '0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x030000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x050000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x070000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x090000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x0a0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x0b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x0c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x0d0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x0e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x0f0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x120000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x130000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x140000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x150000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x160000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x170000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x180000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x190000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x1a0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x1b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x1c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x1d0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x1e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    - {pubkey: '0x1f0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      withdrawal_credentials: '0x2222222222222222222222222222222222222222222222222222222222222222',
+      activation_epoch: 536870912, exit_epoch: 18446744073709551615, withdrawable_epoch: 18446744073709551615,
+      initiated_exit: false, slashed: false}
+    validator_balances: [32000000000, 32000000000, 32000000000, 32000000000, 32000000000,
+      32000000000, 32000000000, 32000000000, 32000000000, 32000000000, 32000000000,
+      32000000000, 32000000000, 32000000000, 32000000000, 32000000000, 32000000000,
+      32000000000, 32000000000, 32000000000, 32000000000, 32000000000, 32000000000,
+      32000000000, 32000000000, 32000000000, 32000000000, 32000000000, 32000000000,
+      32000000000, 32000000000, 32000000000]
+    validator_registry_update_epoch: 536870912
+    latest_randao_mixes: ['0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000']
+    previous_shuffling_start_shard: 0
+    current_shuffling_start_shard: 0
+    previous_shuffling_epoch: 536870912
+    current_shuffling_epoch: 536870912
+    previous_shuffling_seed: '0x0000000000000000000000000000000000000000000000000000000000000000'
+    current_shuffling_seed: '0x94ab448e948e6d501a2b48c1e9a0946f871100969f6fa70a990acf2348c9b185'
+    previous_epoch_attestations: []
+    current_epoch_attestations: []
+    previous_justified_epoch: 536870912
+    current_justified_epoch: 536870912
+    previous_justified_root: '0x0000000000000000000000000000000000000000000000000000000000000000'
+    current_justified_root: '0x0000000000000000000000000000000000000000000000000000000000000000'
+    justification_bitfield: 0
+    finalized_epoch: 536870912
+    finalized_root: '0x0000000000000000000000000000000000000000000000000000000000000000'
+    latest_crosslinks:
+    - {epoch: 536870912, crosslink_data_root: '0x0000000000000000000000000000000000000000000000000000000000000000'}
+    - {epoch: 536870912, crosslink_data_root: '0x0000000000000000000000000000000000000000000000000000000000000000'}
+    - {epoch: 536870912, crosslink_data_root: '0x0000000000000000000000000000000000000000000000000000000000000000'}
+    - {epoch: 536870912, crosslink_data_root: '0x0000000000000000000000000000000000000000000000000000000000000000'}
+    - {epoch: 536870912, crosslink_data_root: '0x0000000000000000000000000000000000000000000000000000000000000000'}
+    - {epoch: 536870912, crosslink_data_root: '0x0000000000000000000000000000000000000000000000000000000000000000'}
+    - {epoch: 536870912, crosslink_data_root: '0x0000000000000000000000000000000000000000000000000000000000000000'}
+    - {epoch: 536870912, crosslink_data_root: '0x0000000000000000000000000000000000000000000000000000000000000000'}
+    latest_block_roots: ['0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000']
+    latest_state_roots: ['0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000000']
+    latest_active_index_roots: ['0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42', '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42',
+      '0xf6b8ca96e524598ba62d563347f5aea6ce2d81d644e2788687e5a92844df1b42']
+    latest_slashed_balances: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+    latest_block_header: {slot: 4294967296, previous_block_root: '0x0000000000000000000000000000000000000000000000000000000000000000',
+      state_root: '0x0000000000000000000000000000000000000000000000000000000000000000',
+      block_body_root: '0x5359b62990beb1d78e1cec479f5a4d80af84709886a8e16c535dff0556dc0e2d',
+      signature: '0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'}
+    historical_roots: []
+    latest_eth1_data: {deposit_root: '0xb05de6a9059df0c9a2ab5f76708d256941dfe9eb89e6fda549b30713087d2a5e',
+      block_hash: '0x0000000000000000000000000000000000000000000000000000000000000000'}
+    eth1_data_votes: []
+    deposit_index: 32
+  blocks:
+  - slot: 4294967297
+    previous_block_root: '0x92ed652508d2b4c109a857107101716b18e257e7ce0d199d4b16232956e9e27e'
+    state_root: '0x0000000000000000000000000000000000000000000000000000000000000000'
+    body:
+      randao_reveal: '0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'
+      eth1_data: {deposit_root: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        block_hash: '0x0000000000000000000000000000000000000000000000000000000000000000'}
+      proposer_slashings: []
+      attester_slashings: []
+      attestations: []
+      deposits: []
+      voluntary_exits: []
+      transfers: []
+    signature: '0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'
+  expected_state: {slot: 4294967297}
diff --git a/eth2/state_processing/tests/tests.rs b/eth2/state_processing/tests/tests.rs
new file mode 100644
index 0000000000..9cee7b34ce
--- /dev/null
+++ b/eth2/state_processing/tests/tests.rs
@@ -0,0 +1,42 @@
+use serde_derive::Deserialize;
+use types::*;
+
+#[derive(Debug, Deserialize)]
+pub struct TestCase {
+    pub name: String,
+    pub config: ChainSpec,
+    pub verify_signatures: bool,
+    pub initial_state: BeaconState,
+    pub blocks: Vec<BeaconBlock>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct TestDoc {
+    pub title: String,
+    pub summary: String,
+    pub fork: String,
+    pub version: String,
+    pub test_cases: Vec<TestCase>,
+}
+
+#[test]
+#[ignore]
+fn yaml() {
+    use serde_yaml;
+    use std::{fs::File, io::prelude::*, path::PathBuf};
+
+    let mut file = {
+        let mut file_path_buf = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+        file_path_buf.push("specs/example.yml");
+
+        File::open(file_path_buf).unwrap()
+    };
+
+    let mut yaml_str = String::new();
+
+    file.read_to_string(&mut yaml_str).unwrap();
+
+    let yaml_str = yaml_str.to_lowercase();
+
+    let _doc: TestDoc = serde_yaml::from_str(&yaml_str.as_str()).unwrap();
+}

From f9964ebd8b04439ff222db5b2e803413141b73ba Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Fri, 15 Mar 2019 13:33:07 +1100
Subject: [PATCH 09/60] Update Fork struct to v0.5.0

---
 beacon_node/src/main.rs                     |  6 +--
 eth2/types/src/chain_spec.rs                | 35 ++++++++++++++--
 eth2/types/src/fork.rs                      | 45 +++++++++++++++++++++
 validator_client/src/duties/epoch_duties.rs |  4 +-
 4 files changed, 79 insertions(+), 11 deletions(-)

diff --git a/beacon_node/src/main.rs b/beacon_node/src/main.rs
index c3182c789b..eacbffa3ef 100644
--- a/beacon_node/src/main.rs
+++ b/beacon_node/src/main.rs
@@ -119,11 +119,7 @@ fn main() {
                             // Get domain from genesis fork_version
                             spec.genesis_epoch,
                             Domain::Deposit,
-                            &Fork {
-                                previous_version: spec.genesis_fork_version,
-                                current_version: spec.genesis_fork_version,
-                                epoch: spec.genesis_epoch,
-                            },
+                            &Fork::genesis(&spec),
                         ),
                     ),
                 },
diff --git a/eth2/types/src/chain_spec.rs b/eth2/types/src/chain_spec.rs
index 108516695d..ae521cc92a 100644
--- a/eth2/types/src/chain_spec.rs
+++ b/eth2/types/src/chain_spec.rs
@@ -1,4 +1,4 @@
-use crate::{Address, Epoch, Fork, Hash256, Slot};
+use crate::*;
 use bls::Signature;
 use int_to_bytes::int_to_bytes4;
 use serde_derive::Deserialize;
@@ -127,7 +127,7 @@ impl ChainSpec {
 
     /// Get the domain number that represents the fork meta and signature domain.
     ///
-    /// Spec v0.4.0
+    /// Spec v0.5.0
     pub fn get_domain(&self, epoch: Epoch, domain: Domain, fork: &Fork) -> u64 {
         let domain_constant = match domain {
             Domain::Deposit => self.domain_deposit,
@@ -138,9 +138,11 @@ impl ChainSpec {
             Domain::Transfer => self.domain_transfer,
         };
 
+        let mut bytes: Vec<u8> = fork.get_fork_version(epoch).to_vec();
+        bytes.append(&mut int_to_bytes4(domain_constant));
+
         let mut fork_and_domain = [0; 8];
-        fork_and_domain.copy_from_slice(&fork.get_fork_version(epoch));
-        fork_and_domain.copy_from_slice(&int_to_bytes4(domain_constant));
+        fork_and_domain.copy_from_slice(&bytes);
 
         u64::from_le_bytes(fork_and_domain)
     }
@@ -269,9 +271,34 @@ impl Default for ChainSpec {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use int_to_bytes::int_to_bytes8;
 
     #[test]
     fn test_foundation_spec_can_be_constructed() {
         let _ = ChainSpec::foundation();
     }
+
+    fn test_domain(domain_type: Domain, raw_domain: u32, spec: &ChainSpec) {
+        let fork = Fork::genesis(&spec);
+        let epoch = Epoch::new(0);
+
+        let domain = spec.get_domain(epoch, domain_type, &fork);
+
+        let mut expected = fork.get_fork_version(epoch).to_vec();
+        expected.append(&mut int_to_bytes4(raw_domain));
+
+        assert_eq!(int_to_bytes8(domain), expected);
+    }
+
+    #[test]
+    fn test_get_domain() {
+        let spec = ChainSpec::foundation();
+
+        test_domain(Domain::Deposit, spec.domain_deposit, &spec);
+        test_domain(Domain::Attestation, spec.domain_attestation, &spec);
+        test_domain(Domain::Proposal, spec.domain_proposal, &spec);
+        test_domain(Domain::Exit, spec.domain_exit, &spec);
+        test_domain(Domain::Randao, spec.domain_randao, &spec);
+        test_domain(Domain::Transfer, spec.domain_transfer, &spec);
+    }
 }
diff --git a/eth2/types/src/fork.rs b/eth2/types/src/fork.rs
index f0e3d10467..b780b95ef3 100644
--- a/eth2/types/src/fork.rs
+++ b/eth2/types/src/fork.rs
@@ -48,4 +48,49 @@ mod tests {
     use super::*;
 
     ssz_tests!(Fork);
+
+    fn test_genesis(version: u32, epoch: Epoch) {
+        let mut spec = ChainSpec::foundation();
+
+        spec.genesis_fork_version = version;
+        spec.genesis_epoch = epoch;
+
+        let fork = Fork::genesis(&spec);
+
+        assert_eq!(fork.epoch, spec.genesis_epoch, "epoch incorrect");
+        assert_eq!(
+            fork.previous_version, fork.current_version,
+            "previous and current are not identical"
+        );
+        assert_eq!(
+            fork.current_version,
+            version.to_le_bytes(),
+            "current version incorrect"
+        );
+    }
+
+    #[test]
+    fn genesis() {
+        test_genesis(0, Epoch::new(0));
+        test_genesis(9, Epoch::new(11));
+        test_genesis(2_u32.pow(31), Epoch::new(2_u64.pow(63)));
+        test_genesis(u32::max_value(), Epoch::max_value());
+    }
+
+    #[test]
+    fn get_fork_version() {
+        let previous_version = [1; 4];
+        let current_version = [2; 4];
+        let epoch = Epoch::new(10);
+
+        let fork = Fork {
+            previous_version,
+            current_version,
+            epoch,
+        };
+
+        assert_eq!(fork.get_fork_version(epoch - 1), previous_version);
+        assert_eq!(fork.get_fork_version(epoch), current_version);
+        assert_eq!(fork.get_fork_version(epoch + 1), current_version);
+    }
 }
diff --git a/validator_client/src/duties/epoch_duties.rs b/validator_client/src/duties/epoch_duties.rs
index 35668b4a9d..71f5f26ab5 100644
--- a/validator_client/src/duties/epoch_duties.rs
+++ b/validator_client/src/duties/epoch_duties.rs
@@ -81,8 +81,8 @@ impl DutiesReader for EpochDutiesMap {
         //
         // It will almost certainly cause signatures to fail verification.
         Ok(Fork {
-            previous_version: 0,
-            current_version: 0,
+            previous_version: [0; 4],
+            current_version: [0; 4],
             epoch: Epoch::new(0),
         })
     }

From 8050ed7a2600ef17bab8c1cc43305dbad08456ec Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Fri, 15 Mar 2019 14:33:40 +1100
Subject: [PATCH 10/60] Fast-forward unchanged 0.4.0 structs to 0.5.0

---
 eth2/types/src/crosslink.rs      | 2 +-
 eth2/types/src/eth1_data.rs      | 2 +-
 eth2/types/src/eth1_data_vote.rs | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/eth2/types/src/crosslink.rs b/eth2/types/src/crosslink.rs
index dfa0311eff..f91680c756 100644
--- a/eth2/types/src/crosslink.rs
+++ b/eth2/types/src/crosslink.rs
@@ -7,7 +7,7 @@ use test_random_derive::TestRandom;
 
 /// Specifies the block hash for a shard at an epoch.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 #[derive(
     Debug,
     Clone,
diff --git a/eth2/types/src/eth1_data.rs b/eth2/types/src/eth1_data.rs
index 0f1dbfec59..deced19fb6 100644
--- a/eth2/types/src/eth1_data.rs
+++ b/eth2/types/src/eth1_data.rs
@@ -7,7 +7,7 @@ use test_random_derive::TestRandom;
 
 /// Contains data obtained from the Eth1 chain.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 #[derive(
     Debug, PartialEq, Clone, Default, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom,
 )]
diff --git a/eth2/types/src/eth1_data_vote.rs b/eth2/types/src/eth1_data_vote.rs
index d709608d5f..2f3a1ade1a 100644
--- a/eth2/types/src/eth1_data_vote.rs
+++ b/eth2/types/src/eth1_data_vote.rs
@@ -7,7 +7,7 @@ use test_random_derive::TestRandom;
 
 /// A summation of votes for some `Eth1Data`.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 #[derive(
     Debug, PartialEq, Clone, Default, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom,
 )]

From 20a439101e57dd55293721c01a7024384ccc6d10 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Fri, 15 Mar 2019 15:19:17 +1100
Subject: [PATCH 11/60] Update "attestation" family of structs in types

Also adds/splits up some testing builders.
---
 eth2/types/src/attestation_data.rs            | 17 +++--
 .../src/attestation_data_and_custody_bit.rs   |  2 +-
 eth2/types/src/slashable_attestation.rs       | 14 ++--
 eth2/types/src/test_utils/mod.rs              |  4 +
 .../test_utils/testing_attestation_builder.rs | 38 +---------
 .../testing_attestation_data_builder.rs       | 66 ++++++++++++++++
 .../testing_attester_slashing_builder.rs      | 48 +++++-------
 .../testing_beacon_state_builder.rs           | 76 ++-----------------
 .../testing_pending_attestation_builder.rs    | 55 ++++++++++++++
 9 files changed, 175 insertions(+), 145 deletions(-)
 create mode 100644 eth2/types/src/test_utils/testing_attestation_data_builder.rs
 create mode 100644 eth2/types/src/test_utils/testing_pending_attestation_builder.rs

diff --git a/eth2/types/src/attestation_data.rs b/eth2/types/src/attestation_data.rs
index 791ba00d27..4a6b57823e 100644
--- a/eth2/types/src/attestation_data.rs
+++ b/eth2/types/src/attestation_data.rs
@@ -8,7 +8,7 @@ use test_random_derive::TestRandom;
 
 /// The data upon which an attestation is based.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 #[derive(
     Debug,
     Clone,
@@ -24,14 +24,19 @@ use test_random_derive::TestRandom;
     SignedRoot,
 )]
 pub struct AttestationData {
+    // LMD GHOST vote
     pub slot: Slot,
-    pub shard: u64,
     pub beacon_block_root: Hash256,
-    pub epoch_boundary_root: Hash256,
+
+    // FFG Vote
+    pub source_epoch: Epoch,
+    pub source_root: Hash256,
+    pub target_root: Hash256,
+
+    // Crosslink Vote
+    pub shard: u64,
+    pub previous_crosslink: Crosslink,
     pub crosslink_data_root: Hash256,
-    pub latest_crosslink: Crosslink,
-    pub justified_epoch: Epoch,
-    pub justified_block_root: Hash256,
 }
 
 impl Eq for AttestationData {}
diff --git a/eth2/types/src/attestation_data_and_custody_bit.rs b/eth2/types/src/attestation_data_and_custody_bit.rs
index 020b07d28e..2cc6bc80ca 100644
--- a/eth2/types/src/attestation_data_and_custody_bit.rs
+++ b/eth2/types/src/attestation_data_and_custody_bit.rs
@@ -6,7 +6,7 @@ use ssz_derive::{Decode, Encode, TreeHash};
 
 /// Used for pairing an attestation with a proof-of-custody.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 #[derive(Debug, Clone, PartialEq, Default, Serialize, Encode, Decode, TreeHash)]
 pub struct AttestationDataAndCustodyBit {
     pub data: AttestationData,
diff --git a/eth2/types/src/slashable_attestation.rs b/eth2/types/src/slashable_attestation.rs
index bc9b2769a4..05c41a72b3 100644
--- a/eth2/types/src/slashable_attestation.rs
+++ b/eth2/types/src/slashable_attestation.rs
@@ -9,7 +9,7 @@ use test_random_derive::TestRandom;
 ///
 /// To be included in an `AttesterSlashing`.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 #[derive(
     Debug,
     PartialEq,
@@ -33,17 +33,17 @@ pub struct SlashableAttestation {
 impl SlashableAttestation {
     /// Check if ``attestation_data_1`` and ``attestation_data_2`` have the same target.
     ///
-    /// Spec v0.4.0
+    /// Spec v0.5.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
+    /// Spec v0.5.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 source_epoch_1 = self.data.source_epoch;
+        let source_epoch_2 = other.data.source_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);
 
@@ -134,14 +134,14 @@ mod tests {
 
     fn create_slashable_attestation(
         slot_factor: u64,
-        justified_epoch: u64,
+        source_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.data.source_epoch = Epoch::new(source_epoch);
         slashable_vote
     }
 }
diff --git a/eth2/types/src/test_utils/mod.rs b/eth2/types/src/test_utils/mod.rs
index 9d04d1ca7c..bc8da05489 100644
--- a/eth2/types/src/test_utils/mod.rs
+++ b/eth2/types/src/test_utils/mod.rs
@@ -4,10 +4,12 @@ mod generate_deterministic_keypairs;
 mod keypairs_file;
 mod test_random;
 mod testing_attestation_builder;
+mod testing_attestation_data_builder;
 mod testing_attester_slashing_builder;
 mod testing_beacon_block_builder;
 mod testing_beacon_state_builder;
 mod testing_deposit_builder;
+mod testing_pending_attestation_builder;
 mod testing_proposer_slashing_builder;
 mod testing_transfer_builder;
 mod testing_voluntary_exit_builder;
@@ -17,10 +19,12 @@ pub use keypairs_file::KeypairsFile;
 pub use rand::{prng::XorShiftRng, SeedableRng};
 pub use test_random::TestRandom;
 pub use testing_attestation_builder::TestingAttestationBuilder;
+pub use testing_attestation_data_builder::TestingAttestationDataBuilder;
 pub use testing_attester_slashing_builder::TestingAttesterSlashingBuilder;
 pub use testing_beacon_block_builder::TestingBeaconBlockBuilder;
 pub use testing_beacon_state_builder::{keypairs_path, TestingBeaconStateBuilder};
 pub use testing_deposit_builder::TestingDepositBuilder;
+pub use testing_pending_attestation_builder::TestingPendingAttestationBuilder;
 pub use testing_proposer_slashing_builder::TestingProposerSlashingBuilder;
 pub use testing_transfer_builder::TestingTransferBuilder;
 pub use testing_voluntary_exit_builder::TestingVoluntaryExitBuilder;
diff --git a/eth2/types/src/test_utils/testing_attestation_builder.rs b/eth2/types/src/test_utils/testing_attestation_builder.rs
index 8c86d756de..60624b48d7 100644
--- a/eth2/types/src/test_utils/testing_attestation_builder.rs
+++ b/eth2/types/src/test_utils/testing_attestation_builder.rs
@@ -1,3 +1,4 @@
+use crate::test_utils::TestingAttestationDataBuilder;
 use crate::*;
 use ssz::TreeHash;
 
@@ -18,31 +19,7 @@ impl TestingAttestationBuilder {
         shard: u64,
         spec: &ChainSpec,
     ) -> Self {
-        let current_epoch = state.current_epoch(spec);
-        let previous_epoch = state.previous_epoch(spec);
-
-        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();
+        let data_builder = TestingAttestationDataBuilder::new(state, shard, slot, spec);
 
         let mut aggregation_bitfield = Bitfield::new();
         let mut custody_bitfield = Bitfield::new();
@@ -54,16 +31,7 @@ impl TestingAttestationBuilder {
 
         let attestation = Attestation {
             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: state.latest_crosslinks[shard as usize].clone(),
-                justified_epoch,
-                justified_block_root,
-            },
+            data: data_builder.build(),
             custody_bitfield,
             aggregate_signature: AggregateSignature::new(),
         };
diff --git a/eth2/types/src/test_utils/testing_attestation_data_builder.rs b/eth2/types/src/test_utils/testing_attestation_data_builder.rs
new file mode 100644
index 0000000000..f31de2fbd1
--- /dev/null
+++ b/eth2/types/src/test_utils/testing_attestation_data_builder.rs
@@ -0,0 +1,66 @@
+use crate::*;
+
+/// Builds an `AttestationData` to be used for testing purposes.
+///
+/// This struct should **never be used for production purposes.**
+pub struct TestingAttestationDataBuilder {
+    data: AttestationData,
+}
+
+impl TestingAttestationDataBuilder {
+    /// Configures a new `AttestationData` which attests to all of the same parameters as the
+    /// state.
+    pub fn new(state: &BeaconState, shard: u64, slot: Slot, spec: &ChainSpec) -> Self {
+        let current_epoch = state.current_epoch(spec);
+        let previous_epoch = state.previous_epoch(spec);
+
+        let is_previous_epoch =
+            state.slot.epoch(spec.slots_per_epoch) != slot.epoch(spec.slots_per_epoch);
+
+        let source_epoch = if is_previous_epoch {
+            state.previous_justified_epoch
+        } else {
+            state.justified_epoch
+        };
+
+        let target_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 source_root = *state
+            .get_block_root(source_epoch.start_slot(spec.slots_per_epoch), spec)
+            .unwrap();
+
+        let data = AttestationData {
+            // LMD GHOST vote
+            slot,
+            beacon_block_root: *state.get_block_root(slot, spec).unwrap(),
+
+            // FFG Vote
+            source_epoch,
+            source_root,
+            target_root,
+
+            // Crosslink vote
+            shard,
+            previous_crosslink: Crosslink {
+                epoch: slot.epoch(spec.slots_per_epoch),
+                crosslink_data_root: spec.zero_hash,
+            },
+            crosslink_data_root: spec.zero_hash,
+        };
+
+        Self { data }
+    }
+
+    /// Returns the `AttestationData`, consuming the builder.
+    pub fn build(self) -> AttestationData {
+        self.data
+    }
+}
diff --git a/eth2/types/src/test_utils/testing_attester_slashing_builder.rs b/eth2/types/src/test_utils/testing_attester_slashing_builder.rs
index 92c7fe814a..fcaa3285be 100644
--- a/eth2/types/src/test_utils/testing_attester_slashing_builder.rs
+++ b/eth2/types/src/test_utils/testing_attester_slashing_builder.rs
@@ -23,45 +23,39 @@ impl TestingAttesterSlashingBuilder {
     {
         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 data_1 = AttestationData {
+            slot: double_voted_slot,
+            beacon_block_root: hash_1,
+            source_epoch: epoch,
+            source_root: hash_1,
+            target_root: hash_1,
+            shard,
+            previous_crosslink: Crosslink {
+                epoch,
+                crosslink_data_root: hash_1,
+            },
+            crosslink_data_root: hash_1,
+        };
+
+        let data_2 = AttestationData {
+            beacon_block_root: hash_2,
+            ..data_1.clone()
+        };
+
         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,
-            },
+            data: data_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,
-            },
+            data: data_2,
             custody_bitfield: Bitfield::new(),
             aggregate_signature: AggregateSignature::new(),
         };
diff --git a/eth2/types/src/test_utils/testing_beacon_state_builder.rs b/eth2/types/src/test_utils/testing_beacon_state_builder.rs
index d3033634a2..5b96dc455c 100644
--- a/eth2/types/src/test_utils/testing_beacon_state_builder.rs
+++ b/eth2/types/src/test_utils/testing_beacon_state_builder.rs
@@ -1,5 +1,6 @@
 use super::{generate_deterministic_keypairs, KeypairsFile};
 use crate::beacon_state::BeaconStateBuilder;
+use crate::test_utils::TestingPendingAttestationBuilder;
 use crate::*;
 use bls::get_withdrawal_credentials;
 use dirs;
@@ -227,76 +228,13 @@ impl TestingBeaconStateBuilder {
                 .clone();
 
             for (committee, shard) in committees {
-                state
-                    .latest_attestations
-                    .push(committee_to_pending_attestation(
-                        state, &committee, shard, slot, spec,
-                    ))
+                let mut builder = TestingPendingAttestationBuilder::new(state, shard, slot, spec);
+                // The entire committee should have signed the pending attestation.
+                let signers = vec![true; committee.len()];
+                builder.add_committee_participation(signers);
+
+                state.latest_attestations.push(builder.build())
             }
         }
     }
 }
-
-/// Maps a committee to a `PendingAttestation`.
-///
-/// The committee will be signed by all validators in the 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 + spec.min_attestation_inclusion_delay,
-    }
-}
diff --git a/eth2/types/src/test_utils/testing_pending_attestation_builder.rs b/eth2/types/src/test_utils/testing_pending_attestation_builder.rs
new file mode 100644
index 0000000000..655b3d1e83
--- /dev/null
+++ b/eth2/types/src/test_utils/testing_pending_attestation_builder.rs
@@ -0,0 +1,55 @@
+use crate::test_utils::TestingAttestationDataBuilder;
+use crate::*;
+
+/// Builds an `AttesterSlashing` to be used for testing purposes.
+///
+/// This struct should **never be used for production purposes.**
+pub struct TestingPendingAttestationBuilder {
+    pending_attestation: PendingAttestation,
+}
+
+impl TestingPendingAttestationBuilder {
+    /// Create a new valid* `PendingAttestation` for the given parameters.
+    ///
+    /// The `inclusion_slot` will be set to be the earliest possible slot the `Attestation` could
+    /// have been included (`slot + MIN_ATTESTATION_INCLUSION_DELAY`).
+    ///
+    /// * The aggregation and custody bitfields will all be empty, they need to be set with
+    /// `Self::add_committee_participation`.
+    pub fn new(state: &BeaconState, shard: u64, slot: Slot, spec: &ChainSpec) -> Self {
+        let data_builder = TestingAttestationDataBuilder::new(state, shard, slot, spec);
+
+        let pending_attestation = PendingAttestation {
+            aggregation_bitfield: Bitfield::new(),
+            data: data_builder.build(),
+            custody_bitfield: Bitfield::new(),
+            inclusion_slot: slot + spec.min_attestation_inclusion_delay,
+        };
+
+        Self {
+            pending_attestation,
+        }
+    }
+
+    /// Sets the committee participation in the `PendingAttestation`.
+    ///
+    /// The `PendingAttestation` will appear to be signed by each committee member who's value in
+    /// `signers` is true.
+    pub fn add_committee_participation(&mut self, signers: Vec<bool>) {
+        let mut aggregation_bitfield = Bitfield::new();
+        let mut custody_bitfield = Bitfield::new();
+
+        for (i, signed) in signers.iter().enumerate() {
+            aggregation_bitfield.set(i, *signed);
+            custody_bitfield.set(i, false); // Fixed to `false` for phase 0.
+        }
+
+        self.pending_attestation.aggregation_bitfield = aggregation_bitfield;
+        self.pending_attestation.custody_bitfield = custody_bitfield;
+    }
+
+    /// Returns the `PendingAttestation`, consuming the builder.
+    pub fn build(self) -> PendingAttestation {
+        self.pending_attestation
+    }
+}

From 2295322e3c3d1921b205fab3cf13ec5bde5ad85e Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Fri, 15 Mar 2019 15:33:14 +1100
Subject: [PATCH 12/60] Update DepositInput to spec v0.5.0

Also modifies the API for creating a proof of possession and adds a test
---
 eth2/types/src/deposit_data.rs                |  2 +-
 eth2/types/src/deposit_input.rs               | 43 +++++++++++++------
 .../src/test_utils/testing_deposit_builder.rs |  9 ++--
 3 files changed, 37 insertions(+), 17 deletions(-)

diff --git a/eth2/types/src/deposit_data.rs b/eth2/types/src/deposit_data.rs
index 9d6c1bda73..a1e30032fb 100644
--- a/eth2/types/src/deposit_data.rs
+++ b/eth2/types/src/deposit_data.rs
@@ -7,7 +7,7 @@ use test_random_derive::TestRandom;
 
 /// Data generated by the deposit contract.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom)]
 pub struct DepositData {
     pub amount: u64,
diff --git a/eth2/types/src/deposit_input.rs b/eth2/types/src/deposit_input.rs
index 9a90319017..9da53a042d 100644
--- a/eth2/types/src/deposit_input.rs
+++ b/eth2/types/src/deposit_input.rs
@@ -9,7 +9,7 @@ use test_random_derive::TestRandom;
 
 /// The data supplied by the user to the deposit contract.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 #[derive(
     Debug,
     PartialEq,
@@ -31,25 +31,23 @@ pub struct DepositInput {
 impl DepositInput {
     /// Generate the 'proof_of_posession' signature for a given DepositInput details.
     ///
-    /// Spec v0.4.0
+    /// Spec v0.5.0
     pub fn create_proof_of_possession(
-        keypair: &Keypair,
-        withdrawal_credentials: &Hash256,
-        domain: u64,
+        &self,
+        secret_key: &SecretKey,
+        epoch: Epoch,
+        fork: &Fork,
+        spec: &ChainSpec,
     ) -> Signature {
-        let signable_deposit_input = DepositInput {
-            pubkey: keypair.pk.clone(),
-            withdrawal_credentials: withdrawal_credentials.clone(),
-            proof_of_possession: Signature::empty_signature(),
-        };
-        let msg = signable_deposit_input.signed_root();
+        let msg = self.signed_root();
+        let domain = spec.get_domain(epoch, Domain::Deposit, fork);
 
-        Signature::new(msg.as_slice(), domain, &keypair.sk)
+        Signature::new(msg.as_slice(), domain, secret_key)
     }
 
     /// Verify that proof-of-possession is valid.
     ///
-    /// Spec v0.4.0
+    /// Spec v0.5.0
     pub fn validate_proof_of_possession(
         &self,
         epoch: Epoch,
@@ -68,4 +66,23 @@ mod tests {
     use super::*;
 
     ssz_tests!(DepositInput);
+
+    #[test]
+    fn can_create_and_validate() {
+        let spec = ChainSpec::foundation();
+        let fork = Fork::genesis(&spec);
+        let keypair = Keypair::random();
+        let epoch = Epoch::new(0);
+
+        let mut deposit_input = DepositInput {
+            pubkey: keypair.pk.clone(),
+            withdrawal_credentials: Hash256::zero(),
+            proof_of_possession: Signature::empty_signature(),
+        };
+
+        deposit_input.proof_of_possession =
+            deposit_input.create_proof_of_possession(&keypair.sk, epoch, &fork, &spec);
+
+        assert!(deposit_input.validate_proof_of_possession(epoch, &fork, &spec));
+    }
 }
diff --git a/eth2/types/src/test_utils/testing_deposit_builder.rs b/eth2/types/src/test_utils/testing_deposit_builder.rs
index 7293114688..90c8d325d2 100644
--- a/eth2/types/src/test_utils/testing_deposit_builder.rs
+++ b/eth2/types/src/test_utils/testing_deposit_builder.rs
@@ -46,15 +46,18 @@ impl TestingDepositBuilder {
         );
 
         let epoch = state.current_epoch(spec);
-        let domain = spec.get_domain(epoch, Domain::Deposit, &state.fork);
 
         self.deposit.deposit_data.deposit_input.pubkey = keypair.pk.clone();
         self.deposit
             .deposit_data
             .deposit_input
             .withdrawal_credentials = withdrawal_credentials.clone();
-        self.deposit.deposit_data.deposit_input.proof_of_possession =
-            DepositInput::create_proof_of_possession(&keypair, &withdrawal_credentials, domain);
+
+        self.deposit.deposit_data.deposit_input.proof_of_possession = self
+            .deposit
+            .deposit_data
+            .deposit_input
+            .create_proof_of_possession(&keypair.sk, epoch, &state.fork, spec);
     }
 
     /// Builds the deposit, consuming the builder.

From d84850b892ba2bc5ffaafb4d9b6f267e64ad88c5 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Fri, 15 Mar 2019 15:40:28 +1100
Subject: [PATCH 13/60] Add `BeaconBlockHeader` type.

---
 eth2/types/src/beacon_block_header.rs | 38 +++++++++++++++++++++++++++
 eth2/types/src/lib.rs                 |  2 ++
 2 files changed, 40 insertions(+)
 create mode 100644 eth2/types/src/beacon_block_header.rs

diff --git a/eth2/types/src/beacon_block_header.rs b/eth2/types/src/beacon_block_header.rs
new file mode 100644
index 0000000000..029c7e56b2
--- /dev/null
+++ b/eth2/types/src/beacon_block_header.rs
@@ -0,0 +1,38 @@
+use crate::test_utils::TestRandom;
+use crate::*;
+use bls::Signature;
+use rand::RngCore;
+use serde_derive::{Deserialize, Serialize};
+use ssz::TreeHash;
+use ssz_derive::{Decode, Encode, SignedRoot, TreeHash};
+use test_random_derive::TestRandom;
+
+/// A header of a `BeaconBlock`.
+///
+/// Spec v0.5.0
+#[derive(
+    Debug,
+    PartialEq,
+    Clone,
+    Serialize,
+    Deserialize,
+    Encode,
+    Decode,
+    TreeHash,
+    TestRandom,
+    SignedRoot,
+)]
+pub struct BeaconBlockHeader {
+    pub slot: Slot,
+    pub previous_block_root: Hash256,
+    pub state_root: Hash256,
+    pub block_body_root: Hash256,
+    pub signature: Signature,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    ssz_tests!(BeaconBlockHeader);
+}
diff --git a/eth2/types/src/lib.rs b/eth2/types/src/lib.rs
index 7b1d848377..2fcb3237d5 100644
--- a/eth2/types/src/lib.rs
+++ b/eth2/types/src/lib.rs
@@ -9,6 +9,7 @@ pub mod attestation_data_and_custody_bit;
 pub mod attester_slashing;
 pub mod beacon_block;
 pub mod beacon_block_body;
+pub mod beacon_block_header;
 pub mod beacon_state;
 pub mod chain_spec;
 pub mod crosslink;
@@ -43,6 +44,7 @@ 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_block_header::BeaconBlockHeader;
 pub use crate::beacon_state::{BeaconState, Error as BeaconStateError, RelativeEpoch};
 pub use crate::chain_spec::{ChainSpec, Domain};
 pub use crate::crosslink::Crosslink;

From 4ffdfbc9938f3fa253a4d6bf944e2e24e82d7ef0 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Fri, 15 Mar 2019 15:48:33 +1100
Subject: [PATCH 14/60] Update `Validator` to 0.5.0, add tests

---
 eth2/types/src/validator.rs | 69 +++++++++++++++++++++++++++----------
 1 file changed, 50 insertions(+), 19 deletions(-)

diff --git a/eth2/types/src/validator.rs b/eth2/types/src/validator.rs
index 6d1936bfd3..f572611757 100644
--- a/eth2/types/src/validator.rs
+++ b/eth2/types/src/validator.rs
@@ -6,7 +6,7 @@ use test_random_derive::TestRandom;
 
 /// Information about a `BeaconChain` validator.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Encode, Decode, TestRandom, TreeHash)]
 pub struct Validator {
     pub pubkey: PublicKey,
@@ -53,29 +53,60 @@ impl Default for Validator {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
 
     #[test]
-    fn test_validator_can_be_active() {
-        let mut rng = XorShiftRng::from_seed([42; 16]);
-        let mut validator = Validator::random_for_test(&mut rng);
+    fn default() {
+        let v = Validator::default();
 
-        let activation_epoch = u64::random_for_test(&mut rng);
-        let exit_epoch = activation_epoch + 234;
+        let epoch = Epoch::new(0);
 
-        validator.activation_epoch = Epoch::from(activation_epoch);
-        validator.exit_epoch = Epoch::from(exit_epoch);
+        assert_eq!(v.is_active_at(epoch), false);
+        assert_eq!(v.is_exited_at(epoch), false);
+        assert_eq!(v.is_withdrawable_at(epoch), false);
+        assert_eq!(v.initiated_exit, false);
+        assert_eq!(v.slashed, false);
+    }
 
-        for slot in (activation_epoch - 100)..(exit_epoch + 100) {
-            let slot = Epoch::from(slot);
-            if slot < activation_epoch {
-                assert!(!validator.is_active_at(slot));
-            } else if slot >= exit_epoch {
-                assert!(!validator.is_active_at(slot));
-            } else {
-                assert!(validator.is_active_at(slot));
-            }
-        }
+    #[test]
+    fn is_active_at() {
+        let epoch = Epoch::new(10);
+
+        let v = Validator {
+            activation_epoch: epoch,
+            ..Validator::default()
+        };
+
+        assert_eq!(v.is_active_at(epoch - 1), false);
+        assert_eq!(v.is_active_at(epoch), true);
+        assert_eq!(v.is_active_at(epoch + 1), true);
+    }
+
+    #[test]
+    fn is_exited_at() {
+        let epoch = Epoch::new(10);
+
+        let v = Validator {
+            exit_epoch: epoch,
+            ..Validator::default()
+        };
+
+        assert_eq!(v.is_exited_at(epoch - 1), false);
+        assert_eq!(v.is_exited_at(epoch), true);
+        assert_eq!(v.is_exited_at(epoch + 1), true);
+    }
+
+    #[test]
+    fn is_withdrawable_at() {
+        let epoch = Epoch::new(10);
+
+        let v = Validator {
+            withdrawable_epoch: epoch,
+            ..Validator::default()
+        };
+
+        assert_eq!(v.is_withdrawable_at(epoch - 1), false);
+        assert_eq!(v.is_withdrawable_at(epoch), true);
+        assert_eq!(v.is_withdrawable_at(epoch + 1), true);
     }
 
     ssz_tests!(Validator);

From 142aaae8ce6cedaefdd57a670568bae22e712369 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Fri, 15 Mar 2019 15:51:57 +1100
Subject: [PATCH 15/60] Fast-forward PendingAttestation to v0.5.0

---
 eth2/types/src/pending_attestation.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/eth2/types/src/pending_attestation.rs b/eth2/types/src/pending_attestation.rs
index 70907c29df..ca50b6d1c4 100644
--- a/eth2/types/src/pending_attestation.rs
+++ b/eth2/types/src/pending_attestation.rs
@@ -7,7 +7,7 @@ use test_random_derive::TestRandom;
 
 /// An attestation that has been included in the state but not yet fully processed.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom)]
 pub struct PendingAttestation {
     pub aggregation_bitfield: Bitfield,

From 15c3e5eab586feccd1082664395cd6227c6c8af2 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Fri, 15 Mar 2019 15:52:17 +1100
Subject: [PATCH 16/60] Add HistoricalBatch type

---
 eth2/types/src/historical_batch.rs | 22 ++++++++++++++++++++++
 eth2/types/src/lib.rs              |  2 ++
 2 files changed, 24 insertions(+)
 create mode 100644 eth2/types/src/historical_batch.rs

diff --git a/eth2/types/src/historical_batch.rs b/eth2/types/src/historical_batch.rs
new file mode 100644
index 0000000000..77859ed1ae
--- /dev/null
+++ b/eth2/types/src/historical_batch.rs
@@ -0,0 +1,22 @@
+use crate::test_utils::TestRandom;
+use crate::Hash256;
+use rand::RngCore;
+use serde_derive::{Deserialize, Serialize};
+use ssz_derive::{Decode, Encode, TreeHash};
+use test_random_derive::TestRandom;
+
+/// Historical block and state roots.
+///
+/// Spec v0.5.0
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom)]
+pub struct HistoricalBatch {
+    pub block_roots: Vec<Hash256>,
+    pub state_roots: Vec<Hash256>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    ssz_tests!(HistoricalBatch);
+}
diff --git a/eth2/types/src/lib.rs b/eth2/types/src/lib.rs
index 2fcb3237d5..4f50e0ea5c 100644
--- a/eth2/types/src/lib.rs
+++ b/eth2/types/src/lib.rs
@@ -20,6 +20,7 @@ pub mod eth1_data;
 pub mod eth1_data_vote;
 pub mod fork;
 pub mod free_attestation;
+pub mod historical_batch;
 pub mod pending_attestation;
 pub mod proposal;
 pub mod proposer_slashing;
@@ -55,6 +56,7 @@ pub use crate::eth1_data::Eth1Data;
 pub use crate::eth1_data_vote::Eth1DataVote;
 pub use crate::fork::Fork;
 pub use crate::free_attestation::FreeAttestation;
+pub use crate::historical_batch::HistoricalBatch;
 pub use crate::pending_attestation::PendingAttestation;
 pub use crate::proposal::Proposal;
 pub use crate::proposer_slashing::ProposerSlashing;

From dc2755c4ea1c7d96dacf0b361ef5685cae59dd89 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Fri, 15 Mar 2019 15:59:04 +1100
Subject: [PATCH 17/60] Update ProposerSlashing to v0.5.0

---
 eth2/types/src/deposit_input.rs                |  2 +-
 eth2/types/src/proposer_slashing.rs            |  8 ++++----
 .../testing_proposer_slashing_builder.rs       | 18 +++++++++---------
 3 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/eth2/types/src/deposit_input.rs b/eth2/types/src/deposit_input.rs
index 9da53a042d..3f8a6177a8 100644
--- a/eth2/types/src/deposit_input.rs
+++ b/eth2/types/src/deposit_input.rs
@@ -1,6 +1,6 @@
 use crate::test_utils::TestRandom;
 use crate::*;
-use bls::{Keypair, PublicKey, Signature};
+use bls::{PublicKey, Signature};
 use rand::RngCore;
 use serde_derive::{Deserialize, Serialize};
 use ssz::{SignedRoot, TreeHash};
diff --git a/eth2/types/src/proposer_slashing.rs b/eth2/types/src/proposer_slashing.rs
index bc5b8665ef..881f0e4059 100644
--- a/eth2/types/src/proposer_slashing.rs
+++ b/eth2/types/src/proposer_slashing.rs
@@ -1,4 +1,4 @@
-use super::Proposal;
+use super::BeaconBlockHeader;
 use crate::test_utils::TestRandom;
 use rand::RngCore;
 use serde_derive::{Deserialize, Serialize};
@@ -7,12 +7,12 @@ use test_random_derive::TestRandom;
 
 /// Two conflicting proposals from the same proposer (validator).
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom)]
 pub struct ProposerSlashing {
     pub proposer_index: u64,
-    pub proposal_1: Proposal,
-    pub proposal_2: Proposal,
+    pub proposal_1: BeaconBlockHeader,
+    pub proposal_2: BeaconBlockHeader,
 }
 
 #[cfg(test)]
diff --git a/eth2/types/src/test_utils/testing_proposer_slashing_builder.rs b/eth2/types/src/test_utils/testing_proposer_slashing_builder.rs
index 7f16b679f7..fc38c185de 100644
--- a/eth2/types/src/test_utils/testing_proposer_slashing_builder.rs
+++ b/eth2/types/src/test_utils/testing_proposer_slashing_builder.rs
@@ -22,20 +22,20 @@ impl TestingProposerSlashingBuilder {
         F: Fn(u64, &[u8], Epoch, Domain) -> Signature,
     {
         let slot = Slot::new(0);
-        let shard = 0;
+        let hash_1 = Hash256::from([1; 32]);
+        let hash_2 = Hash256::from([2; 32]);
 
-        let mut proposal_1 = Proposal {
+        let mut proposal_1 = BeaconBlockHeader {
             slot,
-            shard,
-            block_root: Hash256::from_low_u64_le(1),
+            previous_block_root: hash_1,
+            state_root: hash_1,
+            block_body_root: hash_1,
             signature: Signature::empty_signature(),
         };
 
-        let mut proposal_2 = Proposal {
-            slot,
-            shard,
-            block_root: Hash256::from_low_u64_le(2),
-            signature: Signature::empty_signature(),
+        let mut proposal_2 = BeaconBlockHeader {
+            previous_block_root: hash_2,
+            ..proposal_1.clone()
         };
 
         proposal_1.signature = {

From 77db79900e5911fcd2027bbe9e87aae4555194af Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Fri, 15 Mar 2019 16:02:23 +1100
Subject: [PATCH 18/60] Fast-forward some unchanged types to v0.5.0

---
 eth2/types/src/attestation.rs       | 2 +-
 eth2/types/src/attester_slashing.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/eth2/types/src/attestation.rs b/eth2/types/src/attestation.rs
index 4b3c2e89cc..0b660466e1 100644
--- a/eth2/types/src/attestation.rs
+++ b/eth2/types/src/attestation.rs
@@ -8,7 +8,7 @@ use test_random_derive::TestRandom;
 
 /// Details an attestation that can be slashable.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 #[derive(
     Debug,
     Clone,
diff --git a/eth2/types/src/attester_slashing.rs b/eth2/types/src/attester_slashing.rs
index 195c0fdccd..6fc404f422 100644
--- a/eth2/types/src/attester_slashing.rs
+++ b/eth2/types/src/attester_slashing.rs
@@ -6,7 +6,7 @@ use test_random_derive::TestRandom;
 
 /// Two conflicting attestations.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom)]
 pub struct AttesterSlashing {
     pub slashable_attestation_1: SlashableAttestation,

From db26b8fde732167839ed53ed84a0545fbbbe1fc7 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Fri, 15 Mar 2019 16:02:47 +1100
Subject: [PATCH 19/60] Update Deposit to v0.5.0

---
 eth2/types/src/deposit.rs                            | 4 ++--
 eth2/types/src/test_utils/testing_deposit_builder.rs | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/eth2/types/src/deposit.rs b/eth2/types/src/deposit.rs
index 14eb19ad69..ff8d83d77d 100644
--- a/eth2/types/src/deposit.rs
+++ b/eth2/types/src/deposit.rs
@@ -7,10 +7,10 @@ use test_random_derive::TestRandom;
 
 /// A deposit to potentially become a beacon chain validator.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom)]
 pub struct Deposit {
-    pub branch: Vec<Hash256>,
+    pub proof: Vec<Hash256>,
     pub index: u64,
     pub deposit_data: DepositData,
 }
diff --git a/eth2/types/src/test_utils/testing_deposit_builder.rs b/eth2/types/src/test_utils/testing_deposit_builder.rs
index 90c8d325d2..0d1c962f0c 100644
--- a/eth2/types/src/test_utils/testing_deposit_builder.rs
+++ b/eth2/types/src/test_utils/testing_deposit_builder.rs
@@ -14,7 +14,7 @@ impl TestingDepositBuilder {
         let keypair = Keypair::random();
 
         let deposit = Deposit {
-            branch: vec![],
+            proof: vec![],
             index: 0,
             deposit_data: DepositData {
                 amount,

From a1ee1a45237bb769c3bf0abb7636f8c6038c05b2 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Fri, 15 Mar 2019 16:05:53 +1100
Subject: [PATCH 20/60] Update Transfer to v0.5.0

---
 eth2/types/src/test_utils/testing_transfer_builder.rs | 6 +++---
 eth2/types/src/transfer.rs                            | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/eth2/types/src/test_utils/testing_transfer_builder.rs b/eth2/types/src/test_utils/testing_transfer_builder.rs
index c4256ebea2..354e29aa56 100644
--- a/eth2/types/src/test_utils/testing_transfer_builder.rs
+++ b/eth2/types/src/test_utils/testing_transfer_builder.rs
@@ -10,12 +10,12 @@ pub struct TestingTransferBuilder {
 
 impl TestingTransferBuilder {
     /// Instantiates a new builder.
-    pub fn new(from: u64, to: u64, amount: u64, slot: Slot) -> Self {
+    pub fn new(sender: u64, recipient: u64, amount: u64, slot: Slot) -> Self {
         let keypair = Keypair::random();
 
         let transfer = Transfer {
-            from,
-            to,
+            sender,
+            recipient,
             amount,
             fee: 0,
             slot,
diff --git a/eth2/types/src/transfer.rs b/eth2/types/src/transfer.rs
index a46e24e241..1c99687029 100644
--- a/eth2/types/src/transfer.rs
+++ b/eth2/types/src/transfer.rs
@@ -23,8 +23,8 @@ use test_random_derive::TestRandom;
     SignedRoot,
 )]
 pub struct Transfer {
-    pub from: u64,
-    pub to: u64,
+    pub sender: u64,
+    pub recipient: u64,
     pub amount: u64,
     pub fee: u64,
     pub slot: Slot,

From a51de99d4093704a8013326f0e959f44632b26d3 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Fri, 15 Mar 2019 16:06:02 +1100
Subject: [PATCH 21/60] Fast-forward unchanged exit to v0.5.0

---
 eth2/types/src/voluntary_exit.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/eth2/types/src/voluntary_exit.rs b/eth2/types/src/voluntary_exit.rs
index 5fdfcdd82f..f64f950cbf 100644
--- a/eth2/types/src/voluntary_exit.rs
+++ b/eth2/types/src/voluntary_exit.rs
@@ -8,7 +8,7 @@ use test_random_derive::TestRandom;
 
 /// An exit voluntarily submitted a validator who wishes to withdraw.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 #[derive(
     Debug,
     PartialEq,

From 563304c8d7e9b33dd3bd1d2d92baa5ab2a2a76f9 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Fri, 15 Mar 2019 16:30:05 +1100
Subject: [PATCH 22/60] Update "block" family types to 0.5.0

- Removes Proposal
- Removes "readers" as they aren't actually being used anywhere.
---
 eth2/types/src/beacon_block.rs                | 40 ++++-------
 eth2/types/src/beacon_block_body.rs           | 10 +--
 eth2/types/src/lib.rs                         |  3 -
 eth2/types/src/proposal.rs                    | 67 -------------------
 eth2/types/src/readers/block_reader.rs        | 35 ----------
 eth2/types/src/readers/mod.rs                 |  5 --
 eth2/types/src/readers/state_reader.rs        | 25 -------
 .../testing_beacon_block_builder.rs           |  5 +-
 8 files changed, 20 insertions(+), 170 deletions(-)
 delete mode 100644 eth2/types/src/proposal.rs
 delete mode 100644 eth2/types/src/readers/block_reader.rs
 delete mode 100644 eth2/types/src/readers/mod.rs
 delete mode 100644 eth2/types/src/readers/state_reader.rs

diff --git a/eth2/types/src/beacon_block.rs b/eth2/types/src/beacon_block.rs
index 56f77c8d25..7fa3f5e117 100644
--- a/eth2/types/src/beacon_block.rs
+++ b/eth2/types/src/beacon_block.rs
@@ -1,15 +1,15 @@
 use crate::test_utils::TestRandom;
-use crate::{BeaconBlockBody, ChainSpec, Eth1Data, Hash256, Proposal, Slot};
+use crate::{BeaconBlockBody, ChainSpec, Eth1Data, Hash256, Slot};
 use bls::Signature;
 use rand::RngCore;
 use serde_derive::{Deserialize, Serialize};
-use ssz::{SignedRoot, TreeHash};
+use ssz::TreeHash;
 use ssz_derive::{Decode, Encode, SignedRoot, TreeHash};
 use test_random_derive::TestRandom;
 
 /// A block of the `BeaconChain`.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 #[derive(
     Debug,
     PartialEq,
@@ -24,29 +24,27 @@ use test_random_derive::TestRandom;
 )]
 pub struct BeaconBlock {
     pub slot: Slot,
-    pub parent_root: Hash256,
+    pub previous_block_root: Hash256,
     pub state_root: Hash256,
-    pub randao_reveal: Signature,
-    pub eth1_data: Eth1Data,
     pub body: BeaconBlockBody,
     pub signature: Signature,
 }
 
 impl BeaconBlock {
-    /// Produce the first block of the Beacon Chain.
+    /// The first block of the Beacon Chain.
     ///
-    /// Spec v0.4.0
+    /// Spec v0.5.0
     pub fn genesis(state_root: Hash256, spec: &ChainSpec) -> BeaconBlock {
         BeaconBlock {
             slot: spec.genesis_slot,
-            parent_root: spec.zero_hash,
+            previous_block_root: spec.zero_hash,
             state_root,
-            randao_reveal: spec.empty_signature.clone(),
-            eth1_data: Eth1Data {
-                deposit_root: spec.zero_hash,
-                block_hash: spec.zero_hash,
-            },
             body: BeaconBlockBody {
+                randao_reveal: spec.empty_signature.clone(),
+                eth1_data: Eth1Data {
+                    deposit_root: spec.zero_hash,
+                    block_hash: spec.zero_hash,
+                },
                 proposer_slashings: vec![],
                 attester_slashings: vec![],
                 attestations: vec![],
@@ -60,22 +58,10 @@ impl BeaconBlock {
 
     /// Returns the `hash_tree_root` of the block.
     ///
-    /// Spec v0.4.0
+    /// Spec v0.5.0
     pub fn canonical_root(&self) -> Hash256 {
         Hash256::from_slice(&self.hash_tree_root()[..])
     }
-
-    /// Returns an unsigned proposal for block.
-    ///
-    /// Spec v0.4.0
-    pub fn proposal(&self, spec: &ChainSpec) -> Proposal {
-        Proposal {
-            slot: self.slot,
-            shard: spec.beacon_chain_shard_number,
-            block_root: Hash256::from_slice(&self.signed_root()),
-            signature: spec.empty_signature.clone(),
-        }
-    }
 }
 
 #[cfg(test)]
diff --git a/eth2/types/src/beacon_block_body.rs b/eth2/types/src/beacon_block_body.rs
index ce8020fec0..677e24cec3 100644
--- a/eth2/types/src/beacon_block_body.rs
+++ b/eth2/types/src/beacon_block_body.rs
@@ -1,5 +1,5 @@
-use super::{Attestation, AttesterSlashing, Deposit, ProposerSlashing, Transfer, VoluntaryExit};
 use crate::test_utils::TestRandom;
+use crate::*;
 use rand::RngCore;
 use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode, TreeHash};
@@ -7,11 +7,11 @@ use test_random_derive::TestRandom;
 
 /// The body of a `BeaconChain` block, containing operations.
 ///
-/// Spec v0.4.0
-#[derive(
-    Debug, PartialEq, Clone, Default, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom,
-)]
+/// Spec v0.5.0
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom)]
 pub struct BeaconBlockBody {
+    pub randao_reveal: Signature,
+    pub eth1_data: Eth1Data,
     pub proposer_slashings: Vec<ProposerSlashing>,
     pub attester_slashings: Vec<AttesterSlashing>,
     pub attestations: Vec<Attestation>,
diff --git a/eth2/types/src/lib.rs b/eth2/types/src/lib.rs
index 4f50e0ea5c..a1a58198b1 100644
--- a/eth2/types/src/lib.rs
+++ b/eth2/types/src/lib.rs
@@ -22,9 +22,7 @@ pub mod fork;
 pub mod free_attestation;
 pub mod historical_batch;
 pub mod pending_attestation;
-pub mod proposal;
 pub mod proposer_slashing;
-pub mod readers;
 pub mod shard_reassignment_record;
 pub mod slashable_attestation;
 pub mod transfer;
@@ -58,7 +56,6 @@ pub use crate::fork::Fork;
 pub use crate::free_attestation::FreeAttestation;
 pub use crate::historical_batch::HistoricalBatch;
 pub use crate::pending_attestation::PendingAttestation;
-pub use crate::proposal::Proposal;
 pub use crate::proposer_slashing::ProposerSlashing;
 pub use crate::slashable_attestation::SlashableAttestation;
 pub use crate::slot_epoch::{Epoch, Slot};
diff --git a/eth2/types/src/proposal.rs b/eth2/types/src/proposal.rs
deleted file mode 100644
index 36fba5603e..0000000000
--- a/eth2/types/src/proposal.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-use crate::test_utils::TestRandom;
-use crate::{Hash256, Slot};
-use bls::Signature;
-use rand::RngCore;
-use serde_derive::{Deserialize, 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,
-    Deserialize,
-    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::{SignedRoot, TreeHash};
-
-    #[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());
-    }
-
-    ssz_tests!(Proposal);
-}
diff --git a/eth2/types/src/readers/block_reader.rs b/eth2/types/src/readers/block_reader.rs
deleted file mode 100644
index 93157a1a3c..0000000000
--- a/eth2/types/src/readers/block_reader.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-use crate::{BeaconBlock, Hash256, Slot};
-use std::fmt::Debug;
-
-/// The `BeaconBlockReader` provides interfaces for reading a subset of fields of a `BeaconBlock`.
-///
-/// The purpose of this trait is to allow reading from either;
-///  - a standard `BeaconBlock` struct, or
-///  - a SSZ serialized byte array.
-///
-/// Note: presently, direct SSZ reading has not been implemented so this trait is being used for
-/// "future proofing".
-pub trait BeaconBlockReader: Debug + PartialEq {
-    fn slot(&self) -> Slot;
-    fn parent_root(&self) -> Hash256;
-    fn state_root(&self) -> Hash256;
-    fn into_beacon_block(self) -> Option<BeaconBlock>;
-}
-
-impl BeaconBlockReader for BeaconBlock {
-    fn slot(&self) -> Slot {
-        self.slot
-    }
-
-    fn parent_root(&self) -> Hash256 {
-        self.parent_root
-    }
-
-    fn state_root(&self) -> Hash256 {
-        self.state_root
-    }
-
-    fn into_beacon_block(self) -> Option<BeaconBlock> {
-        Some(self)
-    }
-}
diff --git a/eth2/types/src/readers/mod.rs b/eth2/types/src/readers/mod.rs
deleted file mode 100644
index 4ccb14a8cd..0000000000
--- a/eth2/types/src/readers/mod.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-mod block_reader;
-mod state_reader;
-
-pub use self::block_reader::BeaconBlockReader;
-pub use self::state_reader::BeaconStateReader;
diff --git a/eth2/types/src/readers/state_reader.rs b/eth2/types/src/readers/state_reader.rs
deleted file mode 100644
index e469bee57f..0000000000
--- a/eth2/types/src/readers/state_reader.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-use crate::{BeaconState, Slot};
-use std::fmt::Debug;
-
-/// The `BeaconStateReader` provides interfaces for reading a subset of fields of a `BeaconState`.
-///
-/// The purpose of this trait is to allow reading from either;
-///  - a standard `BeaconState` struct, or
-///  - a SSZ serialized byte array.
-///
-/// Note: presently, direct SSZ reading has not been implemented so this trait is being used for
-/// "future proofing".
-pub trait BeaconStateReader: Debug + PartialEq {
-    fn slot(&self) -> Slot;
-    fn into_beacon_state(self) -> Option<BeaconState>;
-}
-
-impl BeaconStateReader for BeaconState {
-    fn slot(&self) -> Slot {
-        self.slot
-    }
-
-    fn into_beacon_state(self) -> Option<BeaconState> {
-        Some(self)
-    }
-}
diff --git a/eth2/types/src/test_utils/testing_beacon_block_builder.rs b/eth2/types/src/test_utils/testing_beacon_block_builder.rs
index 58633b5cee..e0e4677d48 100644
--- a/eth2/types/src/test_utils/testing_beacon_block_builder.rs
+++ b/eth2/types/src/test_utils/testing_beacon_block_builder.rs
@@ -32,8 +32,7 @@ impl TestingBeaconBlockBuilder {
     ///
     /// Modifying the block after signing may invalidate the signature.
     pub fn sign(&mut self, sk: &SecretKey, fork: &Fork, spec: &ChainSpec) {
-        let proposal = self.block.proposal(spec);
-        let message = proposal.signed_root();
+        let message = self.block.signed_root();
         let epoch = self.block.slot.epoch(spec.slots_per_epoch);
         let domain = spec.get_domain(epoch, Domain::Proposal, fork);
         self.block.signature = Signature::new(&message, domain, sk);
@@ -46,7 +45,7 @@ impl TestingBeaconBlockBuilder {
         let epoch = self.block.slot.epoch(spec.slots_per_epoch);
         let message = epoch.hash_tree_root();
         let domain = spec.get_domain(epoch, Domain::Randao, fork);
-        self.block.randao_reveal = Signature::new(&message, domain, sk);
+        self.block.body.randao_reveal = Signature::new(&message, domain, sk);
     }
 
     /// Inserts a signed, valid `ProposerSlashing` for the validator.

From dffc26a466c10c9f1397f6ab6e226f519a1eea5e Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Fri, 15 Mar 2019 18:33:32 +1100
Subject: [PATCH 23/60] Add field idents support to ssz_derive.

- Adds idents to skip ser, deser and tree hashing
---
 eth2/utils/ssz_derive/src/lib.rs | 123 +++++++++++++++++++++++++++----
 1 file changed, 110 insertions(+), 13 deletions(-)

diff --git a/eth2/utils/ssz_derive/src/lib.rs b/eth2/utils/ssz_derive/src/lib.rs
index a7802a274f..9ba1de4160 100644
--- a/eth2/utils/ssz_derive/src/lib.rs
+++ b/eth2/utils/ssz_derive/src/lib.rs
@@ -56,10 +56,46 @@ fn get_named_field_idents<'a>(struct_data: &'a syn::DataStruct) -> Vec<&'a syn::
         .collect()
 }
 
+/// Returns a Vec of `syn::Ident` for each named field in the struct, whilst filtering out fields
+/// that should not be serialized.
+///
+/// # Panics
+/// Any unnamed struct field (like in a tuple struct) will raise a panic at compile time.
+fn get_serializable_named_field_idents<'a>(
+    struct_data: &'a syn::DataStruct,
+) -> Vec<&'a syn::Ident> {
+    struct_data
+        .fields
+        .iter()
+        .filter_map(|f| {
+            if should_skip_serializing(&f) {
+                None
+            } else {
+                Some(match &f.ident {
+                    Some(ref ident) => ident,
+                    _ => panic!("ssz_derive only supports named struct fields."),
+                })
+            }
+        })
+        .collect()
+}
+
+/// Returns true if some field has an attribute declaring it should not be serialized.
+///
+/// The field attribute is: `#[ssz(skip_serializing)]`
+fn should_skip_serializing(field: &syn::Field) -> bool {
+    for attr in &field.attrs {
+        if attr.tts.to_string() == "( skip_serializing )" {
+            return true;
+        }
+    }
+    false
+}
+
 /// Implements `ssz::Encodable` for some `struct`.
 ///
 /// Fields are encoded in the order they are defined.
-#[proc_macro_derive(Encode)]
+#[proc_macro_derive(Encode, attributes(ssz))]
 pub fn ssz_encode_derive(input: TokenStream) -> TokenStream {
     let item = parse_macro_input!(input as DeriveInput);
 
@@ -70,7 +106,7 @@ pub fn ssz_encode_derive(input: TokenStream) -> TokenStream {
         _ => panic!("ssz_derive only supports structs."),
     };
 
-    let field_idents = get_named_field_idents(&struct_data);
+    let field_idents = get_serializable_named_field_idents(&struct_data);
 
     let output = quote! {
         impl ssz::Encodable for #name {
@@ -84,6 +120,18 @@ pub fn ssz_encode_derive(input: TokenStream) -> TokenStream {
     output.into()
 }
 
+/// Returns true if some field has an attribute declaring it should not be deserialized.
+///
+/// The field attribute is: `#[ssz(skip_deserializing)]`
+fn should_skip_deserializing(field: &syn::Field) -> bool {
+    for attr in &field.attrs {
+        if attr.tts.to_string() == "( skip_deserializing )" {
+            return true;
+        }
+    }
+    false
+}
+
 /// Implements `ssz::Decodable` for some `struct`.
 ///
 /// Fields are decoded in the order they are defined.
@@ -98,26 +146,39 @@ pub fn ssz_decode_derive(input: TokenStream) -> TokenStream {
         _ => panic!("ssz_derive only supports structs."),
     };
 
-    let field_idents = get_named_field_idents(&struct_data);
+    let all_idents = get_named_field_idents(&struct_data);
 
-    // Using a var in an iteration always consumes the var, therefore we must make a `fields_a` and
-    // a `fields_b` in order to perform two loops.
-    //
-    // https://github.com/dtolnay/quote/issues/8
-    let field_idents_a = &field_idents;
-    let field_idents_b = &field_idents;
+    // Build quotes for fields that should be deserialized and those that should be built from
+    // `Default`.
+    let mut quotes = vec![];
+    for field in &struct_data.fields {
+        match &field.ident {
+            Some(ref ident) => {
+                if should_skip_deserializing(field) {
+                    quotes.push(quote! {
+                        let #ident = <_>::default();
+                    });
+                } else {
+                    quotes.push(quote! {
+                        let (#ident, i) = <_>::ssz_decode(bytes, i)?;
+                    });
+                }
+            }
+            _ => panic!("ssz_derive only supports named struct fields."),
+        };
+    }
 
     let output = quote! {
         impl ssz::Decodable for #name {
             fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), ssz::DecodeError> {
                 #(
-                    let (#field_idents_a, i) = <_>::ssz_decode(bytes, i)?;
+                    #quotes
                 )*
 
                 Ok((
                     Self {
                         #(
-                            #field_idents_b,
+                            #all_idents,
                         )*
                     },
                     i
@@ -128,10 +189,46 @@ pub fn ssz_decode_derive(input: TokenStream) -> TokenStream {
     output.into()
 }
 
+/// Returns a Vec of `syn::Ident` for each named field in the struct, whilst filtering out fields
+/// that should not be tree hashed.
+///
+/// # Panics
+/// Any unnamed struct field (like in a tuple struct) will raise a panic at compile time.
+fn get_tree_hashable_named_field_idents<'a>(
+    struct_data: &'a syn::DataStruct,
+) -> Vec<&'a syn::Ident> {
+    struct_data
+        .fields
+        .iter()
+        .filter_map(|f| {
+            if should_skip_tree_hash(&f) {
+                None
+            } else {
+                Some(match &f.ident {
+                    Some(ref ident) => ident,
+                    _ => panic!("ssz_derive only supports named struct fields."),
+                })
+            }
+        })
+        .collect()
+}
+
+/// Returns true if some field has an attribute declaring it should not be tree-hashed.
+///
+/// The field attribute is: `#[tree_hash(skip_hashing)]`
+fn should_skip_tree_hash(field: &syn::Field) -> bool {
+    for attr in &field.attrs {
+        if attr.tts.to_string() == "( skip_hashing )" {
+            return true;
+        }
+    }
+    false
+}
+
 /// Implements `ssz::TreeHash` for some `struct`.
 ///
 /// Fields are processed in the order they are defined.
-#[proc_macro_derive(TreeHash)]
+#[proc_macro_derive(TreeHash, attributes(tree_hash))]
 pub fn ssz_tree_hash_derive(input: TokenStream) -> TokenStream {
     let item = parse_macro_input!(input as DeriveInput);
 
@@ -142,7 +239,7 @@ pub fn ssz_tree_hash_derive(input: TokenStream) -> TokenStream {
         _ => panic!("ssz_derive only supports structs."),
     };
 
-    let field_idents = get_named_field_idents(&struct_data);
+    let field_idents = get_tree_hashable_named_field_idents(&struct_data);
 
     let output = quote! {
         impl ssz::TreeHash for #name {

From 57c4389f9c476c96cbad13484642e6bacb101e8e Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Fri, 15 Mar 2019 18:34:54 +1100
Subject: [PATCH 24/60] Add further BeaconBlock v0.5.0 updates

---
 eth2/types/src/beacon_block.rs | 21 +++++++++++++++++----
 1 file changed, 17 insertions(+), 4 deletions(-)

diff --git a/eth2/types/src/beacon_block.rs b/eth2/types/src/beacon_block.rs
index 7fa3f5e117..bfe266cbd6 100644
--- a/eth2/types/src/beacon_block.rs
+++ b/eth2/types/src/beacon_block.rs
@@ -1,5 +1,5 @@
 use crate::test_utils::TestRandom;
-use crate::{BeaconBlockBody, ChainSpec, Eth1Data, Hash256, Slot};
+use crate::*;
 use bls::Signature;
 use rand::RngCore;
 use serde_derive::{Deserialize, Serialize};
@@ -31,14 +31,14 @@ pub struct BeaconBlock {
 }
 
 impl BeaconBlock {
-    /// The first block of the Beacon Chain.
+    /// Returns an empty block to be used during genesis.
     ///
     /// Spec v0.5.0
-    pub fn genesis(state_root: Hash256, spec: &ChainSpec) -> BeaconBlock {
+    pub fn empty(spec: &ChainSpec) -> BeaconBlock {
         BeaconBlock {
             slot: spec.genesis_slot,
             previous_block_root: spec.zero_hash,
-            state_root,
+            state_root: spec.zero_hash,
             body: BeaconBlockBody {
                 randao_reveal: spec.empty_signature.clone(),
                 eth1_data: Eth1Data {
@@ -62,6 +62,19 @@ impl BeaconBlock {
     pub fn canonical_root(&self) -> Hash256 {
         Hash256::from_slice(&self.hash_tree_root()[..])
     }
+
+    /// Returns a "temporary" header, where the `state_root` is `spec.zero_hash`.
+    ///
+    /// Spec v0.5.0
+    pub fn into_temporary_header(&self, spec: &ChainSpec) -> BeaconBlockHeader {
+        BeaconBlockHeader {
+            slot: self.slot,
+            previous_block_root: self.previous_block_root,
+            state_root: spec.zero_hash,
+            block_body_root: Hash256::from_slice(&self.hash_tree_root()),
+            signature: self.signature,
+        }
+    }
 }
 
 #[cfg(test)]

From 7660cbd4190acabafe64a4ded1668a7568c842c5 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Fri, 15 Mar 2019 18:35:27 +1100
Subject: [PATCH 25/60] Update ChainSpec to v0.5.0

---
 eth2/types/src/chain_spec.rs | 59 ++++++++++++++++++------------------
 1 file changed, 30 insertions(+), 29 deletions(-)

diff --git a/eth2/types/src/chain_spec.rs b/eth2/types/src/chain_spec.rs
index ae521cc92a..f4b113056f 100644
--- a/eth2/types/src/chain_spec.rs
+++ b/eth2/types/src/chain_spec.rs
@@ -5,18 +5,21 @@ use serde_derive::Deserialize;
 
 const GWEI: u64 = 1_000_000_000;
 
+/// Each of the BLS signature domains.
+///
+/// Spec v0.5.0
 pub enum Domain {
-    Deposit,
-    Attestation,
-    Proposal,
-    Exit,
+    BeaconBlock,
     Randao,
+    Attestation,
+    Deposit,
+    Exit,
     Transfer,
 }
 
 /// Holds all the "constants" for a BeaconChain.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 #[derive(PartialEq, Debug, Clone, Deserialize)]
 #[serde(default)]
 pub struct ChainSpec {
@@ -26,7 +29,6 @@ pub struct ChainSpec {
     pub shard_count: u64,
     pub target_committee_size: u64,
     pub max_balance_churn_quotient: u64,
-    pub beacon_chain_shard_number: u64,
     pub max_indices_per_slashable_vote: u64,
     pub max_exit_dequeues_per_epoch: u64,
     pub shuffle_round_count: u8,
@@ -66,12 +68,13 @@ pub struct ChainSpec {
     pub min_seed_lookahead: Epoch,
     pub activation_exit_delay: u64,
     pub epochs_per_eth1_voting_period: u64,
+    pub slots_per_historical_root: usize,
     pub min_validator_withdrawability_delay: Epoch,
+    pub persistent_committee_period: u64,
 
     /*
      * State list lengths
      */
-    pub latest_block_roots_length: usize,
     pub latest_randao_mixes_length: usize,
     pub latest_active_index_roots_length: usize,
     pub latest_slashed_exit_length: usize,
@@ -103,11 +106,11 @@ pub struct ChainSpec {
      *
      * Use `ChainSpec::get_domain(..)` to access these values.
      */
-    domain_deposit: u32,
-    domain_attestation: u32,
-    domain_proposal: u32,
-    domain_exit: u32,
+    domain_beacon_block: u32,
     domain_randao: u32,
+    domain_attestation: u32,
+    domain_deposit: u32,
+    domain_exit: u32,
     domain_transfer: u32,
 }
 
@@ -130,11 +133,11 @@ impl ChainSpec {
     /// Spec v0.5.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::BeaconBlock => self.domain_beacon_block,
             Domain::Randao => self.domain_randao,
+            Domain::Attestation => self.domain_attestation,
+            Domain::Deposit => self.domain_deposit,
+            Domain::Exit => self.domain_exit,
             Domain::Transfer => self.domain_transfer,
         };
 
@@ -149,7 +152,7 @@ impl ChainSpec {
 
     /// Returns a `ChainSpec` compatible with the Ethereum Foundation specification.
     ///
-    /// Spec v0.4.0
+    /// Spec v0.5.0
     pub fn foundation() -> Self {
         let genesis_slot = Slot::new(2_u64.pow(32));
         let slots_per_epoch = 64;
@@ -162,7 +165,6 @@ impl ChainSpec {
             shard_count: 1_024,
             target_committee_size: 128,
             max_balance_churn_quotient: 32,
-            beacon_chain_shard_number: u64::max_value(),
             max_indices_per_slashable_vote: 4_096,
             max_exit_dequeues_per_epoch: 4,
             shuffle_round_count: 90,
@@ -202,12 +204,13 @@ impl ChainSpec {
             min_seed_lookahead: Epoch::new(1),
             activation_exit_delay: 4,
             epochs_per_eth1_voting_period: 16,
+            slots_per_historical_root: 8_192,
             min_validator_withdrawability_delay: Epoch::new(256),
+            persistent_committee_period: 2_048,
 
             /*
              * State list lengths
              */
-            latest_block_roots_length: 8_192,
             latest_randao_mixes_length: 8_192,
             latest_active_index_roots_length: 8_192,
             latest_slashed_exit_length: 8_192,
@@ -234,18 +237,16 @@ impl ChainSpec {
             /*
              * Signature domains
              */
-            domain_deposit: 0,
-            domain_attestation: 1,
-            domain_proposal: 2,
-            domain_exit: 3,
-            domain_randao: 4,
+            domain_beacon_block: 0,
+            domain_randao: 1,
+            domain_attestation: 2,
+            domain_deposit: 3,
+            domain_exit: 4,
             domain_transfer: 5,
         }
     }
 
     /// Returns a `ChainSpec` compatible with the specification suitable for 8 validators.
-    ///
-    /// Spec v0.4.0
     pub fn few_validators() -> Self {
         let genesis_slot = Slot::new(2_u64.pow(32));
         let slots_per_epoch = 8;
@@ -294,11 +295,11 @@ mod tests {
     fn test_get_domain() {
         let spec = ChainSpec::foundation();
 
-        test_domain(Domain::Deposit, spec.domain_deposit, &spec);
-        test_domain(Domain::Attestation, spec.domain_attestation, &spec);
-        test_domain(Domain::Proposal, spec.domain_proposal, &spec);
-        test_domain(Domain::Exit, spec.domain_exit, &spec);
+        test_domain(Domain::BeaconBlock, spec.domain_beacon_block, &spec);
         test_domain(Domain::Randao, spec.domain_randao, &spec);
+        test_domain(Domain::Attestation, spec.domain_attestation, &spec);
+        test_domain(Domain::Deposit, spec.domain_deposit, &spec);
+        test_domain(Domain::Exit, spec.domain_exit, &spec);
         test_domain(Domain::Transfer, spec.domain_transfer, &spec);
     }
 }

From b37cf3a2698562e3c523e798e580b44ed42d2646 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Fri, 15 Mar 2019 18:36:16 +1100
Subject: [PATCH 26/60] Add TreeHash derives for cache objects.

This allows us to avoid a verbose manual impl for BeaconState
---
 eth2/types/src/beacon_state/epoch_cache.rs  | 13 +++++++++++++
 eth2/types/src/beacon_state/pubkey_cache.rs |  9 +++++++++
 2 files changed, 22 insertions(+)

diff --git a/eth2/types/src/beacon_state/epoch_cache.rs b/eth2/types/src/beacon_state/epoch_cache.rs
index ddcca0a9a0..3e580eee1a 100644
--- a/eth2/types/src/beacon_state/epoch_cache.rs
+++ b/eth2/types/src/beacon_state/epoch_cache.rs
@@ -1,5 +1,7 @@
 use super::{AttestationDuty, BeaconState, CrosslinkCommittees, Error};
+use crate::test_utils::TestRandom;
 use crate::{ChainSpec, Epoch};
+use rand::RngCore;
 use serde_derive::{Deserialize, Serialize};
 
 #[derive(Debug, Default, PartialEq, Clone, Serialize, Deserialize)]
@@ -67,3 +69,14 @@ impl EpochCache {
         })
     }
 }
+
+impl<T: RngCore> TestRandom<T> for [EpochCache; 3] {
+    /// Test random should generate an empty cache.
+    fn random_for_test(rng: &mut T) -> Self {
+        [
+            EpochCache::default(),
+            EpochCache::default(),
+            EpochCache::default(),
+        ]
+    }
+}
diff --git a/eth2/types/src/beacon_state/pubkey_cache.rs b/eth2/types/src/beacon_state/pubkey_cache.rs
index 340bdb3119..22fe32694c 100644
--- a/eth2/types/src/beacon_state/pubkey_cache.rs
+++ b/eth2/types/src/beacon_state/pubkey_cache.rs
@@ -1,4 +1,6 @@
+use crate::test_utils::TestRandom;
 use crate::*;
+use rand::RngCore;
 use serde_derive::{Deserialize, Serialize};
 use std::collections::HashMap;
 
@@ -36,3 +38,10 @@ impl PubkeyCache {
         self.map.get(pubkey).cloned()
     }
 }
+
+impl<T: RngCore> TestRandom<T> for PubkeyCache {
+    /// Test random should generate an empty cache.
+    fn random_for_test(rng: &mut T) -> Self {
+        Self::default()
+    }
+}

From 49d3f3d1d64126dd926ca5a3a26247542704882c Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Fri, 15 Mar 2019 18:36:55 +1100
Subject: [PATCH 27/60] Partially update BeaconState to v0.5.0

- Uses new ssz attributes to remove manual impl of ssz.
- Updates struct def to v0.5.0
- Does not update all methods
---
 eth2/types/src/beacon_state.rs | 261 ++++++++-------------------------
 1 file changed, 58 insertions(+), 203 deletions(-)

diff --git a/eth2/types/src/beacon_state.rs b/eth2/types/src/beacon_state.rs
index 2644b3e73d..9bcfa5cecc 100644
--- a/eth2/types/src/beacon_state.rs
+++ b/eth2/types/src/beacon_state.rs
@@ -8,9 +8,11 @@ use log::{debug, error, trace};
 use pubkey_cache::PubkeyCache;
 use rand::RngCore;
 use serde_derive::{Deserialize, Serialize};
-use ssz::{hash, Decodable, DecodeError, Encodable, SignedRoot, SszStream, TreeHash};
+use ssz::{hash, Decodable, SignedRoot, TreeHash};
+use ssz_derive::{Decode, Encode, TreeHash};
 use std::collections::HashMap;
 use swap_or_not_shuffle::shuffle_list;
+use test_random_derive::TestRandom;
 
 pub use builder::BeaconStateBuilder;
 
@@ -72,7 +74,10 @@ macro_rules! safe_sub_assign {
     };
 }
 
-#[derive(Debug, PartialEq, Clone, Default, Serialize, Deserialize)]
+/// The state of the `BeaconChain` at some slot.
+///
+/// Spec v0.5.0
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, TestRandom, Encode, Decode, TreeHash)]
 pub struct BeaconState {
     // Misc
     pub slot: Slot,
@@ -94,18 +99,24 @@ pub struct BeaconState {
     pub current_shuffling_seed: Hash256,
 
     // Finality
+    pub previous_epoch_attestations: Vec<PendingAttestation>,
+    pub current_epoch_attestations: Vec<PendingAttestation>,
     pub previous_justified_epoch: Epoch,
-    pub justified_epoch: Epoch,
+    pub current_justified_epoch: Epoch,
+    pub previous_justified_root: Hash256,
+    pub current_justified_root: Hash256,
     pub justification_bitfield: u64,
     pub finalized_epoch: Epoch,
+    pub finalized_root: Hash256,
 
     // Recent state
     pub latest_crosslinks: Vec<Crosslink>,
     pub latest_block_roots: Vec<Hash256>,
+    pub latest_state_roots: Vec<Hash256>,
     pub latest_active_index_roots: Vec<Hash256>,
     pub latest_slashed_balances: Vec<u64>,
-    pub latest_attestations: Vec<PendingAttestation>,
-    pub batched_block_roots: Vec<Hash256>,
+    pub latest_block_header: BeaconBlockHeader,
+    pub historical_roots: Vec<Hash256>,
 
     // Ethereum 1.0 chain data
     pub latest_eth1_data: Eth1Data,
@@ -113,10 +124,19 @@ pub struct BeaconState {
     pub deposit_index: u64,
 
     // Caching (not in the spec)
+    #[serde(default)]
+    #[ssz(skip_serializing)]
+    #[ssz(skip_deserializing)]
+    #[tree_hash(skip_hashing)]
     pub cache_index_offset: usize,
+    #[ssz(skip_serializing)]
+    #[ssz(skip_deserializing)]
+    #[tree_hash(skip_hashing)]
+    pub caches: [EpochCache; CACHED_EPOCHS],
     #[serde(default)]
-    pub caches: Vec<EpochCache>,
-    #[serde(default)]
+    #[ssz(skip_serializing)]
+    #[ssz(skip_deserializing)]
+    #[tree_hash(skip_hashing)]
     pub pubkey_cache: PubkeyCache,
 }
 
@@ -126,7 +146,7 @@ impl BeaconState {
     /// This does not fully build a genesis beacon state, it omits processing of initial validator
     /// deposits. To obtain a full genesis beacon state, use the `BeaconStateBuilder`.
     ///
-    /// Spec v0.4.0
+    /// Spec v0.5.0
     pub fn genesis(genesis_time: u64, latest_eth1_data: Eth1Data, spec: &ChainSpec) -> BeaconState {
         let initial_crosslink = Crosslink {
             epoch: spec.genesis_epoch,
@@ -134,23 +154,17 @@ impl BeaconState {
         };
 
         BeaconState {
-            /*
-             * Misc
-             */
+            // Misc
             slot: spec.genesis_slot,
             genesis_time,
             fork: Fork::genesis(spec),
 
-            /*
-             * Validator registry
-             */
+            // Validator registry
             validator_registry: vec![], // Set later in the function.
             validator_balances: vec![], // Set later in the function.
             validator_registry_update_epoch: spec.genesis_epoch,
 
-            /*
-             * Randomness and committees
-             */
+            // Randomness and committees
             latest_randao_mixes: vec![spec.zero_hash; spec.latest_randao_mixes_length as usize],
             previous_shuffling_start_shard: spec.genesis_start_shard,
             current_shuffling_start_shard: spec.genesis_start_shard,
@@ -159,26 +173,25 @@ impl BeaconState {
             previous_shuffling_seed: spec.zero_hash,
             current_shuffling_seed: spec.zero_hash,
 
-            /*
-             * Finality
-             */
+            // Finality
+            previous_epoch_attestations: vec![],
+            current_epoch_attestations: vec![],
             previous_justified_epoch: spec.genesis_epoch,
-            justified_epoch: spec.genesis_epoch,
+            current_justified_epoch: spec.genesis_epoch,
+            previous_justified_root: spec.zero_hash,
+            current_justified_root: spec.zero_hash,
             justification_bitfield: 0,
             finalized_epoch: spec.genesis_epoch,
+            finalized_root: spec.zero_hash,
 
-            /*
-             * Recent state
-             */
+            // Recent state
             latest_crosslinks: vec![initial_crosslink; spec.shard_count as usize],
-            latest_block_roots: vec![spec.zero_hash; spec.latest_block_roots_length as usize],
-            latest_active_index_roots: vec![
-                spec.zero_hash;
-                spec.latest_active_index_roots_length as usize
-            ],
-            latest_slashed_balances: vec![0; spec.latest_slashed_exit_length as usize],
-            latest_attestations: vec![],
-            batched_block_roots: vec![],
+            latest_block_roots: vec![spec.zero_hash; spec.slots_per_historical_root],
+            latest_state_roots: vec![spec.zero_hash; spec.slots_per_historical_root],
+            latest_active_index_roots: vec![spec.zero_hash; spec.latest_active_index_roots_length],
+            latest_slashed_balances: vec![0; spec.latest_slashed_exit_length],
+            latest_block_header: BeaconBlock::empty(spec).into_temporary_header(spec),
+            historical_roots: vec![],
 
             /*
              * PoW receipt root
@@ -191,18 +204,26 @@ impl BeaconState {
              * Caching (not in spec)
              */
             cache_index_offset: 0,
-            caches: vec![EpochCache::default(); CACHED_EPOCHS],
+            caches: [
+                EpochCache::default(),
+                EpochCache::default(),
+                EpochCache::default(),
+            ],
             pubkey_cache: PubkeyCache::default(),
         }
     }
 
+    /*
+
     /// Returns the `hash_tree_root` of the state.
     ///
-    /// Spec v0.4.0
+    /// Spec v0.5.0
     pub fn canonical_root(&self) -> Hash256 {
         Hash256::from_slice(&self.hash_tree_root()[..])
     }
 
+    */
+
     /// Build an epoch cache, unless it is has already been built.
     pub fn build_epoch_cache(
         &mut self,
@@ -426,11 +447,11 @@ impl BeaconState {
 
     /// Return the block root at a recent `slot`.
     ///
-    /// Spec v0.4.0
+    /// Spec v0.5.0
     pub fn get_block_root(&self, slot: Slot, spec: &ChainSpec) -> Option<&Hash256> {
-        if (self.slot <= slot + spec.latest_block_roots_length as u64) && (slot < self.slot) {
+        if (self.slot <= slot + spec.slots_per_historical_root as u64) && (slot < self.slot) {
             self.latest_block_roots
-                .get(slot.as_usize() % spec.latest_block_roots_length)
+                .get(slot.as_usize() % spec.slots_per_historical_root)
         } else {
             None
         }
@@ -1135,169 +1156,3 @@ impl BeaconState {
         Ok(all_participants)
     }
 }
-
-impl Encodable for BeaconState {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append(&self.slot);
-        s.append(&self.genesis_time);
-        s.append(&self.fork);
-        s.append(&self.validator_registry);
-        s.append(&self.validator_balances);
-        s.append(&self.validator_registry_update_epoch);
-        s.append(&self.latest_randao_mixes);
-        s.append(&self.previous_shuffling_start_shard);
-        s.append(&self.current_shuffling_start_shard);
-        s.append(&self.previous_shuffling_epoch);
-        s.append(&self.current_shuffling_epoch);
-        s.append(&self.previous_shuffling_seed);
-        s.append(&self.current_shuffling_seed);
-        s.append(&self.previous_justified_epoch);
-        s.append(&self.justified_epoch);
-        s.append(&self.justification_bitfield);
-        s.append(&self.finalized_epoch);
-        s.append(&self.latest_crosslinks);
-        s.append(&self.latest_block_roots);
-        s.append(&self.latest_active_index_roots);
-        s.append(&self.latest_slashed_balances);
-        s.append(&self.latest_attestations);
-        s.append(&self.batched_block_roots);
-        s.append(&self.latest_eth1_data);
-        s.append(&self.eth1_data_votes);
-        s.append(&self.deposit_index);
-    }
-}
-
-impl Decodable for BeaconState {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (slot, i) = <_>::ssz_decode(bytes, i)?;
-        let (genesis_time, i) = <_>::ssz_decode(bytes, i)?;
-        let (fork, i) = <_>::ssz_decode(bytes, i)?;
-        let (validator_registry, i) = <_>::ssz_decode(bytes, i)?;
-        let (validator_balances, i) = <_>::ssz_decode(bytes, i)?;
-        let (validator_registry_update_epoch, i) = <_>::ssz_decode(bytes, i)?;
-        let (latest_randao_mixes, i) = <_>::ssz_decode(bytes, i)?;
-        let (previous_shuffling_start_shard, i) = <_>::ssz_decode(bytes, i)?;
-        let (current_shuffling_start_shard, i) = <_>::ssz_decode(bytes, i)?;
-        let (previous_shuffling_epoch, i) = <_>::ssz_decode(bytes, i)?;
-        let (current_shuffling_epoch, i) = <_>::ssz_decode(bytes, i)?;
-        let (previous_shuffling_seed, i) = <_>::ssz_decode(bytes, i)?;
-        let (current_shuffling_seed, i) = <_>::ssz_decode(bytes, i)?;
-        let (previous_justified_epoch, i) = <_>::ssz_decode(bytes, i)?;
-        let (justified_epoch, i) = <_>::ssz_decode(bytes, i)?;
-        let (justification_bitfield, i) = <_>::ssz_decode(bytes, i)?;
-        let (finalized_epoch, i) = <_>::ssz_decode(bytes, i)?;
-        let (latest_crosslinks, i) = <_>::ssz_decode(bytes, i)?;
-        let (latest_block_roots, i) = <_>::ssz_decode(bytes, i)?;
-        let (latest_active_index_roots, i) = <_>::ssz_decode(bytes, i)?;
-        let (latest_slashed_balances, i) = <_>::ssz_decode(bytes, i)?;
-        let (latest_attestations, i) = <_>::ssz_decode(bytes, i)?;
-        let (batched_block_roots, i) = <_>::ssz_decode(bytes, i)?;
-        let (latest_eth1_data, i) = <_>::ssz_decode(bytes, i)?;
-        let (eth1_data_votes, i) = <_>::ssz_decode(bytes, i)?;
-        let (deposit_index, i) = <_>::ssz_decode(bytes, i)?;
-
-        Ok((
-            Self {
-                slot,
-                genesis_time,
-                fork,
-                validator_registry,
-                validator_balances,
-                validator_registry_update_epoch,
-                latest_randao_mixes,
-                previous_shuffling_start_shard,
-                current_shuffling_start_shard,
-                previous_shuffling_epoch,
-                current_shuffling_epoch,
-                previous_shuffling_seed,
-                current_shuffling_seed,
-                previous_justified_epoch,
-                justified_epoch,
-                justification_bitfield,
-                finalized_epoch,
-                latest_crosslinks,
-                latest_block_roots,
-                latest_active_index_roots,
-                latest_slashed_balances,
-                latest_attestations,
-                batched_block_roots,
-                latest_eth1_data,
-                eth1_data_votes,
-                deposit_index,
-                cache_index_offset: 0,
-                caches: vec![EpochCache::default(); CACHED_EPOCHS],
-                pubkey_cache: PubkeyCache::default(),
-            },
-            i,
-        ))
-    }
-}
-
-impl TreeHash for BeaconState {
-    fn hash_tree_root(&self) -> Vec<u8> {
-        let mut result: Vec<u8> = vec![];
-        result.append(&mut self.slot.hash_tree_root());
-        result.append(&mut self.genesis_time.hash_tree_root());
-        result.append(&mut self.fork.hash_tree_root());
-        result.append(&mut self.validator_registry.hash_tree_root());
-        result.append(&mut self.validator_balances.hash_tree_root());
-        result.append(&mut self.validator_registry_update_epoch.hash_tree_root());
-        result.append(&mut self.latest_randao_mixes.hash_tree_root());
-        result.append(&mut self.previous_shuffling_start_shard.hash_tree_root());
-        result.append(&mut self.current_shuffling_start_shard.hash_tree_root());
-        result.append(&mut self.previous_shuffling_epoch.hash_tree_root());
-        result.append(&mut self.current_shuffling_epoch.hash_tree_root());
-        result.append(&mut self.previous_shuffling_seed.hash_tree_root());
-        result.append(&mut self.current_shuffling_seed.hash_tree_root());
-        result.append(&mut self.previous_justified_epoch.hash_tree_root());
-        result.append(&mut self.justified_epoch.hash_tree_root());
-        result.append(&mut self.justification_bitfield.hash_tree_root());
-        result.append(&mut self.finalized_epoch.hash_tree_root());
-        result.append(&mut self.latest_crosslinks.hash_tree_root());
-        result.append(&mut self.latest_block_roots.hash_tree_root());
-        result.append(&mut self.latest_active_index_roots.hash_tree_root());
-        result.append(&mut self.latest_slashed_balances.hash_tree_root());
-        result.append(&mut self.latest_attestations.hash_tree_root());
-        result.append(&mut self.batched_block_roots.hash_tree_root());
-        result.append(&mut self.latest_eth1_data.hash_tree_root());
-        result.append(&mut self.eth1_data_votes.hash_tree_root());
-        result.append(&mut self.deposit_index.hash_tree_root());
-        hash(&result)
-    }
-}
-
-impl<T: RngCore> TestRandom<T> for BeaconState {
-    fn random_for_test(rng: &mut T) -> Self {
-        Self {
-            slot: <_>::random_for_test(rng),
-            genesis_time: <_>::random_for_test(rng),
-            fork: <_>::random_for_test(rng),
-            validator_registry: <_>::random_for_test(rng),
-            validator_balances: <_>::random_for_test(rng),
-            validator_registry_update_epoch: <_>::random_for_test(rng),
-            latest_randao_mixes: <_>::random_for_test(rng),
-            previous_shuffling_start_shard: <_>::random_for_test(rng),
-            current_shuffling_start_shard: <_>::random_for_test(rng),
-            previous_shuffling_epoch: <_>::random_for_test(rng),
-            current_shuffling_epoch: <_>::random_for_test(rng),
-            previous_shuffling_seed: <_>::random_for_test(rng),
-            current_shuffling_seed: <_>::random_for_test(rng),
-            previous_justified_epoch: <_>::random_for_test(rng),
-            justified_epoch: <_>::random_for_test(rng),
-            justification_bitfield: <_>::random_for_test(rng),
-            finalized_epoch: <_>::random_for_test(rng),
-            latest_crosslinks: <_>::random_for_test(rng),
-            latest_block_roots: <_>::random_for_test(rng),
-            latest_active_index_roots: <_>::random_for_test(rng),
-            latest_slashed_balances: <_>::random_for_test(rng),
-            latest_attestations: <_>::random_for_test(rng),
-            batched_block_roots: <_>::random_for_test(rng),
-            latest_eth1_data: <_>::random_for_test(rng),
-            eth1_data_votes: <_>::random_for_test(rng),
-            deposit_index: <_>::random_for_test(rng),
-            cache_index_offset: 0,
-            caches: vec![EpochCache::default(); CACHED_EPOCHS],
-            pubkey_cache: PubkeyCache::default(),
-        }
-    }
-}

From f739bb55510b9683aa0721f8d5ee125c58eb096d Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Fri, 15 Mar 2019 18:38:58 +1100
Subject: [PATCH 28/60] Add serde default field attr

I accidentally deleted it in the last commit.
---
 eth2/types/src/beacon_state.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/eth2/types/src/beacon_state.rs b/eth2/types/src/beacon_state.rs
index 9bcfa5cecc..ec1008d3c5 100644
--- a/eth2/types/src/beacon_state.rs
+++ b/eth2/types/src/beacon_state.rs
@@ -129,6 +129,7 @@ pub struct BeaconState {
     #[ssz(skip_deserializing)]
     #[tree_hash(skip_hashing)]
     pub cache_index_offset: usize,
+    #[serde(default)]
     #[ssz(skip_serializing)]
     #[ssz(skip_deserializing)]
     #[tree_hash(skip_hashing)]

From 01bfd386375f69e20bc157c8bc26217077b8e97b Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Sat, 16 Mar 2019 14:30:21 +1100
Subject: [PATCH 29/60] Add `default` attribute to `TestRandom` derive.

Allows for generating the item from default instead of randomizing it.
---
 eth2/utils/test_random_derive/src/lib.rs | 48 +++++++++++++++++-------
 1 file changed, 34 insertions(+), 14 deletions(-)

diff --git a/eth2/utils/test_random_derive/src/lib.rs b/eth2/utils/test_random_derive/src/lib.rs
index 9a456606ce..7920ea6958 100644
--- a/eth2/utils/test_random_derive/src/lib.rs
+++ b/eth2/utils/test_random_derive/src/lib.rs
@@ -4,7 +4,20 @@ use crate::proc_macro::TokenStream;
 use quote::quote;
 use syn::{parse_macro_input, DeriveInput};
 
-#[proc_macro_derive(TestRandom)]
+/// Returns true if some field has an attribute declaring it should be generated from default (not
+/// randomized).
+///
+/// The field attribute is: `#[test_random(default)]`
+fn should_use_default(field: &syn::Field) -> bool {
+    for attr in &field.attrs {
+        if attr.tts.to_string() == "( default )" {
+            return true;
+        }
+    }
+    false
+}
+
+#[proc_macro_derive(TestRandom, attributes(test_random))]
 pub fn test_random_derive(input: TokenStream) -> TokenStream {
     let derived_input = parse_macro_input!(input as DeriveInput);
     let name = &derived_input.ident;
@@ -14,14 +27,32 @@ pub fn test_random_derive(input: TokenStream) -> TokenStream {
         _ => panic!("test_random_derive only supports structs."),
     };
 
-    let field_names = get_named_field_idents(&struct_data);
+    // Build quotes for fields that should be generated and those that should be built from
+    // `Default`.
+    let mut quotes = vec![];
+    for field in &struct_data.fields {
+        match &field.ident {
+            Some(ref ident) => {
+                if should_use_default(field) {
+                    quotes.push(quote! {
+                        #ident: <_>::default(),
+                    });
+                } else {
+                    quotes.push(quote! {
+                        #ident: <_>::random_for_test(rng),
+                    });
+                }
+            }
+            _ => panic!("test_random_derive only supports named struct fields."),
+        };
+    }
 
     let output = quote! {
         impl<T: RngCore> TestRandom<T> for #name {
             fn random_for_test(rng: &mut T) -> Self {
                Self {
                     #(
-                        #field_names: <_>::random_for_test(rng),
+                        #quotes
                     )*
                }
             }
@@ -30,14 +61,3 @@ pub fn test_random_derive(input: TokenStream) -> TokenStream {
 
     output.into()
 }
-
-fn get_named_field_idents(struct_data: &syn::DataStruct) -> Vec<(&syn::Ident)> {
-    struct_data
-        .fields
-        .iter()
-        .map(|f| match &f.ident {
-            Some(ref ident) => ident,
-            _ => panic!("test_random_derive only supports named struct fields."),
-        })
-        .collect()
-}

From 6ae5d34d0f3f1063841dab726514067c96e7dcf6 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Sat, 16 Mar 2019 14:31:43 +1100
Subject: [PATCH 30/60] Update testing builders as per state 0.5.0 update

---
 .../src/test_utils/testing_attestation_data_builder.rs   | 2 +-
 .../types/src/test_utils/testing_beacon_block_builder.rs | 4 ++--
 .../types/src/test_utils/testing_beacon_state_builder.rs | 9 +++++++--
 .../src/test_utils/testing_proposer_slashing_builder.rs  | 4 ++--
 4 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/eth2/types/src/test_utils/testing_attestation_data_builder.rs b/eth2/types/src/test_utils/testing_attestation_data_builder.rs
index f31de2fbd1..a270e38599 100644
--- a/eth2/types/src/test_utils/testing_attestation_data_builder.rs
+++ b/eth2/types/src/test_utils/testing_attestation_data_builder.rs
@@ -20,7 +20,7 @@ impl TestingAttestationDataBuilder {
         let source_epoch = if is_previous_epoch {
             state.previous_justified_epoch
         } else {
-            state.justified_epoch
+            state.current_justified_epoch
         };
 
         let target_root = if is_previous_epoch {
diff --git a/eth2/types/src/test_utils/testing_beacon_block_builder.rs b/eth2/types/src/test_utils/testing_beacon_block_builder.rs
index e0e4677d48..7fb3d8e09b 100644
--- a/eth2/types/src/test_utils/testing_beacon_block_builder.rs
+++ b/eth2/types/src/test_utils/testing_beacon_block_builder.rs
@@ -19,7 +19,7 @@ impl TestingBeaconBlockBuilder {
     /// Create a new builder from genesis.
     pub fn new(spec: &ChainSpec) -> Self {
         Self {
-            block: BeaconBlock::genesis(spec.zero_hash, spec),
+            block: BeaconBlock::empty(spec),
         }
     }
 
@@ -34,7 +34,7 @@ impl TestingBeaconBlockBuilder {
     pub fn sign(&mut self, sk: &SecretKey, fork: &Fork, spec: &ChainSpec) {
         let message = self.block.signed_root();
         let epoch = self.block.slot.epoch(spec.slots_per_epoch);
-        let domain = spec.get_domain(epoch, Domain::Proposal, fork);
+        let domain = spec.get_domain(epoch, Domain::BeaconBlock, fork);
         self.block.signature = Signature::new(&message, domain, sk);
     }
 
diff --git a/eth2/types/src/test_utils/testing_beacon_state_builder.rs b/eth2/types/src/test_utils/testing_beacon_state_builder.rs
index 5b96dc455c..8ef4f76ce1 100644
--- a/eth2/types/src/test_utils/testing_beacon_state_builder.rs
+++ b/eth2/types/src/test_utils/testing_beacon_state_builder.rs
@@ -190,7 +190,7 @@ impl TestingBeaconStateBuilder {
         state.current_shuffling_seed = Hash256::from_low_u64_le(1);
 
         state.previous_justified_epoch = epoch - 3;
-        state.justified_epoch = epoch - 2;
+        state.current_justified_epoch = epoch - 2;
         state.justification_bitfield = u64::max_value();
 
         state.finalized_epoch = epoch - 3;
@@ -232,8 +232,13 @@ impl TestingBeaconStateBuilder {
                 // The entire committee should have signed the pending attestation.
                 let signers = vec![true; committee.len()];
                 builder.add_committee_participation(signers);
+                let attestation = builder.build();
 
-                state.latest_attestations.push(builder.build())
+                if attestation.data.slot.epoch(spec.slots_per_epoch) < state.current_epoch(spec) {
+                    state.previous_epoch_attestations.push(attestation)
+                } else {
+                    state.current_epoch_attestations.push(attestation)
+                }
             }
         }
     }
diff --git a/eth2/types/src/test_utils/testing_proposer_slashing_builder.rs b/eth2/types/src/test_utils/testing_proposer_slashing_builder.rs
index fc38c185de..0773cd6da4 100644
--- a/eth2/types/src/test_utils/testing_proposer_slashing_builder.rs
+++ b/eth2/types/src/test_utils/testing_proposer_slashing_builder.rs
@@ -41,13 +41,13 @@ impl TestingProposerSlashingBuilder {
         proposal_1.signature = {
             let message = proposal_1.signed_root();
             let epoch = slot.epoch(spec.slots_per_epoch);
-            signer(proposer_index, &message[..], epoch, Domain::Proposal)
+            signer(proposer_index, &message[..], epoch, Domain::BeaconBlock)
         };
 
         proposal_2.signature = {
             let message = proposal_2.signed_root();
             let epoch = slot.epoch(spec.slots_per_epoch);
-            signer(proposer_index, &message[..], epoch, Domain::Proposal)
+            signer(proposer_index, &message[..], epoch, Domain::BeaconBlock)
         };
 
         ProposerSlashing {

From 33783d4baa2d7edb8be4aa75c6cf997df4da2c37 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Sat, 16 Mar 2019 14:32:07 +1100
Subject: [PATCH 31/60] Fix borrow issue in `BeaconBlock`

---
 eth2/types/src/beacon_block.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/eth2/types/src/beacon_block.rs b/eth2/types/src/beacon_block.rs
index bfe266cbd6..2dcf91d955 100644
--- a/eth2/types/src/beacon_block.rs
+++ b/eth2/types/src/beacon_block.rs
@@ -72,7 +72,7 @@ impl BeaconBlock {
             previous_block_root: self.previous_block_root,
             state_root: spec.zero_hash,
             block_body_root: Hash256::from_slice(&self.hash_tree_root()),
-            signature: self.signature,
+            signature: self.signature.clone(),
         }
     }
 }

From c648491c45fdf858c55006a57cd4b48db6e08a91 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Sat, 16 Mar 2019 14:32:23 +1100
Subject: [PATCH 32/60] Add TestRandom `default` field attr to BeaconState

---
 eth2/types/src/beacon_state.rs              |  5 ++++-
 eth2/types/src/beacon_state/epoch_cache.rs  | 13 -------------
 eth2/types/src/beacon_state/pubkey_cache.rs |  9 ---------
 3 files changed, 4 insertions(+), 23 deletions(-)

diff --git a/eth2/types/src/beacon_state.rs b/eth2/types/src/beacon_state.rs
index ec1008d3c5..ba9c5cd4d5 100644
--- a/eth2/types/src/beacon_state.rs
+++ b/eth2/types/src/beacon_state.rs
@@ -8,7 +8,7 @@ use log::{debug, error, trace};
 use pubkey_cache::PubkeyCache;
 use rand::RngCore;
 use serde_derive::{Deserialize, Serialize};
-use ssz::{hash, Decodable, SignedRoot, TreeHash};
+use ssz::{hash, SignedRoot};
 use ssz_derive::{Decode, Encode, TreeHash};
 use std::collections::HashMap;
 use swap_or_not_shuffle::shuffle_list;
@@ -128,16 +128,19 @@ pub struct BeaconState {
     #[ssz(skip_serializing)]
     #[ssz(skip_deserializing)]
     #[tree_hash(skip_hashing)]
+    #[test_random(default)]
     pub cache_index_offset: usize,
     #[serde(default)]
     #[ssz(skip_serializing)]
     #[ssz(skip_deserializing)]
     #[tree_hash(skip_hashing)]
+    #[test_random(default)]
     pub caches: [EpochCache; CACHED_EPOCHS],
     #[serde(default)]
     #[ssz(skip_serializing)]
     #[ssz(skip_deserializing)]
     #[tree_hash(skip_hashing)]
+    #[test_random(default)]
     pub pubkey_cache: PubkeyCache,
 }
 
diff --git a/eth2/types/src/beacon_state/epoch_cache.rs b/eth2/types/src/beacon_state/epoch_cache.rs
index 3e580eee1a..ddcca0a9a0 100644
--- a/eth2/types/src/beacon_state/epoch_cache.rs
+++ b/eth2/types/src/beacon_state/epoch_cache.rs
@@ -1,7 +1,5 @@
 use super::{AttestationDuty, BeaconState, CrosslinkCommittees, Error};
-use crate::test_utils::TestRandom;
 use crate::{ChainSpec, Epoch};
-use rand::RngCore;
 use serde_derive::{Deserialize, Serialize};
 
 #[derive(Debug, Default, PartialEq, Clone, Serialize, Deserialize)]
@@ -69,14 +67,3 @@ impl EpochCache {
         })
     }
 }
-
-impl<T: RngCore> TestRandom<T> for [EpochCache; 3] {
-    /// Test random should generate an empty cache.
-    fn random_for_test(rng: &mut T) -> Self {
-        [
-            EpochCache::default(),
-            EpochCache::default(),
-            EpochCache::default(),
-        ]
-    }
-}
diff --git a/eth2/types/src/beacon_state/pubkey_cache.rs b/eth2/types/src/beacon_state/pubkey_cache.rs
index 22fe32694c..340bdb3119 100644
--- a/eth2/types/src/beacon_state/pubkey_cache.rs
+++ b/eth2/types/src/beacon_state/pubkey_cache.rs
@@ -1,6 +1,4 @@
-use crate::test_utils::TestRandom;
 use crate::*;
-use rand::RngCore;
 use serde_derive::{Deserialize, Serialize};
 use std::collections::HashMap;
 
@@ -38,10 +36,3 @@ impl PubkeyCache {
         self.map.get(pubkey).cloned()
     }
 }
-
-impl<T: RngCore> TestRandom<T> for PubkeyCache {
-    /// Test random should generate an empty cache.
-    fn random_for_test(rng: &mut T) -> Self {
-        Self::default()
-    }
-}

From d6456a948685af408c913229db1b626e18226123 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Sat, 16 Mar 2019 14:35:45 +1100
Subject: [PATCH 33/60] Remove old types structs.

They've been outdated be v0.5.0 or prior
---
 eth2/types/src/lib.rs                         |   1 -
 eth2/types/src/proposal_signed_data.rs        |  20 ---
 eth2/types/src/shard_reassignment_record.rs   |  19 ---
 eth2/types/src/slashable_vote_data.rs         | 132 ------------------
 .../src/validator_registry_delta_block.rs     |  36 -----
 5 files changed, 208 deletions(-)
 delete mode 100644 eth2/types/src/proposal_signed_data.rs
 delete mode 100644 eth2/types/src/shard_reassignment_record.rs
 delete mode 100644 eth2/types/src/slashable_vote_data.rs
 delete mode 100644 eth2/types/src/validator_registry_delta_block.rs

diff --git a/eth2/types/src/lib.rs b/eth2/types/src/lib.rs
index a1a58198b1..c38fa80311 100644
--- a/eth2/types/src/lib.rs
+++ b/eth2/types/src/lib.rs
@@ -23,7 +23,6 @@ pub mod free_attestation;
 pub mod historical_batch;
 pub mod pending_attestation;
 pub mod proposer_slashing;
-pub mod shard_reassignment_record;
 pub mod slashable_attestation;
 pub mod transfer;
 pub mod voluntary_exit;
diff --git a/eth2/types/src/proposal_signed_data.rs b/eth2/types/src/proposal_signed_data.rs
deleted file mode 100644
index 58f45a41df..0000000000
--- a/eth2/types/src/proposal_signed_data.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-use crate::test_utils::TestRandom;
-use crate::{Hash256, Slot};
-use rand::RngCore;
-use serde_derive::Serialize;
-use ssz_derive::{Decode, Encode, TreeHash};
-use test_random_derive::TestRandom;
-
-#[derive(Debug, PartialEq, Clone, Default, Serialize, Encode, Decode, TreeHash, TestRandom)]
-pub struct ProposalSignedData {
-    pub slot: Slot,
-    pub shard: u64,
-    pub block_root: Hash256,
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    ssz_tests!(ProposalSignedData);
-}
diff --git a/eth2/types/src/shard_reassignment_record.rs b/eth2/types/src/shard_reassignment_record.rs
deleted file mode 100644
index 9f1705f163..0000000000
--- a/eth2/types/src/shard_reassignment_record.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-use crate::{test_utils::TestRandom, Slot};
-use rand::RngCore;
-use serde_derive::Serialize;
-use ssz_derive::{Decode, Encode, TreeHash};
-use test_random_derive::TestRandom;
-
-#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode, TreeHash, TestRandom)]
-pub struct ShardReassignmentRecord {
-    pub validator_index: u64,
-    pub shard: u64,
-    pub slot: Slot,
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    ssz_tests!(ShardReassignmentRecord);
-}
diff --git a/eth2/types/src/slashable_vote_data.rs b/eth2/types/src/slashable_vote_data.rs
deleted file mode 100644
index 73cf91c61b..0000000000
--- a/eth2/types/src/slashable_vote_data.rs
+++ /dev/null
@@ -1,132 +0,0 @@
-use super::AttestationData;
-use crate::chain_spec::ChainSpec;
-use crate::test_utils::TestRandom;
-use bls::AggregateSignature;
-use rand::RngCore;
-use serde_derive::Serialize;
-use ssz_derive::{Decode, Encode, TreeHash};
-use test_random_derive::TestRandom;
-
-#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode, TreeHash, TestRandom)]
-pub struct SlashableVoteData {
-    pub custody_bit_0_indices: Vec<u32>,
-    pub custody_bit_1_indices: Vec<u32>,
-    pub data: AttestationData,
-    pub aggregate_signature: AggregateSignature,
-}
-
-impl SlashableVoteData {
-    /// Check if ``attestation_data_1`` and ``attestation_data_2`` have the same target.
-    ///
-    /// Spec v0.3.0
-    pub fn is_double_vote(&self, other: &SlashableVoteData, spec: &ChainSpec) -> bool {
-        self.data.slot.epoch(spec.epoch_length) == other.data.slot.epoch(spec.epoch_length)
-    }
-
-    /// Check if ``attestation_data_1`` surrounds ``attestation_data_2``.
-    ///
-    /// Spec v0.3.0
-    pub fn is_surround_vote(&self, other: &SlashableVoteData, 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.epoch_length);
-        let target_epoch_2 = other.data.slot.epoch(spec.epoch_length);
-
-        (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};
-
-    #[test]
-    pub fn test_is_double_vote_true() {
-        let spec = ChainSpec::foundation();
-        let slashable_vote_first = create_slashable_vote_data(1, 1, &spec);
-        let slashable_vote_second = create_slashable_vote_data(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_vote_data(1, 1, &spec);
-        let slashable_vote_second = create_slashable_vote_data(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_vote_data(2, 1, &spec);
-        let slashable_vote_second = create_slashable_vote_data(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_vote_data(4, 1, &spec);
-        let slashable_vote_second = create_slashable_vote_data(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_vote_data(2, 2, &spec);
-        let slashable_vote_second = create_slashable_vote_data(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_vote_data(1, 1, &spec);
-        let slashable_vote_second = create_slashable_vote_data(2, 2, &spec);
-
-        assert_eq!(
-            slashable_vote_first.is_surround_vote(&slashable_vote_second, &spec),
-            false
-        );
-    }
-
-    ssz_tests!(SlashableVoteData);
-
-    fn create_slashable_vote_data(
-        slot_factor: u64,
-        justified_epoch: u64,
-        spec: &ChainSpec,
-    ) -> SlashableVoteData {
-        let mut rng = XorShiftRng::from_seed([42; 16]);
-        let mut slashable_vote = SlashableVoteData::random_for_test(&mut rng);
-
-        slashable_vote.data.slot = Slot::new(slot_factor * spec.epoch_length);
-        slashable_vote.data.justified_epoch = Epoch::new(justified_epoch);
-        slashable_vote
-    }
-}
diff --git a/eth2/types/src/validator_registry_delta_block.rs b/eth2/types/src/validator_registry_delta_block.rs
deleted file mode 100644
index e9a0750527..0000000000
--- a/eth2/types/src/validator_registry_delta_block.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-use crate::{test_utils::TestRandom, Hash256, Slot};
-use bls::PublicKey;
-use rand::RngCore;
-use serde_derive::Serialize;
-use ssz_derive::{Decode, Encode, TreeHash};
-use test_random_derive::TestRandom;
-
-// The information gathered from the PoW chain validator registration function.
-#[derive(Debug, Clone, PartialEq, Serialize, Encode, Decode, TreeHash, TestRandom)]
-pub struct ValidatorRegistryDeltaBlock {
-    pub latest_registry_delta_root: Hash256,
-    pub validator_index: u32,
-    pub pubkey: PublicKey,
-    pub slot: Slot,
-    pub flag: u64,
-}
-
-impl Default for ValidatorRegistryDeltaBlock {
-    /// Yields a "default" `Validator`. Primarily used for testing.
-    fn default() -> Self {
-        Self {
-            latest_registry_delta_root: Hash256::zero(),
-            validator_index: std::u32::MAX,
-            pubkey: PublicKey::default(),
-            slot: Slot::from(std::u64::MAX),
-            flag: std::u64::MAX,
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    ssz_tests!(ValidatorRegistryDeltaBlock);
-}

From 7f4af20212c4b07dbb4c682b163f9c99cf3144f5 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Sat, 16 Mar 2019 19:14:49 +1100
Subject: [PATCH 34/60] Refactor shuffling generation

---
 eth2/types/src/attestation_duty.rs            |   9 +
 eth2/types/src/beacon_state.rs                | 459 ++++--------------
 eth2/types/src/beacon_state/builder.rs        |   6 +-
 eth2/types/src/beacon_state/epoch_cache.rs    | 292 +++++++++--
 eth2/types/src/beacon_state/tests.rs          |  48 --
 eth2/types/src/crosslink_committee.rs         |   9 +
 eth2/types/src/epoch_cache.rs                 |   0
 eth2/types/src/lib.rs                         |  12 +-
 eth2/types/src/relative_epoch.rs              |  76 +++
 .../testing_beacon_block_builder.rs           |  12 +-
 .../testing_beacon_state_builder.rs           |  17 +-
 11 files changed, 476 insertions(+), 464 deletions(-)
 create mode 100644 eth2/types/src/attestation_duty.rs
 create mode 100644 eth2/types/src/crosslink_committee.rs
 create mode 100644 eth2/types/src/epoch_cache.rs
 create mode 100644 eth2/types/src/relative_epoch.rs

diff --git a/eth2/types/src/attestation_duty.rs b/eth2/types/src/attestation_duty.rs
new file mode 100644
index 0000000000..f6e86d2632
--- /dev/null
+++ b/eth2/types/src/attestation_duty.rs
@@ -0,0 +1,9 @@
+use crate::*;
+use serde_derive::{Deserialize, Serialize};
+
+#[derive(Debug, PartialEq, Clone, Default, Serialize, Deserialize)]
+pub struct AttestationDuty {
+    pub slot: Slot,
+    pub shard: Shard,
+    pub committee_index: usize,
+}
diff --git a/eth2/types/src/beacon_state.rs b/eth2/types/src/beacon_state.rs
index ba9c5cd4d5..32f8204e38 100644
--- a/eth2/types/src/beacon_state.rs
+++ b/eth2/types/src/beacon_state.rs
@@ -1,17 +1,14 @@
 use self::epoch_cache::EpochCache;
 use crate::test_utils::TestRandom;
 use crate::{validator_registry::get_active_validator_indices, *};
-use helpers::*;
-use honey_badger_split::SplitExt;
 use int_to_bytes::int_to_bytes32;
-use log::{debug, error, trace};
+use log::{debug, trace};
 use pubkey_cache::PubkeyCache;
 use rand::RngCore;
 use serde_derive::{Deserialize, Serialize};
-use ssz::{hash, SignedRoot};
+use ssz::{hash, SignedRoot, TreeHash};
 use ssz_derive::{Decode, Encode, TreeHash};
 use std::collections::HashMap;
-use swap_or_not_shuffle::shuffle_list;
 use test_random_derive::TestRandom;
 
 pub use builder::BeaconStateBuilder;
@@ -22,22 +19,7 @@ pub mod helpers;
 mod pubkey_cache;
 mod tests;
 
-pub type Committee = Vec<usize>;
-pub type CrosslinkCommittees = Vec<(Committee, u64)>;
-pub type Shard = u64;
-pub type CommitteeIndex = u64;
-pub type AttestationDuty = (Slot, Shard, CommitteeIndex);
-pub type AttestationDutyMap = HashMap<u64, AttestationDuty>;
-pub type ShardCommitteeIndexMap = HashMap<Shard, (usize, usize)>;
-
-pub const CACHED_EPOCHS: usize = 3;
-
-#[derive(Debug, PartialEq, Clone, Copy)]
-pub enum RelativeEpoch {
-    Previous,
-    Current,
-    Next,
-}
+pub const CACHED_EPOCHS: usize = 4;
 
 #[derive(Debug, PartialEq)]
 pub enum Error {
@@ -61,6 +43,7 @@ pub enum Error {
         cache_len: usize,
         registry_len: usize,
     },
+    RelativeEpochError(RelativeEpochError),
 }
 
 macro_rules! safe_add_assign {
@@ -212,13 +195,12 @@ impl BeaconState {
                 EpochCache::default(),
                 EpochCache::default(),
                 EpochCache::default(),
+                EpochCache::default(),
             ],
             pubkey_cache: PubkeyCache::default(),
         }
     }
 
-    /*
-
     /// Returns the `hash_tree_root` of the state.
     ///
     /// Spec v0.5.0
@@ -226,8 +208,6 @@ impl BeaconState {
         Hash256::from_slice(&self.hash_tree_root()[..])
     }
 
-    */
-
     /// Build an epoch cache, unless it is has already been built.
     pub fn build_epoch_cache(
         &mut self,
@@ -236,7 +216,8 @@ impl BeaconState {
     ) -> Result<(), Error> {
         let cache_index = self.cache_index(relative_epoch);
 
-        if self.caches[cache_index].initialized {
+        if self.caches[cache_index].initialized_epoch == Some(self.slot.epoch(spec.slots_per_epoch))
+        {
             Ok(())
         } else {
             self.force_build_epoch_cache(relative_epoch, spec)
@@ -249,36 +230,13 @@ impl BeaconState {
         relative_epoch: RelativeEpoch,
         spec: &ChainSpec,
     ) -> Result<(), Error> {
-        let epoch = self.absolute_epoch(relative_epoch, spec);
         let cache_index = self.cache_index(relative_epoch);
 
-        self.caches[cache_index] = EpochCache::initialized(&self, epoch, spec)?;
+        self.caches[cache_index] = EpochCache::initialized(&self, relative_epoch, spec)?;
 
         Ok(())
     }
 
-    /// Converts a `RelativeEpoch` into an `Epoch` with respect to the epoch of this state.
-    fn absolute_epoch(&self, relative_epoch: RelativeEpoch, spec: &ChainSpec) -> Epoch {
-        match relative_epoch {
-            RelativeEpoch::Previous => self.previous_epoch(spec),
-            RelativeEpoch::Current => self.current_epoch(spec),
-            RelativeEpoch::Next => self.next_epoch(spec),
-        }
-    }
-
-    /// Converts an `Epoch` into a `RelativeEpoch` with respect to the epoch of this state.
-    ///
-    /// Returns an error if the given `epoch` not "previous", "current" or "next" compared to the
-    /// epoch of this tate.
-    fn relative_epoch(&self, epoch: Epoch, spec: &ChainSpec) -> Result<RelativeEpoch, Error> {
-        match epoch {
-            e if e == self.current_epoch(spec) => Ok(RelativeEpoch::Current),
-            e if e == self.previous_epoch(spec) => Ok(RelativeEpoch::Previous),
-            e if e == self.next_epoch(spec) => Ok(RelativeEpoch::Next),
-            _ => Err(Error::EpochOutOfBounds),
-        }
-    }
-
     /// Advances the cache for this state into the next epoch.
     ///
     /// This should be used if the `slot` of this state is advanced beyond an epoch boundary.
@@ -305,9 +263,10 @@ impl BeaconState {
     /// Returns the index of `self.caches` for some `RelativeEpoch`.
     fn cache_index(&self, relative_epoch: RelativeEpoch) -> usize {
         let base_index = match relative_epoch {
-            RelativeEpoch::Current => 1,
             RelativeEpoch::Previous => 0,
-            RelativeEpoch::Next => 2,
+            RelativeEpoch::Current => 1,
+            RelativeEpoch::NextWithoutRegistryChange => 2,
+            RelativeEpoch::NextWithRegistryChange => 3,
         };
 
         (base_index + self.cache_index_offset) % CACHED_EPOCHS
@@ -315,10 +274,10 @@ impl BeaconState {
 
     /// Returns the cache for some `RelativeEpoch`. Returns an error if the cache has not been
     /// initialized.
-    fn cache(&self, relative_epoch: RelativeEpoch) -> Result<&EpochCache, Error> {
+    fn cache(&self, relative_epoch: RelativeEpoch, spec: &ChainSpec) -> Result<&EpochCache, Error> {
         let cache = &self.caches[self.cache_index(relative_epoch)];
 
-        if cache.initialized {
+        if cache.initialized_epoch == Some(self.slot.epoch(spec.slots_per_epoch)) {
             Ok(cache)
         } else {
             Err(Error::EpochCacheUninitialized(relative_epoch))
@@ -367,7 +326,7 @@ impl BeaconState {
 
     /// The epoch corresponding to `self.slot`.
     ///
-    /// Spec v0.4.0
+    /// Spec v0.5.0
     pub fn current_epoch(&self, spec: &ChainSpec) -> Epoch {
         self.slot.epoch(spec.slots_per_epoch)
     }
@@ -376,58 +335,16 @@ impl BeaconState {
     ///
     /// If the current epoch is the genesis epoch, the genesis_epoch is returned.
     ///
-    /// Spec v0.4.0
+    /// Spec v0.5.0
     pub fn previous_epoch(&self, spec: &ChainSpec) -> Epoch {
-        let current_epoch = self.current_epoch(&spec);
-        std::cmp::max(current_epoch - 1, spec.genesis_epoch)
+        self.current_epoch(&spec) - 1
     }
 
     /// The epoch following `self.current_epoch()`.
     ///
-    /// Spec v0.4.0
+    /// Spec v0.5.0
     pub fn next_epoch(&self, spec: &ChainSpec) -> Epoch {
-        self.current_epoch(spec).saturating_add(1_u64)
-    }
-
-    /// The first slot of the epoch corresponding to `self.slot`.
-    ///
-    /// Spec v0.4.0
-    pub fn current_epoch_start_slot(&self, spec: &ChainSpec) -> Slot {
-        self.current_epoch(spec).start_slot(spec.slots_per_epoch)
-    }
-
-    /// The first slot of the epoch preceding the one corresponding to `self.slot`.
-    ///
-    /// Spec v0.4.0
-    pub fn previous_epoch_start_slot(&self, spec: &ChainSpec) -> Slot {
-        self.previous_epoch(spec).start_slot(spec.slots_per_epoch)
-    }
-
-    /// Return the number of committees in the previous epoch.
-    ///
-    /// Spec v0.4.0
-    fn get_previous_epoch_committee_count(&self, spec: &ChainSpec) -> u64 {
-        let previous_active_validators =
-            get_active_validator_indices(&self.validator_registry, self.previous_shuffling_epoch);
-        spec.get_epoch_committee_count(previous_active_validators.len())
-    }
-
-    /// Return the number of committees in the current epoch.
-    ///
-    /// Spec v0.4.0
-    pub fn get_current_epoch_committee_count(&self, spec: &ChainSpec) -> u64 {
-        let current_active_validators =
-            get_active_validator_indices(&self.validator_registry, self.current_shuffling_epoch);
-        spec.get_epoch_committee_count(current_active_validators.len())
-    }
-
-    /// Return the number of committees in the next epoch.
-    ///
-    /// Spec v0.4.0
-    pub fn get_next_epoch_committee_count(&self, spec: &ChainSpec) -> u64 {
-        let next_active_validators =
-            get_active_validator_indices(&self.validator_registry, self.next_epoch(spec));
-        spec.get_epoch_committee_count(next_active_validators.len())
+        self.current_epoch(spec) + 1
     }
 
     /// Returns the crosslink committees for some slot.
@@ -438,15 +355,14 @@ impl BeaconState {
     pub fn get_crosslink_committees_at_slot(
         &self,
         slot: Slot,
+        relative_epoch: RelativeEpoch,
         spec: &ChainSpec,
-    ) -> Result<&CrosslinkCommittees, Error> {
-        let epoch = slot.epoch(spec.slots_per_epoch);
-        let relative_epoch = self.relative_epoch(epoch, spec)?;
-        let cache = self.cache(relative_epoch)?;
+    ) -> Result<&Vec<CrosslinkCommittee>, Error> {
+        let cache = self.cache(relative_epoch, spec)?;
 
-        let slot_offset = slot - epoch.start_slot(spec.slots_per_epoch);
-
-        Ok(&cache.committees[slot_offset.as_usize()])
+        Ok(cache
+            .get_crosslink_committees_at_slot(slot, spec)
+            .ok_or_else(|| Error::SlotOutOfBounds)?)
     }
 
     /// Return the block root at a recent `slot`.
@@ -525,8 +441,13 @@ impl BeaconState {
     /// If the state does not contain an index for a beacon proposer at the requested `slot`, then `None` is returned.
     ///
     /// Spec v0.4.0
-    pub fn get_beacon_proposer_index(&self, slot: Slot, spec: &ChainSpec) -> Result<usize, Error> {
-        let committees = self.get_crosslink_committees_at_slot(slot, spec)?;
+    pub fn get_beacon_proposer_index(
+        &self,
+        slot: Slot,
+        relative_epoch: RelativeEpoch,
+        spec: &ChainSpec,
+    ) -> Result<usize, Error> {
+        let committees = self.get_crosslink_committees_at_slot(slot, relative_epoch, spec)?;
         trace!(
             "get_beacon_proposer_index: slot: {}, committees_count: {}",
             slot,
@@ -535,71 +456,28 @@ impl BeaconState {
         committees
             .first()
             .ok_or(Error::InsufficientValidators)
-            .and_then(|(first_committee, _)| {
+            .and_then(|first| {
                 let index = slot
                     .as_usize()
-                    .checked_rem(first_committee.len())
+                    .checked_rem(first.committee.len())
                     .ok_or(Error::InsufficientValidators)?;
-                Ok(first_committee[index])
+                Ok(first.committee[index])
             })
     }
 
-    /// Returns the list of validator indices which participiated in the attestation.
-    ///
-    /// Note: Utilizes the cache and will fail if the appropriate cache is not initialized.
-    ///
-    /// Spec v0.4.0
-    pub fn get_attestation_participants(
-        &self,
-        attestation_data: &AttestationData,
-        bitfield: &Bitfield,
-        spec: &ChainSpec,
-    ) -> Result<Vec<usize>, Error> {
-        let epoch = attestation_data.slot.epoch(spec.slots_per_epoch);
-        let relative_epoch = self.relative_epoch(epoch, spec)?;
-        let cache = self.cache(relative_epoch)?;
-
-        let (committee_slot_index, committee_index) = cache
-            .shard_committee_indices
-            .get(attestation_data.shard as usize)
-            .ok_or_else(|| Error::ShardOutOfBounds)?;
-        let (committee, shard) = &cache.committees[*committee_slot_index][*committee_index];
-
-        assert_eq!(*shard, attestation_data.shard, "Bad epoch cache build.");
-
-        if !verify_bitfield_length(&bitfield, committee.len()) {
-            return Err(Error::InvalidBitfield);
-        }
-
-        let mut participants = Vec::with_capacity(committee.len());
-        for (i, validator_index) in committee.iter().enumerate() {
-            match bitfield.get(i) {
-                Ok(bit) if bit == true => participants.push(*validator_index),
-                _ => {}
-            }
-        }
-        participants.shrink_to_fit();
-
-        Ok(participants)
-    }
-
     /// Return the effective balance (also known as "balance at stake") for a validator with the given ``index``.
     ///
     /// Spec v0.4.0
-    pub fn get_effective_balance(&self, validator_index: usize, spec: &ChainSpec) -> u64 {
-        std::cmp::min(
-            self.validator_balances[validator_index],
-            spec.max_deposit_amount,
-        )
-    }
-
-    /// Return the combined effective balance of an array of validators.
-    ///
-    /// Spec v0.4.0
-    pub fn get_total_balance(&self, validator_indices: &[usize], spec: &ChainSpec) -> u64 {
-        validator_indices
-            .iter()
-            .fold(0, |acc, i| acc + self.get_effective_balance(*i, spec))
+    pub fn get_effective_balance(
+        &self,
+        validator_index: usize,
+        spec: &ChainSpec,
+    ) -> Result<u64, Error> {
+        let balance = self
+            .validator_balances
+            .get(validator_index)
+            .ok_or_else(|| Error::UnknownValidator)?;
+        Ok(std::cmp::min(*balance, spec.max_deposit_amount))
     }
 
     ///  Return the epoch at which an activation or exit triggered in ``epoch`` takes effect.
@@ -767,11 +645,15 @@ impl BeaconState {
 
         self.exit_validator(validator_index, spec);
 
-        self.latest_slashed_balances[current_epoch.as_usize() % spec.latest_slashed_exit_length] +=
-            self.get_effective_balance(validator_index, spec);
+        let effective_balance = self.get_effective_balance(validator_index, spec)?;
 
-        let whistleblower_index = self.get_beacon_proposer_index(self.slot, spec)?;
-        let whistleblower_reward = self.get_effective_balance(validator_index, spec);
+        self.latest_slashed_balances[current_epoch.as_usize() % spec.latest_slashed_exit_length] +=
+            effective_balance;
+
+        let whistleblower_index =
+            self.get_beacon_proposer_index(self.slot, RelativeEpoch::Current, spec)?;
+
+        let whistleblower_reward = effective_balance;
         safe_add_assign!(
             self.validator_balances[whistleblower_index as usize],
             whistleblower_reward
@@ -801,166 +683,6 @@ impl BeaconState {
             self.current_epoch(spec) + spec.min_validator_withdrawability_delay;
     }
 
-    /// Returns the crosslink committees for some slot.
-    ///
-    /// Utilizes the cache and will fail if the appropriate cache is not initialized.
-    ///
-    /// Spec v0.4.0
-    pub(crate) fn get_shuffling_for_slot(
-        &self,
-        slot: Slot,
-        registry_change: bool,
-        spec: &ChainSpec,
-    ) -> Result<Vec<Vec<usize>>, Error> {
-        let (_committees_per_epoch, seed, shuffling_epoch, _shuffling_start_shard) =
-            self.get_committee_params_at_slot(slot, registry_change, spec)?;
-
-        self.get_shuffling(seed, shuffling_epoch, spec)
-    }
-
-    /// Shuffle ``validators`` into crosslink committees seeded by ``seed`` and ``epoch``.
-    ///
-    /// Return a list of ``committees_per_epoch`` committees where each
-    /// committee is itself a list of validator indices.
-    ///
-    /// Spec v0.4.0
-    pub(crate) fn get_shuffling(
-        &self,
-        seed: Hash256,
-        epoch: Epoch,
-        spec: &ChainSpec,
-    ) -> Result<Vec<Vec<usize>>, Error> {
-        let active_validator_indices =
-            get_active_validator_indices(&self.validator_registry, epoch);
-        if active_validator_indices.is_empty() {
-            error!("get_shuffling: no validators.");
-            return Err(Error::InsufficientValidators);
-        }
-
-        debug!("Shuffling {} validators...", active_validator_indices.len());
-
-        let committees_per_epoch = spec.get_epoch_committee_count(active_validator_indices.len());
-
-        trace!(
-            "get_shuffling: active_validator_indices.len() == {}, committees_per_epoch: {}",
-            active_validator_indices.len(),
-            committees_per_epoch
-        );
-
-        let active_validator_indices: Vec<usize> = active_validator_indices.to_vec();
-
-        let shuffled_active_validator_indices = shuffle_list(
-            active_validator_indices,
-            spec.shuffle_round_count,
-            &seed[..],
-            true,
-        )
-        .ok_or_else(|| Error::UnableToShuffle)?;
-
-        Ok(shuffled_active_validator_indices
-            .honey_badger_split(committees_per_epoch as usize)
-            .map(|slice: &[usize]| slice.to_vec())
-            .collect())
-    }
-
-    /// Returns the following params for the given slot:
-    ///
-    /// - epoch committee count
-    /// - epoch seed
-    /// - calculation epoch
-    /// - start shard
-    ///
-    /// In the spec, this functionality is included in the `get_crosslink_committees_at_slot(..)`
-    /// function. It is separated here to allow the division of shuffling and committee building,
-    /// as is required for efficient operations.
-    ///
-    /// Spec v0.4.0
-    pub(crate) fn get_committee_params_at_slot(
-        &self,
-        slot: Slot,
-        registry_change: bool,
-        spec: &ChainSpec,
-    ) -> Result<(u64, Hash256, Epoch, u64), Error> {
-        let epoch = slot.epoch(spec.slots_per_epoch);
-        let current_epoch = self.current_epoch(spec);
-        let previous_epoch = self.previous_epoch(spec);
-        let next_epoch = self.next_epoch(spec);
-
-        if epoch == current_epoch {
-            Ok((
-                self.get_current_epoch_committee_count(spec),
-                self.current_shuffling_seed,
-                self.current_shuffling_epoch,
-                self.current_shuffling_start_shard,
-            ))
-        } else if epoch == previous_epoch {
-            Ok((
-                self.get_previous_epoch_committee_count(spec),
-                self.previous_shuffling_seed,
-                self.previous_shuffling_epoch,
-                self.previous_shuffling_start_shard,
-            ))
-        } else if epoch == next_epoch {
-            let current_committees_per_epoch = self.get_current_epoch_committee_count(spec);
-            let epochs_since_last_registry_update =
-                current_epoch - self.validator_registry_update_epoch;
-            let (seed, shuffling_start_shard) = if registry_change {
-                let next_seed = self.generate_seed(next_epoch, spec)?;
-                (
-                    next_seed,
-                    (self.current_shuffling_start_shard + current_committees_per_epoch)
-                        % spec.shard_count,
-                )
-            } else if (epochs_since_last_registry_update > 1)
-                & epochs_since_last_registry_update.is_power_of_two()
-            {
-                let next_seed = self.generate_seed(next_epoch, spec)?;
-                (next_seed, self.current_shuffling_start_shard)
-            } else {
-                (
-                    self.current_shuffling_seed,
-                    self.current_shuffling_start_shard,
-                )
-            };
-            Ok((
-                self.get_next_epoch_committee_count(spec),
-                seed,
-                next_epoch,
-                shuffling_start_shard,
-            ))
-        } else {
-            Err(Error::EpochOutOfBounds)
-        }
-    }
-
-    /// Return the ordered list of shards tuples for the `slot`.
-    ///
-    /// Note: There are two possible shufflings for crosslink committees for a
-    /// `slot` in the next epoch: with and without a `registry_change`
-    ///
-    /// Spec v0.4.0
-    pub(crate) fn get_shards_for_slot(
-        &self,
-        slot: Slot,
-        registry_change: bool,
-        spec: &ChainSpec,
-    ) -> Result<Vec<u64>, Error> {
-        let (committees_per_epoch, _seed, _shuffling_epoch, shuffling_start_shard) =
-            self.get_committee_params_at_slot(slot, registry_change, spec)?;
-
-        let offset = slot.as_u64() % spec.slots_per_epoch;
-        let committees_per_slot = committees_per_epoch / spec.slots_per_epoch;
-        let slot_start_shard =
-            (shuffling_start_shard + committees_per_slot * offset) % spec.shard_count;
-
-        let mut shards_at_slot = vec![];
-        for i in 0..committees_per_slot {
-            shards_at_slot.push((slot_start_shard + i) % spec.shard_count)
-        }
-
-        Ok(shards_at_slot)
-    }
-
     /// Returns the `slot`, `shard` and `committee_index` for which a validator must produce an
     /// attestation.
     ///
@@ -969,14 +691,14 @@ impl BeaconState {
     /// Note: Utilizes the cache and will fail if the appropriate cache is not initialized.
     ///
     /// Spec v0.4.0
-    pub fn attestation_slot_and_shard_for_validator(
+    pub fn get_attestation_duties(
         &self,
         validator_index: usize,
-        _spec: &ChainSpec,
-    ) -> Result<Option<(Slot, u64, u64)>, Error> {
-        let cache = self.cache(RelativeEpoch::Current)?;
+        spec: &ChainSpec,
+    ) -> Result<&Option<AttestationDuty>, Error> {
+        let cache = self.cache(RelativeEpoch::Current, spec)?;
 
-        Ok(*cache
+        Ok(cache
             .attestation_duties
             .get(validator_index)
             .ok_or_else(|| Error::UnknownValidator)?)
@@ -985,11 +707,11 @@ impl BeaconState {
     /// Process the slashings.
     ///
     /// Spec v0.4.0
-    pub fn process_slashings(&mut self, spec: &ChainSpec) {
+    pub fn process_slashings(&mut self, spec: &ChainSpec) -> Result<(), Error> {
         let current_epoch = self.current_epoch(spec);
         let active_validator_indices =
             get_active_validator_indices(&self.validator_registry, current_epoch);
-        let total_balance = self.get_total_balance(&active_validator_indices[..], spec);
+        let total_balance = self.get_total_balance(&active_validator_indices[..], spec)?;
 
         for (index, validator) in self.validator_registry.iter().enumerate() {
             if validator.slashed
@@ -1003,16 +725,19 @@ impl BeaconState {
                     [(epoch_index + 1) % spec.latest_slashed_exit_length];
                 let total_at_end = self.latest_slashed_balances[epoch_index];
                 let total_penalities = total_at_end.saturating_sub(total_at_start);
+
+                let effective_balance = self.get_effective_balance(index, spec)?;
                 let penalty = std::cmp::max(
-                    self.get_effective_balance(index, spec)
-                        * std::cmp::min(total_penalities * 3, total_balance)
+                    effective_balance * std::cmp::min(total_penalities * 3, total_balance)
                         / total_balance,
-                    self.get_effective_balance(index, spec) / spec.min_penalty_quotient,
+                    effective_balance / spec.min_penalty_quotient,
                 );
 
                 safe_sub_assign!(self.validator_balances[index], penalty);
             }
         }
+
+        Ok(())
     }
 
     /// Process the exit queue.
@@ -1047,11 +772,11 @@ impl BeaconState {
     /// Update validator registry, activating/exiting validators if possible.
     ///
     /// Spec v0.4.0
-    pub fn update_validator_registry(&mut self, spec: &ChainSpec) {
+    pub fn update_validator_registry(&mut self, spec: &ChainSpec) -> Result<(), Error> {
         let current_epoch = self.current_epoch(spec);
         let active_validator_indices =
             get_active_validator_indices(&self.validator_registry, current_epoch);
-        let total_balance = self.get_total_balance(&active_validator_indices[..], spec);
+        let total_balance = self.get_total_balance(&active_validator_indices[..], spec)?;
 
         let max_balance_churn = std::cmp::max(
             spec.max_deposit_amount,
@@ -1065,7 +790,7 @@ impl BeaconState {
             if (validator.activation_epoch == spec.far_future_epoch)
                 & (self.validator_balances[index] == spec.max_deposit_amount)
             {
-                balance_churn += self.get_effective_balance(index, spec);
+                balance_churn += self.get_effective_balance(index, spec)?;
                 if balance_churn > max_balance_churn {
                     break;
                 }
@@ -1078,7 +803,7 @@ impl BeaconState {
             let validator = &self.validator_registry[index];
 
             if (validator.exit_epoch == spec.far_future_epoch) & (validator.initiated_exit) {
-                balance_churn += self.get_effective_balance(index, spec);
+                balance_churn += self.get_effective_balance(index, spec)?;
                 if balance_churn > max_balance_churn {
                     break;
                 }
@@ -1088,6 +813,8 @@ impl BeaconState {
         }
 
         self.validator_registry_update_epoch = current_epoch;
+
+        Ok(())
     }
 
     /// Iterate through the validator registry and eject active validators with balance below
@@ -1115,12 +842,13 @@ impl BeaconState {
         epochs_since_finality: Epoch,
         base_reward_quotient: u64,
         spec: &ChainSpec,
-    ) -> u64 {
-        let effective_balance = self.get_effective_balance(validator_index, spec);
-        self.base_reward(validator_index, base_reward_quotient, spec)
+    ) -> Result<u64, Error> {
+        let effective_balance = self.get_effective_balance(validator_index, spec)?;
+        let base_reward = self.base_reward(validator_index, base_reward_quotient, spec)?;
+        Ok(base_reward
             + effective_balance * epochs_since_finality.as_u64()
                 / spec.inactivity_penalty_quotient
-                / 2
+                / 2)
     }
 
     /// Returns the base reward for some validator.
@@ -1133,30 +861,27 @@ impl BeaconState {
         validator_index: usize,
         base_reward_quotient: u64,
         spec: &ChainSpec,
-    ) -> u64 {
-        self.get_effective_balance(validator_index, spec) / base_reward_quotient / 5
+    ) -> Result<u64, Error> {
+        Ok(self.get_effective_balance(validator_index, spec)? / base_reward_quotient / 5)
     }
 
-    /// Returns the union of all participants in the provided attestations
+    /// Return the combined effective balance of an array of validators.
     ///
     /// Spec v0.4.0
-    pub fn get_attestation_participants_union(
+    pub fn get_total_balance(
         &self,
-        attestations: &[&PendingAttestation],
+        validator_indices: &[usize],
         spec: &ChainSpec,
-    ) -> Result<Vec<usize>, Error> {
-        let mut all_participants = attestations
-            .iter()
-            .try_fold::<_, _, Result<Vec<usize>, Error>>(vec![], |mut acc, a| {
-                acc.append(&mut self.get_attestation_participants(
-                    &a.data,
-                    &a.aggregation_bitfield,
-                    spec,
-                )?);
-                Ok(acc)
-            })?;
-        all_participants.sort_unstable();
-        all_participants.dedup();
-        Ok(all_participants)
+    ) -> Result<u64, Error> {
+        validator_indices.iter().try_fold(0_u64, |acc, i| {
+            self.get_effective_balance(*i, spec)
+                .and_then(|bal| Ok(bal + acc))
+        })
+    }
+}
+
+impl From<RelativeEpochError> for Error {
+    fn from(e: RelativeEpochError) -> Error {
+        Error::RelativeEpochError(e)
     }
 }
diff --git a/eth2/types/src/beacon_state/builder.rs b/eth2/types/src/beacon_state/builder.rs
index 22ca3e6224..780ec9b8ba 100644
--- a/eth2/types/src/beacon_state/builder.rs
+++ b/eth2/types/src/beacon_state/builder.rs
@@ -43,12 +43,14 @@ impl BeaconStateBuilder {
         self.state.deposit_index = initial_validator_deposits.len() as u64;
     }
 
-    fn activate_genesis_validators(&mut self, spec: &ChainSpec) {
+    fn activate_genesis_validators(&mut self, spec: &ChainSpec) -> Result<(), BeaconStateError> {
         for validator_index in 0..self.state.validator_registry.len() {
-            if self.state.get_effective_balance(validator_index, spec) >= spec.max_deposit_amount {
+            if self.state.get_effective_balance(validator_index, spec)? >= spec.max_deposit_amount {
                 self.state.activate_validator(validator_index, true, spec);
             }
         }
+
+        Ok(())
     }
 
     /// Instantiate the validator registry from a YAML file.
diff --git a/eth2/types/src/beacon_state/epoch_cache.rs b/eth2/types/src/beacon_state/epoch_cache.rs
index ddcca0a9a0..6312ea5a54 100644
--- a/eth2/types/src/beacon_state/epoch_cache.rs
+++ b/eth2/types/src/beacon_state/epoch_cache.rs
@@ -1,69 +1,283 @@
-use super::{AttestationDuty, BeaconState, CrosslinkCommittees, Error};
-use crate::{ChainSpec, Epoch};
+use super::{BeaconState, Error};
+use crate::*;
+use honey_badger_split::SplitExt;
 use serde_derive::{Deserialize, Serialize};
+use swap_or_not_shuffle::shuffle_list;
 
 #[derive(Debug, Default, PartialEq, Clone, Serialize, Deserialize)]
 pub struct EpochCache {
-    /// True if this cache has been initialized.
-    pub initialized: bool,
-    /// The crosslink committees for an epoch.
-    pub committees: Vec<CrosslinkCommittees>,
+    /// `Some(epoch)` if the cache is initialized, where `epoch` is the cache it holds.
+    pub initialized_epoch: Option<Epoch>,
+    /// All crosslink committees for an epoch.
+    pub epoch_crosslink_committees: EpochCrosslinkCommittees,
     /// Maps validator index to a slot, shard and committee index for attestation.
     pub attestation_duties: Vec<Option<AttestationDuty>>,
     /// Maps a shard to an index of `self.committees`.
-    pub shard_committee_indices: Vec<(usize, usize)>,
+    pub shard_committee_indices: Vec<(Slot, usize)>,
 }
 
 impl EpochCache {
     /// Return a new, fully initialized cache.
     pub fn initialized(
         state: &BeaconState,
-        epoch: Epoch,
+        relative_epoch: RelativeEpoch,
         spec: &ChainSpec,
     ) -> Result<EpochCache, Error> {
-        let mut epoch_committees: Vec<CrosslinkCommittees> =
-            Vec::with_capacity(spec.slots_per_epoch as usize);
+        let epoch = relative_epoch.into_epoch(state.slot.epoch(spec.slots_per_epoch));
 
+        let active_validator_indices =
+            get_active_validator_indices(&state.validator_registry, epoch);
+
+        let builder = match relative_epoch {
+            RelativeEpoch::Previous => EpochCrosslinkCommitteesBuilder::for_previous_epoch(
+                state,
+                active_validator_indices,
+                spec,
+            ),
+            RelativeEpoch::Current => EpochCrosslinkCommitteesBuilder::for_current_epoch(
+                state,
+                active_validator_indices,
+                spec,
+            ),
+            RelativeEpoch::NextWithRegistryChange => {
+                EpochCrosslinkCommitteesBuilder::for_next_epoch(
+                    state,
+                    active_validator_indices,
+                    true,
+                    spec,
+                )?
+            }
+            RelativeEpoch::NextWithoutRegistryChange => {
+                EpochCrosslinkCommitteesBuilder::for_next_epoch(
+                    state,
+                    active_validator_indices,
+                    false,
+                    spec,
+                )?
+            }
+        };
+        let epoch_crosslink_committees = builder.build(spec)?;
+
+        // Loop through all the validators in the committees and create the following maps:
+        //
+        // 1. `attestation_duties`: maps `ValidatorIndex` to `AttestationDuty`.
+        // 2. `shard_committee_indices`: maps `Shard` into a `CrosslinkCommittee` in
+        //    `EpochCrosslinkCommittees`.
         let mut attestation_duties = vec![None; state.validator_registry.len()];
+        let mut shard_committee_indices = vec![(Slot::default(), 0); spec.shard_count as usize];
+        for (i, slot_committees) in epoch_crosslink_committees
+            .crosslink_committees
+            .iter()
+            .enumerate()
+        {
+            let slot = epoch.start_slot(spec.slots_per_epoch) + i as u64;
 
-        let mut shard_committee_indices = vec![(0, 0); spec.shard_count as usize];
+            for (j, crosslink_committee) in slot_committees.iter().enumerate() {
+                let shard = crosslink_committee.shard;
 
-        let mut shuffling =
-            state.get_shuffling_for_slot(epoch.start_slot(spec.slots_per_epoch), false, spec)?;
+                shard_committee_indices[shard as usize] = (slot, j);
 
-        for (epoch_committees_index, slot) in epoch.slot_iter(spec.slots_per_epoch).enumerate() {
-            let mut slot_committees: Vec<(Vec<usize>, u64)> = vec![];
-
-            let shards = state.get_shards_for_slot(slot, false, spec)?;
-            for shard in shards {
-                let committee = shuffling.remove(0);
-                slot_committees.push((committee, shard));
-            }
-
-            for (slot_committees_index, (committee, shard)) in slot_committees.iter().enumerate() {
-                if committee.is_empty() {
-                    return Err(Error::InsufficientValidators);
-                }
-
-                // Store the slot and committee index for this shard.
-                shard_committee_indices[*shard as usize] =
-                    (epoch_committees_index, slot_committees_index);
-
-                // For each validator, store their attestation duties.
-                for (committee_index, validator_index) in committee.iter().enumerate() {
-                    attestation_duties[*validator_index] =
-                        Some((slot, *shard, committee_index as u64))
+                for (k, validator_index) in crosslink_committee.committee.iter().enumerate() {
+                    let attestation_duty = AttestationDuty {
+                        slot,
+                        shard,
+                        committee_index: k,
+                    };
+                    attestation_duties[*validator_index] = Some(attestation_duty)
                 }
             }
-
-            epoch_committees.push(slot_committees)
         }
 
         Ok(EpochCache {
-            initialized: true,
-            committees: epoch_committees,
+            initialized_epoch: Some(epoch),
+            epoch_crosslink_committees,
             attestation_duties,
             shard_committee_indices,
         })
     }
+
+    pub fn get_crosslink_committees_at_slot(
+        &self,
+        slot: Slot,
+        spec: &ChainSpec,
+    ) -> Option<&Vec<CrosslinkCommittee>> {
+        self.epoch_crosslink_committees
+            .get_crosslink_committees_at_slot(slot, spec)
+    }
+
+    pub fn get_crosslink_committee_for_shard(
+        &self,
+        shard: Shard,
+        spec: &ChainSpec,
+    ) -> Option<&CrosslinkCommittee> {
+        let (slot, committee) = self.shard_committee_indices.get(shard as usize)?;
+        let slot_committees = self.get_crosslink_committees_at_slot(*slot, spec)?;
+        slot_committees.get(*committee)
+    }
+}
+
+pub fn get_active_validator_indices(validators: &[Validator], epoch: Epoch) -> Vec<usize> {
+    let mut active = Vec::with_capacity(validators.len());
+
+    for (index, validator) in validators.iter().enumerate() {
+        if validator.is_active_at(epoch) {
+            active.push(index)
+        }
+    }
+
+    active.shrink_to_fit();
+
+    active
+}
+
+#[derive(Debug, Default, PartialEq, Clone, Serialize, Deserialize)]
+pub struct EpochCrosslinkCommittees {
+    epoch: Epoch,
+    pub crosslink_committees: Vec<Vec<CrosslinkCommittee>>,
+}
+
+impl EpochCrosslinkCommittees {
+    fn new(epoch: Epoch, spec: &ChainSpec) -> Self {
+        Self {
+            epoch,
+            crosslink_committees: vec![vec![]; spec.slots_per_epoch as usize],
+        }
+    }
+
+    fn get_crosslink_committees_at_slot(
+        &self,
+        slot: Slot,
+        spec: &ChainSpec,
+    ) -> Option<&Vec<CrosslinkCommittee>> {
+        let epoch_start_slot = self.epoch.start_slot(spec.slots_per_epoch);
+        let epoch_end_slot = self.epoch.end_slot(spec.slots_per_epoch);
+
+        if (epoch_start_slot < slot) && (slot <= epoch_end_slot) {
+            let index = slot - epoch_start_slot;
+            self.crosslink_committees.get(index.as_usize())
+        } else {
+            None
+        }
+    }
+}
+
+pub struct EpochCrosslinkCommitteesBuilder {
+    epoch: Epoch,
+    shuffling_start_shard: Shard,
+    shuffling_seed: Hash256,
+    active_validator_indices: Vec<usize>,
+    committees_per_epoch: u64,
+}
+
+impl EpochCrosslinkCommitteesBuilder {
+    pub fn for_previous_epoch(
+        state: &BeaconState,
+        active_validator_indices: Vec<usize>,
+        spec: &ChainSpec,
+    ) -> Self {
+        Self {
+            epoch: state.previous_epoch(spec),
+            shuffling_start_shard: state.previous_shuffling_start_shard,
+            shuffling_seed: state.previous_shuffling_seed,
+            committees_per_epoch: spec.get_epoch_committee_count(active_validator_indices.len()),
+            active_validator_indices,
+        }
+    }
+
+    pub fn for_current_epoch(
+        state: &BeaconState,
+        active_validator_indices: Vec<usize>,
+        spec: &ChainSpec,
+    ) -> Self {
+        Self {
+            epoch: state.current_epoch(spec),
+            shuffling_start_shard: state.current_shuffling_start_shard,
+            shuffling_seed: state.current_shuffling_seed,
+            committees_per_epoch: spec.get_epoch_committee_count(active_validator_indices.len()),
+            active_validator_indices,
+        }
+    }
+
+    pub fn for_next_epoch(
+        state: &BeaconState,
+        active_validator_indices: Vec<usize>,
+        registry_change: bool,
+        spec: &ChainSpec,
+    ) -> Result<Self, BeaconStateError> {
+        let current_epoch = state.current_epoch(spec);
+        let next_epoch = state.next_epoch(spec);
+        let committees_per_epoch = spec.get_epoch_committee_count(active_validator_indices.len());
+
+        let epochs_since_last_registry_update =
+            current_epoch - state.validator_registry_update_epoch;
+
+        let (seed, shuffling_start_shard) = if registry_change {
+            let next_seed = state.generate_seed(next_epoch, spec)?;
+            (
+                next_seed,
+                (state.current_shuffling_start_shard + committees_per_epoch) % spec.shard_count,
+            )
+        } else if (epochs_since_last_registry_update > 1)
+            & epochs_since_last_registry_update.is_power_of_two()
+        {
+            let next_seed = state.generate_seed(next_epoch, spec)?;
+            (next_seed, state.current_shuffling_start_shard)
+        } else {
+            (
+                state.current_shuffling_seed,
+                state.current_shuffling_start_shard,
+            )
+        };
+
+        Ok(Self {
+            epoch: state.next_epoch(spec),
+            shuffling_start_shard,
+            shuffling_seed: seed,
+            active_validator_indices,
+            committees_per_epoch,
+        })
+    }
+
+    pub fn build(self, spec: &ChainSpec) -> Result<EpochCrosslinkCommittees, BeaconStateError> {
+        if self.active_validator_indices.is_empty() {
+            return Err(Error::InsufficientValidators);
+        }
+
+        let shuffled_active_validator_indices = shuffle_list(
+            self.active_validator_indices,
+            spec.shuffle_round_count,
+            &self.shuffling_seed[..],
+            true,
+        )
+        .ok_or_else(|| Error::UnableToShuffle)?;
+
+        let mut committees: Vec<Vec<usize>> = shuffled_active_validator_indices
+            .honey_badger_split(self.committees_per_epoch as usize)
+            .map(|slice: &[usize]| slice.to_vec())
+            .collect();
+
+        let mut epoch_crosslink_committees = EpochCrosslinkCommittees::new(self.epoch, spec);
+        let mut shard = self.shuffling_start_shard;
+
+        let committees_per_slot = (self.committees_per_epoch / spec.slots_per_epoch) as usize;
+
+        for i in 0..spec.slots_per_epoch as usize {
+            for j in (0..committees.len())
+                .into_iter()
+                .skip(i * committees_per_slot)
+                .take(committees_per_slot)
+            {
+                let crosslink_committee = CrosslinkCommittee {
+                    shard,
+                    committee: committees.remove(j),
+                };
+                epoch_crosslink_committees.crosslink_committees[i].push(crosslink_committee);
+
+                shard += 1;
+                shard %= spec.shard_count;
+            }
+        }
+
+        Ok(epoch_crosslink_committees)
+    }
 }
diff --git a/eth2/types/src/beacon_state/tests.rs b/eth2/types/src/beacon_state/tests.rs
index 1e1a555fd6..6c10ebe86d 100644
--- a/eth2/types/src/beacon_state/tests.rs
+++ b/eth2/types/src/beacon_state/tests.rs
@@ -1,53 +1,5 @@
 #![cfg(test)]
 
 use super::*;
-use crate::test_utils::TestingBeaconStateBuilder;
-use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-use crate::{BeaconState, ChainSpec};
-
-/// Tests that `get_attestation_participants` is consistent with the result of
-/// get_crosslink_committees_at_slot` with a full bitfield.
-#[test]
-pub fn get_attestation_participants_consistency() {
-    let mut rng = XorShiftRng::from_seed([42; 16]);
-
-    let spec = ChainSpec::few_validators();
-    let builder = TestingBeaconStateBuilder::from_deterministic_keypairs(8, &spec);
-    let (mut state, _keypairs) = builder.build();
-
-    state
-        .build_epoch_cache(RelativeEpoch::Previous, &spec)
-        .unwrap();
-    state
-        .build_epoch_cache(RelativeEpoch::Current, &spec)
-        .unwrap();
-    state.build_epoch_cache(RelativeEpoch::Next, &spec).unwrap();
-
-    for slot in state
-        .slot
-        .epoch(spec.slots_per_epoch)
-        .slot_iter(spec.slots_per_epoch)
-    {
-        let committees = state.get_crosslink_committees_at_slot(slot, &spec).unwrap();
-
-        for (committee, shard) in committees {
-            let mut attestation_data = AttestationData::random_for_test(&mut rng);
-            attestation_data.slot = slot;
-            attestation_data.shard = *shard;
-
-            let mut bitfield = Bitfield::new();
-            for (i, _) in committee.iter().enumerate() {
-                bitfield.set(i, true);
-            }
-
-            assert_eq!(
-                state
-                    .get_attestation_participants(&attestation_data, &bitfield, &spec)
-                    .unwrap(),
-                *committee
-            );
-        }
-    }
-}
 
 ssz_tests!(BeaconState);
diff --git a/eth2/types/src/crosslink_committee.rs b/eth2/types/src/crosslink_committee.rs
new file mode 100644
index 0000000000..06a6562fcd
--- /dev/null
+++ b/eth2/types/src/crosslink_committee.rs
@@ -0,0 +1,9 @@
+use crate::*;
+use serde_derive::{Deserialize, Serialize};
+use ssz_derive::{Decode, Encode, TreeHash};
+
+#[derive(Default, Clone, Debug, PartialEq, Serialize, Deserialize, Decode, Encode, TreeHash)]
+pub struct CrosslinkCommittee {
+    pub shard: Shard,
+    pub committee: Vec<usize>,
+}
diff --git a/eth2/types/src/epoch_cache.rs b/eth2/types/src/epoch_cache.rs
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/eth2/types/src/lib.rs b/eth2/types/src/lib.rs
index c38fa80311..05f8254d5c 100644
--- a/eth2/types/src/lib.rs
+++ b/eth2/types/src/lib.rs
@@ -6,6 +6,7 @@ pub mod test_utils;
 pub mod attestation;
 pub mod attestation_data;
 pub mod attestation_data_and_custody_bit;
+pub mod attestation_duty;
 pub mod attester_slashing;
 pub mod beacon_block;
 pub mod beacon_block_body;
@@ -13,6 +14,7 @@ pub mod beacon_block_header;
 pub mod beacon_state;
 pub mod chain_spec;
 pub mod crosslink;
+pub mod crosslink_committee;
 pub mod deposit;
 pub mod deposit_data;
 pub mod deposit_input;
@@ -28,6 +30,7 @@ pub mod transfer;
 pub mod voluntary_exit;
 #[macro_use]
 pub mod slot_epoch_macros;
+pub mod relative_epoch;
 pub mod slot_epoch;
 pub mod slot_height;
 pub mod validator;
@@ -39,13 +42,15 @@ use std::collections::HashMap;
 pub use crate::attestation::Attestation;
 pub use crate::attestation_data::AttestationData;
 pub use crate::attestation_data_and_custody_bit::AttestationDataAndCustodyBit;
+pub use crate::attestation_duty::AttestationDuty;
 pub use crate::attester_slashing::AttesterSlashing;
 pub use crate::beacon_block::BeaconBlock;
 pub use crate::beacon_block_body::BeaconBlockBody;
 pub use crate::beacon_block_header::BeaconBlockHeader;
-pub use crate::beacon_state::{BeaconState, Error as BeaconStateError, RelativeEpoch};
+pub use crate::beacon_state::{BeaconState, Error as BeaconStateError};
 pub use crate::chain_spec::{ChainSpec, Domain};
 pub use crate::crosslink::Crosslink;
+pub use crate::crosslink_committee::CrosslinkCommittee;
 pub use crate::deposit::Deposit;
 pub use crate::deposit_data::DepositData;
 pub use crate::deposit_input::DepositInput;
@@ -56,6 +61,7 @@ pub use crate::free_attestation::FreeAttestation;
 pub use crate::historical_batch::HistoricalBatch;
 pub use crate::pending_attestation::PendingAttestation;
 pub use crate::proposer_slashing::ProposerSlashing;
+pub use crate::relative_epoch::{Error as RelativeEpochError, RelativeEpoch};
 pub use crate::slashable_attestation::SlashableAttestation;
 pub use crate::slot_epoch::{Epoch, Slot};
 pub use crate::slot_height::SlotHeight;
@@ -63,6 +69,10 @@ pub use crate::transfer::Transfer;
 pub use crate::validator::Validator;
 pub use crate::voluntary_exit::VoluntaryExit;
 
+pub type Shard = u64;
+pub type Committee = Vec<usize>;
+pub type CrosslinkCommittees = Vec<(Committee, u64)>;
+
 pub type Hash256 = H256;
 pub type Address = H160;
 pub type EthBalance = U256;
diff --git a/eth2/types/src/relative_epoch.rs b/eth2/types/src/relative_epoch.rs
new file mode 100644
index 0000000000..9439366059
--- /dev/null
+++ b/eth2/types/src/relative_epoch.rs
@@ -0,0 +1,76 @@
+use crate::*;
+
+#[derive(Debug, PartialEq, Clone, Copy)]
+pub enum Error {
+    EpochTooLow { base: Epoch, other: Epoch },
+    EpochTooHigh { base: Epoch, other: Epoch },
+    AmbiguiousNextEpoch,
+}
+
+/// Defines the epochs relative to some epoch. Most useful when referring to the committees prior
+/// to and following some epoch.
+///
+/// Spec v0.5.0
+#[derive(Debug, PartialEq, Clone, Copy)]
+pub enum RelativeEpoch {
+    /// The prior epoch.
+    Previous,
+    /// The current epoch.
+    Current,
+    /// The next epoch if there _is_ a validator registry update.
+    ///
+    /// If the validator registry is updated during an epoch transition, a new shuffling seed is
+    /// generated, this changes the attestation and proposal roles.
+    NextWithRegistryChange,
+    /// The next epoch if there _is not_ a validator registry update.
+    ///
+    /// If the validator registry _is not_ updated during an epoch transition, the shuffling stays
+    /// the same.
+    NextWithoutRegistryChange,
+}
+
+impl RelativeEpoch {
+    /// Returns the `epoch` that `self` refers to, with respect to the `base` epoch.
+    ///
+    /// Spec v0.5.0
+    pub fn into_epoch(&self, base: Epoch) -> Epoch {
+        match self {
+            RelativeEpoch::Previous => base - 1,
+            RelativeEpoch::Current => base,
+            RelativeEpoch::NextWithoutRegistryChange => base + 1,
+            RelativeEpoch::NextWithRegistryChange => base + 1,
+        }
+    }
+
+    /// Converts the `other` epoch into a `RelativeEpoch`, with respect to `base`
+    ///
+    /// ## Errors
+    /// Returns an error when:
+    /// - `EpochTooLow` when `other` is more than 1 prior to `base`.
+    /// - `EpochTooHigh` when `other` is more than 1 after `base`.
+    /// - `AmbiguiousNextEpoch` whenever `other` is one after `base`, because it's unknowable if
+    ///   there will be a registry change.
+    ///
+    /// Spec v0.5.0
+    pub fn from_epoch(base: Epoch, other: Epoch) -> Result<Self, Error> {
+        if other == base - 1 {
+            Ok(RelativeEpoch::Previous)
+        } else if other == base {
+            Ok(RelativeEpoch::Current)
+        } else if other == base + 1 {
+            Err(Error::AmbiguiousNextEpoch)
+        } else if other < base {
+            Err(Error::EpochTooLow { base, other })
+        } else {
+            Err(Error::EpochTooHigh { base, other })
+        }
+    }
+
+    /// Convenience function for `Self::from_epoch` where both slots are converted into epochs.
+    pub fn from_slot(base: Slot, other: Slot, spec: &ChainSpec) -> Result<Self, Error> {
+        Self::from_epoch(
+            base.epoch(spec.slots_per_epoch),
+            other.epoch(spec.slots_per_epoch),
+        )
+    }
+}
diff --git a/eth2/types/src/test_utils/testing_beacon_block_builder.rs b/eth2/types/src/test_utils/testing_beacon_block_builder.rs
index 7fb3d8e09b..402bd79d63 100644
--- a/eth2/types/src/test_utils/testing_beacon_block_builder.rs
+++ b/eth2/types/src/test_utils/testing_beacon_block_builder.rs
@@ -109,12 +109,20 @@ impl TestingBeaconBlockBuilder {
                 break;
             }
 
-            for (committee, shard) in state.get_crosslink_committees_at_slot(slot, spec)? {
+            let relative_epoch = RelativeEpoch::from_slot(state.slot, slot, spec).unwrap();
+            for crosslink_committee in
+                state.get_crosslink_committees_at_slot(slot, relative_epoch, spec)?
+            {
                 if attestations_added >= num_attestations {
                     break;
                 }
 
-                committees.push((slot, committee.clone(), committee.clone(), *shard));
+                committees.push((
+                    slot,
+                    crosslink_committee.committee.clone(),
+                    crosslink_committee.committee.clone(),
+                    crosslink_committee.shard,
+                ));
 
                 attestations_added += 1;
             }
diff --git a/eth2/types/src/test_utils/testing_beacon_state_builder.rs b/eth2/types/src/test_utils/testing_beacon_state_builder.rs
index 8ef4f76ce1..9e613f0e91 100644
--- a/eth2/types/src/test_utils/testing_beacon_state_builder.rs
+++ b/eth2/types/src/test_utils/testing_beacon_state_builder.rs
@@ -159,7 +159,8 @@ impl TestingBeaconStateBuilder {
 
         state.build_epoch_cache(RelativeEpoch::Previous, &spec)?;
         state.build_epoch_cache(RelativeEpoch::Current, &spec)?;
-        state.build_epoch_cache(RelativeEpoch::Next, &spec)?;
+        state.build_epoch_cache(RelativeEpoch::NextWithRegistryChange, &spec)?;
+        state.build_epoch_cache(RelativeEpoch::NextWithoutRegistryChange, &spec)?;
 
         state.update_pubkey_cache()?;
 
@@ -222,15 +223,21 @@ impl TestingBeaconStateBuilder {
         for slot in first_slot..last_slot + 1 {
             let slot = Slot::from(slot);
 
+            let relative_epoch = RelativeEpoch::from_slot(state.slot, slot, spec).unwrap();
             let committees = state
-                .get_crosslink_committees_at_slot(slot, spec)
+                .get_crosslink_committees_at_slot(slot, relative_epoch, spec)
                 .unwrap()
                 .clone();
 
-            for (committee, shard) in committees {
-                let mut builder = TestingPendingAttestationBuilder::new(state, shard, slot, spec);
+            for crosslink_committee in committees {
+                let mut builder = TestingPendingAttestationBuilder::new(
+                    state,
+                    crosslink_committee.shard,
+                    slot,
+                    spec,
+                );
                 // The entire committee should have signed the pending attestation.
-                let signers = vec![true; committee.len()];
+                let signers = vec![true; crosslink_committee.committee.len()];
                 builder.add_committee_participation(signers);
                 let attestation = builder.build();
 

From 6bd2055a0ac2f15eb47ce837fa56e01f9e5e161a Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Sun, 17 Mar 2019 12:25:37 +1100
Subject: [PATCH 35/60] Update block processing to v0.5.0

---
 .../src/per_block_processing.rs               | 131 +++++-------
 .../src/per_block_processing/errors.rs        |  86 ++++----
 .../validate_attestation.rs                   | 198 ++++++++++--------
 .../verify_attester_slashing.rs               |  16 +-
 .../per_block_processing/verify_deposit.rs    |  33 ++-
 .../src/per_block_processing/verify_exit.rs   |  30 ++-
 .../verify_proposer_slashing.rs               |  50 ++---
 .../per_block_processing/verify_transfer.rs   |  74 ++++---
 .../src/per_slot_processing.rs                |  22 +-
 eth2/types/src/beacon_state.rs                |  85 ++++++--
 eth2/types/src/chain_spec.rs                  |   2 +-
 eth2/types/src/proposer_slashing.rs           |   4 +-
 .../testing_proposer_slashing_builder.rs      |  18 +-
 13 files changed, 413 insertions(+), 336 deletions(-)

diff --git a/eth2/state_processing/src/per_block_processing.rs b/eth2/state_processing/src/per_block_processing.rs
index 13a47836b5..377f92e8b1 100644
--- a/eth2/state_processing/src/per_block_processing.rs
+++ b/eth2/state_processing/src/per_block_processing.rs
@@ -1,17 +1,14 @@
 use self::verify_proposer_slashing::verify_proposer_slashing;
 use errors::{BlockInvalid as Invalid, BlockProcessingError as Error, IntoWithIndex};
-use hashing::hash;
 use rayon::prelude::*;
-use ssz::{ssz_encode, SignedRoot, TreeHash};
+use ssz::{SignedRoot, TreeHash};
 use types::*;
 
 pub use self::verify_attester_slashing::{
     gather_attester_slashing_indices, verify_attester_slashing,
 };
 pub use validate_attestation::{validate_attestation, validate_attestation_without_signature};
-pub use verify_deposit::{
-    build_public_key_hashmap, get_existing_validator_index, verify_deposit, verify_deposit_index,
-};
+pub use verify_deposit::{get_existing_validator_index, verify_deposit, verify_deposit_index};
 pub use verify_exit::verify_exit;
 pub use verify_slashable_attestation::verify_slashable_attestation;
 pub use verify_transfer::{execute_transfer, verify_transfer};
@@ -72,8 +69,7 @@ fn per_block_processing_signature_optional(
     should_verify_block_signature: bool,
     spec: &ChainSpec,
 ) -> Result<(), Error> {
-    // Verify that `block.slot == state.slot`.
-    verify!(block.slot == state.slot, Invalid::StateSlotMismatch);
+    process_block_header(state, block, spec)?;
 
     // Ensure the current and previous epoch cache is built.
     state.build_epoch_cache(RelativeEpoch::Current, spec)?;
@@ -83,7 +79,7 @@ fn per_block_processing_signature_optional(
         verify_block_signature(&state, &block, &spec)?;
     }
     process_randao(&mut state, &block, &spec)?;
-    process_eth1_data(&mut state, &block.eth1_data)?;
+    process_eth1_data(&mut state, &block.body.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)?;
@@ -94,33 +90,47 @@ fn per_block_processing_signature_optional(
     Ok(())
 }
 
+/// Processes the block header.
+///
+/// Spec v0.5.0
+pub fn process_block_header(
+    state: &BeaconState,
+    block: &BeaconBlock,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    verify!(block.slot == state.slot, Invalid::StateSlotMismatch);
+
+    verify!(
+        block.previous_block_root.as_bytes() == &state.latest_block_header.hash_tree_root()[..],
+        Invalid::ParentBlockRootMismatch
+    );
+
+    state.latest_block_header = block.into_temporary_header(spec);
+
+    Ok(())
+}
+
 /// Verifies the signature of a block.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.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 block_proposer = &state.validator_registry
+        [state.get_beacon_proposer_index(block.slot, RelativeEpoch::Current, 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,
+        Domain::BeaconBlock,
         &state.fork,
     );
 
     verify!(
-        proposal
+        block
             .signature
-            .verify(&proposal.signed_root()[..], domain, &block_proposer.pubkey),
+            .verify(&block.signed_root()[..], domain, &block_proposer.pubkey),
         Invalid::BadSignature
     );
 
@@ -130,21 +140,18 @@ pub fn verify_block_signature(
 /// Verifies the `randao_reveal` against the block's proposer pubkey and updates
 /// `state.latest_randao_mixes`.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.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)?];
+    let block_proposer = &state.validator_registry
+        [state.get_beacon_proposer_index(block.slot, RelativeEpoch::Current, 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 the RANDAO is a valid signature of the proposer.
     verify!(
-        block.randao_reveal.verify(
+        block.body.randao_reveal.verify(
             &state.current_epoch(spec).hash_tree_root()[..],
             spec.get_domain(
                 block.slot.epoch(spec.slots_per_epoch),
@@ -156,21 +163,23 @@ pub fn process_randao(
         Invalid::BadRandaoSignature
     );
 
-    // Update the state's RANDAO mix with the one revealed in the block.
-    update_randao(state, &block.randao_reveal, spec)?;
+    // Update the current epoch RANDAO mix.
+    state.update_randao_mix(state.current_epoch(spec), &block.body.randao_reveal, spec)?;
 
     Ok(())
 }
 
 /// Update the `state.eth1_data_votes` based upon the `eth1_data` provided.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.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.
+    // Attempt to find a `Eth1DataVote` with matching `Eth1Data`.
     let matching_eth1_vote_index = state
         .eth1_data_votes
         .iter()
         .position(|vote| vote.eth1_data == *eth1_data);
+
+    // If a vote exists, increment it's `vote_count`. Otherwise, create a new `Eth1DataVote`.
     if let Some(index) = matching_eth1_vote_index {
         state.eth1_data_votes[index].vote_count += 1;
     } else {
@@ -183,46 +192,12 @@ pub fn process_eth1_data(state: &mut BeaconState, eth1_data: &Eth1Data) -> Resul
     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
+/// Spec v0.5.0
 pub fn process_proposer_slashings(
     state: &mut BeaconState,
     proposer_slashings: &[ProposerSlashing],
@@ -242,6 +217,7 @@ pub fn process_proposer_slashings(
                 .map_err(|e| e.into_with_index(i))
         })?;
 
+    // Update the state.
     for proposer_slashing in proposer_slashings {
         state.slash_validator(proposer_slashing.proposer_index as usize, spec)?;
     }
@@ -254,7 +230,7 @@ pub fn process_proposer_slashings(
 /// 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
+/// Spec v0.5.0
 pub fn process_attester_slashings(
     state: &mut BeaconState,
     attester_slashings: &[AttesterSlashing],
@@ -296,7 +272,7 @@ pub fn process_attester_slashings(
         )
         .map_err(|e| e.into_with_index(i))?;
 
-        let slashable_indices = gather_attester_slashing_indices(&state, &attester_slashing)
+        let slashable_indices = gather_attester_slashing_indices(&state, &attester_slashing, spec)
             .map_err(|e| e.into_with_index(i))?;
 
         for i in slashable_indices {
@@ -312,7 +288,7 @@ pub fn process_attester_slashings(
 /// 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
+/// Spec v0.5.0
 pub fn process_attestations(
     state: &mut BeaconState,
     attestations: &[Attestation],
@@ -342,7 +318,14 @@ pub fn process_attestations(
             custody_bitfield: attestation.custody_bitfield.clone(),
             inclusion_slot: state.slot,
         };
-        state.latest_attestations.push(pending_attestation);
+
+        let attestation_epoch = attestation.data.slot.epoch(spec.slots_per_epoch);
+
+        if attestation_epoch == state.current_epoch(spec) {
+            state.current_epoch_attestations.push(pending_attestation)
+        } else if attestation_epoch == state.previous_epoch(spec) {
+            state.previous_epoch_attestations.push(pending_attestation)
+        }
     }
 
     Ok(())
@@ -353,7 +336,7 @@ pub fn process_attestations(
 /// 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
+/// Spec v0.5.0
 pub fn process_deposits(
     state: &mut BeaconState,
     deposits: &[Deposit],
@@ -423,7 +406,7 @@ pub fn process_deposits(
 /// 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
+/// Spec v0.5.0
 pub fn process_exits(
     state: &mut BeaconState,
     voluntary_exits: &[VoluntaryExit],
@@ -455,7 +438,7 @@ pub fn process_exits(
 /// 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
+/// Spec v0.5.0
 pub fn process_transfers(
     state: &mut BeaconState,
     transfers: &[Transfer],
diff --git a/eth2/state_processing/src/per_block_processing/errors.rs b/eth2/state_processing/src/per_block_processing/errors.rs
index 8366a6584f..c0fe252de4 100644
--- a/eth2/state_processing/src/per_block_processing/errors.rs
+++ b/eth2/state_processing/src/per_block_processing/errors.rs
@@ -67,6 +67,7 @@ impl_from_beacon_state_error!(BlockProcessingError);
 #[derive(Debug, PartialEq)]
 pub enum BlockInvalid {
     StateSlotMismatch,
+    ParentBlockRootMismatch,
     BadSignature,
     BadRandaoSignature,
     MaxAttestationsExceeded,
@@ -112,45 +113,53 @@ pub enum AttestationValidationError {
 #[derive(Debug, PartialEq)]
 pub enum AttestationInvalid {
     /// Attestation references a pre-genesis slot.
-    ///
-    /// (genesis_slot, attestation_slot)
-    PreGenesis(Slot, Slot),
+    PreGenesis { genesis: Slot, attestation: Slot },
     /// Attestation included before the inclusion delay.
-    ///
-    /// (state_slot, inclusion_delay, attestation_slot)
-    IncludedTooEarly(Slot, u64, Slot),
+    IncludedTooEarly {
+        state: Slot,
+        delay: u64,
+        attestation: Slot,
+    },
     /// Attestation slot is too far in the past to be included in a block.
-    ///
-    /// (state_slot, attestation_slot)
-    IncludedTooLate(Slot, Slot),
+    IncludedTooLate { state: Slot, attestation: 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),
+    /// `is_current` is `true` if the attestation was compared to the
+    /// `state.current_justified_epoch`, `false` if compared to `state.previous_justified_epoch`.
+    WrongJustifiedEpoch {
+        state: Epoch,
+        attestation: Epoch,
+        is_current: bool,
+    },
     /// Attestation justified epoch root does not match root known to the state.
     ///
-    /// (state_justified_root, attestation_justified_root)
-    WrongJustifiedRoot(Hash256, Hash256),
+    /// `is_current` is `true` if the attestation was compared to the
+    /// `state.current_justified_epoch`, `false` if compared to `state.previous_justified_epoch`.
+    WrongJustifiedRoot {
+        state: Hash256,
+        attestation: Hash256,
+        is_current: bool,
+    },
     /// Attestation crosslink root does not match the state crosslink root for the attestations
     /// slot.
-    BadLatestCrosslinkRoot,
+    BadPreviousCrosslink,
     /// 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),
+    BadCustodyBitfieldLength {
+        committee_len: usize,
+        bitfield_len: 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),
+    BadAggregationBitfieldLength {
+        committee_len: usize,
+        bitfield_len: usize,
+    },
+    /// There was no known committee in this `epoch` for the given shard and slot.
+    NoCommitteeForShard { shard: u64, slot: Slot },
     /// The validator index was unknown.
     UnknownValidator(u64),
     /// The attestation signature verification failed.
@@ -188,6 +197,8 @@ pub enum AttesterSlashingInvalid {
     SlashableAttestation2Invalid(SlashableAttestationInvalid),
     /// The validator index is unknown. One cannot slash one who does not exist.
     UnknownValidator(u64),
+    /// The specified validator has already been withdrawn.
+    ValidatorAlreadyWithdrawn(u64),
     /// There were no indices able to be slashed.
     NoSlashableIndices,
 }
@@ -264,16 +275,12 @@ pub enum ProposerSlashingInvalid {
     ///
     /// (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 proposals are identical and therefore not slashable.
+    ProposalsIdentical,
     /// The specified proposer has already been slashed.
     ProposerAlreadySlashed,
+    /// The specified proposer has already been withdrawn.
+    ProposerAlreadyWithdrawn(u64),
     /// The first proposal signature was invalid.
     BadProposal1Signature,
     /// The second proposal signature was invalid.
@@ -302,9 +309,7 @@ pub enum DepositValidationError {
 #[derive(Debug, PartialEq)]
 pub enum DepositInvalid {
     /// The deposit index does not match the state index.
-    ///
-    /// (state_index, deposit_index)
-    BadIndex(u64, u64),
+    BadIndex { state: u64, deposit: u64 },
     /// The proof-of-possession does not match the given pubkey.
     BadProofOfPossession,
     /// The withdrawal credentials for the depositing validator did not match the withdrawal
@@ -334,11 +339,14 @@ pub enum ExitValidationError {
 pub enum ExitInvalid {
     /// The specified validator is not in the state's validator registry.
     ValidatorUnknown(u64),
-    AlreadyExited,
+    /// The specified validator has a non-maximum exit epoch.
+    AlreadyExited(u64),
+    /// The specified validator has already initiated exit.
+    AlreadyInitiatedExited(u64),
     /// The exit is for a future epoch.
-    ///
-    /// (state_epoch, exit_epoch)
-    FutureEpoch(Epoch, Epoch),
+    FutureEpoch { state: Epoch, exit: Epoch },
+    /// The validator has not been active for long enough.
+    TooYoungToLeave { lifespan: Epoch, expected: u64 },
     /// The exit signature was not signed by the validator.
     BadSignature,
 }
diff --git a/eth2/state_processing/src/per_block_processing/validate_attestation.rs b/eth2/state_processing/src/per_block_processing/validate_attestation.rs
index b153608504..9d13214077 100644
--- a/eth2/state_processing/src/per_block_processing/validate_attestation.rs
+++ b/eth2/state_processing/src/per_block_processing/validate_attestation.rs
@@ -8,7 +8,7 @@ use types::*;
 ///
 /// Returns `Ok(())` if the `Attestation` is valid, otherwise indicates the reason for invalidity.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 pub fn validate_attestation(
     state: &BeaconState,
     attestation: &Attestation,
@@ -22,7 +22,7 @@ pub fn validate_attestation(
 ///
 /// Returns `Ok(())` if the `Attestation` is valid, otherwise indicates the reason for invalidity.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 pub fn validate_attestation_without_signature(
     state: &BeaconState,
     attestation: &Attestation,
@@ -35,74 +35,83 @@ pub fn validate_attestation_without_signature(
 /// given state, optionally validating the aggregate signature.
 ///
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 fn validate_attestation_signature_optional(
     state: &BeaconState,
     attestation: &Attestation,
     spec: &ChainSpec,
     verify_signature: bool,
 ) -> Result<(), Error> {
-    // Verify that `attestation.data.slot >= GENESIS_SLOT`.
+    let state_epoch = state.slot.epoch(spec.slots_per_epoch);
+    let attestation_epoch = attestation.data.slot.epoch(spec.slots_per_epoch);
+
+    // Can't submit pre-historic attestations.
     verify!(
         attestation.data.slot >= spec.genesis_slot,
-        Invalid::PreGenesis(spec.genesis_slot, attestation.data.slot)
+        Invalid::PreGenesis {
+            genesis: spec.genesis_slot,
+            attestation: attestation.data.slot
+        }
     );
 
-    // Verify that `attestation.data.slot + MIN_ATTESTATION_INCLUSION_DELAY <= state.slot`.
+    // Can't submit attestations too far in history.
+    verify!(
+        state.slot <= attestation.data.slot + spec.slots_per_epoch,
+        Invalid::IncludedTooLate {
+            state: spec.genesis_slot,
+            attestation: attestation.data.slot
+        }
+    );
+
+    // Can't submit attestation too quickly.
     verify!(
         attestation.data.slot + spec.min_attestation_inclusion_delay <= state.slot,
-        Invalid::IncludedTooEarly(
-            state.slot,
-            spec.min_attestation_inclusion_delay,
-            attestation.data.slot
-        )
+        Invalid::IncludedTooEarly {
+            state: state.slot,
+            delay: spec.min_attestation_inclusion_delay,
+            attestation: 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 the justified epoch and root is correct.
+    if attestation_epoch >= state_epoch {
         verify!(
-            attestation.data.justified_epoch == state.justified_epoch,
-            Invalid::WrongJustifiedEpoch(
-                attestation.data.justified_epoch,
-                state.justified_epoch,
-                false
-            )
+            attestation.data.source_epoch == state.current_justified_epoch,
+            Invalid::WrongJustifiedEpoch {
+                state: state.current_justified_epoch,
+                attestation: attestation.data.source_epoch,
+                is_current: true,
+            }
+        );
+        verify!(
+            attestation.data.source_root == state.current_justified_root,
+            Invalid::WrongJustifiedRoot {
+                state: state.current_justified_root,
+                attestation: attestation.data.source_root,
+                is_current: true,
+            }
         );
     } else {
         verify!(
-            attestation.data.justified_epoch == state.previous_justified_epoch,
-            Invalid::WrongJustifiedEpoch(
-                attestation.data.justified_epoch,
-                state.previous_justified_epoch,
-                true
-            )
+            attestation.data.source_epoch == state.previous_justified_epoch,
+            Invalid::WrongJustifiedEpoch {
+                state: state.previous_justified_epoch,
+                attestation: attestation.data.source_epoch,
+                is_current: false,
+            }
+        );
+        verify!(
+            attestation.data.source_root == state.previous_justified_root,
+            Invalid::WrongJustifiedRoot {
+                state: state.previous_justified_root,
+                attestation: attestation.data.source_root,
+                is_current: 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)
-    );
-
+    // Check that the crosslink data is valid.
+    //
     // Verify that either:
     //
     // (i)`state.latest_crosslinks[attestation.data.shard] == attestation.data.latest_crosslink`,
@@ -115,46 +124,59 @@ fn validate_attestation_signature_optional(
         epoch: attestation.data.slot.epoch(spec.slots_per_epoch),
     };
     verify!(
-        (attestation.data.latest_crosslink
+        (attestation.data.previous_crosslink
             == state.latest_crosslinks[attestation.data.shard as usize])
             | (state.latest_crosslinks[attestation.data.shard as usize] == potential_crosslink),
-        Invalid::BadLatestCrosslinkRoot
+        Invalid::BadPreviousCrosslink
     );
 
-    // 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.
+    // Attestation must be non-empty!
     verify!(
         attestation.aggregation_bitfield.num_set_bits() != 0,
         Invalid::AggregationBitfieldIsEmpty
     );
+    // Custody bitfield must be empty (be be removed in phase 1)
+    verify!(
+        attestation.custody_bitfield.num_set_bits() == 0,
+        Invalid::CustodyBitfieldHasSetBits
+    );
+
+    // Get the committee for the specific shard that this attestation is for.
+    let crosslink_committee = state
+        .get_crosslink_committees_at_slot(
+            attestation.data.slot,
+            RelativeEpoch::NextWithoutRegistryChange,
+            spec,
+        )?
+        .iter()
+        .find(|c| c.shard == attestation.data.shard)
+        .ok_or_else(|| {
+            Error::Invalid(Invalid::NoCommitteeForShard {
+                shard: attestation.data.shard,
+                slot: attestation.data.slot,
+            })
+        })?;
+    let committee = &crosslink_committee.committee;
+
+    // Custody bitfield length is correct.
+    //
+    // This is not directly in the spec, but it is inferred.
+    verify!(
+        verify_bitfield_length(&attestation.custody_bitfield, committee.len()),
+        Invalid::BadCustodyBitfieldLength {
+            committee_len: committee.len(),
+            bitfield_len: attestation.custody_bitfield.len()
+        }
+    );
     // Aggregation bitfield length is correct.
+    //
+    // This is not directly in the spec, but it is inferred.
     verify!(
         verify_bitfield_length(&attestation.aggregation_bitfield, committee.len()),
-        Invalid::BadAggregationBitfieldLength(
-            committee.len(),
-            attestation.aggregation_bitfield.len()
-        )
+        Invalid::BadAggregationBitfieldLength {
+            committee_len: committee.len(),
+            bitfield_len: attestation.custody_bitfield.len()
+        }
     );
 
     if verify_signature {
@@ -171,7 +193,7 @@ fn validate_attestation_signature_optional(
         )?;
     }
 
-    // [TO BE REMOVED IN PHASE 1] Verify that `attestation.data.crosslink_data_root == ZERO_HASH`.
+    // Crosslink data root is zero (to be removed in phase 1).
     verify!(
         attestation.data.crosslink_data_root == spec.zero_hash,
         Invalid::ShardBlockRootNotZero
@@ -188,7 +210,7 @@ fn validate_attestation_signature_optional(
 ///  - `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
+/// Spec v0.5.0
 fn verify_attestation_signature(
     state: &BeaconState,
     committee: &[usize],
@@ -204,10 +226,10 @@ fn verify_attestation_signature(
 
     for (i, v) in committee.iter().enumerate() {
         let validator_signed = aggregation_bitfield.get(i).map_err(|_| {
-            Error::Invalid(Invalid::BadAggregationBitfieldLength(
-                committee.len(),
-                aggregation_bitfield.len(),
-            ))
+            Error::Invalid(Invalid::BadAggregationBitfieldLength {
+                committee_len: committee.len(),
+                bitfield_len: aggregation_bitfield.len(),
+            })
         })?;
 
         if validator_signed {
@@ -215,10 +237,10 @@ fn verify_attestation_signature(
                 Ok(bit) => bit,
                 // Invalidate signature if custody_bitfield.len() < committee
                 Err(_) => {
-                    return Err(Error::Invalid(Invalid::BadCustodyBitfieldLength(
-                        committee.len(),
-                        custody_bitfield.len(),
-                    )));
+                    return Err(Error::Invalid(Invalid::BadCustodyBitfieldLength {
+                        committee_len: committee.len(),
+                        bitfield_len: aggregation_bitfield.len(),
+                    }));
                 }
             };
 
diff --git a/eth2/state_processing/src/per_block_processing/verify_attester_slashing.rs b/eth2/state_processing/src/per_block_processing/verify_attester_slashing.rs
index d126849b63..a198d2a3e2 100644
--- a/eth2/state_processing/src/per_block_processing/verify_attester_slashing.rs
+++ b/eth2/state_processing/src/per_block_processing/verify_attester_slashing.rs
@@ -7,7 +7,7 @@ use types::*;
 ///
 /// Returns `Ok(())` if the `AttesterSlashing` is valid, otherwise indicates the reason for invalidity.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 pub fn verify_attester_slashing(
     state: &BeaconState,
     attester_slashing: &AttesterSlashing,
@@ -41,15 +41,16 @@ pub fn verify_attester_slashing(
 ///
 /// Returns Ok(indices) if `indices.len() > 0`.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 pub fn gather_attester_slashing_indices(
     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;
 
-    let mut slashable_indices = vec![];
+    let mut slashable_indices = Vec::with_capacity(spec.max_indices_per_slashable_vote);
     for i in &slashable_attestation_1.validator_indices {
         let validator = state
             .validator_registry
@@ -57,11 +58,20 @@ pub fn gather_attester_slashing_indices(
             .ok_or_else(|| Error::Invalid(Invalid::UnknownValidator(*i)))?;
 
         if slashable_attestation_2.validator_indices.contains(&i) & !validator.slashed {
+            // TODO: verify that we should reject any slashable attestation which includes a
+            // withdrawn validator. PH has asked the question on gitter, awaiting response.
+            verify!(
+                validator.withdrawable_epoch > state.slot.epoch(spec.slots_per_epoch),
+                Invalid::ValidatorAlreadyWithdrawn(*i)
+            );
+
             slashable_indices.push(*i);
         }
     }
 
     verify!(!slashable_indices.is_empty(), Invalid::NoSlashableIndices);
 
+    slashable_indices.shrink_to_fit();
+
     Ok(slashable_indices)
 }
diff --git a/eth2/state_processing/src/per_block_processing/verify_deposit.rs b/eth2/state_processing/src/per_block_processing/verify_deposit.rs
index aad38f616c..2aeab6c5a6 100644
--- a/eth2/state_processing/src/per_block_processing/verify_deposit.rs
+++ b/eth2/state_processing/src/per_block_processing/verify_deposit.rs
@@ -18,7 +18,7 @@ pub type PublicKeyValidatorIndexHashmap = HashMap<PublicKey, u64>;
 ///
 /// Note: this function is incomplete.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 pub fn verify_deposit(
     state: &BeaconState,
     deposit: &Deposit,
@@ -49,26 +49,25 @@ pub fn verify_deposit(
 
 /// Verify that the `Deposit` index is correct.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 pub fn verify_deposit_index(state: &BeaconState, deposit: &Deposit) -> Result<(), Error> {
     verify!(
         deposit.index == state.deposit_index,
-        Invalid::BadIndex(state.deposit_index, deposit.index)
+        Invalid::BadIndex {
+            state: state.deposit_index,
+            deposit: deposit.index
+        }
     );
 
     Ok(())
 }
 
-pub fn build_public_key_hashmap(state: &BeaconState) -> PublicKeyValidatorIndexHashmap {
-    let mut hashmap = HashMap::with_capacity(state.validator_registry.len());
-
-    for (i, validator) in state.validator_registry.iter().enumerate() {
-        hashmap.insert(validator.pubkey.clone(), i as u64);
-    }
-
-    hashmap
-}
-
+/// Returns a `Some(validator index)` if a pubkey already exists in the `validator_registry`,
+/// otherwise returns `None`.
+///
+/// ## Errors
+///
+/// Errors if the state's `pubkey_cache` is not current.
 pub fn get_existing_validator_index(
     state: &BeaconState,
     deposit: &Deposit,
@@ -94,12 +93,12 @@ pub fn get_existing_validator_index(
 
 /// Verify that a deposit is included in the state's eth1 deposit root.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.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,
+        &deposit.proof,
         spec.deposit_contract_tree_depth as usize,
         deposit.index as usize,
         state.latest_eth1_data.deposit_root,
@@ -108,7 +107,7 @@ fn verify_deposit_merkle_proof(state: &BeaconState, deposit: &Deposit, spec: &Ch
 
 /// Helper struct for easily getting the serialized data generated by the deposit contract.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 #[derive(Encode)]
 struct SerializedDepositData {
     amount: u64,
@@ -119,7 +118,7 @@ struct SerializedDepositData {
 /// Return the serialized data generated by the deposit contract that is used to generate the
 /// merkle proof.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 fn get_serialized_deposit_data(deposit: &Deposit) -> Vec<u8> {
     let serialized_deposit_data = SerializedDepositData {
         amount: deposit.deposit_data.amount,
diff --git a/eth2/state_processing/src/per_block_processing/verify_exit.rs b/eth2/state_processing/src/per_block_processing/verify_exit.rs
index 8cd54fb690..7893cea966 100644
--- a/eth2/state_processing/src/per_block_processing/verify_exit.rs
+++ b/eth2/state_processing/src/per_block_processing/verify_exit.rs
@@ -7,7 +7,7 @@ use types::*;
 ///
 /// Returns `Ok(())` if the `Exit` is valid, otherwise indicates the reason for invalidity.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 pub fn verify_exit(
     state: &BeaconState,
     exit: &VoluntaryExit,
@@ -18,15 +18,35 @@ pub fn verify_exit(
         .get(exit.validator_index as usize)
         .ok_or_else(|| Error::Invalid(Invalid::ValidatorUnknown(exit.validator_index)))?;
 
+    // Verify that the validator has not yet exited.
     verify!(
-        validator.exit_epoch
-            > state.get_delayed_activation_exit_epoch(state.current_epoch(spec), spec),
-        Invalid::AlreadyExited
+        validator.exit_epoch == spec.far_future_epoch,
+        Invalid::AlreadyExited(exit.validator_index)
     );
 
+    // Verify that the validator has not yet initiated.
+    verify!(
+        !validator.initiated_exit,
+        Invalid::AlreadyInitiatedExited(exit.validator_index)
+    );
+
+    // Exits must specify an epoch when they become valid; they are not valid before then.
     verify!(
         state.current_epoch(spec) >= exit.epoch,
-        Invalid::FutureEpoch(state.current_epoch(spec), exit.epoch)
+        Invalid::FutureEpoch {
+            state: state.current_epoch(spec),
+            exit: exit.epoch
+        }
+    );
+
+    // Must have been in the validator set long enough.
+    let lifespan = state.slot.epoch(spec.slots_per_epoch) - validator.activation_epoch;
+    verify!(
+        lifespan >= spec.persistent_committee_period,
+        Invalid::TooYoungToLeave {
+            lifespan,
+            expected: spec.persistent_committee_period,
+        }
     );
 
     let message = exit.signed_root();
diff --git a/eth2/state_processing/src/per_block_processing/verify_proposer_slashing.rs b/eth2/state_processing/src/per_block_processing/verify_proposer_slashing.rs
index c3c0079a96..dffb9d898c 100644
--- a/eth2/state_processing/src/per_block_processing/verify_proposer_slashing.rs
+++ b/eth2/state_processing/src/per_block_processing/verify_proposer_slashing.rs
@@ -7,7 +7,7 @@ use types::*;
 ///
 /// Returns `Ok(())` if the `ProposerSlashing` is valid, otherwise indicates the reason for invalidity.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 pub fn verify_proposer_slashing(
     proposer_slashing: &ProposerSlashing,
     state: &BeaconState,
@@ -21,34 +21,28 @@ pub fn verify_proposer_slashing(
         })?;
 
     verify!(
-        proposer_slashing.proposal_1.slot == proposer_slashing.proposal_2.slot,
+        proposer_slashing.header_1.slot == proposer_slashing.header_2.slot,
         Invalid::ProposalSlotMismatch(
-            proposer_slashing.proposal_1.slot,
-            proposer_slashing.proposal_2.slot
+            proposer_slashing.header_1.slot,
+            proposer_slashing.header_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
-        )
+        proposer_slashing.header_1 != proposer_slashing.header_2,
+        Invalid::ProposalsIdentical
     );
 
     verify!(!proposer.slashed, Invalid::ProposerAlreadySlashed);
 
     verify!(
-        verify_proposal_signature(
-            &proposer_slashing.proposal_1,
+        proposer.withdrawable_epoch > state.slot.epoch(spec.slots_per_epoch),
+        Invalid::ProposerAlreadyWithdrawn(proposer_slashing.proposer_index)
+    );
+
+    verify!(
+        verify_header_signature(
+            &proposer_slashing.header_1,
             &proposer.pubkey,
             &state.fork,
             spec
@@ -56,8 +50,8 @@ pub fn verify_proposer_slashing(
         Invalid::BadProposal1Signature
     );
     verify!(
-        verify_proposal_signature(
-            &proposer_slashing.proposal_2,
+        verify_header_signature(
+            &proposer_slashing.header_2,
             &proposer.pubkey,
             &state.fork,
             spec
@@ -71,17 +65,19 @@ pub fn verify_proposer_slashing(
 /// Verifies the signature of a proposal.
 ///
 /// Returns `true` if the signature is valid.
-fn verify_proposal_signature(
-    proposal: &Proposal,
+///
+/// Spec v0.5.0
+fn verify_header_signature(
+    header: &BeaconBlockHeader,
     pubkey: &PublicKey,
     fork: &Fork,
     spec: &ChainSpec,
 ) -> bool {
-    let message = proposal.signed_root();
+    let message = header.signed_root();
     let domain = spec.get_domain(
-        proposal.slot.epoch(spec.slots_per_epoch),
-        Domain::Proposal,
+        header.slot.epoch(spec.slots_per_epoch),
+        Domain::BeaconBlock,
         fork,
     );
-    proposal.signature.verify(&message[..], domain, pubkey)
+    header.signature.verify(&message[..], domain, pubkey)
 }
diff --git a/eth2/state_processing/src/per_block_processing/verify_transfer.rs b/eth2/state_processing/src/per_block_processing/verify_transfer.rs
index 4746fc75cc..546760fd09 100644
--- a/eth2/state_processing/src/per_block_processing/verify_transfer.rs
+++ b/eth2/state_processing/src/per_block_processing/verify_transfer.rs
@@ -10,16 +10,16 @@ use types::*;
 ///
 /// Note: this function is incomplete.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 pub fn verify_transfer(
     state: &BeaconState,
     transfer: &Transfer,
     spec: &ChainSpec,
 ) -> Result<(), Error> {
-    let from_balance = *state
+    let sender_balance = *state
         .validator_balances
-        .get(transfer.from as usize)
-        .ok_or_else(|| Error::Invalid(Invalid::FromValidatorUnknown(transfer.from)))?;
+        .get(transfer.sender as usize)
+        .ok_or_else(|| Error::Invalid(Invalid::FromValidatorUnknown(transfer.sender)))?;
 
     let total_amount = transfer
         .amount
@@ -27,19 +27,22 @@ pub fn verify_transfer(
         .ok_or_else(|| Error::Invalid(Invalid::FeeOverflow(transfer.amount, transfer.fee)))?;
 
     verify!(
-        from_balance >= transfer.amount,
-        Invalid::FromBalanceInsufficient(transfer.amount, from_balance)
+        sender_balance >= transfer.amount,
+        Invalid::FromBalanceInsufficient(transfer.amount, sender_balance)
     );
 
     verify!(
-        from_balance >= transfer.fee,
-        Invalid::FromBalanceInsufficient(transfer.fee, from_balance)
+        sender_balance >= transfer.fee,
+        Invalid::FromBalanceInsufficient(transfer.fee, sender_balance)
     );
 
     verify!(
-        (from_balance == total_amount)
-            || (from_balance >= (total_amount + spec.min_deposit_amount)),
-        Invalid::InvalidResultingFromBalance(from_balance - total_amount, spec.min_deposit_amount)
+        (sender_balance == total_amount)
+            || (sender_balance >= (total_amount + spec.min_deposit_amount)),
+        Invalid::InvalidResultingFromBalance(
+            sender_balance - total_amount,
+            spec.min_deposit_amount
+        )
     );
 
     verify!(
@@ -47,25 +50,25 @@ pub fn verify_transfer(
         Invalid::StateSlotMismatch(state.slot, transfer.slot)
     );
 
-    let from_validator = state
+    let sender_validator = state
         .validator_registry
-        .get(transfer.from as usize)
-        .ok_or_else(|| Error::Invalid(Invalid::FromValidatorUnknown(transfer.from)))?;
+        .get(transfer.sender as usize)
+        .ok_or_else(|| Error::Invalid(Invalid::FromValidatorUnknown(transfer.sender)))?;
     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)
+        sender_validator.is_withdrawable_at(epoch)
+            || sender_validator.activation_epoch == spec.far_future_epoch,
+        Invalid::FromValidatorIneligableForTransfer(transfer.sender)
     );
 
     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,
+        sender_validator.withdrawal_credentials == transfer_withdrawal_credentials,
         Invalid::WithdrawalCredentialsMismatch(
-            from_validator.withdrawal_credentials,
+            sender_validator.withdrawal_credentials,
             transfer_withdrawal_credentials
         )
     );
@@ -97,16 +100,17 @@ pub fn execute_transfer(
     transfer: &Transfer,
     spec: &ChainSpec,
 ) -> Result<(), Error> {
-    let from_balance = *state
+    let sender_balance = *state
         .validator_balances
-        .get(transfer.from as usize)
-        .ok_or_else(|| Error::Invalid(Invalid::FromValidatorUnknown(transfer.from)))?;
-    let to_balance = *state
+        .get(transfer.sender as usize)
+        .ok_or_else(|| Error::Invalid(Invalid::FromValidatorUnknown(transfer.sender)))?;
+    let recipient_balance = *state
         .validator_balances
-        .get(transfer.to as usize)
-        .ok_or_else(|| Error::Invalid(Invalid::ToValidatorUnknown(transfer.to)))?;
+        .get(transfer.recipient as usize)
+        .ok_or_else(|| Error::Invalid(Invalid::ToValidatorUnknown(transfer.recipient)))?;
 
-    let proposer_index = state.get_beacon_proposer_index(state.slot, spec)?;
+    let proposer_index =
+        state.get_beacon_proposer_index(state.slot, RelativeEpoch::Current, spec)?;
     let proposer_balance = state.validator_balances[proposer_index];
 
     let total_amount = transfer
@@ -114,14 +118,22 @@ pub fn execute_transfer(
         .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.sender as usize] =
+        sender_balance.checked_sub(total_amount).ok_or_else(|| {
+            Error::Invalid(Invalid::FromBalanceInsufficient(
+                total_amount,
+                sender_balance,
+            ))
         })?;
 
-    state.validator_balances[transfer.to as usize] = to_balance
+    state.validator_balances[transfer.recipient as usize] = recipient_balance
         .checked_add(transfer.amount)
-        .ok_or_else(|| Error::Invalid(Invalid::ToBalanceOverflow(to_balance, transfer.amount)))?;
+        .ok_or_else(|| {
+            Error::Invalid(Invalid::ToBalanceOverflow(
+                recipient_balance,
+                transfer.amount,
+            ))
+        })?;
 
     state.validator_balances[proposer_index] =
         proposer_balance.checked_add(transfer.fee).ok_or_else(|| {
diff --git a/eth2/state_processing/src/per_slot_processing.rs b/eth2/state_processing/src/per_slot_processing.rs
index 0bb405c986..aafc7166ad 100644
--- a/eth2/state_processing/src/per_slot_processing.rs
+++ b/eth2/state_processing/src/per_slot_processing.rs
@@ -9,7 +9,7 @@ pub enum Error {
 
 /// Advances a state forward by one slot, performing per-epoch processing if required.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 pub fn per_slot_processing(
     state: &mut BeaconState,
     previous_block_root: Hash256,
@@ -22,29 +22,9 @@ pub fn per_slot_processing(
 
     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)
diff --git a/eth2/types/src/beacon_state.rs b/eth2/types/src/beacon_state.rs
index 32f8204e38..7c77a5a3e5 100644
--- a/eth2/types/src/beacon_state.rs
+++ b/eth2/types/src/beacon_state.rs
@@ -2,11 +2,11 @@ use self::epoch_cache::EpochCache;
 use crate::test_utils::TestRandom;
 use crate::{validator_registry::get_active_validator_indices, *};
 use int_to_bytes::int_to_bytes32;
-use log::{debug, trace};
+use log::trace;
 use pubkey_cache::PubkeyCache;
 use rand::RngCore;
 use serde_derive::{Deserialize, Serialize};
-use ssz::{hash, SignedRoot, TreeHash};
+use ssz::{hash, ssz_encode, SignedRoot, TreeHash};
 use ssz_derive::{Decode, Encode, TreeHash};
 use std::collections::HashMap;
 use test_random_derive::TestRandom;
@@ -31,12 +31,14 @@ pub enum Error {
     UnableToShuffle,
     UnknownValidator,
     InvalidBitfield,
+    ValidatorIsWithdrawable,
     InsufficientRandaoMixes,
     InsufficientValidators,
     InsufficientBlockRoots,
     InsufficientIndexRoots,
     InsufficientAttestations,
     InsufficientCommittees,
+    InsufficientSlashedBalances,
     EpochCacheUninitialized(RelativeEpoch),
     PubkeyCacheInconsistent,
     PubkeyCacheIncomplete {
@@ -377,10 +379,37 @@ impl BeaconState {
         }
     }
 
+    /// XOR-assigns the existing `epoch` randao mix with the hash of the `signature`.
+    ///
+    /// # Errors:
+    ///
+    /// See `Self::get_randao_mix`.
+    ///
+    /// Spec v0.5.0
+    pub fn update_randao_mix(
+        &mut self,
+        epoch: Epoch,
+        signature: &Signature,
+        spec: &ChainSpec,
+    ) -> Result<(), Error> {
+        let i = epoch.as_usize() % spec.latest_randao_mixes_length;
+
+        let signature_hash = Hash256::from_slice(&hash(&ssz_encode(signature)));
+
+        self.latest_randao_mixes[i] = *self.get_randao_mix(epoch, spec)? ^ signature_hash;
+
+        Ok(())
+    }
+
     /// Return the randao mix at a recent ``epoch``.
     ///
-    /// Spec v0.4.0
-    pub fn get_randao_mix(&self, epoch: Epoch, spec: &ChainSpec) -> Option<&Hash256> {
+    /// # Errors:
+    /// - `InsufficientRandaoMixes` if `self.latest_randao_mixes` is shorter than
+    /// `spec.latest_randao_mixes_length`.
+    /// - `EpochOutOfBounds` if the state no longer stores randao mixes for the given `epoch`.
+    ///
+    /// Spec v0.5.0
+    pub fn get_randao_mix(&self, epoch: Epoch, spec: &ChainSpec) -> Result<&Hash256, Error> {
         let current_epoch = self.current_epoch(spec);
 
         if (current_epoch - (spec.latest_randao_mixes_length as u64) < epoch)
@@ -388,8 +417,9 @@ impl BeaconState {
         {
             self.latest_randao_mixes
                 .get(epoch.as_usize() % spec.latest_randao_mixes_length)
+                .ok_or_else(|| Error::InsufficientRandaoMixes)
         } else {
-            None
+            Err(Error::EpochOutOfBounds)
         }
     }
 
@@ -418,8 +448,7 @@ impl BeaconState {
     /// Spec v0.4.0
     pub fn generate_seed(&self, epoch: Epoch, spec: &ChainSpec) -> Result<Hash256, Error> {
         let mut input = self
-            .get_randao_mix(epoch - spec.min_seed_lookahead, spec)
-            .ok_or_else(|| Error::InsufficientRandaoMixes)?
+            .get_randao_mix(epoch - spec.min_seed_lookahead, spec)?
             .as_bytes()
             .to_vec();
 
@@ -601,7 +630,7 @@ impl BeaconState {
 
     /// Initiate an exit for the validator of the given `index`.
     ///
-    /// Spec v0.4.0
+    /// Spec v0.5.0
     pub fn initiate_validator_exit(&mut self, validator_index: usize) {
         self.validator_registry[validator_index].initiated_exit = true;
     }
@@ -622,7 +651,7 @@ impl BeaconState {
 
     /// Slash the validator with index ``index``.
     ///
-    /// Spec v0.4.0
+    /// Spec v0.5.0
     pub fn slash_validator(
         &mut self,
         validator_index: usize,
@@ -634,26 +663,27 @@ impl BeaconState {
             .validator_registry
             .get(validator_index)
             .ok_or_else(|| Error::UnknownValidator)?;
+        let effective_balance = self.get_effective_balance(validator_index, spec)?;
 
+        // A validator that is withdrawn cannot be slashed.
+        //
+        // This constraint will be lifted in Phase 0.
         if self.slot
             >= validator
                 .withdrawable_epoch
                 .start_slot(spec.slots_per_epoch)
         {
-            return Err(Error::SlotOutOfBounds);
+            return Err(Error::ValidatorIsWithdrawable);
         }
 
         self.exit_validator(validator_index, spec);
 
-        let effective_balance = self.get_effective_balance(validator_index, spec)?;
-
-        self.latest_slashed_balances[current_epoch.as_usize() % spec.latest_slashed_exit_length] +=
-            effective_balance;
+        self.increment_current_epoch_slashed_balances(effective_balance, spec)?;
 
         let whistleblower_index =
             self.get_beacon_proposer_index(self.slot, RelativeEpoch::Current, spec)?;
+        let whistleblower_reward = effective_balance / spec.whistleblower_reward_quotient;
 
-        let whistleblower_reward = effective_balance;
         safe_add_assign!(
             self.validator_balances[whistleblower_index as usize],
             whistleblower_reward
@@ -662,14 +692,31 @@ impl BeaconState {
             self.validator_balances[validator_index],
             whistleblower_reward
         );
+
         self.validator_registry[validator_index].slashed = true;
+
         self.validator_registry[validator_index].withdrawable_epoch =
             current_epoch + Epoch::from(spec.latest_slashed_exit_length);
 
-        debug!(
-            "Whistleblower {} penalized validator {}.",
-            whistleblower_index, validator_index
-        );
+        Ok(())
+    }
+
+    /// Increment `self.latest_slashed_balances` with a slashing from the current epoch.
+    ///
+    /// Spec v0.5.0.
+    fn increment_current_epoch_slashed_balances(
+        &mut self,
+        increment: u64,
+        spec: &ChainSpec,
+    ) -> Result<(), Error> {
+        let current_epoch = self.current_epoch(spec);
+
+        let slashed_balances_index = current_epoch.as_usize() % spec.latest_slashed_exit_length;
+        if slashed_balances_index >= self.latest_slashed_balances.len() {
+            return Err(Error::InsufficientSlashedBalances);
+        }
+
+        self.latest_slashed_balances[slashed_balances_index] += increment;
 
         Ok(())
     }
diff --git a/eth2/types/src/chain_spec.rs b/eth2/types/src/chain_spec.rs
index f4b113056f..e9ade2c913 100644
--- a/eth2/types/src/chain_spec.rs
+++ b/eth2/types/src/chain_spec.rs
@@ -29,7 +29,7 @@ pub struct ChainSpec {
     pub shard_count: u64,
     pub target_committee_size: u64,
     pub max_balance_churn_quotient: u64,
-    pub max_indices_per_slashable_vote: u64,
+    pub max_indices_per_slashable_vote: usize,
     pub max_exit_dequeues_per_epoch: u64,
     pub shuffle_round_count: u8,
 
diff --git a/eth2/types/src/proposer_slashing.rs b/eth2/types/src/proposer_slashing.rs
index 881f0e4059..02216a2fc6 100644
--- a/eth2/types/src/proposer_slashing.rs
+++ b/eth2/types/src/proposer_slashing.rs
@@ -11,8 +11,8 @@ use test_random_derive::TestRandom;
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Encode, Decode, TreeHash, TestRandom)]
 pub struct ProposerSlashing {
     pub proposer_index: u64,
-    pub proposal_1: BeaconBlockHeader,
-    pub proposal_2: BeaconBlockHeader,
+    pub header_1: BeaconBlockHeader,
+    pub header_2: BeaconBlockHeader,
 }
 
 #[cfg(test)]
diff --git a/eth2/types/src/test_utils/testing_proposer_slashing_builder.rs b/eth2/types/src/test_utils/testing_proposer_slashing_builder.rs
index 0773cd6da4..2cfebd9153 100644
--- a/eth2/types/src/test_utils/testing_proposer_slashing_builder.rs
+++ b/eth2/types/src/test_utils/testing_proposer_slashing_builder.rs
@@ -25,7 +25,7 @@ impl TestingProposerSlashingBuilder {
         let hash_1 = Hash256::from([1; 32]);
         let hash_2 = Hash256::from([2; 32]);
 
-        let mut proposal_1 = BeaconBlockHeader {
+        let mut header_1 = BeaconBlockHeader {
             slot,
             previous_block_root: hash_1,
             state_root: hash_1,
@@ -33,27 +33,27 @@ impl TestingProposerSlashingBuilder {
             signature: Signature::empty_signature(),
         };
 
-        let mut proposal_2 = BeaconBlockHeader {
+        let mut header_2 = BeaconBlockHeader {
             previous_block_root: hash_2,
-            ..proposal_1.clone()
+            ..header_1.clone()
         };
 
-        proposal_1.signature = {
-            let message = proposal_1.signed_root();
+        header_1.signature = {
+            let message = header_1.signed_root();
             let epoch = slot.epoch(spec.slots_per_epoch);
             signer(proposer_index, &message[..], epoch, Domain::BeaconBlock)
         };
 
-        proposal_2.signature = {
-            let message = proposal_2.signed_root();
+        header_2.signature = {
+            let message = header_2.signed_root();
             let epoch = slot.epoch(spec.slots_per_epoch);
             signer(proposer_index, &message[..], epoch, Domain::BeaconBlock)
         };
 
         ProposerSlashing {
             proposer_index,
-            proposal_1,
-            proposal_2,
+            header_1,
+            header_2,
         }
     }
 }

From 3b8c1df5da123170c23482d86c1bb064ce557b09 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Sun, 17 Mar 2019 12:49:55 +1100
Subject: [PATCH 36/60] Fix bug in per block processing.

---
 .../src/per_block_processing/validate_attestation.rs      | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/eth2/state_processing/src/per_block_processing/validate_attestation.rs b/eth2/state_processing/src/per_block_processing/validate_attestation.rs
index 9d13214077..68a51b2df6 100644
--- a/eth2/state_processing/src/per_block_processing/validate_attestation.rs
+++ b/eth2/state_processing/src/per_block_processing/validate_attestation.rs
@@ -142,12 +142,10 @@ fn validate_attestation_signature_optional(
     );
 
     // Get the committee for the specific shard that this attestation is for.
+    let relative_epoch = RelativeEpoch::from_slot(state.slot, attestation.data.slot, spec)
+        .map_err(|_| BeaconStateError::EpochOutOfBounds)?; // Should not fail due to previous checks.
     let crosslink_committee = state
-        .get_crosslink_committees_at_slot(
-            attestation.data.slot,
-            RelativeEpoch::NextWithoutRegistryChange,
-            spec,
-        )?
+        .get_crosslink_committees_at_slot(attestation.data.slot, relative_epoch, spec)?
         .iter()
         .find(|c| c.shard == attestation.data.shard)
         .ok_or_else(|| {

From 3a384d93f85001bd316819571a635a4cfab1c2a4 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Sun, 17 Mar 2019 17:47:12 +1100
Subject: [PATCH 37/60] Allow state processing to compile under v0.5.0

---
 .../src/per_block_processing.rs               |   4 +-
 .../validate_attestation.rs                   |   4 +-
 .../src/per_epoch_processing.rs               | 172 ++++++++----------
 .../get_attestation_participants.rs           |  37 ++++
 .../inclusion_distance.rs                     |  15 +-
 .../process_validator_registry.rs             |  72 ++++++++
 .../validator_statuses.rs                     |  60 +++---
 .../src/per_epoch_processing/winning_root.rs  | 100 +++++++---
 eth2/types/src/beacon_state.rs                | 161 ++++++++++------
 eth2/types/src/beacon_state/epoch_cache.rs    |  30 +--
 eth2/types/src/crosslink_committee.rs         |   1 +
 .../testing_beacon_block_builder.rs           |   5 +-
 .../testing_beacon_state_builder.rs           |   3 +-
 13 files changed, 422 insertions(+), 242 deletions(-)
 create mode 100644 eth2/state_processing/src/per_epoch_processing/get_attestation_participants.rs
 create mode 100644 eth2/state_processing/src/per_epoch_processing/process_validator_registry.rs

diff --git a/eth2/state_processing/src/per_block_processing.rs b/eth2/state_processing/src/per_block_processing.rs
index 377f92e8b1..c6b22fa752 100644
--- a/eth2/state_processing/src/per_block_processing.rs
+++ b/eth2/state_processing/src/per_block_processing.rs
@@ -72,8 +72,8 @@ fn per_block_processing_signature_optional(
     process_block_header(state, block, spec)?;
 
     // Ensure the current and previous epoch cache is built.
-    state.build_epoch_cache(RelativeEpoch::Current, spec)?;
     state.build_epoch_cache(RelativeEpoch::Previous, spec)?;
+    state.build_epoch_cache(RelativeEpoch::Current, spec)?;
 
     if should_verify_block_signature {
         verify_block_signature(&state, &block, &spec)?;
@@ -94,7 +94,7 @@ fn per_block_processing_signature_optional(
 ///
 /// Spec v0.5.0
 pub fn process_block_header(
-    state: &BeaconState,
+    state: &mut BeaconState,
     block: &BeaconBlock,
     spec: &ChainSpec,
 ) -> Result<(), Error> {
diff --git a/eth2/state_processing/src/per_block_processing/validate_attestation.rs b/eth2/state_processing/src/per_block_processing/validate_attestation.rs
index 68a51b2df6..272eeb18b8 100644
--- a/eth2/state_processing/src/per_block_processing/validate_attestation.rs
+++ b/eth2/state_processing/src/per_block_processing/validate_attestation.rs
@@ -142,10 +142,8 @@ fn validate_attestation_signature_optional(
     );
 
     // Get the committee for the specific shard that this attestation is for.
-    let relative_epoch = RelativeEpoch::from_slot(state.slot, attestation.data.slot, spec)
-        .map_err(|_| BeaconStateError::EpochOutOfBounds)?; // Should not fail due to previous checks.
     let crosslink_committee = state
-        .get_crosslink_committees_at_slot(attestation.data.slot, relative_epoch, spec)?
+        .get_crosslink_committees_at_slot(attestation.data.slot, spec)?
         .iter()
         .find(|c| c.shard == attestation.data.shard)
         .ok_or_else(|| {
diff --git a/eth2/state_processing/src/per_epoch_processing.rs b/eth2/state_processing/src/per_epoch_processing.rs
index 8c4b8e88ba..2f1cc35518 100644
--- a/eth2/state_processing/src/per_epoch_processing.rs
+++ b/eth2/state_processing/src/per_epoch_processing.rs
@@ -1,5 +1,6 @@
 use errors::EpochProcessingError as Error;
 use integer_sqrt::IntegerSquareRoot;
+use process_validator_registry::process_validator_registry;
 use rayon::prelude::*;
 use ssz::TreeHash;
 use std::collections::HashMap;
@@ -8,7 +9,9 @@ use validator_statuses::{TotalBalances, ValidatorStatuses};
 use winning_root::{winning_root, WinningRoot};
 
 pub mod errors;
+pub mod get_attestation_participants;
 pub mod inclusion_distance;
+pub mod process_validator_registry;
 pub mod tests;
 pub mod validator_statuses;
 pub mod winning_root;
@@ -25,10 +28,9 @@ pub type WinningRootHashSet = HashMap<u64, WinningRoot>;
 ///
 /// Spec v0.4.0
 pub fn per_epoch_processing(state: &mut BeaconState, spec: &ChainSpec) -> Result<(), Error> {
-    // Ensure all of the caches are built.
+    // Ensure the previous and next epoch 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 mut statuses = initialize_validator_statuses(&state, spec)?;
 
@@ -61,7 +63,7 @@ pub fn per_epoch_processing(state: &mut BeaconState, spec: &ChainSpec) -> Result
 
 /// Returns a list of active validator indices for the state's current epoch.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 pub fn calculate_active_validator_indices(state: &BeaconState, spec: &ChainSpec) -> Vec<usize> {
     get_active_validator_indices(
         &state.validator_registry,
@@ -76,26 +78,28 @@ pub fn calculate_active_validator_indices(state: &BeaconState, spec: &ChainSpec)
 /// - previous epoch attesters
 /// - etc.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 pub fn initialize_validator_statuses(
     state: &BeaconState,
     spec: &ChainSpec,
 ) -> Result<ValidatorStatuses, BeaconStateError> {
-    let mut statuses = ValidatorStatuses::new(state, spec);
+    let mut statuses = ValidatorStatuses::new(state, spec)?;
 
-    statuses.process_attestations(&state, &state.latest_attestations, spec)?;
+    statuses.process_attestations(&state, spec)?;
 
     Ok(statuses)
 }
 
-/// Spec v0.4.0
+/// Maybe resets the eth1 period.
+///
+/// Spec v0.5.0
 pub 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 {
+            if eth1_data_vote.vote_count * 2 > voting_period * spec.slots_per_epoch {
                 state.latest_eth1_data = eth1_data_vote.eth1_data.clone();
             }
         }
@@ -119,7 +123,7 @@ pub fn process_justification(
     let previous_epoch = state.previous_epoch(spec);
     let current_epoch = state.current_epoch(spec);
 
-    let mut new_justified_epoch = state.justified_epoch;
+    let mut new_justified_epoch = state.current_justified_epoch;
     state.justification_bitfield <<= 1;
 
     // If > 2/3 of the total balance attested to the previous epoch boundary
@@ -168,8 +172,10 @@ pub fn process_justification(
     // - 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 (state.justification_bitfield % 8 == 0b111)
+        & (state.current_justified_epoch == previous_epoch - 1)
+    {
+        state.finalized_epoch = state.current_justified_epoch;
     }
     // If:
     //
@@ -177,12 +183,14 @@ pub fn process_justification(
     // - 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;
+    if (state.justification_bitfield % 4 == 0b11)
+        & (state.current_justified_epoch == previous_epoch)
+    {
+        state.finalized_epoch = state.current_justified_epoch;
     }
 
-    state.previous_justified_epoch = state.justified_epoch;
-    state.justified_epoch = new_justified_epoch;
+    state.previous_justified_epoch = state.current_justified_epoch;
+    state.current_justified_epoch = new_justified_epoch;
 }
 
 /// Updates the following fields on the `BeaconState`:
@@ -191,23 +199,11 @@ pub fn process_justification(
 ///
 /// Also returns a `WinningRootHashSet` for later use during epoch processing.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 pub 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
@@ -221,24 +217,18 @@ pub fn process_crosslinks(
         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;
+        for c in crosslink_committees_at_slot {
+            let shard = c.shard as u64;
 
-            let winning_root = winning_root(
-                state,
-                shard,
-                &current_epoch_attestations[..],
-                &previous_epoch_attestations[..],
-                spec,
-            )?;
+            let winning_root = winning_root(state, shard, spec)?;
 
             if let Some(winning_root) = winning_root {
-                let total_committee_balance = state.get_total_balance(&crosslink_committee, spec);
+                let total_committee_balance = state.get_total_balance(&c.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),
+                        epoch: slot.epoch(spec.slots_per_epoch),
                         crosslink_data_root: winning_root.crosslink_data_root,
                     }
                 }
@@ -294,7 +284,10 @@ pub fn process_rewards_and_penalities(
         .map(|(index, &balance)| {
             let mut balance = balance;
             let status = &statuses.statuses[index];
-            let base_reward = state.base_reward(index, base_reward_quotient, spec);
+            let base_reward = get_base_reward(state, index, total_balances.previous_epoch, spec)
+                .expect(
+                    "Cannot fail to access a validator balance when iterating validator balances.",
+                );
 
             if epochs_since_finality <= 4 {
                 // Expected FFG source
@@ -330,11 +323,15 @@ pub fn process_rewards_and_penalities(
                     safe_sub_assign!(balance, base_reward);
                 };
             } else {
-                let inactivity_penalty = state.inactivity_penalty(
+                let inactivity_penalty = get_inactivity_penalty(
+                    state,
                     index,
-                    epochs_since_finality,
-                    base_reward_quotient,
+                    epochs_since_finality.as_u64(),
+                    total_balances.previous_epoch,
                     spec,
+                )
+                .expect(
+                    "Cannot fail to access a validator balance when iterating validator balances.",
                 );
 
                 if status.is_active_in_previous_epoch {
@@ -349,7 +346,10 @@ pub fn process_rewards_and_penalities(
                     }
 
                     if state.validator_registry[index].slashed {
-                        let base_reward = state.base_reward(index, base_reward_quotient, spec);
+                        let base_reward =
+                            get_base_reward(state, index, total_balances.previous_epoch, spec).expect(
+                                "Cannot fail to access a validator balance when iterating validator balances.",
+                            );
                         safe_sub_assign!(balance, 2 * inactivity_penalty + base_reward);
                     }
                 }
@@ -384,7 +384,10 @@ pub fn process_rewards_and_penalities(
             let proposer_index = status.inclusion_info.proposer_index;
             let inclusion_distance = status.inclusion_info.distance;
 
-            let base_reward = state.base_reward(proposer_index, base_reward_quotient, spec);
+            let base_reward =
+                get_base_reward(state, proposer_index, total_balances.previous_epoch, spec).expect(
+                    "Cannot fail to access a validator balance when iterating validator balances.",
+                );
 
             if inclusion_distance > 0 && inclusion_distance < Slot::max_value() {
                 safe_add_assign!(
@@ -399,53 +402,37 @@ pub fn process_rewards_and_penalities(
     Ok(())
 }
 
-/// Peforms a validator registry update, if required.
+/// Returns the base reward for some validator.
 ///
-/// Spec v0.4.0
-pub 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
-        })
+/// Spec v0.5.0
+pub fn get_base_reward(
+    state: &BeaconState,
+    index: usize,
+    previous_total_balance: u64,
+    spec: &ChainSpec,
+) -> Result<u64, BeaconStateError> {
+    if previous_total_balance == 0 {
+        Ok(0)
     } 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)?
-        }
+        let adjusted_quotient = previous_total_balance.integer_sqrt() / spec.base_reward_quotient;
+        Ok(state.get_effective_balance(index, spec)? / adjusted_quotient / 5)
     }
+}
 
-    state.process_slashings(spec);
-    state.process_exit_queue(spec);
-
-    Ok(())
+/// Returns the inactivity penalty for some validator.
+///
+/// Spec v0.5.0
+pub fn get_inactivity_penalty(
+    state: &BeaconState,
+    index: usize,
+    epochs_since_finality: u64,
+    previous_total_balance: u64,
+    spec: &ChainSpec,
+) -> Result<u64, BeaconStateError> {
+    Ok(get_base_reward(state, index, previous_total_balance, spec)?
+        + state.get_effective_balance(index, spec)? * epochs_since_finality
+            / spec.inactivity_penalty_quotient
+            / 2)
 }
 
 /// Updates the state's `latest_active_index_roots` field with a tree hash the active validator
@@ -486,12 +473,5 @@ pub fn update_latest_slashed_balances(state: &mut BeaconState, spec: &ChainSpec)
 ///
 /// Spec v0.4.0
 pub fn clean_attestations(state: &mut BeaconState, spec: &ChainSpec) {
-    let current_epoch = state.current_epoch(spec);
-
-    state.latest_attestations = state
-        .latest_attestations
-        .iter()
-        .filter(|a| a.data.slot.epoch(spec.slots_per_epoch) >= current_epoch)
-        .cloned()
-        .collect();
+    state.previous_epoch_attestations = vec![];
 }
diff --git a/eth2/state_processing/src/per_epoch_processing/get_attestation_participants.rs b/eth2/state_processing/src/per_epoch_processing/get_attestation_participants.rs
new file mode 100644
index 0000000000..d822e434d1
--- /dev/null
+++ b/eth2/state_processing/src/per_epoch_processing/get_attestation_participants.rs
@@ -0,0 +1,37 @@
+use types::{beacon_state::helpers::verify_bitfield_length, *};
+
+/// Returns validator indices which participated in the attestation.
+///
+/// Spec v0.5.0
+pub fn get_attestation_participants(
+    state: &BeaconState,
+    attestation_data: &AttestationData,
+    bitfield: &Bitfield,
+    spec: &ChainSpec,
+) -> Result<Vec<usize>, BeaconStateError> {
+    let epoch = attestation_data.slot.epoch(spec.slots_per_epoch);
+
+    let crosslink_committee =
+        state.get_crosslink_committee_for_shard(epoch, attestation_data.shard, spec)?;
+
+    if crosslink_committee.slot != attestation_data.slot {
+        return Err(BeaconStateError::NoCommitteeForShard);
+    }
+
+    let committee = &crosslink_committee.committee;
+
+    if !verify_bitfield_length(&bitfield, committee.len()) {
+        return Err(BeaconStateError::InvalidBitfield);
+    }
+
+    let mut participants = Vec::with_capacity(committee.len());
+    for (i, validator_index) in committee.iter().enumerate() {
+        match bitfield.get(i) {
+            Ok(bit) if bit == true => participants.push(*validator_index),
+            _ => {}
+        }
+    }
+    participants.shrink_to_fit();
+
+    Ok(participants)
+}
diff --git a/eth2/state_processing/src/per_epoch_processing/inclusion_distance.rs b/eth2/state_processing/src/per_epoch_processing/inclusion_distance.rs
index 243dc67f0a..b52485947d 100644
--- a/eth2/state_processing/src/per_epoch_processing/inclusion_distance.rs
+++ b/eth2/state_processing/src/per_epoch_processing/inclusion_distance.rs
@@ -1,12 +1,11 @@
 use super::errors::InclusionError;
+use super::get_attestation_participants::get_attestation_participants;
 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
+/// Spec v0.5.0
 pub fn inclusion_distance(
     state: &BeaconState,
     attestations: &[&PendingAttestation],
@@ -19,9 +18,7 @@ pub fn inclusion_distance(
 
 /// 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
+/// Spec v0.5.0
 pub fn inclusion_slot(
     state: &BeaconState,
     attestations: &[&PendingAttestation],
@@ -34,9 +31,7 @@ pub fn 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
+/// Spec v0.5.0
 fn earliest_included_attestation(
     state: &BeaconState,
     attestations: &[&PendingAttestation],
@@ -47,7 +42,7 @@ fn earliest_included_attestation(
 
     for (i, a) in attestations.iter().enumerate() {
         let participants =
-            state.get_attestation_participants(&a.data, &a.aggregation_bitfield, spec)?;
+            get_attestation_participants(state, &a.data, &a.aggregation_bitfield, spec)?;
         if participants.iter().any(|i| *i == validator_index) {
             included_attestations.push(i);
         }
diff --git a/eth2/state_processing/src/per_epoch_processing/process_validator_registry.rs b/eth2/state_processing/src/per_epoch_processing/process_validator_registry.rs
new file mode 100644
index 0000000000..c830bfc243
--- /dev/null
+++ b/eth2/state_processing/src/per_epoch_processing/process_validator_registry.rs
@@ -0,0 +1,72 @@
+use super::Error;
+use types::*;
+
+/// Peforms a validator registry update, if required.
+///
+/// Spec v0.4.0
+pub 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;
+
+    if should_update_validator_registry(state, spec)? {
+        state.update_validator_registry(spec);
+
+        state.current_shuffling_epoch = next_epoch;
+        state.current_shuffling_start_shard = (state.current_shuffling_start_shard
+            + spec.get_epoch_committee_count(
+                state
+                    .get_active_validator_indices(current_epoch, spec)?
+                    .len(),
+            ) 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(())
+}
+
+/// Returns `true` if the validator registry should be updated during an epoch processing.
+///
+/// Spec v0.5.0
+pub fn should_update_validator_registry(
+    state: &BeaconState,
+    spec: &ChainSpec,
+) -> Result<bool, BeaconStateError> {
+    if state.finalized_epoch <= state.validator_registry_update_epoch {
+        return Ok(false);
+    }
+
+    let num_active_validators = state
+        .get_active_validator_indices(state.current_epoch(spec), spec)?
+        .len();
+    let current_epoch_committee_count = spec.get_epoch_committee_count(num_active_validators);
+
+    for shard in (0..current_epoch_committee_count)
+        .into_iter()
+        .map(|i| (state.current_shuffling_start_shard + i as u64) % spec.shard_count)
+    {
+        if state.latest_crosslinks[shard as usize].epoch <= state.validator_registry_update_epoch {
+            return Ok(false);
+        }
+    }
+
+    Ok(true)
+}
diff --git a/eth2/state_processing/src/per_epoch_processing/validator_statuses.rs b/eth2/state_processing/src/per_epoch_processing/validator_statuses.rs
index f76900f3b4..bcbca82440 100644
--- a/eth2/state_processing/src/per_epoch_processing/validator_statuses.rs
+++ b/eth2/state_processing/src/per_epoch_processing/validator_statuses.rs
@@ -1,3 +1,4 @@
+use super::get_attestation_participants::get_attestation_participants;
 use super::WinningRootHashSet;
 use types::*;
 
@@ -147,8 +148,8 @@ impl ValidatorStatuses {
     /// - Active validators
     /// - Total balances for the current and previous epochs.
     ///
-    /// Spec v0.4.0
-    pub fn new(state: &BeaconState, spec: &ChainSpec) -> Self {
+    /// Spec v0.5.0
+    pub fn new(state: &BeaconState, spec: &ChainSpec) -> Result<Self, BeaconStateError> {
         let mut statuses = Vec::with_capacity(state.validator_registry.len());
         let mut total_balances = TotalBalances::default();
 
@@ -157,37 +158,40 @@ impl ValidatorStatuses {
 
             if validator.is_active_at(state.current_epoch(spec)) {
                 status.is_active_in_current_epoch = true;
-                total_balances.current_epoch += state.get_effective_balance(i, spec);
+                total_balances.current_epoch += state.get_effective_balance(i, spec)?;
             }
 
             if validator.is_active_at(state.previous_epoch(spec)) {
                 status.is_active_in_previous_epoch = true;
-                total_balances.previous_epoch += state.get_effective_balance(i, spec);
+                total_balances.previous_epoch += state.get_effective_balance(i, spec)?;
             }
 
             statuses.push(status);
         }
 
-        Self {
+        Ok(Self {
             statuses,
             total_balances,
-        }
+        })
     }
 
     /// Process some attestations from the given `state` updating the `statuses` and
     /// `total_balances` fields.
     ///
-    /// Spec v0.4.0
+    /// Spec v0.5.0
     pub fn process_attestations(
         &mut self,
         state: &BeaconState,
-        attestations: &[PendingAttestation],
         spec: &ChainSpec,
     ) -> Result<(), BeaconStateError> {
-        for a in attestations {
+        for a in state
+            .previous_epoch_attestations
+            .iter()
+            .chain(state.current_epoch_attestations.iter())
+        {
             let attesting_indices =
-                state.get_attestation_participants(&a.data, &a.aggregation_bitfield, spec)?;
-            let attesting_balance = state.get_total_balance(&attesting_indices, spec);
+                get_attestation_participants(state, &a.data, &a.aggregation_bitfield, spec)?;
+            let attesting_balance = state.get_total_balance(&attesting_indices, spec)?;
 
             let mut status = AttesterStatus::default();
 
@@ -206,10 +210,15 @@ impl ValidatorStatuses {
                 status.is_previous_epoch_attester = true;
 
                 // The inclusion slot and distance are only required for previous epoch attesters.
+                let relative_epoch = RelativeEpoch::from_slot(state.slot, a.data.slot, spec)?;
                 status.inclusion_info = InclusionInfo {
                     slot: a.inclusion_slot,
                     distance: inclusion_distance(a),
-                    proposer_index: state.get_beacon_proposer_index(a.inclusion_slot, spec)?,
+                    proposer_index: state.get_beacon_proposer_index(
+                        a.inclusion_slot,
+                        relative_epoch,
+                        spec,
+                    )?,
                 };
 
                 if has_common_epoch_boundary_root(a, state, state.previous_epoch(spec), spec)? {
@@ -235,7 +244,7 @@ impl ValidatorStatuses {
     /// Update the `statuses` for each validator based upon whether or not they attested to the
     /// "winning" shard block root for the previous epoch.
     ///
-    /// Spec v0.4.0
+    /// Spec v0.5.0
     pub fn process_winning_roots(
         &mut self,
         state: &BeaconState,
@@ -248,11 +257,10 @@ impl ValidatorStatuses {
                 state.get_crosslink_committees_at_slot(slot, spec)?;
 
             // Loop through each committee in the slot.
-            for (crosslink_committee, shard) in crosslink_committees_at_slot {
+            for c in crosslink_committees_at_slot {
                 // If there was some winning crosslink root for the committee's shard.
-                if let Some(winning_root) = winning_roots.get(&shard) {
-                    let total_committee_balance =
-                        state.get_total_balance(&crosslink_committee, spec);
+                if let Some(winning_root) = winning_roots.get(&c.shard) {
+                    let total_committee_balance = state.get_total_balance(&c.committee, spec)?;
                     for &validator_index in &winning_root.attesting_validator_indices {
                         // Take note of the balance information for the winning root, it will be
                         // used later to calculate rewards for that validator.
@@ -272,14 +280,14 @@ impl ValidatorStatuses {
 /// Returns the distance between when the attestation was created and when it was included in a
 /// block.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 fn inclusion_distance(a: &PendingAttestation) -> Slot {
     a.inclusion_slot - a.data.slot
 }
 
 /// Returns `true` if some `PendingAttestation` is from the supplied `epoch`.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 fn is_from_epoch(a: &PendingAttestation, epoch: Epoch, spec: &ChainSpec) -> bool {
     a.data.slot.epoch(spec.slots_per_epoch) == epoch
 }
@@ -287,7 +295,7 @@ fn is_from_epoch(a: &PendingAttestation, epoch: Epoch, spec: &ChainSpec) -> bool
 /// Returns `true` if a `PendingAttestation` and `BeaconState` share the same beacon block hash for
 /// the first slot of the given epoch.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 fn has_common_epoch_boundary_root(
     a: &PendingAttestation,
     state: &BeaconState,
@@ -295,25 +303,21 @@ fn has_common_epoch_boundary_root(
     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)?;
+    let state_boundary_root = *state.get_block_root(slot, spec)?;
 
-    Ok(a.data.epoch_boundary_root == state_boundary_root)
+    Ok(a.data.target_root == state_boundary_root)
 }
 
 /// Returns `true` if a `PendingAttestation` and `BeaconState` share the same beacon block hash for
 /// the current slot of the `PendingAttestation`.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 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)?;
+    let state_block_root = *state.get_block_root(a.data.slot, spec)?;
 
     Ok(a.data.beacon_block_root == state_block_root)
 }
diff --git a/eth2/state_processing/src/per_epoch_processing/winning_root.rs b/eth2/state_processing/src/per_epoch_processing/winning_root.rs
index 07678f93b6..97cff3e13a 100644
--- a/eth2/state_processing/src/per_epoch_processing/winning_root.rs
+++ b/eth2/state_processing/src/per_epoch_processing/winning_root.rs
@@ -1,3 +1,4 @@
+use super::get_attestation_participants::get_attestation_participants;
 use std::collections::HashSet;
 use std::iter::FromIterator;
 use types::*;
@@ -13,14 +14,14 @@ 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.
+    /// are broken by favouring the higher `crosslink_data_root` value.
     ///
-    /// Spec v0.4.0
+    /// Spec v0.5.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
+            self.crosslink_data_root > other.crosslink_data_root
         } else {
             false
         }
@@ -33,22 +34,21 @@ impl WinningRoot {
 /// The `WinningRoot` object also contains additional fields that are useful in later stages of
 /// per-epoch processing.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.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
+        state
+            .previous_epoch_attestations
             .iter()
-            .chain(current_epoch_attestations.iter())
+            .chain(state.current_epoch_attestations.iter())
             .filter_map(|a| {
-                if a.data.shard == shard {
+                if is_eligible_for_winning_root(state, a, shard) {
                     Some(a.data.crosslink_data_root)
                 } else {
                     None
@@ -57,18 +57,17 @@ pub fn winning_root(
     );
 
     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 attesting_validator_indices =
+            get_attesting_validator_indices(state, shard, &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 total_attesting_balance: u64 =
+            attesting_validator_indices
+                .iter()
+                .try_fold(0_u64, |acc, i| {
+                    state
+                        .get_effective_balance(*i, spec)
+                        .and_then(|bal| Ok(acc + bal))
+                })?;
 
         let candidate = WinningRoot {
             crosslink_data_root,
@@ -88,25 +87,36 @@ pub fn winning_root(
     Ok(winning_root)
 }
 
-/// Returns all indices which voted for a given crosslink. May contain duplicates.
+/// Returns `true` if pending attestation `a` is eligible to become a winning root.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
+fn is_eligible_for_winning_root(state: &BeaconState, a: &PendingAttestation, shard: Shard) -> bool {
+    if shard >= state.latest_crosslinks.len() as u64 {
+        return false;
+    }
+
+    a.data.previous_crosslink == state.latest_crosslinks[shard as usize]
+}
+
+/// Returns all indices which voted for a given crosslink. Does not contain duplicates.
+///
+/// Spec v0.5.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
+    for a in state
+        .current_epoch_attestations
         .iter()
-        .chain(previous_epoch_attestations.iter())
+        .chain(state.previous_epoch_attestations.iter())
     {
         if (a.data.shard == shard) && (a.data.crosslink_data_root == *crosslink_data_root) {
-            indices.append(&mut state.get_attestation_participants(
+            indices.append(&mut get_attestation_participants(
+                state,
                 &a.data,
                 &a.aggregation_bitfield,
                 spec,
@@ -114,5 +124,41 @@ fn get_attesting_validator_indices(
         }
     }
 
+    // Sort the list (required for dedup). "Unstable" means the sort may re-order equal elements,
+    // this causes no issue here.
+    //
+    // These sort + dedup ops are potentially good CPU time optimisation targets.
+    indices.sort_unstable();
+    // Remove all duplicate indices (requires a sorted list).
+    indices.dedup();
+
     Ok(indices)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn is_better_than() {
+        let worse = WinningRoot {
+            crosslink_data_root: Hash256::from_slice(&[1; 32]),
+            attesting_validator_indices: vec![],
+            total_attesting_balance: 42,
+        };
+
+        let better = WinningRoot {
+            crosslink_data_root: Hash256::from_slice(&[2; 32]),
+            ..worse.clone()
+        };
+
+        assert!(better.is_better_than(&worse));
+
+        let better = WinningRoot {
+            total_attesting_balance: worse.total_attesting_balance + 1,
+            ..worse.clone()
+        };
+
+        assert!(better.is_better_than(&worse));
+    }
+}
diff --git a/eth2/types/src/beacon_state.rs b/eth2/types/src/beacon_state.rs
index 7c77a5a3e5..a90f09759d 100644
--- a/eth2/types/src/beacon_state.rs
+++ b/eth2/types/src/beacon_state.rs
@@ -1,8 +1,7 @@
 use self::epoch_cache::EpochCache;
 use crate::test_utils::TestRandom;
-use crate::{validator_registry::get_active_validator_indices, *};
+use crate::*;
 use int_to_bytes::int_to_bytes32;
-use log::trace;
 use pubkey_cache::PubkeyCache;
 use rand::RngCore;
 use serde_derive::{Deserialize, Serialize};
@@ -39,6 +38,7 @@ pub enum Error {
     InsufficientAttestations,
     InsufficientCommittees,
     InsufficientSlashedBalances,
+    NoCommitteeForShard,
     EpochCacheUninitialized(RelativeEpoch),
     PubkeyCacheInconsistent,
     PubkeyCacheIncomplete {
@@ -349,17 +349,49 @@ impl BeaconState {
         self.current_epoch(spec) + 1
     }
 
+    /// Returns the active validator indices for the given epoch, assuming there is no validator
+    /// registry update in the next epoch.
+    ///
+    /// Note: Utilizes the cache and will fail if the appropriate cache is not initialized.
+    ///
+    /// Spec v0.5.0
+    pub fn get_active_validator_indices(
+        &self,
+        epoch: Epoch,
+        spec: &ChainSpec,
+    ) -> Result<&[usize], Error> {
+        // If the slot is in the next epoch, assume there was no validator registry update.
+        let relative_epoch =
+            match RelativeEpoch::from_epoch(self.slot.epoch(spec.slots_per_epoch), epoch) {
+                Err(RelativeEpochError::AmbiguiousNextEpoch) => {
+                    Ok(RelativeEpoch::NextWithoutRegistryChange)
+                }
+                e => e,
+            }?;
+
+        let cache = self.cache(relative_epoch, spec)?;
+
+        Ok(&cache.active_validator_indices)
+    }
+
     /// Returns the crosslink committees for some slot.
     ///
     /// Note: Utilizes the cache and will fail if the appropriate cache is not initialized.
     ///
-    /// Spec v0.4.0
+    /// Spec v0.5.0
     pub fn get_crosslink_committees_at_slot(
         &self,
         slot: Slot,
-        relative_epoch: RelativeEpoch,
         spec: &ChainSpec,
     ) -> Result<&Vec<CrosslinkCommittee>, Error> {
+        // If the slot is in the next epoch, assume there was no validator registry update.
+        let relative_epoch = match RelativeEpoch::from_slot(self.slot, slot, spec) {
+            Err(RelativeEpochError::AmbiguiousNextEpoch) => {
+                Ok(RelativeEpoch::NextWithoutRegistryChange)
+            }
+            e => e,
+        }?;
+
         let cache = self.cache(relative_epoch, spec)?;
 
         Ok(cache
@@ -367,15 +399,46 @@ impl BeaconState {
             .ok_or_else(|| Error::SlotOutOfBounds)?)
     }
 
+    /// Returns the crosslink committees for some shard in an epoch.
+    ///
+    /// Note: Utilizes the cache and will fail if the appropriate cache is not initialized.
+    ///
+    /// Spec v0.4.0
+    pub fn get_crosslink_committee_for_shard(
+        &self,
+        epoch: Epoch,
+        shard: Shard,
+        spec: &ChainSpec,
+    ) -> Result<&CrosslinkCommittee, Error> {
+        // If the slot is in the next epoch, assume there was no validator registry update.
+        let relative_epoch = match RelativeEpoch::from_epoch(self.current_epoch(spec), epoch) {
+            Err(RelativeEpochError::AmbiguiousNextEpoch) => {
+                Ok(RelativeEpoch::NextWithoutRegistryChange)
+            }
+            e => e,
+        }?;
+
+        let cache = self.cache(relative_epoch, spec)?;
+
+        Ok(cache
+            .get_crosslink_committee_for_shard(shard, spec)
+            .ok_or_else(|| Error::NoCommitteeForShard)?)
+    }
+
     /// Return the block root at a recent `slot`.
     ///
     /// Spec v0.5.0
-    pub fn get_block_root(&self, slot: Slot, spec: &ChainSpec) -> Option<&Hash256> {
+    pub fn get_block_root(
+        &self,
+        slot: Slot,
+        spec: &ChainSpec,
+    ) -> Result<&Hash256, BeaconStateError> {
         if (self.slot <= slot + spec.slots_per_historical_root as u64) && (slot < self.slot) {
             self.latest_block_roots
                 .get(slot.as_usize() % spec.slots_per_historical_root)
+                .ok_or_else(|| Error::InsufficientBlockRoots)
         } else {
-            None
+            Err(Error::EpochOutOfBounds)
         }
     }
 
@@ -476,12 +539,12 @@ impl BeaconState {
         relative_epoch: RelativeEpoch,
         spec: &ChainSpec,
     ) -> Result<usize, Error> {
-        let committees = self.get_crosslink_committees_at_slot(slot, relative_epoch, spec)?;
-        trace!(
-            "get_beacon_proposer_index: slot: {}, committees_count: {}",
-            slot,
-            committees.len()
-        );
+        let cache = self.cache(relative_epoch, spec)?;
+
+        let committees = cache
+            .get_crosslink_committees_at_slot(slot, spec)
+            .ok_or_else(|| Error::SlotOutOfBounds)?;
+
         committees
             .first()
             .ok_or(Error::InsufficientValidators)
@@ -751,13 +814,14 @@ impl BeaconState {
             .ok_or_else(|| Error::UnknownValidator)?)
     }
 
-    /// Process the slashings.
+    /// Process slashings.
+    ///
+    /// Note: Utilizes the cache and will fail if the appropriate cache is not initialized.
     ///
     /// Spec v0.4.0
     pub fn process_slashings(&mut self, spec: &ChainSpec) -> Result<(), Error> {
         let current_epoch = self.current_epoch(spec);
-        let active_validator_indices =
-            get_active_validator_indices(&self.validator_registry, current_epoch);
+        let active_validator_indices = self.get_active_validator_indices(current_epoch, spec)?;
         let total_balance = self.get_total_balance(&active_validator_indices[..], spec)?;
 
         for (index, validator) in self.validator_registry.iter().enumerate() {
@@ -818,11 +882,12 @@ impl BeaconState {
 
     /// Update validator registry, activating/exiting validators if possible.
     ///
+    /// Note: Utilizes the cache and will fail if the appropriate cache is not initialized.
+    ///
     /// Spec v0.4.0
     pub fn update_validator_registry(&mut self, spec: &ChainSpec) -> Result<(), Error> {
         let current_epoch = self.current_epoch(spec);
-        let active_validator_indices =
-            get_active_validator_indices(&self.validator_registry, current_epoch);
+        let active_validator_indices = self.get_active_validator_indices(current_epoch, spec)?;
         let total_balance = self.get_total_balance(&active_validator_indices[..], spec)?;
 
         let max_balance_churn = std::cmp::max(
@@ -867,54 +932,32 @@ impl BeaconState {
     /// Iterate through the validator registry and eject active validators with balance below
     /// ``EJECTION_BALANCE``.
     ///
-    /// Spec v0.4.0
-    pub fn process_ejections(&mut self, spec: &ChainSpec) {
-        for validator_index in
-            get_active_validator_indices(&self.validator_registry, self.current_epoch(spec))
-        {
-            if self.validator_balances[validator_index] < spec.ejection_balance {
-                self.exit_validator(validator_index, spec)
-            }
+    /// Spec v0.5.0
+    pub fn process_ejections(&mut self, spec: &ChainSpec) -> Result<(), Error> {
+        // There is an awkward double (triple?) loop here because we can't loop across the borrowed
+        // active validator indices and mutate state in the one loop.
+        let exitable: Vec<usize> = self
+            .get_active_validator_indices(self.current_epoch(spec), spec)?
+            .iter()
+            .filter_map(|&i| {
+                if self.validator_balances[i as usize] < spec.ejection_balance {
+                    Some(i)
+                } else {
+                    None
+                }
+            })
+            .collect();
+
+        for validator_index in exitable {
+            self.exit_validator(validator_index, spec)
         }
-    }
 
-    /// Returns the penality that should be applied to some validator for inactivity.
-    ///
-    /// Note: this is defined "inline" in the spec, not as a helper function.
-    ///
-    /// Spec v0.4.0
-    pub fn inactivity_penalty(
-        &self,
-        validator_index: usize,
-        epochs_since_finality: Epoch,
-        base_reward_quotient: u64,
-        spec: &ChainSpec,
-    ) -> Result<u64, Error> {
-        let effective_balance = self.get_effective_balance(validator_index, spec)?;
-        let base_reward = self.base_reward(validator_index, base_reward_quotient, spec)?;
-        Ok(base_reward
-            + effective_balance * epochs_since_finality.as_u64()
-                / spec.inactivity_penalty_quotient
-                / 2)
-    }
-
-    /// Returns the base reward for some validator.
-    ///
-    /// Note: In the spec this is defined "inline", not as a helper function.
-    ///
-    /// Spec v0.4.0
-    pub fn base_reward(
-        &self,
-        validator_index: usize,
-        base_reward_quotient: u64,
-        spec: &ChainSpec,
-    ) -> Result<u64, Error> {
-        Ok(self.get_effective_balance(validator_index, spec)? / base_reward_quotient / 5)
+        Ok(())
     }
 
     /// Return the combined effective balance of an array of validators.
     ///
-    /// Spec v0.4.0
+    /// Spec v0.5.0
     pub fn get_total_balance(
         &self,
         validator_indices: &[usize],
diff --git a/eth2/types/src/beacon_state/epoch_cache.rs b/eth2/types/src/beacon_state/epoch_cache.rs
index 6312ea5a54..0759a76170 100644
--- a/eth2/types/src/beacon_state/epoch_cache.rs
+++ b/eth2/types/src/beacon_state/epoch_cache.rs
@@ -13,7 +13,9 @@ pub struct EpochCache {
     /// Maps validator index to a slot, shard and committee index for attestation.
     pub attestation_duties: Vec<Option<AttestationDuty>>,
     /// Maps a shard to an index of `self.committees`.
-    pub shard_committee_indices: Vec<(Slot, usize)>,
+    pub shard_committee_indices: Vec<Option<(Slot, usize)>>,
+    /// Indices of all active validators in the epoch
+    pub active_validator_indices: Vec<usize>,
 }
 
 impl EpochCache {
@@ -31,18 +33,18 @@ impl EpochCache {
         let builder = match relative_epoch {
             RelativeEpoch::Previous => EpochCrosslinkCommitteesBuilder::for_previous_epoch(
                 state,
-                active_validator_indices,
+                active_validator_indices.clone(),
                 spec,
             ),
             RelativeEpoch::Current => EpochCrosslinkCommitteesBuilder::for_current_epoch(
                 state,
-                active_validator_indices,
+                active_validator_indices.clone(),
                 spec,
             ),
             RelativeEpoch::NextWithRegistryChange => {
                 EpochCrosslinkCommitteesBuilder::for_next_epoch(
                     state,
-                    active_validator_indices,
+                    active_validator_indices.clone(),
                     true,
                     spec,
                 )?
@@ -50,7 +52,7 @@ impl EpochCache {
             RelativeEpoch::NextWithoutRegistryChange => {
                 EpochCrosslinkCommitteesBuilder::for_next_epoch(
                     state,
-                    active_validator_indices,
+                    active_validator_indices.clone(),
                     false,
                     spec,
                 )?
@@ -64,7 +66,7 @@ impl EpochCache {
         // 2. `shard_committee_indices`: maps `Shard` into a `CrosslinkCommittee` in
         //    `EpochCrosslinkCommittees`.
         let mut attestation_duties = vec![None; state.validator_registry.len()];
-        let mut shard_committee_indices = vec![(Slot::default(), 0); spec.shard_count as usize];
+        let mut shard_committee_indices = vec![None; spec.shard_count as usize];
         for (i, slot_committees) in epoch_crosslink_committees
             .crosslink_committees
             .iter()
@@ -75,7 +77,7 @@ impl EpochCache {
             for (j, crosslink_committee) in slot_committees.iter().enumerate() {
                 let shard = crosslink_committee.shard;
 
-                shard_committee_indices[shard as usize] = (slot, j);
+                shard_committee_indices[shard as usize] = Some((slot, j));
 
                 for (k, validator_index) in crosslink_committee.committee.iter().enumerate() {
                     let attestation_duty = AttestationDuty {
@@ -93,6 +95,7 @@ impl EpochCache {
             epoch_crosslink_committees,
             attestation_duties,
             shard_committee_indices,
+            active_validator_indices,
         })
     }
 
@@ -110,9 +113,13 @@ impl EpochCache {
         shard: Shard,
         spec: &ChainSpec,
     ) -> Option<&CrosslinkCommittee> {
-        let (slot, committee) = self.shard_committee_indices.get(shard as usize)?;
-        let slot_committees = self.get_crosslink_committees_at_slot(*slot, spec)?;
-        slot_committees.get(*committee)
+        if shard > self.shard_committee_indices.len() as u64 {
+            None
+        } else {
+            let (slot, committee) = self.shard_committee_indices[shard as usize]?;
+            let slot_committees = self.get_crosslink_committees_at_slot(slot, spec)?;
+            slot_committees.get(committee)
+        }
     }
 }
 
@@ -261,13 +268,14 @@ impl EpochCrosslinkCommitteesBuilder {
 
         let committees_per_slot = (self.committees_per_epoch / spec.slots_per_epoch) as usize;
 
-        for i in 0..spec.slots_per_epoch as usize {
+        for (i, slot) in self.epoch.slot_iter(spec.slots_per_epoch).enumerate() {
             for j in (0..committees.len())
                 .into_iter()
                 .skip(i * committees_per_slot)
                 .take(committees_per_slot)
             {
                 let crosslink_committee = CrosslinkCommittee {
+                    slot,
                     shard,
                     committee: committees.remove(j),
                 };
diff --git a/eth2/types/src/crosslink_committee.rs b/eth2/types/src/crosslink_committee.rs
index 06a6562fcd..af1778a1b7 100644
--- a/eth2/types/src/crosslink_committee.rs
+++ b/eth2/types/src/crosslink_committee.rs
@@ -4,6 +4,7 @@ use ssz_derive::{Decode, Encode, TreeHash};
 
 #[derive(Default, Clone, Debug, PartialEq, Serialize, Deserialize, Decode, Encode, TreeHash)]
 pub struct CrosslinkCommittee {
+    pub slot: Slot,
     pub shard: Shard,
     pub committee: Vec<usize>,
 }
diff --git a/eth2/types/src/test_utils/testing_beacon_block_builder.rs b/eth2/types/src/test_utils/testing_beacon_block_builder.rs
index 402bd79d63..6e48c8c178 100644
--- a/eth2/types/src/test_utils/testing_beacon_block_builder.rs
+++ b/eth2/types/src/test_utils/testing_beacon_block_builder.rs
@@ -109,10 +109,7 @@ impl TestingBeaconBlockBuilder {
                 break;
             }
 
-            let relative_epoch = RelativeEpoch::from_slot(state.slot, slot, spec).unwrap();
-            for crosslink_committee in
-                state.get_crosslink_committees_at_slot(slot, relative_epoch, spec)?
-            {
+            for crosslink_committee in state.get_crosslink_committees_at_slot(slot, spec)? {
                 if attestations_added >= num_attestations {
                     break;
                 }
diff --git a/eth2/types/src/test_utils/testing_beacon_state_builder.rs b/eth2/types/src/test_utils/testing_beacon_state_builder.rs
index 9e613f0e91..54e2fbe964 100644
--- a/eth2/types/src/test_utils/testing_beacon_state_builder.rs
+++ b/eth2/types/src/test_utils/testing_beacon_state_builder.rs
@@ -223,9 +223,8 @@ impl TestingBeaconStateBuilder {
         for slot in first_slot..last_slot + 1 {
             let slot = Slot::from(slot);
 
-            let relative_epoch = RelativeEpoch::from_slot(state.slot, slot, spec).unwrap();
             let committees = state
-                .get_crosslink_committees_at_slot(slot, relative_epoch, spec)
+                .get_crosslink_committees_at_slot(slot, spec)
                 .unwrap()
                 .clone();
 

From 6b3cdc34dd4197a87468ba67549da376a678c834 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Sun, 17 Mar 2019 17:50:22 +1100
Subject: [PATCH 38/60] Update block proposer to v0.5.0

---
 eth2/block_proposer/src/lib.rs | 13 +++----------
 1 file changed, 3 insertions(+), 10 deletions(-)

diff --git a/eth2/block_proposer/src/lib.rs b/eth2/block_proposer/src/lib.rs
index 5cddbaedc5..e62c4b71d5 100644
--- a/eth2/block_proposer/src/lib.rs
+++ b/eth2/block_proposer/src/lib.rs
@@ -4,7 +4,7 @@ mod traits;
 use slot_clock::SlotClock;
 use ssz::{SignedRoot, TreeHash};
 use std::sync::Arc;
-use types::{BeaconBlock, ChainSpec, Domain, Hash256, Proposal, Slot};
+use types::{BeaconBlock, ChainSpec, Domain, Slot};
 
 pub use self::traits::{
     BeaconNode, BeaconNodeError, DutiesReader, DutiesReaderError, PublishOutcome, Signer,
@@ -158,7 +158,7 @@ impl<T: SlotClock, U: BeaconNode, V: DutiesReader, W: Signer> BlockProducer<T, U
             if self.safe_to_produce(&block) {
                 let domain = self.spec.get_domain(
                     slot.epoch(self.spec.slots_per_epoch),
-                    Domain::Proposal,
+                    Domain::BeaconBlock,
                     &fork,
                 );
                 if let Some(block) = self.sign_block(block, domain) {
@@ -182,16 +182,9 @@ impl<T: SlotClock, U: BeaconNode, V: DutiesReader, W: Signer> BlockProducer<T, U
     fn sign_block(&mut self, mut block: BeaconBlock, domain: u64) -> Option<BeaconBlock> {
         self.store_produce(&block);
 
-        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)
+            .sign_block_proposal(&block.signed_root()[..], domain)
         {
             None => None,
             Some(signature) => {

From 8b08e9dd2e2fe90f3e5c9269397cbf82e24bd413 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Sun, 17 Mar 2019 17:54:43 +1100
Subject: [PATCH 39/60] Remove block and state readers from db crate

---
 .../db/src/stores/beacon_block_store.rs       | 37 +++++--------------
 .../db/src/stores/beacon_state_store.rs       | 22 +----------
 2 files changed, 12 insertions(+), 47 deletions(-)

diff --git a/beacon_node/db/src/stores/beacon_block_store.rs b/beacon_node/db/src/stores/beacon_block_store.rs
index 92d296c373..e2e16e60b8 100644
--- a/beacon_node/db/src/stores/beacon_block_store.rs
+++ b/beacon_node/db/src/stores/beacon_block_store.rs
@@ -2,7 +2,7 @@ use super::BLOCKS_DB_COLUMN as DB_COLUMN;
 use super::{ClientDB, DBError};
 use ssz::Decodable;
 use std::sync::Arc;
-use types::{readers::BeaconBlockReader, BeaconBlock, Hash256, Slot};
+use types::{BeaconBlock, Hash256, Slot};
 
 #[derive(Clone, Debug, PartialEq)]
 pub enum BeaconBlockAtSlotError {
@@ -38,23 +38,6 @@ impl<T: ClientDB> BeaconBlockStore<T> {
         }
     }
 
-    /// Retuns an object implementing `BeaconBlockReader`, or `None` (if hash not known).
-    ///
-    /// Note: Presently, this function fully deserializes a `BeaconBlock` and returns that. In the
-    /// future, it would be ideal to return an object capable of reading directly from serialized
-    /// SSZ bytes.
-    pub fn get_reader(&self, hash: &Hash256) -> Result<Option<impl BeaconBlockReader>, DBError> {
-        match self.get(&hash)? {
-            None => Ok(None),
-            Some(ssz) => {
-                let (block, _) = BeaconBlock::ssz_decode(&ssz, 0).map_err(|_| DBError {
-                    message: "Bad BeaconBlock SSZ.".to_string(),
-                })?;
-                Ok(Some(block))
-            }
-        }
-    }
-
     /// Retrieve the block at a slot given a "head_hash" and a slot.
     ///
     /// A "head_hash" must be a block hash with a slot number greater than or equal to the desired
@@ -72,17 +55,17 @@ impl<T: ClientDB> BeaconBlockStore<T> {
         &self,
         head_hash: &Hash256,
         slot: Slot,
-    ) -> Result<Option<(Hash256, impl BeaconBlockReader)>, BeaconBlockAtSlotError> {
+    ) -> Result<Option<(Hash256, BeaconBlock)>, BeaconBlockAtSlotError> {
         let mut current_hash = *head_hash;
 
         loop {
-            if let Some(block_reader) = self.get_reader(&current_hash)? {
-                if block_reader.slot() == slot {
-                    break Ok(Some((current_hash, block_reader)));
-                } else if block_reader.slot() < slot {
+            if let Some(block) = self.get_deserialized(&current_hash)? {
+                if block.slot == slot {
+                    break Ok(Some((current_hash, block)));
+                } else if block.slot < slot {
                     break Ok(None);
                 } else {
-                    current_hash = block_reader.parent_root();
+                    current_hash = block.previous_block_root;
                 }
             } else {
                 break Err(BeaconBlockAtSlotError::UnknownBeaconBlock(current_hash));
@@ -228,7 +211,7 @@ mod tests {
         for i in 0..block_count {
             let mut block = BeaconBlock::random_for_test(&mut rng);
 
-            block.parent_root = parent_hashes[i];
+            block.previous_block_root = parent_hashes[i];
             block.slot = slots[i];
 
             let ssz = ssz_encode(&block);
@@ -240,12 +223,12 @@ mod tests {
         // Test that certain slots can be reached from certain hashes.
         let test_cases = vec![(4, 4), (4, 3), (4, 2), (4, 1), (4, 0)];
         for (hashes_index, slot_index) in test_cases {
-            let (matched_block_hash, reader) = bs
+            let (matched_block_hash, block) = bs
                 .block_at_slot(&hashes[hashes_index], slots[slot_index])
                 .unwrap()
                 .unwrap();
             assert_eq!(matched_block_hash, hashes[slot_index]);
-            assert_eq!(reader.slot(), slots[slot_index]);
+            assert_eq!(block.slot, slots[slot_index]);
         }
 
         let ssz = bs.block_at_slot(&hashes[4], Slot::new(2)).unwrap();
diff --git a/beacon_node/db/src/stores/beacon_state_store.rs b/beacon_node/db/src/stores/beacon_state_store.rs
index ed22696cb2..fd6ff569af 100644
--- a/beacon_node/db/src/stores/beacon_state_store.rs
+++ b/beacon_node/db/src/stores/beacon_state_store.rs
@@ -2,7 +2,7 @@ use super::STATES_DB_COLUMN as DB_COLUMN;
 use super::{ClientDB, DBError};
 use ssz::Decodable;
 use std::sync::Arc;
-use types::{readers::BeaconStateReader, BeaconState, Hash256};
+use types::{BeaconState, Hash256};
 
 pub struct BeaconStateStore<T>
 where
@@ -30,23 +30,6 @@ impl<T: ClientDB> BeaconStateStore<T> {
             }
         }
     }
-
-    /// Retuns an object implementing `BeaconStateReader`, or `None` (if hash not known).
-    ///
-    /// Note: Presently, this function fully deserializes a `BeaconState` and returns that. In the
-    /// future, it would be ideal to return an object capable of reading directly from serialized
-    /// SSZ bytes.
-    pub fn get_reader(&self, hash: &Hash256) -> Result<Option<impl BeaconStateReader>, DBError> {
-        match self.get(&hash)? {
-            None => Ok(None),
-            Some(ssz) => {
-                let (state, _) = BeaconState::ssz_decode(&ssz, 0).map_err(|_| DBError {
-                    message: "Bad State SSZ.".to_string(),
-                })?;
-                Ok(Some(state))
-            }
-        }
-    }
 }
 
 #[cfg(test)]
@@ -72,8 +55,7 @@ mod tests {
 
         store.put(&state_root, &ssz_encode(&state)).unwrap();
 
-        let reader = store.get_reader(&state_root).unwrap().unwrap();
-        let decoded = reader.into_beacon_state().unwrap();
+        let decoded = store.get_deserialized(&state_root).unwrap().unwrap();
 
         assert_eq!(state, decoded);
     }

From d94540c85c6f98068c6a5cadac312c55eff22353 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Sun, 17 Mar 2019 17:59:29 +1100
Subject: [PATCH 40/60] Remove readers from fork choice crate.

---
 eth2/fork_choice/src/bitwise_lmd_ghost.rs   | 24 ++++++++++-----------
 eth2/fork_choice/src/optimized_lmd_ghost.rs | 24 ++++++++++-----------
 eth2/fork_choice/src/slow_lmd_ghost.rs      | 15 ++++++-------
 3 files changed, 31 insertions(+), 32 deletions(-)

diff --git a/eth2/fork_choice/src/bitwise_lmd_ghost.rs b/eth2/fork_choice/src/bitwise_lmd_ghost.rs
index d7b10015be..9410fd2034 100644
--- a/eth2/fork_choice/src/bitwise_lmd_ghost.rs
+++ b/eth2/fork_choice/src/bitwise_lmd_ghost.rs
@@ -11,8 +11,8 @@ use log::{debug, trace};
 use std::collections::HashMap;
 use std::sync::Arc;
 use types::{
-    readers::BeaconBlockReader, validator_registry::get_active_validator_indices, BeaconBlock,
-    ChainSpec, Hash256, Slot, SlotHeight,
+    validator_registry::get_active_validator_indices, BeaconBlock, ChainSpec, Hash256, Slot,
+    SlotHeight,
 };
 
 //TODO: Pruning - Children
@@ -255,17 +255,17 @@ impl<T: ClientDB + Sized> ForkChoice for BitwiseLMDGhost<T> {
         // get the height of the parent
         let parent_height = self
             .block_store
-            .get_deserialized(&block.parent_root)?
-            .ok_or_else(|| ForkChoiceError::MissingBeaconBlock(block.parent_root))?
-            .slot()
+            .get_deserialized(&block.previous_block_root)?
+            .ok_or_else(|| ForkChoiceError::MissingBeaconBlock(block.previous_block_root))?
+            .slot
             .height(spec.genesis_slot);
 
-        let parent_hash = &block.parent_root;
+        let parent_hash = &block.previous_block_root;
 
         // add the new block to the children of parent
         (*self
             .children
-            .entry(block.parent_root)
+            .entry(block.previous_block_root)
             .or_insert_with(|| vec![]))
         .push(block_hash.clone());
 
@@ -309,7 +309,7 @@ impl<T: ClientDB + Sized> ForkChoice for BitwiseLMDGhost<T> {
                 .block_store
                 .get_deserialized(&target_block_root)?
                 .ok_or_else(|| ForkChoiceError::MissingBeaconBlock(*target_block_root))?
-                .slot()
+                .slot
                 .height(spec.genesis_slot);
 
             // get the height of the past target block
@@ -317,7 +317,7 @@ impl<T: ClientDB + Sized> ForkChoice for BitwiseLMDGhost<T> {
                 .block_store
                 .get_deserialized(&attestation_target)?
                 .ok_or_else(|| ForkChoiceError::MissingBeaconBlock(*attestation_target))?
-                .slot()
+                .slot
                 .height(spec.genesis_slot);
             // update the attestation only if the new target is higher
             if past_block_height < block_height {
@@ -343,8 +343,8 @@ impl<T: ClientDB + Sized> ForkChoice for BitwiseLMDGhost<T> {
             .get_deserialized(&justified_block_start)?
             .ok_or_else(|| ForkChoiceError::MissingBeaconBlock(*justified_block_start))?;
 
-        let block_slot = block.slot();
-        let state_root = block.state_root();
+        let block_slot = block.slot;
+        let state_root = block.state_root;
         let mut block_height = block_slot.height(spec.genesis_slot);
 
         let mut current_head = *justified_block_start;
@@ -434,7 +434,7 @@ impl<T: ClientDB + Sized> ForkChoice for BitwiseLMDGhost<T> {
                 .block_store
                 .get_deserialized(&current_head)?
                 .ok_or_else(|| ForkChoiceError::MissingBeaconBlock(current_head))?
-                .slot()
+                .slot
                 .height(spec.genesis_slot);
             // prune the latest votes for votes that are not part of current chosen chain
             // more specifically, only keep votes that have head as an ancestor
diff --git a/eth2/fork_choice/src/optimized_lmd_ghost.rs b/eth2/fork_choice/src/optimized_lmd_ghost.rs
index 30c84e9e14..e1b8914a63 100644
--- a/eth2/fork_choice/src/optimized_lmd_ghost.rs
+++ b/eth2/fork_choice/src/optimized_lmd_ghost.rs
@@ -11,8 +11,8 @@ use std::cmp::Ordering;
 use std::collections::HashMap;
 use std::sync::Arc;
 use types::{
-    readers::BeaconBlockReader, validator_registry::get_active_validator_indices, BeaconBlock,
-    ChainSpec, Hash256, Slot, SlotHeight,
+    validator_registry::get_active_validator_indices, BeaconBlock, ChainSpec, Hash256, Slot,
+    SlotHeight,
 };
 
 //TODO: Pruning - Children
@@ -226,17 +226,17 @@ impl<T: ClientDB + Sized> ForkChoice for OptimizedLMDGhost<T> {
         // get the height of the parent
         let parent_height = self
             .block_store
-            .get_deserialized(&block.parent_root)?
-            .ok_or_else(|| ForkChoiceError::MissingBeaconBlock(block.parent_root))?
-            .slot()
+            .get_deserialized(&block.previous_block_root)?
+            .ok_or_else(|| ForkChoiceError::MissingBeaconBlock(block.previous_block_root))?
+            .slot
             .height(spec.genesis_slot);
 
-        let parent_hash = &block.parent_root;
+        let parent_hash = &block.previous_block_root;
 
         // add the new block to the children of parent
         (*self
             .children
-            .entry(block.parent_root)
+            .entry(block.previous_block_root)
             .or_insert_with(|| vec![]))
         .push(block_hash.clone());
 
@@ -280,7 +280,7 @@ impl<T: ClientDB + Sized> ForkChoice for OptimizedLMDGhost<T> {
                 .block_store
                 .get_deserialized(&target_block_root)?
                 .ok_or_else(|| ForkChoiceError::MissingBeaconBlock(*target_block_root))?
-                .slot()
+                .slot
                 .height(spec.genesis_slot);
 
             // get the height of the past target block
@@ -288,7 +288,7 @@ impl<T: ClientDB + Sized> ForkChoice for OptimizedLMDGhost<T> {
                 .block_store
                 .get_deserialized(&attestation_target)?
                 .ok_or_else(|| ForkChoiceError::MissingBeaconBlock(*attestation_target))?
-                .slot()
+                .slot
                 .height(spec.genesis_slot);
             // update the attestation only if the new target is higher
             if past_block_height < block_height {
@@ -314,8 +314,8 @@ impl<T: ClientDB + Sized> ForkChoice for OptimizedLMDGhost<T> {
             .get_deserialized(&justified_block_start)?
             .ok_or_else(|| ForkChoiceError::MissingBeaconBlock(*justified_block_start))?;
 
-        let block_slot = block.slot();
-        let state_root = block.state_root();
+        let block_slot = block.slot;
+        let state_root = block.state_root;
         let mut block_height = block_slot.height(spec.genesis_slot);
 
         let mut current_head = *justified_block_start;
@@ -405,7 +405,7 @@ impl<T: ClientDB + Sized> ForkChoice for OptimizedLMDGhost<T> {
                 .block_store
                 .get_deserialized(&current_head)?
                 .ok_or_else(|| ForkChoiceError::MissingBeaconBlock(current_head))?
-                .slot()
+                .slot
                 .height(spec.genesis_slot);
             // prune the latest votes for votes that are not part of current chosen chain
             // more specifically, only keep votes that have head as an ancestor
diff --git a/eth2/fork_choice/src/slow_lmd_ghost.rs b/eth2/fork_choice/src/slow_lmd_ghost.rs
index abf13f21b0..af58aa7b83 100644
--- a/eth2/fork_choice/src/slow_lmd_ghost.rs
+++ b/eth2/fork_choice/src/slow_lmd_ghost.rs
@@ -9,8 +9,7 @@ use log::{debug, trace};
 use std::collections::HashMap;
 use std::sync::Arc;
 use types::{
-    readers::BeaconBlockReader, validator_registry::get_active_validator_indices, BeaconBlock,
-    ChainSpec, Hash256, Slot,
+    validator_registry::get_active_validator_indices, BeaconBlock, ChainSpec, Hash256, Slot,
 };
 
 //TODO: Pruning and syncing
@@ -95,7 +94,7 @@ where
             .block_store
             .get_deserialized(&block_root)?
             .ok_or_else(|| ForkChoiceError::MissingBeaconBlock(*block_root))?
-            .slot();
+            .slot;
 
         for (vote_hash, votes) in latest_votes.iter() {
             let (root_at_slot, _) = self
@@ -122,7 +121,7 @@ impl<T: ClientDB + Sized> ForkChoice for SlowLMDGhost<T> {
         // add the new block to the children of parent
         (*self
             .children
-            .entry(block.parent_root)
+            .entry(block.previous_block_root)
             .or_insert_with(|| vec![]))
         .push(block_hash.clone());
 
@@ -155,7 +154,7 @@ impl<T: ClientDB + Sized> ForkChoice for SlowLMDGhost<T> {
                 .block_store
                 .get_deserialized(&target_block_root)?
                 .ok_or_else(|| ForkChoiceError::MissingBeaconBlock(*target_block_root))?
-                .slot()
+                .slot
                 .height(spec.genesis_slot);
 
             // get the height of the past target block
@@ -163,7 +162,7 @@ impl<T: ClientDB + Sized> ForkChoice for SlowLMDGhost<T> {
                 .block_store
                 .get_deserialized(&attestation_target)?
                 .ok_or_else(|| ForkChoiceError::MissingBeaconBlock(*attestation_target))?
-                .slot()
+                .slot
                 .height(spec.genesis_slot);
             // update the attestation only if the new target is higher
             if past_block_height < block_height {
@@ -186,9 +185,9 @@ impl<T: ClientDB + Sized> ForkChoice for SlowLMDGhost<T> {
             .get_deserialized(&justified_block_start)?
             .ok_or_else(|| ForkChoiceError::MissingBeaconBlock(*justified_block_start))?;
 
-        let start_state_root = start.state_root();
+        let start_state_root = start.state_root;
 
-        let latest_votes = self.get_latest_votes(&start_state_root, start.slot(), spec)?;
+        let latest_votes = self.get_latest_votes(&start_state_root, start.slot, spec)?;
 
         let mut head_hash = *justified_block_start;
 

From 6df5eee7f49809da48868629c1567860c957d3fc Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Sun, 17 Mar 2019 18:10:20 +1100
Subject: [PATCH 41/60] Update beacon_chain crate with v0.5.0 updates

---
 .../src/attestation_aggregator.rs             |  53 ++++-----
 beacon_node/beacon_chain/src/beacon_chain.rs  | 104 ++++++++----------
 2 files changed, 67 insertions(+), 90 deletions(-)

diff --git a/beacon_node/beacon_chain/src/attestation_aggregator.rs b/beacon_node/beacon_chain/src/attestation_aggregator.rs
index 75cfd7ee5f..9b4e5a6874 100644
--- a/beacon_node/beacon_chain/src/attestation_aggregator.rs
+++ b/beacon_node/beacon_chain/src/attestation_aggregator.rs
@@ -1,4 +1,3 @@
-use log::trace;
 use ssz::TreeHash;
 use state_processing::per_block_processing::validate_attestation_without_signature;
 use std::collections::{HashMap, HashSet};
@@ -86,34 +85,22 @@ impl AttestationAggregator {
         free_attestation: &FreeAttestation,
         spec: &ChainSpec,
     ) -> Result<Outcome, BeaconStateError> {
-        let attestation_duties = match state.attestation_slot_and_shard_for_validator(
-            free_attestation.validator_index as usize,
-            spec,
-        ) {
-            Err(BeaconStateError::EpochCacheUninitialized(e)) => {
-                panic!("Attempted to access unbuilt cache {:?}.", e)
-            }
-            Err(BeaconStateError::EpochOutOfBounds) => invalid_outcome!(Message::TooOld),
-            Err(BeaconStateError::ShardOutOfBounds) => invalid_outcome!(Message::BadShard),
-            Err(e) => return Err(e),
-            Ok(None) => invalid_outcome!(Message::BadValidatorIndex),
-            Ok(Some(attestation_duties)) => attestation_duties,
-        };
+        let duties =
+            match state.get_attestation_duties(free_attestation.validator_index as usize, spec) {
+                Err(BeaconStateError::EpochCacheUninitialized(e)) => {
+                    panic!("Attempted to access unbuilt cache {:?}.", e)
+                }
+                Err(BeaconStateError::EpochOutOfBounds) => invalid_outcome!(Message::TooOld),
+                Err(BeaconStateError::ShardOutOfBounds) => invalid_outcome!(Message::BadShard),
+                Err(e) => return Err(e),
+                Ok(None) => invalid_outcome!(Message::BadValidatorIndex),
+                Ok(Some(attestation_duties)) => attestation_duties,
+            };
 
-        let (slot, shard, committee_index) = attestation_duties;
-
-        trace!(
-            "slot: {}, shard: {}, committee_index: {}, val_index: {}",
-            slot,
-            shard,
-            committee_index,
-            free_attestation.validator_index
-        );
-
-        if free_attestation.data.slot != slot {
+        if free_attestation.data.slot != duties.slot {
             invalid_outcome!(Message::BadSlot);
         }
-        if free_attestation.data.shard != shard {
+        if free_attestation.data.shard != duties.shard {
             invalid_outcome!(Message::BadShard);
         }
 
@@ -143,7 +130,7 @@ impl AttestationAggregator {
             if let Some(updated_attestation) = aggregate_attestation(
                 existing_attestation,
                 &free_attestation.signature,
-                committee_index as usize,
+                duties.committee_index as usize,
             ) {
                 self.store.insert(signable_message, updated_attestation);
                 valid_outcome!(Message::Aggregated);
@@ -154,7 +141,7 @@ impl AttestationAggregator {
             let mut aggregate_signature = AggregateSignature::new();
             aggregate_signature.add(&free_attestation.signature);
             let mut aggregation_bitfield = Bitfield::new();
-            aggregation_bitfield.set(committee_index as usize, true);
+            aggregation_bitfield.set(duties.committee_index as usize, true);
             let new_attestation = Attestation {
                 data: free_attestation.data.clone(),
                 aggregation_bitfield,
@@ -177,9 +164,13 @@ impl AttestationAggregator {
     ) -> Vec<Attestation> {
         let mut known_attestation_data: HashSet<AttestationData> = HashSet::new();
 
-        state.latest_attestations.iter().for_each(|attestation| {
-            known_attestation_data.insert(attestation.data.clone());
-        });
+        state
+            .previous_epoch_attestations
+            .iter()
+            .chain(state.current_epoch_attestations.iter())
+            .for_each(|attestation| {
+                known_attestation_data.insert(attestation.data.clone());
+            });
 
         self.store
             .values()
diff --git a/beacon_node/beacon_chain/src/beacon_chain.rs b/beacon_node/beacon_chain/src/beacon_chain.rs
index b0e84e1e12..1082f6cabf 100644
--- a/beacon_node/beacon_chain/src/beacon_chain.rs
+++ b/beacon_node/beacon_chain/src/beacon_chain.rs
@@ -15,10 +15,7 @@ use state_processing::{
     per_slot_processing, BlockProcessingError, SlotProcessingError,
 };
 use std::sync::Arc;
-use types::{
-    readers::{BeaconBlockReader, BeaconStateReader},
-    *,
-};
+use types::*;
 
 #[derive(Debug, PartialEq)]
 pub enum ValidBlock {
@@ -106,7 +103,8 @@ where
 
         genesis_state.build_epoch_cache(RelativeEpoch::Previous, &spec)?;
         genesis_state.build_epoch_cache(RelativeEpoch::Current, &spec)?;
-        genesis_state.build_epoch_cache(RelativeEpoch::Next, &spec)?;
+        genesis_state.build_epoch_cache(RelativeEpoch::NextWithoutRegistryChange, &spec)?;
+        genesis_state.build_epoch_cache(RelativeEpoch::NextWithRegistryChange, &spec)?;
 
         Ok(Self {
             block_store,
@@ -248,19 +246,15 @@ where
     /// present and prior epoch is available.
     pub fn block_proposer(&self, slot: Slot) -> Result<usize, BeaconStateError> {
         trace!("BeaconChain::block_proposer: slot: {}", slot);
-        let index = self
-            .state
-            .read()
-            .get_beacon_proposer_index(slot, &self.spec)?;
+        let index = self.state.read().get_beacon_proposer_index(
+            slot,
+            RelativeEpoch::Current,
+            &self.spec,
+        )?;
 
         Ok(index)
     }
 
-    /// Returns the justified slot for the present state.
-    pub fn justified_epoch(&self) -> Epoch {
-        self.state.read().justified_epoch
-    }
-
     /// Returns the attestation slot and shard for a given validator index.
     ///
     /// Information is read from the current state, so only information from the present and prior
@@ -273,12 +267,12 @@ where
             "BeaconChain::validator_attestion_slot_and_shard: validator_index: {}",
             validator_index
         );
-        if let Some((slot, shard, _committee)) = self
+        if let Some(attestation_duty) = self
             .state
             .read()
-            .attestation_slot_and_shard_for_validator(validator_index, &self.spec)?
+            .get_attestation_duties(validator_index, &self.spec)?
         {
-            Ok(Some((slot, shard)))
+            Ok(Some((attestation_duty.slot, attestation_duty.shard)))
         } else {
             Ok(None)
         }
@@ -287,37 +281,33 @@ where
     /// Produce an `AttestationData` that is valid for the present `slot` and given `shard`.
     pub fn produce_attestation_data(&self, shard: u64) -> Result<AttestationData, Error> {
         trace!("BeaconChain::produce_attestation_data: shard: {}", shard);
-        let justified_epoch = self.justified_epoch();
-        let justified_block_root = *self
-            .state
-            .read()
-            .get_block_root(
-                justified_epoch.start_slot(self.spec.slots_per_epoch),
-                &self.spec,
-            )
-            .ok_or_else(|| Error::BadRecentBlockRoots)?;
+        let source_epoch = self.state.read().current_justified_epoch;
+        let source_root = *self.state.read().get_block_root(
+            source_epoch.start_slot(self.spec.slots_per_epoch),
+            &self.spec,
+        )?;
 
-        let epoch_boundary_root = *self
-            .state
-            .read()
-            .get_block_root(
-                self.state.read().current_epoch_start_slot(&self.spec),
-                &self.spec,
-            )
-            .ok_or_else(|| Error::BadRecentBlockRoots)?;
+        let target_root = *self.state.read().get_block_root(
+            self.state
+                .read()
+                .slot
+                .epoch(self.spec.slots_per_epoch)
+                .start_slot(self.spec.slots_per_epoch),
+            &self.spec,
+        )?;
 
         Ok(AttestationData {
             slot: self.state.read().slot,
             shard,
             beacon_block_root: self.head().beacon_block_root,
-            epoch_boundary_root,
+            target_root,
             crosslink_data_root: Hash256::zero(),
-            latest_crosslink: Crosslink {
+            previous_crosslink: Crosslink {
                 epoch: self.state.read().slot.epoch(self.spec.slots_per_epoch),
                 crosslink_data_root: Hash256::zero(),
             },
-            justified_epoch,
-            justified_block_root,
+            source_epoch,
+            source_root,
         })
     }
 
@@ -581,7 +571,7 @@ where
         dump.push(last_slot.clone());
 
         loop {
-            let beacon_block_root = last_slot.beacon_block.parent_root;
+            let beacon_block_root = last_slot.beacon_block.previous_block_root;
 
             if beacon_block_root == self.spec.zero_hash {
                 break; // Genesis has been reached.
@@ -621,7 +611,7 @@ where
     ///
     /// Will accept blocks from prior slots, however it will reject any block from a future slot.
     pub fn process_block(&self, block: BeaconBlock) -> Result<BlockProcessingOutcome, Error> {
-        debug!("Processing block with slot {}...", block.slot());
+        debug!("Processing block with slot {}...", block.slot);
 
         let block_root = block.canonical_root();
 
@@ -635,9 +625,9 @@ where
 
         // Load the blocks parent block from the database, returning invalid if that block is not
         // found.
-        let parent_block_root = block.parent_root;
-        let parent_block = match self.block_store.get_reader(&parent_block_root)? {
-            Some(parent_root) => parent_root,
+        let parent_block_root = block.previous_block_root;
+        let parent_block = match self.block_store.get_deserialized(&parent_block_root)? {
+            Some(previous_block_root) => previous_block_root,
             None => {
                 return Ok(BlockProcessingOutcome::InvalidBlock(
                     InvalidBlock::ParentUnknown,
@@ -647,15 +637,11 @@ where
 
         // Load the parent blocks state from the database, returning an error if it is not found.
         // It is an error because if know the parent block we should also know the parent state.
-        let parent_state_root = parent_block.state_root();
+        let parent_state_root = parent_block.state_root;
         let parent_state = self
             .state_store
-            .get_reader(&parent_state_root)?
-            .ok_or_else(|| Error::DBInconsistent(format!("Missing state {}", parent_state_root)))?
-            .into_beacon_state()
-            .ok_or_else(|| {
-                Error::DBInconsistent(format!("State SSZ invalid {}", parent_state_root))
-            })?;
+            .get_deserialized(&parent_state_root)?
+            .ok_or_else(|| Error::DBInconsistent(format!("Missing state {}", parent_state_root)))?;
 
         // TODO: check the block proposer signature BEFORE doing a state transition. This will
         // significantly lower exposure surface to DoS attacks.
@@ -739,22 +725,22 @@ where
             attestations.len()
         );
 
-        let parent_root = *state
+        let previous_block_root = *state
             .get_block_root(state.slot.saturating_sub(1_u64), &self.spec)
-            .ok_or_else(|| BlockProductionError::UnableToGetBlockRootFromState)?;
+            .map_err(|_| BlockProductionError::UnableToGetBlockRootFromState)?;
 
         let mut block = BeaconBlock {
             slot: state.slot,
-            parent_root,
+            previous_block_root,
             state_root: Hash256::zero(), // Updated after the state is calculated.
-            randao_reveal,
-            eth1_data: Eth1Data {
-                // TODO: replace with real data
-                deposit_root: Hash256::zero(),
-                block_hash: Hash256::zero(),
-            },
             signature: self.spec.empty_signature.clone(), // To be completed by a validator.
             body: BeaconBlockBody {
+                randao_reveal,
+                eth1_data: Eth1Data {
+                    // TODO: replace with real data
+                    deposit_root: Hash256::zero(),
+                    block_hash: Hash256::zero(),
+                },
                 proposer_slashings: self.get_proposer_slashings_for_block(),
                 attester_slashings: self.get_attester_slashings_for_block(),
                 attestations,

From df3f8df7bdd5b00c4d81bf89f3ee1350478ea04d Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Sun, 17 Mar 2019 18:56:05 +1100
Subject: [PATCH 42/60] Ensure fork_choice tests pass under v0.5.0

---
 eth2/fork_choice/src/longest_chain.rs |  2 +-
 eth2/fork_choice/tests/tests.rs       | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/eth2/fork_choice/src/longest_chain.rs b/eth2/fork_choice/src/longest_chain.rs
index 333553c025..423edc567f 100644
--- a/eth2/fork_choice/src/longest_chain.rs
+++ b/eth2/fork_choice/src/longest_chain.rs
@@ -34,7 +34,7 @@ impl<T: ClientDB + Sized> ForkChoice for LongestChain<T> {
     ) -> Result<(), ForkChoiceError> {
         // add the block hash to head_block_hashes removing the parent if it exists
         self.head_block_hashes
-            .retain(|hash| *hash != block.parent_root);
+            .retain(|hash| *hash != block.previous_block_root);
         self.head_block_hashes.push(*block_hash);
         Ok(())
     }
diff --git a/eth2/fork_choice/tests/tests.rs b/eth2/fork_choice/tests/tests.rs
index cd5ff360f8..80fbbbe209 100644
--- a/eth2/fork_choice/tests/tests.rs
+++ b/eth2/fork_choice/tests/tests.rs
@@ -90,6 +90,8 @@ fn test_yaml_vectors(
     let randao_reveal = Signature::empty_signature();
     let signature = Signature::empty_signature();
     let body = BeaconBlockBody {
+        eth1_data,
+        randao_reveal,
         proposer_slashings: vec![],
         attester_slashings: vec![],
         attestations: vec![],
@@ -117,14 +119,14 @@ fn test_yaml_vectors(
             // default params for genesis
             let block_hash = id_to_hash(&block_id);
             let mut slot = spec.genesis_slot;
-            let parent_root = id_to_hash(&parent_id);
+            let previous_block_root = id_to_hash(&parent_id);
 
             // set the slot and parent based off the YAML. Start with genesis;
             // if not the genesis, update slot
             if parent_id != block_id {
                 // find parent slot
                 slot = *(block_slot
-                    .get(&parent_root)
+                    .get(&previous_block_root)
                     .expect("Parent should have a slot number"))
                     + 1;
             } else {
@@ -137,10 +139,8 @@ fn test_yaml_vectors(
             // build the BeaconBlock
             let beacon_block = BeaconBlock {
                 slot,
-                parent_root,
+                previous_block_root,
                 state_root: state_root.clone(),
-                randao_reveal: randao_reveal.clone(),
-                eth1_data: eth1_data.clone(),
                 signature: signature.clone(),
                 body: body.clone(),
             };

From 446ff0c27e7f9a7a71d0135f3090e37ce8f745d7 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Sun, 17 Mar 2019 19:19:52 +1100
Subject: [PATCH 43/60] Ensure test_harness crate compiles under v0.5.0

---
 .../test_harness/src/beacon_chain_harness.rs  | 29 ++++++--
 .../test_harness/src/test_case.rs             | 67 +++++--------------
 .../testing_beacon_block_builder.rs           |  9 ++-
 .../src/test_utils/testing_deposit_builder.rs | 12 ++--
 4 files changed, 51 insertions(+), 66 deletions(-)

diff --git a/beacon_node/beacon_chain/test_harness/src/beacon_chain_harness.rs b/beacon_node/beacon_chain/test_harness/src/beacon_chain_harness.rs
index d74464ad4c..bc5c93b94a 100644
--- a/beacon_node/beacon_chain/test_harness/src/beacon_chain_harness.rs
+++ b/beacon_node/beacon_chain/test_harness/src/beacon_chain_harness.rs
@@ -46,8 +46,8 @@ impl BeaconChainHarness {
             TestingBeaconStateBuilder::from_default_keypairs_file_if_exists(validator_count, &spec);
         let (genesis_state, keypairs) = state_builder.build();
 
-        let state_root = Hash256::from_slice(&genesis_state.hash_tree_root());
-        let genesis_block = BeaconBlock::genesis(state_root, &spec);
+        let mut genesis_block = BeaconBlock::empty(&spec);
+        genesis_block.state_root = Hash256::from_slice(&genesis_state.hash_tree_root());
 
         // Create the Beacon Chain
         let beacon_chain = Arc::new(
@@ -127,8 +127,8 @@ impl BeaconChainHarness {
             .get_crosslink_committees_at_slot(present_slot, &self.spec)
             .unwrap()
             .iter()
-            .fold(vec![], |mut acc, (committee, _slot)| {
-                acc.append(&mut committee.clone());
+            .fold(vec![], |mut acc, c| {
+                acc.append(&mut c.committee.clone());
                 acc
             });
         let attesting_validators: HashSet<usize> =
@@ -233,6 +233,27 @@ impl BeaconChainHarness {
         Some(Signature::new(message, domain, &validator.keypair.sk))
     }
 
+    /// Returns the current `Fork` of the `beacon_chain`.
+    pub fn fork(&self) -> Fork {
+        self.beacon_chain.state.read().fork.clone()
+    }
+
+    /// Returns the current `epoch` of the `beacon_chain`.
+    pub fn epoch(&self) -> Epoch {
+        self.beacon_chain
+            .state
+            .read()
+            .slot
+            .epoch(self.spec.slots_per_epoch)
+    }
+
+    /// Returns the keypair for some validator index.
+    pub fn validator_keypair(&self, validator_index: usize) -> Option<&Keypair> {
+        self.validators
+            .get(validator_index)
+            .and_then(|v| Some(&v.keypair))
+    }
+
     /// Submit a deposit to the `BeaconChain` and, if given a keypair, create a new
     /// `ValidatorHarness` instance for this validator.
     ///
diff --git a/beacon_node/beacon_chain/test_harness/src/test_case.rs b/beacon_node/beacon_chain/test_harness/src/test_case.rs
index 0a62069724..1361127a19 100644
--- a/beacon_node/beacon_chain/test_harness/src/test_case.rs
+++ b/beacon_node/beacon_chain/test_harness/src/test_case.rs
@@ -3,12 +3,11 @@
 
 use crate::beacon_chain_harness::BeaconChainHarness;
 use beacon_chain::CheckPoint;
-use bls::get_withdrawal_credentials;
 use log::{info, warn};
 use ssz::SignedRoot;
 use types::*;
 
-use types::test_utils::{TestingAttesterSlashingBuilder, TestingProposerSlashingBuilder};
+use types::test_utils::*;
 use yaml_rust::Yaml;
 
 mod config;
@@ -222,27 +221,20 @@ impl TestCase {
 }
 
 /// Builds a `Deposit` this is valid for the given `BeaconChainHarness` at its next slot.
-fn build_transfer(harness: &BeaconChainHarness, from: u64, to: u64, amount: u64) -> Transfer {
+fn build_transfer(
+    harness: &BeaconChainHarness,
+    sender: u64,
+    recipient: u64,
+    amount: u64,
+) -> Transfer {
     let slot = harness.beacon_chain.state.read().slot + 1;
 
-    let mut transfer = Transfer {
-        from,
-        to,
-        amount,
-        fee: 0,
-        slot,
-        pubkey: harness.validators[from as usize].keypair.pk.clone(),
-        signature: Signature::empty_signature(),
-    };
+    let mut builder = TestingTransferBuilder::new(sender, recipient, amount, slot);
 
-    let message = transfer.signed_root();
-    let epoch = slot.epoch(harness.spec.slots_per_epoch);
+    let keypair = harness.validator_keypair(sender as usize).unwrap();
+    builder.sign(keypair.clone(), &harness.fork(), &harness.spec);
 
-    transfer.signature = harness
-        .validator_sign(from as usize, &message[..], epoch, Domain::Transfer)
-        .expect("Unable to sign Transfer");
-
-    transfer
+    builder.build()
 }
 
 /// Builds a `Deposit` this is valid for the given `BeaconChainHarness`.
@@ -255,41 +247,12 @@ fn build_deposit(
     index_offset: u64,
 ) -> (Deposit, Keypair) {
     let keypair = Keypair::random();
-    let withdrawal_credentials = Hash256::from_slice(
-        &get_withdrawal_credentials(&keypair.pk, harness.spec.bls_withdrawal_prefix_byte)[..],
-    );
-    let proof_of_possession = DepositInput::create_proof_of_possession(
-        &keypair,
-        &withdrawal_credentials,
-        harness.spec.get_domain(
-            harness
-                .beacon_chain
-                .state
-                .read()
-                .current_epoch(&harness.spec),
-            Domain::Deposit,
-            &harness.beacon_chain.state.read().fork,
-        ),
-    );
-    let index = harness.beacon_chain.state.read().deposit_index + index_offset;
 
-    let deposit = Deposit {
-        // Note: `branch` and `index` will need to be updated once the spec defines their
-        // validity.
-        branch: vec![],
-        index,
-        deposit_data: DepositData {
-            amount,
-            timestamp: 1,
-            deposit_input: DepositInput {
-                pubkey: keypair.pk.clone(),
-                withdrawal_credentials,
-                proof_of_possession,
-            },
-        },
-    };
+    let mut builder = TestingDepositBuilder::new(keypair.pk.clone(), amount);
+    builder.set_index(harness.beacon_chain.state.read().deposit_index + index_offset);
+    builder.sign(&keypair, harness.epoch(), &harness.fork(), &harness.spec);
 
-    (deposit, keypair)
+    (builder.build(), keypair)
 }
 
 /// Builds a `VoluntaryExit` this is valid for the given `BeaconChainHarness`.
diff --git a/eth2/types/src/test_utils/testing_beacon_block_builder.rs b/eth2/types/src/test_utils/testing_beacon_block_builder.rs
index 6e48c8c178..c5cd22ed46 100644
--- a/eth2/types/src/test_utils/testing_beacon_block_builder.rs
+++ b/eth2/types/src/test_utils/testing_beacon_block_builder.rs
@@ -180,9 +180,14 @@ impl TestingBeaconBlockBuilder {
     ) {
         let keypair = Keypair::random();
 
-        let mut builder = TestingDepositBuilder::new(amount);
+        let mut builder = TestingDepositBuilder::new(keypair.pk.clone(), amount);
         builder.set_index(index);
-        builder.sign(&keypair, state, spec);
+        builder.sign(
+            &keypair,
+            state.slot.epoch(spec.slots_per_epoch),
+            &state.fork,
+            spec,
+        );
 
         self.block.body.deposits.push(builder.build())
     }
diff --git a/eth2/types/src/test_utils/testing_deposit_builder.rs b/eth2/types/src/test_utils/testing_deposit_builder.rs
index 0d1c962f0c..ee258e7fe7 100644
--- a/eth2/types/src/test_utils/testing_deposit_builder.rs
+++ b/eth2/types/src/test_utils/testing_deposit_builder.rs
@@ -10,9 +10,7 @@ pub struct TestingDepositBuilder {
 
 impl TestingDepositBuilder {
     /// Instantiates a new builder.
-    pub fn new(amount: u64) -> Self {
-        let keypair = Keypair::random();
-
+    pub fn new(pubkey: PublicKey, amount: u64) -> Self {
         let deposit = Deposit {
             proof: vec![],
             index: 0,
@@ -20,7 +18,7 @@ impl TestingDepositBuilder {
                 amount,
                 timestamp: 1,
                 deposit_input: DepositInput {
-                    pubkey: keypair.pk,
+                    pubkey,
                     withdrawal_credentials: Hash256::zero(),
                     proof_of_possession: Signature::empty_signature(),
                 },
@@ -40,13 +38,11 @@ impl TestingDepositBuilder {
     /// - `pubkey` to the signing pubkey.
     /// - `withdrawal_credentials` to the signing pubkey.
     /// - `proof_of_possesssion`
-    pub fn sign(&mut self, keypair: &Keypair, state: &BeaconState, spec: &ChainSpec) {
+    pub fn sign(&mut self, keypair: &Keypair, epoch: Epoch, fork: &Fork, spec: &ChainSpec) {
         let withdrawal_credentials = Hash256::from_slice(
             &get_withdrawal_credentials(&keypair.pk, spec.bls_withdrawal_prefix_byte)[..],
         );
 
-        let epoch = state.current_epoch(spec);
-
         self.deposit.deposit_data.deposit_input.pubkey = keypair.pk.clone();
         self.deposit
             .deposit_data
@@ -57,7 +53,7 @@ impl TestingDepositBuilder {
             .deposit
             .deposit_data
             .deposit_input
-            .create_proof_of_possession(&keypair.sk, epoch, &state.fork, spec);
+            .create_proof_of_possession(&keypair.sk, epoch, fork, spec);
     }
 
     /// Builds the deposit, consuming the builder.

From 919a15de229fa97e90bb3082cc552dc9f2edb466 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Sun, 17 Mar 2019 19:21:19 +1100
Subject: [PATCH 44/60] Ensure validator client compiles under v0.5.0

---
 .../beacon_block_grpc_client.rs                    | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/validator_client/src/block_producer_service/beacon_block_grpc_client.rs b/validator_client/src/block_producer_service/beacon_block_grpc_client.rs
index 6ce5c0fa03..04a02a2213 100644
--- a/validator_client/src/block_producer_service/beacon_block_grpc_client.rs
+++ b/validator_client/src/block_producer_service/beacon_block_grpc_client.rs
@@ -50,15 +50,15 @@ impl BeaconNode for BeaconBlockGrpcClient {
             // TODO: this conversion is incomplete; fix it.
             Ok(Some(BeaconBlock {
                 slot: Slot::new(block.get_slot()),
-                parent_root: Hash256::zero(),
+                previous_block_root: Hash256::zero(),
                 state_root: Hash256::zero(),
-                randao_reveal,
-                eth1_data: Eth1Data {
-                    deposit_root: Hash256::zero(),
-                    block_hash: Hash256::zero(),
-                },
                 signature,
                 body: BeaconBlockBody {
+                    randao_reveal,
+                    eth1_data: Eth1Data {
+                        deposit_root: Hash256::zero(),
+                        block_hash: Hash256::zero(),
+                    },
                     proposer_slashings: vec![],
                     attester_slashings: vec![],
                     attestations: vec![],
@@ -83,7 +83,7 @@ impl BeaconNode for BeaconBlockGrpcClient {
         let mut grpc_block = GrpcBeaconBlock::new();
         grpc_block.set_slot(block.slot.as_u64());
         grpc_block.set_block_root(vec![0]);
-        grpc_block.set_randao_reveal(ssz_encode(&block.randao_reveal));
+        grpc_block.set_randao_reveal(ssz_encode(&block.body.randao_reveal));
         grpc_block.set_signature(ssz_encode(&block.signature));
 
         req.set_block(grpc_block);

From f71cab8ba2525142019c8adfc1386145f90cb2f9 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Sun, 17 Mar 2019 19:28:29 +1100
Subject: [PATCH 45/60] Ensure project tests compile on v0.5.0

---
 beacon_node/src/main.rs | 47 +++++++++++++++++++++--------------------
 1 file changed, 24 insertions(+), 23 deletions(-)

diff --git a/beacon_node/src/main.rs b/beacon_node/src/main.rs
index eacbffa3ef..780a3d338a 100644
--- a/beacon_node/src/main.rs
+++ b/beacon_node/src/main.rs
@@ -20,7 +20,7 @@ use ssz::TreeHash;
 use std::sync::Arc;
 use types::{
     beacon_state::BeaconStateBuilder, BeaconBlock, ChainSpec, Deposit, DepositData, DepositInput,
-    Domain, Eth1Data, Fork, Hash256, Keypair,
+    Eth1Data, Fork, Hash256, Keypair,
 };
 
 fn main() {
@@ -103,35 +103,36 @@ fn main() {
 
     let initial_validator_deposits: Vec<Deposit> = 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: DepositInput::create_proof_of_possession(
-                        &keypair,
-                        &Hash256::zero(),
-                        spec.get_domain(
-                            // Get domain from genesis fork_version
-                            spec.genesis_epoch,
-                            Domain::Deposit,
-                            &Fork::genesis(&spec),
-                        ),
-                    ),
+        .map(|keypair| {
+            let mut deposit_input = DepositInput {
+                pubkey: keypair.pk.clone(),
+                withdrawal_credentials: Hash256::zero(),
+                proof_of_possession: spec.empty_signature.clone(),
+            };
+            deposit_input.proof_of_possession = deposit_input.create_proof_of_possession(
+                &keypair.sk,
+                spec.genesis_epoch,
+                &Fork::genesis(&spec),
+                &spec,
+            );
+
+            Deposit {
+                proof: 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,
                 },
-            },
+            }
         })
         .collect();
 
     let mut state_builder = BeaconStateBuilder::new(genesis_time, latest_eth1_data, &spec);
     state_builder.process_initial_deposits(&initial_validator_deposits, &spec);
     let genesis_state = state_builder.build(&spec).unwrap();
-    let state_root = Hash256::from_slice(&genesis_state.hash_tree_root());
-    let genesis_block = BeaconBlock::genesis(state_root, &spec);
+    let mut genesis_block = BeaconBlock::empty(&spec);
+    genesis_block.state_root = Hash256::from_slice(&genesis_state.hash_tree_root());
 
     // Genesis chain
     let _chain_result = BeaconChain::from_genesis(

From 8677b9e9cc61fd6792fb2ae4f18ee7be92b4d9da Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Sun, 17 Mar 2019 21:07:19 +1100
Subject: [PATCH 46/60] Fix bug with epoch caches, add tests

---
 .../src/per_block_processing.rs               |  6 +-
 .../verify_slashable_attestation.rs           |  2 +-
 .../per_block_processing/verify_transfer.rs   |  2 +-
 eth2/types/src/beacon_state.rs                |  4 +-
 eth2/types/src/beacon_state/epoch_cache.rs    |  2 +-
 eth2/types/src/beacon_state/tests.rs          | 54 ++++++++++++++++-
 eth2/types/src/relative_epoch.rs              | 58 +++++++++++++++++++
 7 files changed, 120 insertions(+), 8 deletions(-)

diff --git a/eth2/state_processing/src/per_block_processing.rs b/eth2/state_processing/src/per_block_processing.rs
index c6b22fa752..78cf927f5e 100644
--- a/eth2/state_processing/src/per_block_processing.rs
+++ b/eth2/state_processing/src/per_block_processing.rs
@@ -32,7 +32,7 @@ const VERIFY_DEPOSIT_MERKLE_PROOFS: bool = false;
 /// 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
+/// Spec v0.5.0
 pub fn per_block_processing(
     state: &mut BeaconState,
     block: &BeaconBlock,
@@ -47,7 +47,7 @@ pub fn per_block_processing(
 /// 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
+/// Spec v0.5.0
 pub fn per_block_processing_without_verifying_block_signature(
     state: &mut BeaconState,
     block: &BeaconBlock,
@@ -62,7 +62,7 @@ pub fn per_block_processing_without_verifying_block_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
+/// Spec v0.5.0
 fn per_block_processing_signature_optional(
     mut state: &mut BeaconState,
     block: &BeaconBlock,
diff --git a/eth2/state_processing/src/per_block_processing/verify_slashable_attestation.rs b/eth2/state_processing/src/per_block_processing/verify_slashable_attestation.rs
index f0d371043b..aa9a321969 100644
--- a/eth2/state_processing/src/per_block_processing/verify_slashable_attestation.rs
+++ b/eth2/state_processing/src/per_block_processing/verify_slashable_attestation.rs
@@ -10,7 +10,7 @@ use types::*;
 ///
 /// Returns `Ok(())` if the `SlashableAttestation` is valid, otherwise indicates the reason for invalidity.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 pub fn verify_slashable_attestation(
     state: &BeaconState,
     slashable_attestation: &SlashableAttestation,
diff --git a/eth2/state_processing/src/per_block_processing/verify_transfer.rs b/eth2/state_processing/src/per_block_processing/verify_transfer.rs
index 546760fd09..f873cd8503 100644
--- a/eth2/state_processing/src/per_block_processing/verify_transfer.rs
+++ b/eth2/state_processing/src/per_block_processing/verify_transfer.rs
@@ -94,7 +94,7 @@ pub fn verify_transfer(
 ///
 /// Does not check that the transfer is valid, however checks for overflow in all actions.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 pub fn execute_transfer(
     state: &mut BeaconState,
     transfer: &Transfer,
diff --git a/eth2/types/src/beacon_state.rs b/eth2/types/src/beacon_state.rs
index a90f09759d..8999d8be84 100644
--- a/eth2/types/src/beacon_state.rs
+++ b/eth2/types/src/beacon_state.rs
@@ -279,7 +279,9 @@ impl BeaconState {
     fn cache(&self, relative_epoch: RelativeEpoch, spec: &ChainSpec) -> Result<&EpochCache, Error> {
         let cache = &self.caches[self.cache_index(relative_epoch)];
 
-        if cache.initialized_epoch == Some(self.slot.epoch(spec.slots_per_epoch)) {
+        let epoch = relative_epoch.into_epoch(self.slot.epoch(spec.slots_per_epoch));
+
+        if cache.initialized_epoch == Some(epoch) {
             Ok(cache)
         } else {
             Err(Error::EpochCacheUninitialized(relative_epoch))
diff --git a/eth2/types/src/beacon_state/epoch_cache.rs b/eth2/types/src/beacon_state/epoch_cache.rs
index 0759a76170..4436972f1e 100644
--- a/eth2/types/src/beacon_state/epoch_cache.rs
+++ b/eth2/types/src/beacon_state/epoch_cache.rs
@@ -159,7 +159,7 @@ impl EpochCrosslinkCommittees {
         let epoch_start_slot = self.epoch.start_slot(spec.slots_per_epoch);
         let epoch_end_slot = self.epoch.end_slot(spec.slots_per_epoch);
 
-        if (epoch_start_slot < slot) && (slot <= epoch_end_slot) {
+        if (epoch_start_slot <= slot) && (slot <= epoch_end_slot) {
             let index = slot - epoch_start_slot;
             self.crosslink_committees.get(index.as_usize())
         } else {
diff --git a/eth2/types/src/beacon_state/tests.rs b/eth2/types/src/beacon_state/tests.rs
index 6c10ebe86d..dc16a013b3 100644
--- a/eth2/types/src/beacon_state/tests.rs
+++ b/eth2/types/src/beacon_state/tests.rs
@@ -1,5 +1,57 @@
 #![cfg(test)]
-
 use super::*;
+use crate::test_utils::*;
 
 ssz_tests!(BeaconState);
+
+/// Test that
+///
+/// 1. Using the cache before it's built fails.
+/// 2. Using the cache after it's build passes.
+/// 3. Using the cache after it's dropped fails.
+fn test_cache_initialization<'a>(
+    state: &'a mut BeaconState,
+    relative_epoch: RelativeEpoch,
+    spec: &ChainSpec,
+) {
+    let slot = relative_epoch
+        .into_epoch(state.slot.epoch(spec.slots_per_epoch))
+        .start_slot(spec.slots_per_epoch);
+
+    // Assuming the cache isn't already built, assert that a call to a cache-using function fails.
+    assert_eq!(
+        state.get_beacon_proposer_index(slot, relative_epoch, spec),
+        Err(BeaconStateError::EpochCacheUninitialized(relative_epoch))
+    );
+
+    // Build the cache.
+    state.build_epoch_cache(relative_epoch, spec).unwrap();
+
+    // Assert a call to a cache-using function passes.
+    let _ = state
+        .get_beacon_proposer_index(slot, relative_epoch, spec)
+        .unwrap();
+
+    // Drop the cache.
+    state.drop_cache(relative_epoch);
+
+    // Assert a call to a cache-using function fail.
+    assert_eq!(
+        state.get_beacon_proposer_index(slot, relative_epoch, spec),
+        Err(BeaconStateError::EpochCacheUninitialized(relative_epoch))
+    );
+}
+
+#[test]
+fn cache_initialization() {
+    let spec = ChainSpec::few_validators();
+    let (mut state, _keypairs) =
+        TestingBeaconStateBuilder::from_default_keypairs_file_if_exists(16, &spec).build();
+
+    state.slot = (spec.genesis_epoch + 1).start_slot(spec.slots_per_epoch);
+
+    test_cache_initialization(&mut state, RelativeEpoch::Previous, &spec);
+    test_cache_initialization(&mut state, RelativeEpoch::Current, &spec);
+    test_cache_initialization(&mut state, RelativeEpoch::NextWithRegistryChange, &spec);
+    test_cache_initialization(&mut state, RelativeEpoch::NextWithoutRegistryChange, &spec);
+}
diff --git a/eth2/types/src/relative_epoch.rs b/eth2/types/src/relative_epoch.rs
index 9439366059..6c135b1a6d 100644
--- a/eth2/types/src/relative_epoch.rs
+++ b/eth2/types/src/relative_epoch.rs
@@ -74,3 +74,61 @@ impl RelativeEpoch {
         )
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_into_epoch() {
+        let base = Epoch::new(10);
+
+        assert_eq!(RelativeEpoch::Current.into_epoch(base), base);
+        assert_eq!(RelativeEpoch::Previous.into_epoch(base), base - 1);
+        assert_eq!(
+            RelativeEpoch::NextWithRegistryChange.into_epoch(base),
+            base + 1
+        );
+        assert_eq!(
+            RelativeEpoch::NextWithoutRegistryChange.into_epoch(base),
+            base + 1
+        );
+    }
+
+    #[test]
+    fn from_epoch() {
+        let base = Epoch::new(10);
+
+        assert_eq!(
+            RelativeEpoch::from_epoch(base, base - 1),
+            Ok(RelativeEpoch::Previous)
+        );
+        assert_eq!(
+            RelativeEpoch::from_epoch(base, base),
+            Ok(RelativeEpoch::Current)
+        );
+        assert_eq!(
+            RelativeEpoch::from_epoch(base, base + 1),
+            Err(RelativeEpochError::AmbiguiousNextEpoch)
+        );
+    }
+
+    #[test]
+    fn from_slot() {
+        let spec = ChainSpec::foundation();
+        let base = Epoch::new(10).start_slot(spec.slots_per_epoch);
+
+        assert_eq!(
+            RelativeEpoch::from_slot(base, base - 1, &spec),
+            Ok(RelativeEpoch::Previous)
+        );
+        assert_eq!(
+            RelativeEpoch::from_slot(base, base, &spec),
+            Ok(RelativeEpoch::Current)
+        );
+        assert_eq!(
+            RelativeEpoch::from_slot(base, base + spec.slots_per_epoch, &spec),
+            Err(RelativeEpochError::AmbiguiousNextEpoch)
+        );
+    }
+}

From 816c2c651bc953472ecab72d2b44a5b0d1c8d417 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Sun, 17 Mar 2019 23:11:07 +1100
Subject: [PATCH 47/60] Modify genesis processing process.

- Removed BeaconStateBuilder
- Added genesis code to `state_processing`.
---
 beacon_node/Cargo.toml                        |   1 +
 beacon_node/src/main.rs                       |  63 ++------
 .../state_processing/src/get_genesis_state.rs |  59 ++++++++
 eth2/state_processing/src/lib.rs              |   2 +
 .../src/per_epoch_processing.rs               |   6 +-
 eth2/types/src/beacon_state.rs                | 112 ++------------
 eth2/types/src/beacon_state/builder.rs        | 101 -------------
 eth2/types/src/beacon_state/epoch_cache.rs    |   6 +-
 .../src/beacon_state/epoch_cache/tests.rs     | 142 ++++++++++++++++++
 .../testing_beacon_state_builder.rs           |  16 +-
 10 files changed, 234 insertions(+), 274 deletions(-)
 create mode 100644 eth2/state_processing/src/get_genesis_state.rs
 delete mode 100644 eth2/types/src/beacon_state/builder.rs
 create mode 100644 eth2/types/src/beacon_state/epoch_cache/tests.rs

diff --git a/beacon_node/Cargo.toml b/beacon_node/Cargo.toml
index a4804e07e6..b76bc3e82f 100644
--- a/beacon_node/Cargo.toml
+++ b/beacon_node/Cargo.toml
@@ -19,6 +19,7 @@ slog = "^2.2.3"
 slot_clock = { path = "../eth2/utils/slot_clock" }
 slog-term = "^2.4.0"
 slog-async = "^2.3.0"
+state_processing = { path = "../eth2/state_processing" }
 types = { path = "../eth2/types" }
 ssz = { path = "../eth2/utils/ssz" }
 tokio = "0.1"
diff --git a/beacon_node/src/main.rs b/beacon_node/src/main.rs
index 780a3d338a..2436d4f7c5 100644
--- a/beacon_node/src/main.rs
+++ b/beacon_node/src/main.rs
@@ -18,10 +18,8 @@ use slog::{error, info, o, Drain};
 use slot_clock::SystemTimeSlotClock;
 use ssz::TreeHash;
 use std::sync::Arc;
-use types::{
-    beacon_state::BeaconStateBuilder, BeaconBlock, ChainSpec, Deposit, DepositData, DepositInput,
-    Eth1Data, Fork, Hash256, Keypair,
-};
+use types::test_utils::TestingBeaconStateBuilder;
+use types::*;
 
 fn main() {
     let decorator = slog_term::TermDecorator::new().build();
@@ -79,61 +77,18 @@ fn main() {
     let block_store = Arc::new(BeaconBlockStore::new(db.clone()));
     let state_store = Arc::new(BeaconStateStore::new(db.clone()));
 
+    let state_builder = TestingBeaconStateBuilder::from_deterministic_keypairs(8, &spec);
+    let (genesis_state, _keypairs) = state_builder.build();
+
+    let mut genesis_block = BeaconBlock::empty(&spec);
+    genesis_block.state_root = Hash256::from_slice(&genesis_state.hash_tree_root());
+
     // Slot clock
-    let genesis_time = 1_549_935_547; // 12th Feb 2018 (arbitrary value in the past).
-    let slot_clock = SystemTimeSlotClock::new(genesis_time, spec.seconds_per_slot)
+    let slot_clock = SystemTimeSlotClock::new(genesis_state.genesis_time, spec.seconds_per_slot)
         .expect("Unable to load SystemTimeSlotClock");
     // Choose the fork choice
     let fork_choice = BitwiseLMDGhost::new(block_store.clone(), state_store.clone());
 
-    /*
-     * Generate some random data to start a chain with.
-     *
-     * This is will need to be replace for production usage.
-     */
-    let latest_eth1_data = Eth1Data {
-        deposit_root: Hash256::zero(),
-        block_hash: Hash256::zero(),
-    };
-    let keypairs: Vec<Keypair> = (0..10)
-        .collect::<Vec<usize>>()
-        .iter()
-        .map(|_| Keypair::random())
-        .collect();
-
-    let initial_validator_deposits: Vec<Deposit> = keypairs
-        .iter()
-        .map(|keypair| {
-            let mut deposit_input = DepositInput {
-                pubkey: keypair.pk.clone(),
-                withdrawal_credentials: Hash256::zero(),
-                proof_of_possession: spec.empty_signature.clone(),
-            };
-            deposit_input.proof_of_possession = deposit_input.create_proof_of_possession(
-                &keypair.sk,
-                spec.genesis_epoch,
-                &Fork::genesis(&spec),
-                &spec,
-            );
-
-            Deposit {
-                proof: 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,
-                },
-            }
-        })
-        .collect();
-
-    let mut state_builder = BeaconStateBuilder::new(genesis_time, latest_eth1_data, &spec);
-    state_builder.process_initial_deposits(&initial_validator_deposits, &spec);
-    let genesis_state = state_builder.build(&spec).unwrap();
-    let mut genesis_block = BeaconBlock::empty(&spec);
-    genesis_block.state_root = Hash256::from_slice(&genesis_state.hash_tree_root());
-
     // Genesis chain
     let _chain_result = BeaconChain::from_genesis(
         state_store.clone(),
diff --git a/eth2/state_processing/src/get_genesis_state.rs b/eth2/state_processing/src/get_genesis_state.rs
new file mode 100644
index 0000000000..3c6612349a
--- /dev/null
+++ b/eth2/state_processing/src/get_genesis_state.rs
@@ -0,0 +1,59 @@
+use super::per_block_processing::{errors::BlockProcessingError, process_deposits};
+use ssz::TreeHash;
+use types::*;
+
+pub enum GenesisError {
+    BlockProcessingError(BlockProcessingError),
+    BeaconStateError(BeaconStateError),
+}
+
+/// Returns the genesis `BeaconState`
+///
+/// Spec v0.5.0
+pub fn get_genesis_state(
+    genesis_validator_deposits: &[Deposit],
+    genesis_time: u64,
+    genesis_eth1_data: Eth1Data,
+    spec: &ChainSpec,
+) -> Result<(), BlockProcessingError> {
+    // Get the genesis `BeaconState`
+    let mut state = BeaconState::genesis(genesis_time, genesis_eth1_data, spec);
+
+    // Process genesis deposits.
+    process_deposits(&mut state, genesis_validator_deposits, spec)?;
+
+    // Process genesis activations.
+    for i in 0..state.validator_registry.len() {
+        if state.get_effective_balance(i, spec)? >= spec.max_deposit_amount {
+            state.validator_registry[i].activation_epoch = spec.genesis_epoch;
+        }
+    }
+
+    // Ensure the current epoch cache is built.
+    state.build_epoch_cache(RelativeEpoch::Current, spec)?;
+
+    // Set all the active index roots to be the genesis active index root.
+    let active_validator_indices = state
+        .get_active_validator_indices(spec.genesis_epoch, spec)?
+        .to_vec();
+    let genesis_active_index_root = Hash256::from_slice(&active_validator_indices.hash_tree_root());
+    state.latest_active_index_roots =
+        vec![genesis_active_index_root; spec.latest_active_index_roots_length as usize];
+
+    // Generate the current shuffling seed.
+    state.current_shuffling_seed = state.generate_seed(spec.genesis_epoch, spec)?;
+
+    Ok(())
+}
+
+impl From<BlockProcessingError> for GenesisError {
+    fn from(e: BlockProcessingError) -> GenesisError {
+        GenesisError::BlockProcessingError(e)
+    }
+}
+
+impl From<BeaconStateError> for GenesisError {
+    fn from(e: BeaconStateError) -> GenesisError {
+        GenesisError::BeaconStateError(e)
+    }
+}
diff --git a/eth2/state_processing/src/lib.rs b/eth2/state_processing/src/lib.rs
index 2b30844cb2..78dc7270d2 100644
--- a/eth2/state_processing/src/lib.rs
+++ b/eth2/state_processing/src/lib.rs
@@ -1,10 +1,12 @@
 #[macro_use]
 mod macros;
 
+pub mod get_genesis_state;
 pub mod per_block_processing;
 pub mod per_epoch_processing;
 pub mod per_slot_processing;
 
+pub use get_genesis_state::get_genesis_state;
 pub use per_block_processing::{
     errors::{BlockInvalid, BlockProcessingError},
     per_block_processing, per_block_processing_without_verifying_block_signature,
diff --git a/eth2/state_processing/src/per_epoch_processing.rs b/eth2/state_processing/src/per_epoch_processing.rs
index 2f1cc35518..d1bb4269a7 100644
--- a/eth2/state_processing/src/per_epoch_processing.rs
+++ b/eth2/state_processing/src/per_epoch_processing.rs
@@ -45,7 +45,7 @@ pub fn per_epoch_processing(state: &mut BeaconState, spec: &ChainSpec) -> Result
     process_rewards_and_penalities(state, &mut statuses, &winning_root_for_shards, spec)?;
 
     // Ejections
-    state.process_ejections(spec);
+    state.process_ejections(spec)?;
 
     // Validator Registry
     process_validator_registry(state, spec)?;
@@ -53,7 +53,7 @@ pub fn per_epoch_processing(state: &mut BeaconState, spec: &ChainSpec) -> Result
     // Final updates
     update_active_tree_index_roots(state, spec)?;
     update_latest_slashed_balances(state, spec);
-    clean_attestations(state, spec);
+    clean_attestations(state);
 
     // Rotate the epoch caches to suit the epoch transition.
     state.advance_caches();
@@ -472,6 +472,6 @@ pub fn update_latest_slashed_balances(state: &mut BeaconState, spec: &ChainSpec)
 /// Removes all pending attestations from the previous epoch.
 ///
 /// Spec v0.4.0
-pub fn clean_attestations(state: &mut BeaconState, spec: &ChainSpec) {
+pub fn clean_attestations(state: &mut BeaconState) {
     state.previous_epoch_attestations = vec![];
 }
diff --git a/eth2/types/src/beacon_state.rs b/eth2/types/src/beacon_state.rs
index 8999d8be84..d7dbda782e 100644
--- a/eth2/types/src/beacon_state.rs
+++ b/eth2/types/src/beacon_state.rs
@@ -10,9 +10,6 @@ use ssz_derive::{Decode, Encode, TreeHash};
 use std::collections::HashMap;
 use test_random_derive::TestRandom;
 
-pub use builder::BeaconStateBuilder;
-
-mod builder;
 mod epoch_cache;
 pub mod helpers;
 mod pubkey_cache;
@@ -32,7 +29,8 @@ pub enum Error {
     InvalidBitfield,
     ValidatorIsWithdrawable,
     InsufficientRandaoMixes,
-    InsufficientValidators,
+    NoValidators,
+    UnableToDetermineProducer,
     InsufficientBlockRoots,
     InsufficientIndexRoots,
     InsufficientAttestations,
@@ -534,7 +532,7 @@ impl BeaconState {
     ///
     /// If the state does not contain an index for a beacon proposer at the requested `slot`, then `None` is returned.
     ///
-    /// Spec v0.4.0
+    /// Spec v0.5.0
     pub fn get_beacon_proposer_index(
         &self,
         slot: Slot,
@@ -547,14 +545,16 @@ impl BeaconState {
             .get_crosslink_committees_at_slot(slot, spec)
             .ok_or_else(|| Error::SlotOutOfBounds)?;
 
+        let epoch = slot.epoch(spec.slots_per_epoch);
+
         committees
             .first()
-            .ok_or(Error::InsufficientValidators)
+            .ok_or(Error::UnableToDetermineProducer)
             .and_then(|first| {
-                let index = slot
+                let index = epoch
                     .as_usize()
                     .checked_rem(first.committee.len())
-                    .ok_or(Error::InsufficientValidators)?;
+                    .ok_or(Error::UnableToDetermineProducer)?;
                 Ok(first.committee[index])
             })
     }
@@ -581,103 +581,9 @@ impl BeaconState {
         epoch + 1 + spec.activation_exit_delay
     }
 
-    /// Process multiple deposits in sequence.
-    ///
-    /// Builds a hashmap of validator pubkeys to validator index and passes it to each successive
-    /// call to `process_deposit(..)`. This requires much less computation than successive calls to
-    /// `process_deposits(..)` without the hashmap.
-    ///
-    /// Spec v0.4.0
-    pub fn process_deposits(
-        &mut self,
-        deposits: Vec<&DepositData>,
-        spec: &ChainSpec,
-    ) -> Vec<usize> {
-        let mut added_indices = vec![];
-        let mut pubkey_map: HashMap<PublicKey, usize> = HashMap::new();
-
-        for (i, validator) in self.validator_registry.iter().enumerate() {
-            pubkey_map.insert(validator.pubkey.clone(), i);
-        }
-
-        for deposit_data in deposits {
-            let result = self.process_deposit(
-                deposit_data.deposit_input.clone(),
-                deposit_data.amount,
-                Some(&pubkey_map),
-                spec,
-            );
-            if let Ok(index) = result {
-                added_indices.push(index);
-            }
-        }
-        added_indices
-    }
-
-    /// Process a validator deposit, returning the validator index if the deposit is valid.
-    ///
-    /// Optionally accepts a hashmap of all validator pubkeys to their validator index. Without
-    /// this hashmap, each call to `process_deposits` requires an iteration though
-    /// `self.validator_registry`. This becomes highly inefficient at scale.
-    ///
-    /// TODO: this function also exists in a more optimal form in the `state_processing` crate as
-    /// `process_deposits`; unify these two functions.
-    ///
-    /// Spec v0.4.0
-    pub fn process_deposit(
-        &mut self,
-        deposit_input: DepositInput,
-        amount: u64,
-        pubkey_map: Option<&HashMap<PublicKey, usize>>,
-        spec: &ChainSpec,
-    ) -> Result<usize, ()> {
-        let proof_is_valid = deposit_input.proof_of_possession.verify(
-            &deposit_input.signed_root(),
-            spec.get_domain(self.current_epoch(&spec), Domain::Deposit, &self.fork),
-            &deposit_input.pubkey,
-        );
-
-        if !proof_is_valid {
-            return Err(());
-        }
-
-        let pubkey = deposit_input.pubkey.clone();
-        let withdrawal_credentials = deposit_input.withdrawal_credentials.clone();
-
-        let validator_index = if let Some(pubkey_map) = pubkey_map {
-            pubkey_map.get(&pubkey).and_then(|i| Some(*i))
-        } else {
-            self.validator_registry
-                .iter()
-                .position(|v| v.pubkey == pubkey)
-        };
-
-        if let Some(index) = validator_index {
-            if self.validator_registry[index].withdrawal_credentials == withdrawal_credentials {
-                safe_add_assign!(self.validator_balances[index], amount);
-                Ok(index)
-            } else {
-                Err(())
-            }
-        } else {
-            let validator = Validator {
-                pubkey,
-                withdrawal_credentials,
-                activation_epoch: spec.far_future_epoch,
-                exit_epoch: spec.far_future_epoch,
-                withdrawable_epoch: spec.far_future_epoch,
-                initiated_exit: false,
-                slashed: false,
-            };
-            self.validator_registry.push(validator);
-            self.validator_balances.push(amount);
-            Ok(self.validator_registry.len() - 1)
-        }
-    }
-
     /// Activate the validator of the given ``index``.
     ///
-    /// Spec v0.4.0
+    /// Spec v0.5.0
     pub fn activate_validator(
         &mut self,
         validator_index: usize,
diff --git a/eth2/types/src/beacon_state/builder.rs b/eth2/types/src/beacon_state/builder.rs
deleted file mode 100644
index 780ec9b8ba..0000000000
--- a/eth2/types/src/beacon_state/builder.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-use super::BeaconStateError;
-use crate::validator_registry::get_active_validator_indices;
-use crate::*;
-use rayon::prelude::*;
-use ssz::TreeHash;
-
-/// Builds a `BeaconState` for use in production.
-///
-/// This struct should _not_ be modified for use in testing scenarios. Use `TestingBeaconStateBuilder` for that purpose.
-///
-/// This struct should remain safe and sensible for production usage.
-pub struct BeaconStateBuilder {
-    pub state: BeaconState,
-}
-
-impl BeaconStateBuilder {
-    /// Create a new builder with the given number of validators.
-    ///
-    /// Spec v0.4.0
-    pub fn new(genesis_time: u64, latest_eth1_data: Eth1Data, spec: &ChainSpec) -> Self {
-        Self {
-            state: BeaconState::genesis(genesis_time, latest_eth1_data, spec),
-        }
-    }
-
-    /// Process deposit objects.
-    ///
-    /// Spec v0.4.0
-    pub fn process_initial_deposits(
-        &mut self,
-        initial_validator_deposits: &[Deposit],
-        spec: &ChainSpec,
-    ) {
-        let deposit_data = initial_validator_deposits
-            .par_iter()
-            .map(|deposit| &deposit.deposit_data)
-            .collect();
-
-        self.state.process_deposits(deposit_data, spec);
-
-        self.activate_genesis_validators(spec);
-
-        self.state.deposit_index = initial_validator_deposits.len() as u64;
-    }
-
-    fn activate_genesis_validators(&mut self, spec: &ChainSpec) -> Result<(), BeaconStateError> {
-        for validator_index in 0..self.state.validator_registry.len() {
-            if self.state.get_effective_balance(validator_index, spec)? >= spec.max_deposit_amount {
-                self.state.activate_validator(validator_index, true, spec);
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Instantiate the validator registry from a YAML file.
-    ///
-    /// This skips a lot of signing and verification, useful if signing and verification has been
-    /// completed previously.
-    ///
-    /// Spec v0.4.0
-    pub fn import_existing_validators(
-        &mut self,
-        validators: Vec<Validator>,
-        initial_balances: Vec<u64>,
-        deposit_index: u64,
-        spec: &ChainSpec,
-    ) {
-        self.state.validator_registry = validators;
-
-        assert_eq!(
-            self.state.validator_registry.len(),
-            initial_balances.len(),
-            "Not enough balances for validators"
-        );
-
-        self.state.validator_balances = initial_balances;
-
-        self.activate_genesis_validators(spec);
-
-        self.state.deposit_index = deposit_index;
-    }
-
-    /// Updates the final state variables and returns a fully built genesis state.
-    ///
-    /// Spec v0.4.0
-    pub fn build(mut self, spec: &ChainSpec) -> Result<BeaconState, BeaconStateError> {
-        let genesis_active_index_root =
-            get_active_validator_indices(&self.state.validator_registry, spec.genesis_epoch)
-                .hash_tree_root();
-
-        self.state.latest_active_index_roots = vec![
-            Hash256::from_slice(&genesis_active_index_root);
-            spec.latest_active_index_roots_length
-        ];
-
-        self.state.current_shuffling_seed = self.state.generate_seed(spec.genesis_epoch, spec)?;
-
-        Ok(self.state)
-    }
-}
diff --git a/eth2/types/src/beacon_state/epoch_cache.rs b/eth2/types/src/beacon_state/epoch_cache.rs
index 4436972f1e..0dbdf40546 100644
--- a/eth2/types/src/beacon_state/epoch_cache.rs
+++ b/eth2/types/src/beacon_state/epoch_cache.rs
@@ -4,6 +4,8 @@ use honey_badger_split::SplitExt;
 use serde_derive::{Deserialize, Serialize};
 use swap_or_not_shuffle::shuffle_list;
 
+mod tests;
+
 #[derive(Debug, Default, PartialEq, Clone, Serialize, Deserialize)]
 pub struct EpochCache {
     /// `Some(epoch)` if the cache is initialized, where `epoch` is the cache it holds.
@@ -247,7 +249,7 @@ impl EpochCrosslinkCommitteesBuilder {
 
     pub fn build(self, spec: &ChainSpec) -> Result<EpochCrosslinkCommittees, BeaconStateError> {
         if self.active_validator_indices.is_empty() {
-            return Err(Error::InsufficientValidators);
+            return Err(Error::NoValidators);
         }
 
         let shuffled_active_validator_indices = shuffle_list(
@@ -277,7 +279,7 @@ impl EpochCrosslinkCommitteesBuilder {
                 let crosslink_committee = CrosslinkCommittee {
                     slot,
                     shard,
-                    committee: committees.remove(j),
+                    committee: committees[j].drain(..).collect(),
                 };
                 epoch_crosslink_committees.crosslink_committees[i].push(crosslink_committee);
 
diff --git a/eth2/types/src/beacon_state/epoch_cache/tests.rs b/eth2/types/src/beacon_state/epoch_cache/tests.rs
new file mode 100644
index 0000000000..10df635f28
--- /dev/null
+++ b/eth2/types/src/beacon_state/epoch_cache/tests.rs
@@ -0,0 +1,142 @@
+#![cfg(test)]
+
+use super::*;
+use crate::test_utils::*;
+use swap_or_not_shuffle::shuffle_list;
+
+fn do_sane_cache_test(
+    state: BeaconState,
+    epoch: Epoch,
+    validator_count: usize,
+    expected_seed: Hash256,
+    expected_shuffling_start: u64,
+    spec: &ChainSpec,
+) {
+    let active_indices: Vec<usize> = (0..validator_count).collect();
+    assert_eq!(
+        &active_indices[..],
+        state.get_active_validator_indices(epoch, &spec).unwrap(),
+        "Validator indices mismatch"
+    );
+
+    let shuffling = shuffle_list(
+        active_indices,
+        spec.shuffle_round_count,
+        &expected_seed[..],
+        true,
+    )
+    .unwrap();
+
+    let committees_per_epoch = spec.get_epoch_committee_count(shuffling.len());
+    let committees_per_slot = committees_per_epoch / spec.slots_per_epoch;
+
+    let mut expected_indices_iter = shuffling.iter();
+    let mut shard_counter = expected_shuffling_start;
+
+    for (i, slot) in epoch.slot_iter(spec.slots_per_epoch).enumerate() {
+        let crosslink_committees_at_slot =
+            state.get_crosslink_committees_at_slot(slot, &spec).unwrap();
+
+        assert_eq!(
+            crosslink_committees_at_slot.len(),
+            committees_per_slot as usize,
+            "Bad committees per slot ({})",
+            i
+        );
+
+        for c in crosslink_committees_at_slot {
+            assert_eq!(c.shard, shard_counter, "Bad shard");
+            shard_counter += 1;
+            shard_counter %= spec.shard_count;
+
+            for &i in &c.committee {
+                assert_eq!(
+                    i,
+                    *expected_indices_iter.next().unwrap(),
+                    "Non-sequential validators."
+                );
+            }
+        }
+    }
+}
+
+fn setup_sane_cache_test(validator_count: usize, spec: &ChainSpec) -> BeaconState {
+    let mut builder =
+        TestingBeaconStateBuilder::from_default_keypairs_file_if_exists(validator_count, spec);
+
+    let epoch = spec.genesis_epoch + 4;
+    let slot = epoch.start_slot(spec.slots_per_epoch);
+    builder.teleport_to_slot(slot, spec);
+
+    let (mut state, _keypairs) = builder.build();
+
+    state.current_shuffling_start_shard = 0;
+    state.current_shuffling_seed = Hash256::from_slice(&[1; 32]);
+
+    state.previous_shuffling_start_shard = spec.shard_count - 1;
+    state.previous_shuffling_seed = Hash256::from_slice(&[2; 32]);
+
+    state
+        .build_epoch_cache(RelativeEpoch::Previous, spec)
+        .unwrap();
+    state
+        .build_epoch_cache(RelativeEpoch::Current, spec)
+        .unwrap();
+    state
+        .build_epoch_cache(RelativeEpoch::NextWithRegistryChange, spec)
+        .unwrap();
+    state
+        .build_epoch_cache(RelativeEpoch::NextWithoutRegistryChange, spec)
+        .unwrap();
+
+    state
+}
+
+#[test]
+fn builds_sane_current_epoch_cache() {
+    let mut spec = ChainSpec::few_validators();
+    spec.shard_count = 4;
+    let validator_count = (spec.shard_count * spec.target_committee_size) + 1;
+    let state = setup_sane_cache_test(validator_count as usize, &spec);
+    do_sane_cache_test(
+        state.clone(),
+        state.current_epoch(&spec),
+        validator_count as usize,
+        state.current_shuffling_seed,
+        state.current_shuffling_start_shard,
+        &spec,
+    );
+}
+
+#[test]
+fn builds_sane_previous_epoch_cache() {
+    let mut spec = ChainSpec::few_validators();
+    spec.shard_count = 2;
+    let validator_count = (spec.shard_count * spec.target_committee_size) + 1;
+    let state = setup_sane_cache_test(validator_count as usize, &spec);
+    do_sane_cache_test(
+        state.clone(),
+        state.previous_epoch(&spec),
+        validator_count as usize,
+        state.previous_shuffling_seed,
+        state.previous_shuffling_start_shard,
+        &spec,
+    );
+}
+
+#[test]
+fn builds_sane_next_without_update_epoch_cache() {
+    let mut spec = ChainSpec::few_validators();
+    spec.shard_count = 2;
+    let validator_count = (spec.shard_count * spec.target_committee_size) + 1;
+    let mut state = setup_sane_cache_test(validator_count as usize, &spec);
+    state.validator_registry_update_epoch = state.slot.epoch(spec.slots_per_epoch);
+    do_sane_cache_test(
+        state.clone(),
+        state.next_epoch(&spec),
+        validator_count as usize,
+        state.current_shuffling_seed,
+        state.current_shuffling_start_shard,
+        &spec,
+    );
+}
diff --git a/eth2/types/src/test_utils/testing_beacon_state_builder.rs b/eth2/types/src/test_utils/testing_beacon_state_builder.rs
index 54e2fbe964..8180673d16 100644
--- a/eth2/types/src/test_utils/testing_beacon_state_builder.rs
+++ b/eth2/types/src/test_utils/testing_beacon_state_builder.rs
@@ -1,5 +1,4 @@
 use super::{generate_deterministic_keypairs, KeypairsFile};
-use crate::beacon_state::BeaconStateBuilder;
 use crate::test_utils::TestingPendingAttestationBuilder;
 use crate::*;
 use bls::get_withdrawal_credentials;
@@ -110,7 +109,8 @@ impl TestingBeaconStateBuilder {
                 Validator {
                     pubkey: keypair.pk.clone(),
                     withdrawal_credentials,
-                    activation_epoch: spec.far_future_epoch,
+                    // All validators start active.
+                    activation_epoch: spec.genesis_epoch,
                     exit_epoch: spec.far_future_epoch,
                     withdrawable_epoch: spec.far_future_epoch,
                     initiated_exit: false,
@@ -119,7 +119,7 @@ impl TestingBeaconStateBuilder {
             })
             .collect();
 
-        let mut state_builder = BeaconStateBuilder::new(
+        let mut state = BeaconState::genesis(
             0,
             Eth1Data {
                 deposit_root: Hash256::zero(),
@@ -131,14 +131,8 @@ impl TestingBeaconStateBuilder {
         let balances = vec![32_000_000_000; validator_count];
 
         debug!("Importing {} existing validators...", validator_count);
-        state_builder.import_existing_validators(
-            validators,
-            balances,
-            validator_count as u64,
-            spec,
-        );
-
-        let state = state_builder.build(spec).unwrap();
+        state.validator_registry = validators;
+        state.validator_balances = balances;
 
         debug!("BeaconState built.");
 

From 979353f136b7c9c434050483c1a244c1bdb48d12 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Sun, 17 Mar 2019 23:23:45 +1100
Subject: [PATCH 48/60] Make separate errors for epoch cache.

Helps with troubleshooting.
---
 eth2/types/src/beacon_state.rs             | 12 ++++++++---
 eth2/types/src/beacon_state/epoch_cache.rs | 23 ++++++++++++++++------
 2 files changed, 26 insertions(+), 9 deletions(-)

diff --git a/eth2/types/src/beacon_state.rs b/eth2/types/src/beacon_state.rs
index d7dbda782e..1a77d34490 100644
--- a/eth2/types/src/beacon_state.rs
+++ b/eth2/types/src/beacon_state.rs
@@ -1,13 +1,12 @@
-use self::epoch_cache::EpochCache;
+use self::epoch_cache::{EpochCache, Error as EpochCacheError};
 use crate::test_utils::TestRandom;
 use crate::*;
 use int_to_bytes::int_to_bytes32;
 use pubkey_cache::PubkeyCache;
 use rand::RngCore;
 use serde_derive::{Deserialize, Serialize};
-use ssz::{hash, ssz_encode, SignedRoot, TreeHash};
+use ssz::{hash, ssz_encode, TreeHash};
 use ssz_derive::{Decode, Encode, TreeHash};
-use std::collections::HashMap;
 use test_random_derive::TestRandom;
 
 mod epoch_cache;
@@ -44,6 +43,7 @@ pub enum Error {
         registry_len: usize,
     },
     RelativeEpochError(RelativeEpochError),
+    EpochCacheError(EpochCacheError),
 }
 
 macro_rules! safe_add_assign {
@@ -883,3 +883,9 @@ impl From<RelativeEpochError> for Error {
         Error::RelativeEpochError(e)
     }
 }
+
+impl From<EpochCacheError> for Error {
+    fn from(e: EpochCacheError) -> Error {
+        Error::EpochCacheError(e)
+    }
+}
diff --git a/eth2/types/src/beacon_state/epoch_cache.rs b/eth2/types/src/beacon_state/epoch_cache.rs
index 0dbdf40546..75d791e8f3 100644
--- a/eth2/types/src/beacon_state/epoch_cache.rs
+++ b/eth2/types/src/beacon_state/epoch_cache.rs
@@ -1,9 +1,16 @@
-use super::{BeaconState, Error};
+use super::BeaconState;
 use crate::*;
 use honey_badger_split::SplitExt;
 use serde_derive::{Deserialize, Serialize};
 use swap_or_not_shuffle::shuffle_list;
 
+#[derive(Debug, PartialEq)]
+pub enum Error {
+    UnableToShuffle,
+    NoValidators { epoch: Epoch },
+    UnableToGenerateSeed,
+}
+
 mod tests;
 
 #[derive(Debug, Default, PartialEq, Clone, Serialize, Deserialize)]
@@ -212,7 +219,7 @@ impl EpochCrosslinkCommitteesBuilder {
         active_validator_indices: Vec<usize>,
         registry_change: bool,
         spec: &ChainSpec,
-    ) -> Result<Self, BeaconStateError> {
+    ) -> Result<Self, Error> {
         let current_epoch = state.current_epoch(spec);
         let next_epoch = state.next_epoch(spec);
         let committees_per_epoch = spec.get_epoch_committee_count(active_validator_indices.len());
@@ -221,7 +228,9 @@ impl EpochCrosslinkCommitteesBuilder {
             current_epoch - state.validator_registry_update_epoch;
 
         let (seed, shuffling_start_shard) = if registry_change {
-            let next_seed = state.generate_seed(next_epoch, spec)?;
+            let next_seed = state
+                .generate_seed(next_epoch, spec)
+                .map_err(|_| Error::UnableToGenerateSeed)?;
             (
                 next_seed,
                 (state.current_shuffling_start_shard + committees_per_epoch) % spec.shard_count,
@@ -229,7 +238,9 @@ impl EpochCrosslinkCommitteesBuilder {
         } else if (epochs_since_last_registry_update > 1)
             & epochs_since_last_registry_update.is_power_of_two()
         {
-            let next_seed = state.generate_seed(next_epoch, spec)?;
+            let next_seed = state
+                .generate_seed(next_epoch, spec)
+                .map_err(|_| Error::UnableToGenerateSeed)?;
             (next_seed, state.current_shuffling_start_shard)
         } else {
             (
@@ -247,9 +258,9 @@ impl EpochCrosslinkCommitteesBuilder {
         })
     }
 
-    pub fn build(self, spec: &ChainSpec) -> Result<EpochCrosslinkCommittees, BeaconStateError> {
+    pub fn build(self, spec: &ChainSpec) -> Result<EpochCrosslinkCommittees, Error> {
         if self.active_validator_indices.is_empty() {
-            return Err(Error::NoValidators);
+            return Err(Error::NoValidators { epoch: self.epoch });
         }
 
         let shuffled_active_validator_indices = shuffle_list(

From 191761f356bb72b2ed06790360f40d56e0ab3856 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Sun, 17 Mar 2019 23:32:27 +1100
Subject: [PATCH 49/60] Allow epoch cache with zero validators.

---
 .../per_block_processing/verify_deposit.rs    |  3 ---
 .../process_validator_registry.rs             |  4 +--
 eth2/types/src/beacon_state/epoch_cache.rs    | 25 ++++++++++---------
 .../testing_beacon_state_builder.rs           |  2 +-
 4 files changed, 16 insertions(+), 18 deletions(-)

diff --git a/eth2/state_processing/src/per_block_processing/verify_deposit.rs b/eth2/state_processing/src/per_block_processing/verify_deposit.rs
index 2aeab6c5a6..80d8bc24fa 100644
--- a/eth2/state_processing/src/per_block_processing/verify_deposit.rs
+++ b/eth2/state_processing/src/per_block_processing/verify_deposit.rs
@@ -3,11 +3,8 @@ use hashing::hash;
 use merkle_proof::verify_merkle_proof;
 use ssz::ssz_encode;
 use ssz_derive::Encode;
-use std::collections::HashMap;
 use types::*;
 
-pub type PublicKeyValidatorIndexHashmap = HashMap<PublicKey, u64>;
-
 /// Indicates if a `Deposit` is valid to be included in a block in the current epoch of the given
 /// state.
 ///
diff --git a/eth2/state_processing/src/per_epoch_processing/process_validator_registry.rs b/eth2/state_processing/src/per_epoch_processing/process_validator_registry.rs
index c830bfc243..26ebd60b33 100644
--- a/eth2/state_processing/src/per_epoch_processing/process_validator_registry.rs
+++ b/eth2/state_processing/src/per_epoch_processing/process_validator_registry.rs
@@ -14,7 +14,7 @@ pub fn process_validator_registry(state: &mut BeaconState, spec: &ChainSpec) ->
     state.previous_shuffling_seed = state.current_shuffling_seed;
 
     if should_update_validator_registry(state, spec)? {
-        state.update_validator_registry(spec);
+        state.update_validator_registry(spec)?;
 
         state.current_shuffling_epoch = next_epoch;
         state.current_shuffling_start_shard = (state.current_shuffling_start_shard
@@ -37,7 +37,7 @@ pub fn process_validator_registry(state: &mut BeaconState, spec: &ChainSpec) ->
         }
     }
 
-    state.process_slashings(spec);
+    state.process_slashings(spec)?;
     state.process_exit_queue(spec);
 
     Ok(())
diff --git a/eth2/types/src/beacon_state/epoch_cache.rs b/eth2/types/src/beacon_state/epoch_cache.rs
index 75d791e8f3..ca8bcc70e9 100644
--- a/eth2/types/src/beacon_state/epoch_cache.rs
+++ b/eth2/types/src/beacon_state/epoch_cache.rs
@@ -7,7 +7,6 @@ use swap_or_not_shuffle::shuffle_list;
 #[derive(Debug, PartialEq)]
 pub enum Error {
     UnableToShuffle,
-    NoValidators { epoch: Epoch },
     UnableToGenerateSeed,
 }
 
@@ -259,17 +258,19 @@ impl EpochCrosslinkCommitteesBuilder {
     }
 
     pub fn build(self, spec: &ChainSpec) -> Result<EpochCrosslinkCommittees, Error> {
-        if self.active_validator_indices.is_empty() {
-            return Err(Error::NoValidators { epoch: self.epoch });
-        }
-
-        let shuffled_active_validator_indices = shuffle_list(
-            self.active_validator_indices,
-            spec.shuffle_round_count,
-            &self.shuffling_seed[..],
-            true,
-        )
-        .ok_or_else(|| Error::UnableToShuffle)?;
+        // The shuffler fails on a empty list, so if there are no active validator indices, simply
+        // return an empty list.
+        let shuffled_active_validator_indices = if self.active_validator_indices.is_empty() {
+            vec![]
+        } else {
+            shuffle_list(
+                self.active_validator_indices,
+                spec.shuffle_round_count,
+                &self.shuffling_seed[..],
+                true,
+            )
+            .ok_or_else(|| Error::UnableToShuffle)?
+        };
 
         let mut committees: Vec<Vec<usize>> = shuffled_active_validator_indices
             .honey_badger_split(self.committees_per_epoch as usize)
diff --git a/eth2/types/src/test_utils/testing_beacon_state_builder.rs b/eth2/types/src/test_utils/testing_beacon_state_builder.rs
index 8180673d16..e76a01e49b 100644
--- a/eth2/types/src/test_utils/testing_beacon_state_builder.rs
+++ b/eth2/types/src/test_utils/testing_beacon_state_builder.rs
@@ -134,7 +134,7 @@ impl TestingBeaconStateBuilder {
         state.validator_registry = validators;
         state.validator_balances = balances;
 
-        debug!("BeaconState built.");
+        debug!("BeaconState initialized.");
 
         Self { state, keypairs }
     }

From edeace9e7596b93e30b0955b3b09a32e6b09e0e6 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Mon, 18 Mar 2019 16:53:59 +1100
Subject: [PATCH 50/60] Fix issues with building on genesis block

---
 beacon_node/beacon_chain/src/beacon_chain.rs  | 129 +++++++++---------
 .../src/per_slot_processing.rs                |  38 +++++-
 eth2/types/src/beacon_block.rs                |  24 +++-
 eth2/types/src/beacon_block_header.rs         |   9 ++
 eth2/types/src/beacon_state.rs                |  76 ++++++++++-
 5 files changed, 202 insertions(+), 74 deletions(-)

diff --git a/beacon_node/beacon_chain/src/beacon_chain.rs b/beacon_node/beacon_chain/src/beacon_chain.rs
index 1082f6cabf..bf87adf10d 100644
--- a/beacon_node/beacon_chain/src/beacon_chain.rs
+++ b/beacon_node/beacon_chain/src/beacon_chain.rs
@@ -82,20 +82,18 @@ where
         let state_root = genesis_state.canonical_root();
         state_store.put(&state_root, &ssz_encode(&genesis_state)[..])?;
 
-        let block_root = genesis_block.canonical_root();
+        let block_root = genesis_block.into_header().canonical_root();
         block_store.put(&block_root, &ssz_encode(&genesis_block)[..])?;
 
         let finalized_head = RwLock::new(CheckPoint::new(
             genesis_block.clone(),
             block_root,
-            // TODO: this is a memory waste; remove full clone.
             genesis_state.clone(),
             state_root,
         ));
         let canonical_head = RwLock::new(CheckPoint::new(
             genesis_block.clone(),
             block_root,
-            // TODO: this is a memory waste; remove full clone.
             genesis_state.clone(),
             state_root,
         ));
@@ -190,10 +188,13 @@ where
     /// processing applied to it.
     pub fn advance_state(&self, slot: Slot) -> Result<(), SlotProcessingError> {
         let state_slot = self.state.read().slot;
-        let head_block_root = self.head().beacon_block_root;
+
+        let latest_block_header = self.head().beacon_block.into_header();
+
         for _ in state_slot.as_u64()..slot.as_u64() {
-            per_slot_processing(&mut *self.state.write(), head_block_root, &self.spec)?;
+            per_slot_processing(&mut *self.state.write(), &latest_block_header, &self.spec)?;
         }
+
         Ok(())
     }
 
@@ -554,66 +555,13 @@ where
         }
     }
 
-    /// Dumps the entire canonical chain, from the head to genesis to a vector for analysis.
-    ///
-    /// This could be a very expensive operation and should only be done in testing/analysis
-    /// activities.
-    pub fn chain_dump(&self) -> Result<Vec<CheckPoint>, Error> {
-        let mut dump = vec![];
-
-        let mut last_slot = CheckPoint {
-            beacon_block: self.head().beacon_block.clone(),
-            beacon_block_root: self.head().beacon_block_root,
-            beacon_state: self.head().beacon_state.clone(),
-            beacon_state_root: self.head().beacon_state_root,
-        };
-
-        dump.push(last_slot.clone());
-
-        loop {
-            let beacon_block_root = last_slot.beacon_block.previous_block_root;
-
-            if beacon_block_root == self.spec.zero_hash {
-                break; // Genesis has been reached.
-            }
-
-            let beacon_block = self
-                .block_store
-                .get_deserialized(&beacon_block_root)?
-                .ok_or_else(|| {
-                    Error::DBInconsistent(format!("Missing block {}", beacon_block_root))
-                })?;
-            let beacon_state_root = beacon_block.state_root;
-            let beacon_state = self
-                .state_store
-                .get_deserialized(&beacon_state_root)?
-                .ok_or_else(|| {
-                    Error::DBInconsistent(format!("Missing state {}", beacon_state_root))
-                })?;
-
-            let slot = CheckPoint {
-                beacon_block,
-                beacon_block_root,
-                beacon_state,
-                beacon_state_root,
-            };
-
-            dump.push(slot.clone());
-            last_slot = slot;
-        }
-
-        dump.reverse();
-
-        Ok(dump)
-    }
-
     /// Accept some block and attempt to add it to block DAG.
     ///
     /// Will accept blocks from prior slots, however it will reject any block from a future slot.
     pub fn process_block(&self, block: BeaconBlock) -> Result<BlockProcessingOutcome, Error> {
         debug!("Processing block with slot {}...", block.slot);
 
-        let block_root = block.canonical_root();
+        let block_root = block.into_header().canonical_root();
 
         let present_slot = self.present_slot();
 
@@ -648,8 +596,10 @@ where
 
         // Transition the parent state to the present slot.
         let mut state = parent_state;
+        println!("parent process state: {:?}", state.latest_block_header);
+        let previous_block_header = parent_block.into_header();
         for _ in state.slot.as_u64()..present_slot.as_u64() {
-            if let Err(e) = per_slot_processing(&mut state, parent_block_root, &self.spec) {
+            if let Err(e) = per_slot_processing(&mut state, &previous_block_header, &self.spec) {
                 return Ok(BlockProcessingOutcome::InvalidBlock(
                     InvalidBlock::SlotProcessingError(e),
                 ));
@@ -664,6 +614,8 @@ where
             ));
         }
 
+        println!("process state: {:?}", state.latest_block_header);
+
         let state_root = state.canonical_root();
 
         if block.state_root != state_root {
@@ -726,7 +678,7 @@ where
         );
 
         let previous_block_root = *state
-            .get_block_root(state.slot.saturating_sub(1_u64), &self.spec)
+            .get_block_root(state.slot - 1, &self.spec)
             .map_err(|_| BlockProductionError::UnableToGetBlockRootFromState)?;
 
         let mut block = BeaconBlock {
@@ -754,6 +706,8 @@ where
 
         per_block_processing_without_verifying_block_signature(&mut state, &block, &self.spec)?;
 
+        println!("produce state: {:?}", state.latest_block_header);
+
         let state_root = state.canonical_root();
 
         block.state_root = state_root;
@@ -788,6 +742,59 @@ where
 
         Ok(())
     }
+
+    /// Dumps the entire canonical chain, from the head to genesis to a vector for analysis.
+    ///
+    /// This could be a very expensive operation and should only be done in testing/analysis
+    /// activities.
+    pub fn chain_dump(&self) -> Result<Vec<CheckPoint>, Error> {
+        let mut dump = vec![];
+
+        let mut last_slot = CheckPoint {
+            beacon_block: self.head().beacon_block.clone(),
+            beacon_block_root: self.head().beacon_block_root,
+            beacon_state: self.head().beacon_state.clone(),
+            beacon_state_root: self.head().beacon_state_root,
+        };
+
+        dump.push(last_slot.clone());
+
+        loop {
+            let beacon_block_root = last_slot.beacon_block.previous_block_root;
+
+            if beacon_block_root == self.spec.zero_hash {
+                break; // Genesis has been reached.
+            }
+
+            let beacon_block = self
+                .block_store
+                .get_deserialized(&beacon_block_root)?
+                .ok_or_else(|| {
+                    Error::DBInconsistent(format!("Missing block {}", beacon_block_root))
+                })?;
+            let beacon_state_root = beacon_block.state_root;
+            let beacon_state = self
+                .state_store
+                .get_deserialized(&beacon_state_root)?
+                .ok_or_else(|| {
+                    Error::DBInconsistent(format!("Missing state {}", beacon_state_root))
+                })?;
+
+            let slot = CheckPoint {
+                beacon_block,
+                beacon_block_root,
+                beacon_state,
+                beacon_state_root,
+            };
+
+            dump.push(slot.clone());
+            last_slot = slot;
+        }
+
+        dump.reverse();
+
+        Ok(dump)
+    }
 }
 
 impl From<DBError> for Error {
diff --git a/eth2/state_processing/src/per_slot_processing.rs b/eth2/state_processing/src/per_slot_processing.rs
index aafc7166ad..a90c5b4088 100644
--- a/eth2/state_processing/src/per_slot_processing.rs
+++ b/eth2/state_processing/src/per_slot_processing.rs
@@ -1,5 +1,6 @@
 use crate::*;
-use types::{BeaconState, BeaconStateError, ChainSpec, Hash256};
+use ssz::TreeHash;
+use types::*;
 
 #[derive(Debug, PartialEq)]
 pub enum Error {
@@ -12,9 +13,11 @@ pub enum Error {
 /// Spec v0.5.0
 pub fn per_slot_processing(
     state: &mut BeaconState,
-    previous_block_root: Hash256,
+    latest_block_header: &BeaconBlockHeader,
     spec: &ChainSpec,
 ) -> Result<(), Error> {
+    cache_state(state, latest_block_header, spec)?;
+
     if (state.slot + 1) % spec.slots_per_epoch == 0 {
         per_epoch_processing(state, spec)?;
         state.advance_caches();
@@ -22,6 +25,37 @@ pub fn per_slot_processing(
 
     state.slot += 1;
 
+    let latest_block_root = Hash256::from_slice(&state.latest_block_header.hash_tree_root()[..]);
+    state.set_block_root(state.slot - 1, latest_block_root, spec)?;
+
+    Ok(())
+}
+
+fn cache_state(
+    state: &mut BeaconState,
+    latest_block_header: &BeaconBlockHeader,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    let previous_slot_state_root = Hash256::from_slice(&state.hash_tree_root()[..]);
+
+    // Note: increment the state slot here to allow use of our `state_root` and `block_root`
+    // getter/setter functions.
+    //
+    // This is a bit hacky, however it gets the job safely without lots of code.
+    let previous_slot = state.slot;
+    state.slot += 1;
+
+    // Store the previous slot's post-state transition root.
+    if state.latest_block_header.state_root == spec.zero_hash {
+        state.latest_block_header.state_root = previous_slot_state_root
+    }
+
+    let latest_block_root = Hash256::from_slice(&latest_block_header.hash_tree_root()[..]);
+    state.set_block_root(previous_slot, latest_block_root, spec)?;
+
+    // Set the state slot back to what it should be.
+    state.slot -= 1;
+
     Ok(())
 }
 
diff --git a/eth2/types/src/beacon_block.rs b/eth2/types/src/beacon_block.rs
index 2dcf91d955..b966751ed8 100644
--- a/eth2/types/src/beacon_block.rs
+++ b/eth2/types/src/beacon_block.rs
@@ -63,16 +63,32 @@ impl BeaconBlock {
         Hash256::from_slice(&self.hash_tree_root()[..])
     }
 
+    /// Returns a full `BeaconBlockHeader` of this block.
+    ///
+    /// Note: This method is used instead of an `Into` impl to avoid a `Clone` of an entire block
+    /// when you want to have the block _and_ the header.
+    ///
+    /// Note: performs a full tree-hash of `self.body`.
+    ///
+    /// Spec v0.5.0
+    pub fn into_header(&self) -> BeaconBlockHeader {
+        BeaconBlockHeader {
+            slot: self.slot,
+            previous_block_root: self.previous_block_root,
+            state_root: self.state_root,
+            block_body_root: Hash256::from_slice(&self.body.hash_tree_root()[..]),
+            signature: self.signature.clone(),
+        }
+    }
+
     /// Returns a "temporary" header, where the `state_root` is `spec.zero_hash`.
     ///
     /// Spec v0.5.0
     pub fn into_temporary_header(&self, spec: &ChainSpec) -> BeaconBlockHeader {
         BeaconBlockHeader {
-            slot: self.slot,
-            previous_block_root: self.previous_block_root,
             state_root: spec.zero_hash,
-            block_body_root: Hash256::from_slice(&self.hash_tree_root()),
-            signature: self.signature.clone(),
+            signature: spec.empty_signature.clone(),
+            ..self.into_header()
         }
     }
 }
diff --git a/eth2/types/src/beacon_block_header.rs b/eth2/types/src/beacon_block_header.rs
index 029c7e56b2..3d8b08cc84 100644
--- a/eth2/types/src/beacon_block_header.rs
+++ b/eth2/types/src/beacon_block_header.rs
@@ -30,6 +30,15 @@ pub struct BeaconBlockHeader {
     pub signature: Signature,
 }
 
+impl BeaconBlockHeader {
+    /// Returns the `hash_tree_root` of the header.
+    ///
+    /// Spec v0.5.0
+    pub fn canonical_root(&self) -> Hash256 {
+        Hash256::from_slice(&self.hash_tree_root()[..])
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/eth2/types/src/beacon_state.rs b/eth2/types/src/beacon_state.rs
index 1a77d34490..1b2424774d 100644
--- a/eth2/types/src/beacon_state.rs
+++ b/eth2/types/src/beacon_state.rs
@@ -35,6 +35,7 @@ pub enum Error {
     InsufficientAttestations,
     InsufficientCommittees,
     InsufficientSlashedBalances,
+    InsufficientStateRoots,
     NoCommitteeForShard,
     EpochCacheUninitialized(RelativeEpoch),
     PubkeyCacheInconsistent,
@@ -425,6 +426,22 @@ impl BeaconState {
             .ok_or_else(|| Error::NoCommitteeForShard)?)
     }
 
+    /// Safely obtains the index for latest block roots, given some `slot`.
+    ///
+    /// Spec v0.5.0
+    fn get_latest_block_roots_index(&self, slot: Slot, spec: &ChainSpec) -> Result<usize, Error> {
+        if (slot < self.slot) && (self.slot <= slot + spec.slots_per_historical_root as u64) {
+            let i = slot.as_usize() % spec.slots_per_historical_root;
+            if i >= self.latest_block_roots.len() {
+                Err(Error::InsufficientStateRoots)
+            } else {
+                Ok(i)
+            }
+        } else {
+            Err(BeaconStateError::SlotOutOfBounds)
+        }
+    }
+
     /// Return the block root at a recent `slot`.
     ///
     /// Spec v0.5.0
@@ -433,13 +450,21 @@ impl BeaconState {
         slot: Slot,
         spec: &ChainSpec,
     ) -> Result<&Hash256, BeaconStateError> {
-        if (self.slot <= slot + spec.slots_per_historical_root as u64) && (slot < self.slot) {
-            self.latest_block_roots
-                .get(slot.as_usize() % spec.slots_per_historical_root)
-                .ok_or_else(|| Error::InsufficientBlockRoots)
-        } else {
-            Err(Error::EpochOutOfBounds)
-        }
+        let i = self.get_latest_block_roots_index(slot, spec)?;
+        Ok(&self.latest_block_roots[i])
+    }
+
+    /// Sets the block root for some given slot.
+    ///
+    /// Spec v0.5.0
+    pub fn set_block_root(
+        &mut self,
+        slot: Slot,
+        block_root: Hash256,
+        spec: &ChainSpec,
+    ) -> Result<(), BeaconStateError> {
+        let i = self.get_latest_block_roots_index(slot, spec)?;
+        Ok(self.latest_block_roots[i] = block_root)
     }
 
     /// XOR-assigns the existing `epoch` randao mix with the hash of the `signature`.
@@ -506,6 +531,43 @@ impl BeaconState {
         }
     }
 
+    /// Safely obtains the index for latest state roots, given some `slot`.
+    ///
+    /// Spec v0.5.0
+    fn get_latest_state_roots_index(&self, slot: Slot, spec: &ChainSpec) -> Result<usize, Error> {
+        if (slot < self.slot) && (self.slot <= slot + spec.slots_per_historical_root as u64) {
+            let i = slot.as_usize() % spec.slots_per_historical_root;
+            if i >= self.latest_state_roots.len() {
+                Err(Error::InsufficientStateRoots)
+            } else {
+                Ok(i)
+            }
+        } else {
+            Err(BeaconStateError::SlotOutOfBounds)
+        }
+    }
+
+    /// Gets the state root for some slot.
+    ///
+    /// Spec v0.5.0
+    pub fn get_state_root(&mut self, slot: Slot, spec: &ChainSpec) -> Result<&Hash256, Error> {
+        let i = self.get_latest_state_roots_index(slot, spec)?;
+        Ok(&self.latest_state_roots[i])
+    }
+
+    /// Sets the latest state root for slot.
+    ///
+    /// Spec v0.5.0
+    pub fn set_state_root(
+        &mut self,
+        slot: Slot,
+        state_root: Hash256,
+        spec: &ChainSpec,
+    ) -> Result<(), Error> {
+        let i = self.get_latest_state_roots_index(slot, spec)?;
+        Ok(self.latest_state_roots[i] = state_root)
+    }
+
     /// Generate a seed for the given `epoch`.
     ///
     /// Spec v0.4.0

From 71d95ee9db698aa558dd78780202db7128de8ac1 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Mon, 18 Mar 2019 18:08:53 +1100
Subject: [PATCH 51/60] Add new field to test_harness YAML, remove prints

---
 beacon_node/beacon_chain/src/beacon_chain.rs                 | 5 -----
 .../beacon_chain/test_harness/specs/validator_registry.yaml  | 1 +
 beacon_node/beacon_chain/test_harness/src/test_case.rs       | 4 ++++
 .../beacon_chain/test_harness/src/test_case/config.rs        | 3 +++
 4 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/beacon_node/beacon_chain/src/beacon_chain.rs b/beacon_node/beacon_chain/src/beacon_chain.rs
index bf87adf10d..01787f95bc 100644
--- a/beacon_node/beacon_chain/src/beacon_chain.rs
+++ b/beacon_node/beacon_chain/src/beacon_chain.rs
@@ -596,7 +596,6 @@ where
 
         // Transition the parent state to the present slot.
         let mut state = parent_state;
-        println!("parent process state: {:?}", state.latest_block_header);
         let previous_block_header = parent_block.into_header();
         for _ in state.slot.as_u64()..present_slot.as_u64() {
             if let Err(e) = per_slot_processing(&mut state, &previous_block_header, &self.spec) {
@@ -614,8 +613,6 @@ where
             ));
         }
 
-        println!("process state: {:?}", state.latest_block_header);
-
         let state_root = state.canonical_root();
 
         if block.state_root != state_root {
@@ -706,8 +703,6 @@ where
 
         per_block_processing_without_verifying_block_signature(&mut state, &block, &self.spec)?;
 
-        println!("produce state: {:?}", state.latest_block_header);
-
         let state_root = state.canonical_root();
 
         block.state_root = state_root;
diff --git a/beacon_node/beacon_chain/test_harness/specs/validator_registry.yaml b/beacon_node/beacon_chain/test_harness/specs/validator_registry.yaml
index aea7dcf31b..0c4f5004bb 100644
--- a/beacon_node/beacon_chain/test_harness/specs/validator_registry.yaml
+++ b/beacon_node/beacon_chain/test_harness/specs/validator_registry.yaml
@@ -9,6 +9,7 @@ test_cases:
       deposits_for_chain_start: 1000
       num_slots: 64
       skip_slots: [2, 3]
+      persistent_committee_period: 0
       deposits:
           # At slot 1, create a new validator deposit of 5 ETH.
         - slot: 1
diff --git a/beacon_node/beacon_chain/test_harness/src/test_case.rs b/beacon_node/beacon_chain/test_harness/src/test_case.rs
index 1361127a19..f65b45505e 100644
--- a/beacon_node/beacon_chain/test_harness/src/test_case.rs
+++ b/beacon_node/beacon_chain/test_harness/src/test_case.rs
@@ -62,6 +62,10 @@ impl TestCase {
             spec.slots_per_epoch = n;
         }
 
+        if let Some(n) = self.config.persistent_committee_period {
+            spec.persistent_committee_period = n;
+        }
+
         spec
     }
 
diff --git a/beacon_node/beacon_chain/test_harness/src/test_case/config.rs b/beacon_node/beacon_chain/test_harness/src/test_case/config.rs
index f336b9d536..12d5da2d72 100644
--- a/beacon_node/beacon_chain/test_harness/src/test_case/config.rs
+++ b/beacon_node/beacon_chain/test_harness/src/test_case/config.rs
@@ -20,6 +20,8 @@ pub struct Config {
     pub deposits_for_chain_start: usize,
     /// Number of slots in an epoch.
     pub slots_per_epoch: Option<u64>,
+    /// Affects the number of epochs a validator must be active before they can withdraw.
+    pub persistent_committee_period: Option<u64>,
     /// Number of slots to build before ending execution.
     pub num_slots: u64,
     /// Number of slots that should be skipped due to inactive validator.
@@ -45,6 +47,7 @@ impl Config {
             deposits_for_chain_start: as_usize(&yaml, "deposits_for_chain_start")
                 .expect("Must specify validator count"),
             slots_per_epoch: as_u64(&yaml, "slots_per_epoch"),
+            persistent_committee_period: as_u64(&yaml, "persistent_committee_period"),
             num_slots: as_u64(&yaml, "num_slots").expect("Must specify `config.num_slots`"),
             skip_slots: as_vec_u64(yaml, "skip_slots"),
             deposits: parse_deposits(&yaml),

From 7503f31ddc117b91debcfacd8d7b3e517a86899e Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Mon, 18 Mar 2019 18:09:31 +1100
Subject: [PATCH 52/60] Fix bug with per-block processing

---
 eth2/state_processing/src/per_block_processing.rs | 5 ++++-
 eth2/state_processing/src/per_slot_processing.rs  | 3 ---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/eth2/state_processing/src/per_block_processing.rs b/eth2/state_processing/src/per_block_processing.rs
index 78cf927f5e..14c72c53be 100644
--- a/eth2/state_processing/src/per_block_processing.rs
+++ b/eth2/state_processing/src/per_block_processing.rs
@@ -100,8 +100,11 @@ pub fn process_block_header(
 ) -> Result<(), Error> {
     verify!(block.slot == state.slot, Invalid::StateSlotMismatch);
 
+    // NOTE: this is not to spec. I think spec is broken. See:
+    //
+    // https://github.com/ethereum/eth2.0-specs/issues/797
     verify!(
-        block.previous_block_root.as_bytes() == &state.latest_block_header.hash_tree_root()[..],
+        block.previous_block_root == *state.get_block_root(state.slot - 1, spec)?,
         Invalid::ParentBlockRootMismatch
     );
 
diff --git a/eth2/state_processing/src/per_slot_processing.rs b/eth2/state_processing/src/per_slot_processing.rs
index a90c5b4088..8f02b70e3a 100644
--- a/eth2/state_processing/src/per_slot_processing.rs
+++ b/eth2/state_processing/src/per_slot_processing.rs
@@ -25,9 +25,6 @@ pub fn per_slot_processing(
 
     state.slot += 1;
 
-    let latest_block_root = Hash256::from_slice(&state.latest_block_header.hash_tree_root()[..]);
-    state.set_block_root(state.slot - 1, latest_block_root, spec)?;
-
     Ok(())
 }
 

From 1028acf3f184bdf4982557ec65f0fa52d9eb92b6 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Mon, 18 Mar 2019 21:34:42 +1100
Subject: [PATCH 53/60] Move state trans fns into state_processing

---
 .../src/common/exit_validator.rs              |   22 +
 eth2/state_processing/src/common/mod.rs       |    7 +
 .../src/common/slash_validator.rs             |   62 +
 .../src/common/verify_bitfield.rs}            |    2 +-
 .../state_processing/src/get_genesis_state.rs |    3 +-
 eth2/state_processing/src/lib.rs              |    1 +
 .../src/per_block_processing.rs               |    5 +-
 .../validate_attestation.rs                   |    2 +-
 .../verify_slashable_attestation.rs           |    2 +-
 .../src/per_epoch_processing.rs               |   31 +-
 .../get_attestation_participants.rs           |    3 +-
 .../per_epoch_processing/process_ejections.rs |   28 +
 .../process_exit_queue.rs                     |   42 +
 .../per_epoch_processing/process_slashings.rs |   36 +
 .../process_validator_registry.rs             |    6 +-
 .../update_validator_registry.rs              |   51 +
 eth2/types/src/beacon_state.rs                | 1107 +++++++----------
 17 files changed, 741 insertions(+), 669 deletions(-)
 create mode 100644 eth2/state_processing/src/common/exit_validator.rs
 create mode 100644 eth2/state_processing/src/common/mod.rs
 create mode 100644 eth2/state_processing/src/common/slash_validator.rs
 rename eth2/{types/src/beacon_state/helpers.rs => state_processing/src/common/verify_bitfield.rs} (96%)
 create mode 100644 eth2/state_processing/src/per_epoch_processing/process_ejections.rs
 create mode 100644 eth2/state_processing/src/per_epoch_processing/process_exit_queue.rs
 create mode 100644 eth2/state_processing/src/per_epoch_processing/process_slashings.rs
 create mode 100644 eth2/state_processing/src/per_epoch_processing/update_validator_registry.rs

diff --git a/eth2/state_processing/src/common/exit_validator.rs b/eth2/state_processing/src/common/exit_validator.rs
new file mode 100644
index 0000000000..8ab530b18a
--- /dev/null
+++ b/eth2/state_processing/src/common/exit_validator.rs
@@ -0,0 +1,22 @@
+use types::{BeaconStateError as Error, *};
+
+/// Exit the validator of the given `index`.
+///
+/// Spec v0.5.0
+pub fn exit_validator(
+    state: &mut BeaconState,
+    validator_index: usize,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    if validator_index >= state.validator_registry.len() {
+        return Err(Error::UnknownValidator);
+    }
+
+    let delayed_epoch = state.get_delayed_activation_exit_epoch(state.current_epoch(spec), spec);
+
+    if state.validator_registry[validator_index].exit_epoch > delayed_epoch {
+        state.validator_registry[validator_index].exit_epoch = delayed_epoch;
+    }
+
+    Ok(())
+}
diff --git a/eth2/state_processing/src/common/mod.rs b/eth2/state_processing/src/common/mod.rs
new file mode 100644
index 0000000000..49898d10f7
--- /dev/null
+++ b/eth2/state_processing/src/common/mod.rs
@@ -0,0 +1,7 @@
+mod exit_validator;
+mod slash_validator;
+mod verify_bitfield;
+
+pub use exit_validator::exit_validator;
+pub use slash_validator::slash_validator;
+pub use verify_bitfield::verify_bitfield_length;
diff --git a/eth2/state_processing/src/common/slash_validator.rs b/eth2/state_processing/src/common/slash_validator.rs
new file mode 100644
index 0000000000..9be87b978e
--- /dev/null
+++ b/eth2/state_processing/src/common/slash_validator.rs
@@ -0,0 +1,62 @@
+use crate::common::exit_validator;
+use types::{BeaconStateError as Error, *};
+
+/// Slash the validator with index ``index``.
+///
+/// Spec v0.5.0
+pub fn slash_validator(
+    state: &mut BeaconState,
+    validator_index: usize,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    let current_epoch = state.current_epoch(spec);
+
+    if (validator_index >= state.validator_registry.len())
+        | (validator_index >= state.validator_balances.len())
+    {
+        return Err(BeaconStateError::UnknownValidator);
+    }
+
+    let validator = &state.validator_registry[validator_index];
+
+    let effective_balance = state.get_effective_balance(validator_index, spec)?;
+
+    // A validator that is withdrawn cannot be slashed.
+    //
+    // This constraint will be lifted in Phase 0.
+    if state.slot
+        >= validator
+            .withdrawable_epoch
+            .start_slot(spec.slots_per_epoch)
+    {
+        return Err(Error::ValidatorIsWithdrawable);
+    }
+
+    exit_validator(state, validator_index, spec)?;
+
+    state.set_slashed_balance(
+        current_epoch,
+        state.get_slashed_balance(current_epoch, spec)? + effective_balance,
+        spec,
+    )?;
+
+    let whistleblower_index =
+        state.get_beacon_proposer_index(state.slot, RelativeEpoch::Current, spec)?;
+    let whistleblower_reward = effective_balance / spec.whistleblower_reward_quotient;
+
+    safe_add_assign!(
+        state.validator_balances[whistleblower_index as usize],
+        whistleblower_reward
+    );
+    safe_sub_assign!(
+        state.validator_balances[validator_index],
+        whistleblower_reward
+    );
+
+    state.validator_registry[validator_index].slashed = true;
+
+    state.validator_registry[validator_index].withdrawable_epoch =
+        current_epoch + Epoch::from(spec.latest_slashed_exit_length);
+
+    Ok(())
+}
diff --git a/eth2/types/src/beacon_state/helpers.rs b/eth2/state_processing/src/common/verify_bitfield.rs
similarity index 96%
rename from eth2/types/src/beacon_state/helpers.rs
rename to eth2/state_processing/src/common/verify_bitfield.rs
index adae7bab49..8ff5c96ca3 100644
--- a/eth2/types/src/beacon_state/helpers.rs
+++ b/eth2/state_processing/src/common/verify_bitfield.rs
@@ -1,4 +1,4 @@
-use crate::*;
+use types::*;
 
 /// Verify ``bitfield`` against the ``committee_size``.
 ///
diff --git a/eth2/state_processing/src/get_genesis_state.rs b/eth2/state_processing/src/get_genesis_state.rs
index 3c6612349a..bfcf822164 100644
--- a/eth2/state_processing/src/get_genesis_state.rs
+++ b/eth2/state_processing/src/get_genesis_state.rs
@@ -37,8 +37,7 @@ pub fn get_genesis_state(
         .get_active_validator_indices(spec.genesis_epoch, spec)?
         .to_vec();
     let genesis_active_index_root = Hash256::from_slice(&active_validator_indices.hash_tree_root());
-    state.latest_active_index_roots =
-        vec![genesis_active_index_root; spec.latest_active_index_roots_length as usize];
+    state.fill_active_index_roots_with(genesis_active_index_root, spec);
 
     // Generate the current shuffling seed.
     state.current_shuffling_seed = state.generate_seed(spec.genesis_epoch, spec)?;
diff --git a/eth2/state_processing/src/lib.rs b/eth2/state_processing/src/lib.rs
index 78dc7270d2..6757b5dbd9 100644
--- a/eth2/state_processing/src/lib.rs
+++ b/eth2/state_processing/src/lib.rs
@@ -1,6 +1,7 @@
 #[macro_use]
 mod macros;
 
+pub mod common;
 pub mod get_genesis_state;
 pub mod per_block_processing;
 pub mod per_epoch_processing;
diff --git a/eth2/state_processing/src/per_block_processing.rs b/eth2/state_processing/src/per_block_processing.rs
index 14c72c53be..33f953b711 100644
--- a/eth2/state_processing/src/per_block_processing.rs
+++ b/eth2/state_processing/src/per_block_processing.rs
@@ -1,4 +1,5 @@
 use self::verify_proposer_slashing::verify_proposer_slashing;
+use crate::common::slash_validator;
 use errors::{BlockInvalid as Invalid, BlockProcessingError as Error, IntoWithIndex};
 use rayon::prelude::*;
 use ssz::{SignedRoot, TreeHash};
@@ -222,7 +223,7 @@ pub fn process_proposer_slashings(
 
     // Update the state.
     for proposer_slashing in proposer_slashings {
-        state.slash_validator(proposer_slashing.proposer_index as usize, spec)?;
+        slash_validator(state, proposer_slashing.proposer_index as usize, spec)?;
     }
 
     Ok(())
@@ -279,7 +280,7 @@ pub fn process_attester_slashings(
             .map_err(|e| e.into_with_index(i))?;
 
         for i in slashable_indices {
-            state.slash_validator(i as usize, spec)?;
+            slash_validator(state, i as usize, spec)?;
         }
     }
 
diff --git a/eth2/state_processing/src/per_block_processing/validate_attestation.rs b/eth2/state_processing/src/per_block_processing/validate_attestation.rs
index 272eeb18b8..113dbc4ced 100644
--- a/eth2/state_processing/src/per_block_processing/validate_attestation.rs
+++ b/eth2/state_processing/src/per_block_processing/validate_attestation.rs
@@ -1,6 +1,6 @@
 use super::errors::{AttestationInvalid as Invalid, AttestationValidationError as Error};
+use crate::common::verify_bitfield_length;
 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
diff --git a/eth2/state_processing/src/per_block_processing/verify_slashable_attestation.rs b/eth2/state_processing/src/per_block_processing/verify_slashable_attestation.rs
index aa9a321969..d3ab5e398f 100644
--- a/eth2/state_processing/src/per_block_processing/verify_slashable_attestation.rs
+++ b/eth2/state_processing/src/per_block_processing/verify_slashable_attestation.rs
@@ -1,8 +1,8 @@
 use super::errors::{
     SlashableAttestationInvalid as Invalid, SlashableAttestationValidationError as Error,
 };
+use crate::common::verify_bitfield_length;
 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
diff --git a/eth2/state_processing/src/per_epoch_processing.rs b/eth2/state_processing/src/per_epoch_processing.rs
index d1bb4269a7..97a0e9987f 100644
--- a/eth2/state_processing/src/per_epoch_processing.rs
+++ b/eth2/state_processing/src/per_epoch_processing.rs
@@ -1,5 +1,8 @@
 use errors::EpochProcessingError as Error;
 use integer_sqrt::IntegerSquareRoot;
+use process_ejections::process_ejections;
+use process_exit_queue::process_exit_queue;
+use process_slashings::process_slashings;
 use process_validator_registry::process_validator_registry;
 use rayon::prelude::*;
 use ssz::TreeHash;
@@ -11,8 +14,12 @@ use winning_root::{winning_root, WinningRoot};
 pub mod errors;
 pub mod get_attestation_participants;
 pub mod inclusion_distance;
+pub mod process_ejections;
+pub mod process_exit_queue;
+pub mod process_slashings;
 pub mod process_validator_registry;
 pub mod tests;
+pub mod update_validator_registry;
 pub mod validator_statuses;
 pub mod winning_root;
 
@@ -45,14 +52,16 @@ pub fn per_epoch_processing(state: &mut BeaconState, spec: &ChainSpec) -> Result
     process_rewards_and_penalities(state, &mut statuses, &winning_root_for_shards, spec)?;
 
     // Ejections
-    state.process_ejections(spec)?;
+    process_ejections(state, spec)?;
 
     // Validator Registry
     process_validator_registry(state, spec)?;
+    process_slashings(state, spec)?;
+    process_exit_queue(state, spec);
 
     // Final updates
     update_active_tree_index_roots(state, spec)?;
-    update_latest_slashed_balances(state, spec);
+    update_latest_slashed_balances(state, spec)?;
     clean_attestations(state);
 
     // Rotate the epoch caches to suit the epoch transition.
@@ -451,9 +460,7 @@ pub fn update_active_tree_index_roots(
     )
     .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.set_active_index_root(next_epoch, Hash256::from_slice(&active_tree_root[..]), spec)?;
 
     Ok(())
 }
@@ -461,12 +468,20 @@ pub fn update_active_tree_index_roots(
 /// Advances the state's `latest_slashed_balances` field.
 ///
 /// Spec v0.4.0
-pub fn update_latest_slashed_balances(state: &mut BeaconState, spec: &ChainSpec) {
+pub fn update_latest_slashed_balances(
+    state: &mut BeaconState,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
     let current_epoch = state.current_epoch(spec);
     let next_epoch = state.next_epoch(spec);
 
-    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.set_slashed_balance(
+        next_epoch,
+        state.get_slashed_balance(current_epoch, spec)?,
+        spec,
+    )?;
+
+    Ok(())
 }
 
 /// Removes all pending attestations from the previous epoch.
diff --git a/eth2/state_processing/src/per_epoch_processing/get_attestation_participants.rs b/eth2/state_processing/src/per_epoch_processing/get_attestation_participants.rs
index d822e434d1..3e52776b10 100644
--- a/eth2/state_processing/src/per_epoch_processing/get_attestation_participants.rs
+++ b/eth2/state_processing/src/per_epoch_processing/get_attestation_participants.rs
@@ -1,4 +1,5 @@
-use types::{beacon_state::helpers::verify_bitfield_length, *};
+use crate::common::verify_bitfield_length;
+use types::*;
 
 /// Returns validator indices which participated in the attestation.
 ///
diff --git a/eth2/state_processing/src/per_epoch_processing/process_ejections.rs b/eth2/state_processing/src/per_epoch_processing/process_ejections.rs
new file mode 100644
index 0000000000..27dd37479d
--- /dev/null
+++ b/eth2/state_processing/src/per_epoch_processing/process_ejections.rs
@@ -0,0 +1,28 @@
+use crate::common::exit_validator;
+use types::{BeaconStateError as Error, *};
+
+/// Iterate through the validator registry and eject active validators with balance below
+/// ``EJECTION_BALANCE``.
+///
+/// Spec v0.5.0
+pub fn process_ejections(state: &mut BeaconState, spec: &ChainSpec) -> Result<(), Error> {
+    // There is an awkward double (triple?) loop here because we can't loop across the borrowed
+    // active validator indices and mutate state in the one loop.
+    let exitable: Vec<usize> = state
+        .get_active_validator_indices(state.current_epoch(spec), spec)?
+        .iter()
+        .filter_map(|&i| {
+            if state.validator_balances[i as usize] < spec.ejection_balance {
+                Some(i)
+            } else {
+                None
+            }
+        })
+        .collect();
+
+    for validator_index in exitable {
+        exit_validator(state, validator_index, spec)?
+    }
+
+    Ok(())
+}
diff --git a/eth2/state_processing/src/per_epoch_processing/process_exit_queue.rs b/eth2/state_processing/src/per_epoch_processing/process_exit_queue.rs
new file mode 100644
index 0000000000..f672c97be3
--- /dev/null
+++ b/eth2/state_processing/src/per_epoch_processing/process_exit_queue.rs
@@ -0,0 +1,42 @@
+use types::*;
+
+/// Process the exit queue.
+///
+/// Spec v0.5.0
+pub fn process_exit_queue(state: &mut BeaconState, spec: &ChainSpec) {
+    let current_epoch = state.current_epoch(spec);
+
+    let eligible = |index: usize| {
+        let validator = &state.validator_registry[index];
+
+        if validator.withdrawable_epoch != spec.far_future_epoch {
+            false
+        } else {
+            current_epoch >= validator.exit_epoch + spec.min_validator_withdrawability_delay
+        }
+    };
+
+    let mut eligable_indices: Vec<usize> = (0..state.validator_registry.len())
+        .filter(|i| eligible(*i))
+        .collect();
+    eligable_indices.sort_by_key(|i| state.validator_registry[*i].exit_epoch);
+
+    for (withdrawn_so_far, index) in eligable_indices.iter().enumerate() {
+        if withdrawn_so_far as u64 >= spec.max_exit_dequeues_per_epoch {
+            break;
+        }
+        prepare_validator_for_withdrawal(state, *index, spec);
+    }
+}
+
+/// Initiate an exit for the validator of the given `index`.
+///
+/// Spec v0.5.0
+fn prepare_validator_for_withdrawal(
+    state: &mut BeaconState,
+    validator_index: usize,
+    spec: &ChainSpec,
+) {
+    state.validator_registry[validator_index].withdrawable_epoch =
+        state.current_epoch(spec) + spec.min_validator_withdrawability_delay;
+}
diff --git a/eth2/state_processing/src/per_epoch_processing/process_slashings.rs b/eth2/state_processing/src/per_epoch_processing/process_slashings.rs
new file mode 100644
index 0000000000..b14a9ee373
--- /dev/null
+++ b/eth2/state_processing/src/per_epoch_processing/process_slashings.rs
@@ -0,0 +1,36 @@
+use types::{BeaconStateError as Error, *};
+
+/// Process slashings.
+///
+/// Note: Utilizes the cache and will fail if the appropriate cache is not initialized.
+///
+/// Spec v0.4.0
+pub fn process_slashings(state: &mut BeaconState, spec: &ChainSpec) -> Result<(), Error> {
+    let current_epoch = state.current_epoch(spec);
+    let active_validator_indices = state.get_active_validator_indices(current_epoch, spec)?;
+    let total_balance = state.get_total_balance(&active_validator_indices[..], spec)?;
+
+    for (index, validator) in state.validator_registry.iter().enumerate() {
+        if validator.slashed
+            && (current_epoch
+                == validator.withdrawable_epoch - Epoch::from(spec.latest_slashed_exit_length / 2))
+        {
+            // TODO: check the following two lines are correct.
+            let total_at_start = state.get_slashed_balance(current_epoch + 1, spec)?;
+            let total_at_end = state.get_slashed_balance(current_epoch, spec)?;
+
+            let total_penalities = total_at_end.saturating_sub(total_at_start);
+
+            let effective_balance = state.get_effective_balance(index, spec)?;
+            let penalty = std::cmp::max(
+                effective_balance * std::cmp::min(total_penalities * 3, total_balance)
+                    / total_balance,
+                effective_balance / spec.min_penalty_quotient,
+            );
+
+            safe_sub_assign!(state.validator_balances[index], penalty);
+        }
+    }
+
+    Ok(())
+}
diff --git a/eth2/state_processing/src/per_epoch_processing/process_validator_registry.rs b/eth2/state_processing/src/per_epoch_processing/process_validator_registry.rs
index 26ebd60b33..2eb39711d2 100644
--- a/eth2/state_processing/src/per_epoch_processing/process_validator_registry.rs
+++ b/eth2/state_processing/src/per_epoch_processing/process_validator_registry.rs
@@ -1,3 +1,4 @@
+use super::update_validator_registry::update_validator_registry;
 use super::Error;
 use types::*;
 
@@ -14,7 +15,7 @@ pub fn process_validator_registry(state: &mut BeaconState, spec: &ChainSpec) ->
     state.previous_shuffling_seed = state.current_shuffling_seed;
 
     if should_update_validator_registry(state, spec)? {
-        state.update_validator_registry(spec)?;
+        update_validator_registry(state, spec)?;
 
         state.current_shuffling_epoch = next_epoch;
         state.current_shuffling_start_shard = (state.current_shuffling_start_shard
@@ -37,9 +38,6 @@ pub fn process_validator_registry(state: &mut BeaconState, spec: &ChainSpec) ->
         }
     }
 
-    state.process_slashings(spec)?;
-    state.process_exit_queue(spec);
-
     Ok(())
 }
 
diff --git a/eth2/state_processing/src/per_epoch_processing/update_validator_registry.rs b/eth2/state_processing/src/per_epoch_processing/update_validator_registry.rs
new file mode 100644
index 0000000000..8b612c3463
--- /dev/null
+++ b/eth2/state_processing/src/per_epoch_processing/update_validator_registry.rs
@@ -0,0 +1,51 @@
+use crate::common::exit_validator;
+use types::{BeaconStateError as Error, *};
+
+/// Update validator registry, activating/exiting validators if possible.
+///
+/// Note: Utilizes the cache and will fail if the appropriate cache is not initialized.
+///
+/// Spec v0.4.0
+pub fn update_validator_registry(state: &mut BeaconState, spec: &ChainSpec) -> Result<(), Error> {
+    let current_epoch = state.current_epoch(spec);
+    let active_validator_indices = state.get_active_validator_indices(current_epoch, spec)?;
+    let total_balance = state.get_total_balance(&active_validator_indices[..], spec)?;
+
+    let max_balance_churn = std::cmp::max(
+        spec.max_deposit_amount,
+        total_balance / (2 * spec.max_balance_churn_quotient),
+    );
+
+    let mut balance_churn = 0;
+    for index in 0..state.validator_registry.len() {
+        let validator = &state.validator_registry[index];
+
+        if (validator.activation_epoch == spec.far_future_epoch)
+            & (state.validator_balances[index] == spec.max_deposit_amount)
+        {
+            balance_churn += state.get_effective_balance(index, spec)?;
+            if balance_churn > max_balance_churn {
+                break;
+            }
+            state.activate_validator(index, false, spec);
+        }
+    }
+
+    let mut balance_churn = 0;
+    for index in 0..state.validator_registry.len() {
+        let validator = &state.validator_registry[index];
+
+        if (validator.exit_epoch == spec.far_future_epoch) & (validator.initiated_exit) {
+            balance_churn += state.get_effective_balance(index, spec)?;
+            if balance_churn > max_balance_churn {
+                break;
+            }
+
+            exit_validator(state, index, spec)?;
+        }
+    }
+
+    state.validator_registry_update_epoch = current_epoch;
+
+    Ok(())
+}
diff --git a/eth2/types/src/beacon_state.rs b/eth2/types/src/beacon_state.rs
index 1b2424774d..30f95c02c2 100644
--- a/eth2/types/src/beacon_state.rs
+++ b/eth2/types/src/beacon_state.rs
@@ -10,7 +10,6 @@ use ssz_derive::{Decode, Encode, TreeHash};
 use test_random_derive::TestRandom;
 
 mod epoch_cache;
-pub mod helpers;
 mod pubkey_cache;
 mod tests;
 
@@ -19,17 +18,13 @@ pub const CACHED_EPOCHS: usize = 4;
 #[derive(Debug, PartialEq)]
 pub enum Error {
     EpochOutOfBounds,
-    /// The supplied shard is unknown. It may be larger than the maximum shard count, or not in a
-    /// committee for the given slot.
     SlotOutOfBounds,
     ShardOutOfBounds,
-    UnableToShuffle,
     UnknownValidator,
+    UnableToDetermineProducer,
     InvalidBitfield,
     ValidatorIsWithdrawable,
     InsufficientRandaoMixes,
-    NoValidators,
-    UnableToDetermineProducer,
     InsufficientBlockRoots,
     InsufficientIndexRoots,
     InsufficientAttestations,
@@ -37,27 +32,16 @@ pub enum Error {
     InsufficientSlashedBalances,
     InsufficientStateRoots,
     NoCommitteeForShard,
-    EpochCacheUninitialized(RelativeEpoch),
     PubkeyCacheInconsistent,
     PubkeyCacheIncomplete {
         cache_len: usize,
         registry_len: usize,
     },
+    EpochCacheUninitialized(RelativeEpoch),
     RelativeEpochError(RelativeEpochError),
     EpochCacheError(EpochCacheError),
 }
 
-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);
-    };
-}
-
 /// The state of the `BeaconChain` at some slot.
 ///
 /// Spec v0.5.0
@@ -95,10 +79,10 @@ pub struct BeaconState {
 
     // Recent state
     pub latest_crosslinks: Vec<Crosslink>,
-    pub latest_block_roots: Vec<Hash256>,
-    pub latest_state_roots: Vec<Hash256>,
-    pub latest_active_index_roots: Vec<Hash256>,
-    pub latest_slashed_balances: Vec<u64>,
+    latest_block_roots: Vec<Hash256>,
+    latest_state_roots: Vec<Hash256>,
+    latest_active_index_roots: Vec<Hash256>,
+    latest_slashed_balances: Vec<u64>,
     pub latest_block_header: BeaconBlockHeader,
     pub historical_roots: Vec<Hash256>,
 
@@ -209,6 +193,458 @@ impl BeaconState {
         Hash256::from_slice(&self.hash_tree_root()[..])
     }
 
+    /// If a validator pubkey exists in the validator registry, returns `Some(i)`, otherwise
+    /// returns `None`.
+    ///
+    /// Requires a fully up-to-date `pubkey_cache`, returns an error if this is not the case.
+    pub fn get_validator_index(&self, pubkey: &PublicKey) -> Result<Option<usize>, Error> {
+        if self.pubkey_cache.len() == self.validator_registry.len() {
+            Ok(self.pubkey_cache.get(pubkey))
+        } else {
+            Err(Error::PubkeyCacheIncomplete {
+                cache_len: self.pubkey_cache.len(),
+                registry_len: self.validator_registry.len(),
+            })
+        }
+    }
+
+    /// The epoch corresponding to `self.slot`.
+    ///
+    /// Spec v0.5.0
+    pub fn current_epoch(&self, spec: &ChainSpec) -> Epoch {
+        self.slot.epoch(spec.slots_per_epoch)
+    }
+
+    /// The epoch prior to `self.current_epoch()`.
+    ///
+    /// If the current epoch is the genesis epoch, the genesis_epoch is returned.
+    ///
+    /// Spec v0.5.0
+    pub fn previous_epoch(&self, spec: &ChainSpec) -> Epoch {
+        self.current_epoch(&spec) - 1
+    }
+
+    /// The epoch following `self.current_epoch()`.
+    ///
+    /// Spec v0.5.0
+    pub fn next_epoch(&self, spec: &ChainSpec) -> Epoch {
+        self.current_epoch(spec) + 1
+    }
+
+    /// Returns the active validator indices for the given epoch, assuming there is no validator
+    /// registry update in the next epoch.
+    ///
+    /// Note: Utilizes the cache and will fail if the appropriate cache is not initialized.
+    ///
+    /// Spec v0.5.0
+    pub fn get_active_validator_indices(
+        &self,
+        epoch: Epoch,
+        spec: &ChainSpec,
+    ) -> Result<&[usize], Error> {
+        // If the slot is in the next epoch, assume there was no validator registry update.
+        let relative_epoch =
+            match RelativeEpoch::from_epoch(self.slot.epoch(spec.slots_per_epoch), epoch) {
+                Err(RelativeEpochError::AmbiguiousNextEpoch) => {
+                    Ok(RelativeEpoch::NextWithoutRegistryChange)
+                }
+                e => e,
+            }?;
+
+        let cache = self.cache(relative_epoch, spec)?;
+
+        Ok(&cache.active_validator_indices)
+    }
+
+    /// Returns the crosslink committees for some slot.
+    ///
+    /// Note: Utilizes the cache and will fail if the appropriate cache is not initialized.
+    ///
+    /// Spec v0.5.0
+    pub fn get_crosslink_committees_at_slot(
+        &self,
+        slot: Slot,
+        spec: &ChainSpec,
+    ) -> Result<&Vec<CrosslinkCommittee>, Error> {
+        // If the slot is in the next epoch, assume there was no validator registry update.
+        let relative_epoch = match RelativeEpoch::from_slot(self.slot, slot, spec) {
+            Err(RelativeEpochError::AmbiguiousNextEpoch) => {
+                Ok(RelativeEpoch::NextWithoutRegistryChange)
+            }
+            e => e,
+        }?;
+
+        let cache = self.cache(relative_epoch, spec)?;
+
+        Ok(cache
+            .get_crosslink_committees_at_slot(slot, spec)
+            .ok_or_else(|| Error::SlotOutOfBounds)?)
+    }
+
+    /// Returns the crosslink committees for some shard in an epoch.
+    ///
+    /// Note: Utilizes the cache and will fail if the appropriate cache is not initialized.
+    ///
+    /// Spec v0.5.0
+    pub fn get_crosslink_committee_for_shard(
+        &self,
+        epoch: Epoch,
+        shard: Shard,
+        spec: &ChainSpec,
+    ) -> Result<&CrosslinkCommittee, Error> {
+        // If the slot is in the next epoch, assume there was no validator registry update.
+        let relative_epoch = match RelativeEpoch::from_epoch(self.current_epoch(spec), epoch) {
+            Err(RelativeEpochError::AmbiguiousNextEpoch) => {
+                Ok(RelativeEpoch::NextWithoutRegistryChange)
+            }
+            e => e,
+        }?;
+
+        let cache = self.cache(relative_epoch, spec)?;
+
+        Ok(cache
+            .get_crosslink_committee_for_shard(shard, spec)
+            .ok_or_else(|| Error::NoCommitteeForShard)?)
+    }
+
+    /// Returns the beacon proposer index for the `slot`.
+    ///
+    /// If the state does not contain an index for a beacon proposer at the requested `slot`, then `None` is returned.
+    ///
+    /// Spec v0.5.0
+    pub fn get_beacon_proposer_index(
+        &self,
+        slot: Slot,
+        relative_epoch: RelativeEpoch,
+        spec: &ChainSpec,
+    ) -> Result<usize, Error> {
+        let cache = self.cache(relative_epoch, spec)?;
+
+        let committees = cache
+            .get_crosslink_committees_at_slot(slot, spec)
+            .ok_or_else(|| Error::SlotOutOfBounds)?;
+
+        let epoch = slot.epoch(spec.slots_per_epoch);
+
+        committees
+            .first()
+            .ok_or(Error::UnableToDetermineProducer)
+            .and_then(|first| {
+                let index = epoch
+                    .as_usize()
+                    .checked_rem(first.committee.len())
+                    .ok_or(Error::UnableToDetermineProducer)?;
+                Ok(first.committee[index])
+            })
+    }
+
+    /// Safely obtains the index for latest block roots, given some `slot`.
+    ///
+    /// Spec v0.5.0
+    fn get_latest_block_roots_index(&self, slot: Slot, spec: &ChainSpec) -> Result<usize, Error> {
+        if (slot < self.slot) && (self.slot <= slot + spec.slots_per_historical_root as u64) {
+            let i = slot.as_usize() % spec.slots_per_historical_root;
+            if i >= self.latest_block_roots.len() {
+                Err(Error::InsufficientStateRoots)
+            } else {
+                Ok(i)
+            }
+        } else {
+            Err(BeaconStateError::SlotOutOfBounds)
+        }
+    }
+
+    /// Return the block root at a recent `slot`.
+    ///
+    /// Spec v0.5.0
+    pub fn get_block_root(
+        &self,
+        slot: Slot,
+        spec: &ChainSpec,
+    ) -> Result<&Hash256, BeaconStateError> {
+        let i = self.get_latest_block_roots_index(slot, spec)?;
+        Ok(&self.latest_block_roots[i])
+    }
+
+    /// Sets the block root for some given slot.
+    ///
+    /// Spec v0.5.0
+    pub fn set_block_root(
+        &mut self,
+        slot: Slot,
+        block_root: Hash256,
+        spec: &ChainSpec,
+    ) -> Result<(), BeaconStateError> {
+        let i = self.get_latest_block_roots_index(slot, spec)?;
+        Ok(self.latest_block_roots[i] = block_root)
+    }
+
+    /// XOR-assigns the existing `epoch` randao mix with the hash of the `signature`.
+    ///
+    /// # Errors:
+    ///
+    /// See `Self::get_randao_mix`.
+    ///
+    /// Spec v0.5.0
+    pub fn update_randao_mix(
+        &mut self,
+        epoch: Epoch,
+        signature: &Signature,
+        spec: &ChainSpec,
+    ) -> Result<(), Error> {
+        let i = epoch.as_usize() % spec.latest_randao_mixes_length;
+
+        let signature_hash = Hash256::from_slice(&hash(&ssz_encode(signature)));
+
+        self.latest_randao_mixes[i] = *self.get_randao_mix(epoch, spec)? ^ signature_hash;
+
+        Ok(())
+    }
+
+    /// Return the randao mix at a recent ``epoch``.
+    ///
+    /// # Errors:
+    /// - `InsufficientRandaoMixes` if `self.latest_randao_mixes` is shorter than
+    /// `spec.latest_randao_mixes_length`.
+    /// - `EpochOutOfBounds` if the state no longer stores randao mixes for the given `epoch`.
+    ///
+    /// Spec v0.5.0
+    pub fn get_randao_mix(&self, epoch: Epoch, spec: &ChainSpec) -> Result<&Hash256, Error> {
+        let current_epoch = self.current_epoch(spec);
+
+        if (current_epoch - (spec.latest_randao_mixes_length as u64) < epoch)
+            & (epoch <= current_epoch)
+        {
+            self.latest_randao_mixes
+                .get(epoch.as_usize() % spec.latest_randao_mixes_length)
+                .ok_or_else(|| Error::InsufficientRandaoMixes)
+        } else {
+            Err(Error::EpochOutOfBounds)
+        }
+    }
+
+    /// Safely obtains the index for `latest_active_index_roots`, given some `epoch`.
+    ///
+    /// Spec v0.5.0
+    fn get_active_index_root_index(&self, epoch: Epoch, spec: &ChainSpec) -> Result<usize, Error> {
+        let current_epoch = self.current_epoch(spec);
+
+        if (current_epoch - spec.latest_active_index_roots_length as u64
+            + spec.activation_exit_delay
+            < epoch)
+            & (epoch <= current_epoch + spec.activation_exit_delay)
+        {
+            let i = epoch.as_usize() % spec.latest_active_index_roots_length;
+            if i < self.latest_active_index_roots.len() {
+                Ok(i)
+            } else {
+                Err(Error::InsufficientIndexRoots)
+            }
+        } else {
+            Err(Error::EpochOutOfBounds)
+        }
+    }
+
+    /// Return the `active_index_root` at a recent `epoch`.
+    ///
+    /// Spec v0.5.0
+    pub fn get_active_index_root(&self, epoch: Epoch, spec: &ChainSpec) -> Result<Hash256, Error> {
+        let i = self.get_active_index_root_index(epoch, spec)?;
+        Ok(self.latest_active_index_roots[i])
+    }
+
+    /// Set the `active_index_root` at a recent `epoch`.
+    ///
+    /// Spec v0.5.0
+    pub fn set_active_index_root(
+        &mut self,
+        epoch: Epoch,
+        index_root: Hash256,
+        spec: &ChainSpec,
+    ) -> Result<(), Error> {
+        let i = self.get_active_index_root_index(epoch, spec)?;
+        Ok(self.latest_active_index_roots[i] = index_root)
+    }
+
+    /// Replace `active_index_roots` with clones of `index_root`.
+    ///
+    /// Spec v0.5.0
+    pub fn fill_active_index_roots_with(&mut self, index_root: Hash256, spec: &ChainSpec) {
+        self.latest_active_index_roots =
+            vec![index_root; spec.latest_active_index_roots_length as usize]
+    }
+
+    /// Safely obtains the index for latest state roots, given some `slot`.
+    ///
+    /// Spec v0.5.0
+    fn get_latest_state_roots_index(&self, slot: Slot, spec: &ChainSpec) -> Result<usize, Error> {
+        if (slot < self.slot) && (self.slot <= slot + spec.slots_per_historical_root as u64) {
+            let i = slot.as_usize() % spec.slots_per_historical_root;
+            if i >= self.latest_state_roots.len() {
+                Err(Error::InsufficientStateRoots)
+            } else {
+                Ok(i)
+            }
+        } else {
+            Err(BeaconStateError::SlotOutOfBounds)
+        }
+    }
+
+    /// Gets the state root for some slot.
+    ///
+    /// Spec v0.5.0
+    pub fn get_state_root(&mut self, slot: Slot, spec: &ChainSpec) -> Result<&Hash256, Error> {
+        let i = self.get_latest_state_roots_index(slot, spec)?;
+        Ok(&self.latest_state_roots[i])
+    }
+
+    /// Sets the latest state root for slot.
+    ///
+    /// Spec v0.5.0
+    pub fn set_state_root(
+        &mut self,
+        slot: Slot,
+        state_root: Hash256,
+        spec: &ChainSpec,
+    ) -> Result<(), Error> {
+        let i = self.get_latest_state_roots_index(slot, spec)?;
+        Ok(self.latest_state_roots[i] = state_root)
+    }
+
+    /// Safely obtains the index for `latest_slashed_balances`, given some `epoch`.
+    ///
+    /// Spec v0.5.0
+    fn get_slashed_balance_index(&self, epoch: Epoch, spec: &ChainSpec) -> Result<usize, Error> {
+        let i = epoch.as_usize() % spec.latest_slashed_exit_length;
+
+        // NOTE: the validity of the epoch is not checked. It is not in the spec but it's probably
+        // useful to have.
+        if i < self.latest_slashed_balances.len() {
+            Ok(i)
+        } else {
+            Err(Error::InsufficientSlashedBalances)
+        }
+    }
+
+    /// Gets the total slashed balances for some epoch.
+    ///
+    /// Spec v0.5.0
+    pub fn get_slashed_balance(&self, epoch: Epoch, spec: &ChainSpec) -> Result<u64, Error> {
+        let i = self.get_slashed_balance_index(epoch, spec)?;
+        Ok(self.latest_slashed_balances[i])
+    }
+
+    /// Sets the total slashed balances for some epoch.
+    ///
+    /// Spec v0.5.0
+    pub fn set_slashed_balance(
+        &mut self,
+        epoch: Epoch,
+        balance: u64,
+        spec: &ChainSpec,
+    ) -> Result<(), Error> {
+        let i = self.get_slashed_balance_index(epoch, spec)?;
+        Ok(self.latest_slashed_balances[i] = balance)
+    }
+
+    /// Generate a seed for the given `epoch`.
+    ///
+    /// Spec v0.5.0
+    pub fn generate_seed(&self, epoch: Epoch, spec: &ChainSpec) -> Result<Hash256, Error> {
+        let mut input = self
+            .get_randao_mix(epoch - spec.min_seed_lookahead, spec)?
+            .as_bytes()
+            .to_vec();
+
+        input.append(&mut self.get_active_index_root(epoch, spec)?.as_bytes().to_vec());
+
+        input.append(&mut int_to_bytes32(epoch.as_u64()));
+
+        Ok(Hash256::from_slice(&hash(&input[..])[..]))
+    }
+
+    /// Return the effective balance (also known as "balance at stake") for a validator with the given ``index``.
+    ///
+    /// Spec v0.5.0
+    pub fn get_effective_balance(
+        &self,
+        validator_index: usize,
+        spec: &ChainSpec,
+    ) -> Result<u64, Error> {
+        let balance = self
+            .validator_balances
+            .get(validator_index)
+            .ok_or_else(|| Error::UnknownValidator)?;
+        Ok(std::cmp::min(*balance, spec.max_deposit_amount))
+    }
+
+    ///  Return the epoch at which an activation or exit triggered in ``epoch`` takes effect.
+    ///
+    ///  Spec v0.5.0
+    pub fn get_delayed_activation_exit_epoch(&self, epoch: Epoch, spec: &ChainSpec) -> Epoch {
+        epoch + 1 + spec.activation_exit_delay
+    }
+
+    /// Activate the validator of the given ``index``.
+    ///
+    /// Spec v0.5.0
+    pub fn activate_validator(
+        &mut self,
+        validator_index: usize,
+        is_genesis: bool,
+        spec: &ChainSpec,
+    ) {
+        let current_epoch = self.current_epoch(spec);
+
+        self.validator_registry[validator_index].activation_epoch = if is_genesis {
+            spec.genesis_epoch
+        } else {
+            self.get_delayed_activation_exit_epoch(current_epoch, spec)
+        }
+    }
+
+    /// Initiate an exit for the validator of the given `index`.
+    ///
+    /// Spec v0.5.0
+    pub fn initiate_validator_exit(&mut self, validator_index: usize) {
+        self.validator_registry[validator_index].initiated_exit = true;
+    }
+
+    /// Returns the `slot`, `shard` and `committee_index` for which a validator must produce an
+    /// attestation.
+    ///
+    /// Only reads the current epoch.
+    ///
+    /// Note: Utilizes the cache and will fail if the appropriate cache is not initialized.
+    ///
+    /// Spec v0.5.0
+    pub fn get_attestation_duties(
+        &self,
+        validator_index: usize,
+        spec: &ChainSpec,
+    ) -> Result<&Option<AttestationDuty>, Error> {
+        let cache = self.cache(RelativeEpoch::Current, spec)?;
+
+        Ok(cache
+            .attestation_duties
+            .get(validator_index)
+            .ok_or_else(|| Error::UnknownValidator)?)
+    }
+
+    /// Return the combined effective balance of an array of validators.
+    ///
+    /// Spec v0.5.0
+    pub fn get_total_balance(
+        &self,
+        validator_indices: &[usize],
+        spec: &ChainSpec,
+    ) -> Result<u64, Error> {
+        validator_indices.iter().try_fold(0_u64, |acc, i| {
+            self.get_effective_balance(*i, spec)
+                .and_then(|bal| Ok(bal + acc))
+        })
+    }
+
     /// Build an epoch cache, unless it is has already been built.
     pub fn build_epoch_cache(
         &mut self,
@@ -311,633 +747,6 @@ impl BeaconState {
     pub fn drop_pubkey_cache(&mut self) {
         self.pubkey_cache = PubkeyCache::default()
     }
-
-    /// If a validator pubkey exists in the validator registry, returns `Some(i)`, otherwise
-    /// returns `None`.
-    ///
-    /// Requires a fully up-to-date `pubkey_cache`, returns an error if this is not the case.
-    pub fn get_validator_index(&self, pubkey: &PublicKey) -> Result<Option<usize>, Error> {
-        if self.pubkey_cache.len() == self.validator_registry.len() {
-            Ok(self.pubkey_cache.get(pubkey))
-        } else {
-            Err(Error::PubkeyCacheIncomplete {
-                cache_len: self.pubkey_cache.len(),
-                registry_len: self.validator_registry.len(),
-            })
-        }
-    }
-
-    /// The epoch corresponding to `self.slot`.
-    ///
-    /// Spec v0.5.0
-    pub fn current_epoch(&self, spec: &ChainSpec) -> Epoch {
-        self.slot.epoch(spec.slots_per_epoch)
-    }
-
-    /// The epoch prior to `self.current_epoch()`.
-    ///
-    /// If the current epoch is the genesis epoch, the genesis_epoch is returned.
-    ///
-    /// Spec v0.5.0
-    pub fn previous_epoch(&self, spec: &ChainSpec) -> Epoch {
-        self.current_epoch(&spec) - 1
-    }
-
-    /// The epoch following `self.current_epoch()`.
-    ///
-    /// Spec v0.5.0
-    pub fn next_epoch(&self, spec: &ChainSpec) -> Epoch {
-        self.current_epoch(spec) + 1
-    }
-
-    /// Returns the active validator indices for the given epoch, assuming there is no validator
-    /// registry update in the next epoch.
-    ///
-    /// Note: Utilizes the cache and will fail if the appropriate cache is not initialized.
-    ///
-    /// Spec v0.5.0
-    pub fn get_active_validator_indices(
-        &self,
-        epoch: Epoch,
-        spec: &ChainSpec,
-    ) -> Result<&[usize], Error> {
-        // If the slot is in the next epoch, assume there was no validator registry update.
-        let relative_epoch =
-            match RelativeEpoch::from_epoch(self.slot.epoch(spec.slots_per_epoch), epoch) {
-                Err(RelativeEpochError::AmbiguiousNextEpoch) => {
-                    Ok(RelativeEpoch::NextWithoutRegistryChange)
-                }
-                e => e,
-            }?;
-
-        let cache = self.cache(relative_epoch, spec)?;
-
-        Ok(&cache.active_validator_indices)
-    }
-
-    /// Returns the crosslink committees for some slot.
-    ///
-    /// Note: Utilizes the cache and will fail if the appropriate cache is not initialized.
-    ///
-    /// Spec v0.5.0
-    pub fn get_crosslink_committees_at_slot(
-        &self,
-        slot: Slot,
-        spec: &ChainSpec,
-    ) -> Result<&Vec<CrosslinkCommittee>, Error> {
-        // If the slot is in the next epoch, assume there was no validator registry update.
-        let relative_epoch = match RelativeEpoch::from_slot(self.slot, slot, spec) {
-            Err(RelativeEpochError::AmbiguiousNextEpoch) => {
-                Ok(RelativeEpoch::NextWithoutRegistryChange)
-            }
-            e => e,
-        }?;
-
-        let cache = self.cache(relative_epoch, spec)?;
-
-        Ok(cache
-            .get_crosslink_committees_at_slot(slot, spec)
-            .ok_or_else(|| Error::SlotOutOfBounds)?)
-    }
-
-    /// Returns the crosslink committees for some shard in an epoch.
-    ///
-    /// Note: Utilizes the cache and will fail if the appropriate cache is not initialized.
-    ///
-    /// Spec v0.4.0
-    pub fn get_crosslink_committee_for_shard(
-        &self,
-        epoch: Epoch,
-        shard: Shard,
-        spec: &ChainSpec,
-    ) -> Result<&CrosslinkCommittee, Error> {
-        // If the slot is in the next epoch, assume there was no validator registry update.
-        let relative_epoch = match RelativeEpoch::from_epoch(self.current_epoch(spec), epoch) {
-            Err(RelativeEpochError::AmbiguiousNextEpoch) => {
-                Ok(RelativeEpoch::NextWithoutRegistryChange)
-            }
-            e => e,
-        }?;
-
-        let cache = self.cache(relative_epoch, spec)?;
-
-        Ok(cache
-            .get_crosslink_committee_for_shard(shard, spec)
-            .ok_or_else(|| Error::NoCommitteeForShard)?)
-    }
-
-    /// Safely obtains the index for latest block roots, given some `slot`.
-    ///
-    /// Spec v0.5.0
-    fn get_latest_block_roots_index(&self, slot: Slot, spec: &ChainSpec) -> Result<usize, Error> {
-        if (slot < self.slot) && (self.slot <= slot + spec.slots_per_historical_root as u64) {
-            let i = slot.as_usize() % spec.slots_per_historical_root;
-            if i >= self.latest_block_roots.len() {
-                Err(Error::InsufficientStateRoots)
-            } else {
-                Ok(i)
-            }
-        } else {
-            Err(BeaconStateError::SlotOutOfBounds)
-        }
-    }
-
-    /// Return the block root at a recent `slot`.
-    ///
-    /// Spec v0.5.0
-    pub fn get_block_root(
-        &self,
-        slot: Slot,
-        spec: &ChainSpec,
-    ) -> Result<&Hash256, BeaconStateError> {
-        let i = self.get_latest_block_roots_index(slot, spec)?;
-        Ok(&self.latest_block_roots[i])
-    }
-
-    /// Sets the block root for some given slot.
-    ///
-    /// Spec v0.5.0
-    pub fn set_block_root(
-        &mut self,
-        slot: Slot,
-        block_root: Hash256,
-        spec: &ChainSpec,
-    ) -> Result<(), BeaconStateError> {
-        let i = self.get_latest_block_roots_index(slot, spec)?;
-        Ok(self.latest_block_roots[i] = block_root)
-    }
-
-    /// XOR-assigns the existing `epoch` randao mix with the hash of the `signature`.
-    ///
-    /// # Errors:
-    ///
-    /// See `Self::get_randao_mix`.
-    ///
-    /// Spec v0.5.0
-    pub fn update_randao_mix(
-        &mut self,
-        epoch: Epoch,
-        signature: &Signature,
-        spec: &ChainSpec,
-    ) -> Result<(), Error> {
-        let i = epoch.as_usize() % spec.latest_randao_mixes_length;
-
-        let signature_hash = Hash256::from_slice(&hash(&ssz_encode(signature)));
-
-        self.latest_randao_mixes[i] = *self.get_randao_mix(epoch, spec)? ^ signature_hash;
-
-        Ok(())
-    }
-
-    /// Return the randao mix at a recent ``epoch``.
-    ///
-    /// # Errors:
-    /// - `InsufficientRandaoMixes` if `self.latest_randao_mixes` is shorter than
-    /// `spec.latest_randao_mixes_length`.
-    /// - `EpochOutOfBounds` if the state no longer stores randao mixes for the given `epoch`.
-    ///
-    /// Spec v0.5.0
-    pub fn get_randao_mix(&self, epoch: Epoch, spec: &ChainSpec) -> Result<&Hash256, Error> {
-        let current_epoch = self.current_epoch(spec);
-
-        if (current_epoch - (spec.latest_randao_mixes_length as u64) < epoch)
-            & (epoch <= current_epoch)
-        {
-            self.latest_randao_mixes
-                .get(epoch.as_usize() % spec.latest_randao_mixes_length)
-                .ok_or_else(|| Error::InsufficientRandaoMixes)
-        } else {
-            Err(Error::EpochOutOfBounds)
-        }
-    }
-
-    /// Return the index root at a recent `epoch`.
-    ///
-    /// Spec v0.4.0
-    pub fn get_active_index_root(&self, epoch: Epoch, spec: &ChainSpec) -> Option<Hash256> {
-        let current_epoch = self.current_epoch(spec);
-
-        if (current_epoch - spec.latest_active_index_roots_length as u64
-            + spec.activation_exit_delay
-            < epoch)
-            & (epoch <= current_epoch + spec.activation_exit_delay)
-        {
-            Some(
-                self.latest_active_index_roots
-                    [epoch.as_usize() % spec.latest_active_index_roots_length],
-            )
-        } else {
-            None
-        }
-    }
-
-    /// Safely obtains the index for latest state roots, given some `slot`.
-    ///
-    /// Spec v0.5.0
-    fn get_latest_state_roots_index(&self, slot: Slot, spec: &ChainSpec) -> Result<usize, Error> {
-        if (slot < self.slot) && (self.slot <= slot + spec.slots_per_historical_root as u64) {
-            let i = slot.as_usize() % spec.slots_per_historical_root;
-            if i >= self.latest_state_roots.len() {
-                Err(Error::InsufficientStateRoots)
-            } else {
-                Ok(i)
-            }
-        } else {
-            Err(BeaconStateError::SlotOutOfBounds)
-        }
-    }
-
-    /// Gets the state root for some slot.
-    ///
-    /// Spec v0.5.0
-    pub fn get_state_root(&mut self, slot: Slot, spec: &ChainSpec) -> Result<&Hash256, Error> {
-        let i = self.get_latest_state_roots_index(slot, spec)?;
-        Ok(&self.latest_state_roots[i])
-    }
-
-    /// Sets the latest state root for slot.
-    ///
-    /// Spec v0.5.0
-    pub fn set_state_root(
-        &mut self,
-        slot: Slot,
-        state_root: Hash256,
-        spec: &ChainSpec,
-    ) -> Result<(), Error> {
-        let i = self.get_latest_state_roots_index(slot, spec)?;
-        Ok(self.latest_state_roots[i] = state_root)
-    }
-
-    /// Generate a seed for the given `epoch`.
-    ///
-    /// Spec v0.4.0
-    pub fn generate_seed(&self, epoch: Epoch, spec: &ChainSpec) -> Result<Hash256, Error> {
-        let mut input = self
-            .get_randao_mix(epoch - spec.min_seed_lookahead, spec)?
-            .as_bytes()
-            .to_vec();
-
-        input.append(
-            &mut self
-                .get_active_index_root(epoch, spec)
-                .ok_or_else(|| Error::InsufficientIndexRoots)?
-                .as_bytes()
-                .to_vec(),
-        );
-
-        input.append(&mut int_to_bytes32(epoch.as_u64()));
-
-        Ok(Hash256::from_slice(&hash(&input[..])[..]))
-    }
-
-    /// Returns the beacon proposer index for the `slot`.
-    ///
-    /// If the state does not contain an index for a beacon proposer at the requested `slot`, then `None` is returned.
-    ///
-    /// Spec v0.5.0
-    pub fn get_beacon_proposer_index(
-        &self,
-        slot: Slot,
-        relative_epoch: RelativeEpoch,
-        spec: &ChainSpec,
-    ) -> Result<usize, Error> {
-        let cache = self.cache(relative_epoch, spec)?;
-
-        let committees = cache
-            .get_crosslink_committees_at_slot(slot, spec)
-            .ok_or_else(|| Error::SlotOutOfBounds)?;
-
-        let epoch = slot.epoch(spec.slots_per_epoch);
-
-        committees
-            .first()
-            .ok_or(Error::UnableToDetermineProducer)
-            .and_then(|first| {
-                let index = epoch
-                    .as_usize()
-                    .checked_rem(first.committee.len())
-                    .ok_or(Error::UnableToDetermineProducer)?;
-                Ok(first.committee[index])
-            })
-    }
-
-    /// Return the effective balance (also known as "balance at stake") for a validator with the given ``index``.
-    ///
-    /// Spec v0.4.0
-    pub fn get_effective_balance(
-        &self,
-        validator_index: usize,
-        spec: &ChainSpec,
-    ) -> Result<u64, Error> {
-        let balance = self
-            .validator_balances
-            .get(validator_index)
-            .ok_or_else(|| Error::UnknownValidator)?;
-        Ok(std::cmp::min(*balance, spec.max_deposit_amount))
-    }
-
-    ///  Return the epoch at which an activation or exit triggered in ``epoch`` takes effect.
-    ///
-    ///  Spec v0.4.0
-    pub fn get_delayed_activation_exit_epoch(&self, epoch: Epoch, spec: &ChainSpec) -> Epoch {
-        epoch + 1 + spec.activation_exit_delay
-    }
-
-    /// Activate the validator of the given ``index``.
-    ///
-    /// Spec v0.5.0
-    pub fn activate_validator(
-        &mut self,
-        validator_index: usize,
-        is_genesis: bool,
-        spec: &ChainSpec,
-    ) {
-        let current_epoch = self.current_epoch(spec);
-
-        self.validator_registry[validator_index].activation_epoch = if is_genesis {
-            spec.genesis_epoch
-        } else {
-            self.get_delayed_activation_exit_epoch(current_epoch, spec)
-        }
-    }
-
-    /// Initiate an exit for the validator of the given `index`.
-    ///
-    /// Spec v0.5.0
-    pub fn initiate_validator_exit(&mut self, validator_index: usize) {
-        self.validator_registry[validator_index].initiated_exit = true;
-    }
-
-    /// Exit the validator of the given `index`.
-    ///
-    /// Spec v0.4.0
-    fn exit_validator(&mut self, validator_index: usize, spec: &ChainSpec) {
-        let current_epoch = self.current_epoch(spec);
-        let delayed_epoch = self.get_delayed_activation_exit_epoch(current_epoch, spec);
-
-        if self.validator_registry[validator_index].exit_epoch <= delayed_epoch {
-            return;
-        }
-
-        self.validator_registry[validator_index].exit_epoch = delayed_epoch;
-    }
-
-    /// Slash the validator with index ``index``.
-    ///
-    /// Spec v0.5.0
-    pub fn slash_validator(
-        &mut self,
-        validator_index: usize,
-        spec: &ChainSpec,
-    ) -> Result<(), Error> {
-        let current_epoch = self.current_epoch(spec);
-
-        let validator = &self
-            .validator_registry
-            .get(validator_index)
-            .ok_or_else(|| Error::UnknownValidator)?;
-        let effective_balance = self.get_effective_balance(validator_index, spec)?;
-
-        // A validator that is withdrawn cannot be slashed.
-        //
-        // This constraint will be lifted in Phase 0.
-        if self.slot
-            >= validator
-                .withdrawable_epoch
-                .start_slot(spec.slots_per_epoch)
-        {
-            return Err(Error::ValidatorIsWithdrawable);
-        }
-
-        self.exit_validator(validator_index, spec);
-
-        self.increment_current_epoch_slashed_balances(effective_balance, spec)?;
-
-        let whistleblower_index =
-            self.get_beacon_proposer_index(self.slot, RelativeEpoch::Current, spec)?;
-        let whistleblower_reward = effective_balance / spec.whistleblower_reward_quotient;
-
-        safe_add_assign!(
-            self.validator_balances[whistleblower_index as usize],
-            whistleblower_reward
-        );
-        safe_sub_assign!(
-            self.validator_balances[validator_index],
-            whistleblower_reward
-        );
-
-        self.validator_registry[validator_index].slashed = true;
-
-        self.validator_registry[validator_index].withdrawable_epoch =
-            current_epoch + Epoch::from(spec.latest_slashed_exit_length);
-
-        Ok(())
-    }
-
-    /// Increment `self.latest_slashed_balances` with a slashing from the current epoch.
-    ///
-    /// Spec v0.5.0.
-    fn increment_current_epoch_slashed_balances(
-        &mut self,
-        increment: u64,
-        spec: &ChainSpec,
-    ) -> Result<(), Error> {
-        let current_epoch = self.current_epoch(spec);
-
-        let slashed_balances_index = current_epoch.as_usize() % spec.latest_slashed_exit_length;
-        if slashed_balances_index >= self.latest_slashed_balances.len() {
-            return Err(Error::InsufficientSlashedBalances);
-        }
-
-        self.latest_slashed_balances[slashed_balances_index] += increment;
-
-        Ok(())
-    }
-
-    /// Initiate an exit for the validator of the given `index`.
-    ///
-    /// Spec v0.4.0
-    pub fn prepare_validator_for_withdrawal(&mut self, validator_index: usize, spec: &ChainSpec) {
-        //TODO: we're not ANDing here, we're setting. Potentially wrong.
-        self.validator_registry[validator_index].withdrawable_epoch =
-            self.current_epoch(spec) + spec.min_validator_withdrawability_delay;
-    }
-
-    /// Returns the `slot`, `shard` and `committee_index` for which a validator must produce an
-    /// attestation.
-    ///
-    /// Only reads the current epoch.
-    ///
-    /// Note: Utilizes the cache and will fail if the appropriate cache is not initialized.
-    ///
-    /// Spec v0.4.0
-    pub fn get_attestation_duties(
-        &self,
-        validator_index: usize,
-        spec: &ChainSpec,
-    ) -> Result<&Option<AttestationDuty>, Error> {
-        let cache = self.cache(RelativeEpoch::Current, spec)?;
-
-        Ok(cache
-            .attestation_duties
-            .get(validator_index)
-            .ok_or_else(|| Error::UnknownValidator)?)
-    }
-
-    /// Process slashings.
-    ///
-    /// Note: Utilizes the cache and will fail if the appropriate cache is not initialized.
-    ///
-    /// Spec v0.4.0
-    pub fn process_slashings(&mut self, spec: &ChainSpec) -> Result<(), Error> {
-        let current_epoch = self.current_epoch(spec);
-        let active_validator_indices = self.get_active_validator_indices(current_epoch, spec)?;
-        let total_balance = self.get_total_balance(&active_validator_indices[..], spec)?;
-
-        for (index, validator) in self.validator_registry.iter().enumerate() {
-            if validator.slashed
-                && (current_epoch
-                    == validator.withdrawable_epoch
-                        - Epoch::from(spec.latest_slashed_exit_length / 2))
-            {
-                let epoch_index: usize = current_epoch.as_usize() % spec.latest_slashed_exit_length;
-
-                let total_at_start = self.latest_slashed_balances
-                    [(epoch_index + 1) % spec.latest_slashed_exit_length];
-                let total_at_end = self.latest_slashed_balances[epoch_index];
-                let total_penalities = total_at_end.saturating_sub(total_at_start);
-
-                let effective_balance = self.get_effective_balance(index, spec)?;
-                let penalty = std::cmp::max(
-                    effective_balance * std::cmp::min(total_penalities * 3, total_balance)
-                        / total_balance,
-                    effective_balance / spec.min_penalty_quotient,
-                );
-
-                safe_sub_assign!(self.validator_balances[index], penalty);
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Process the exit queue.
-    ///
-    /// Spec v0.4.0
-    pub fn process_exit_queue(&mut self, spec: &ChainSpec) {
-        let current_epoch = self.current_epoch(spec);
-
-        let eligible = |index: usize| {
-            let validator = &self.validator_registry[index];
-
-            if validator.withdrawable_epoch != spec.far_future_epoch {
-                false
-            } else {
-                current_epoch >= validator.exit_epoch + spec.min_validator_withdrawability_delay
-            }
-        };
-
-        let mut eligable_indices: Vec<usize> = (0..self.validator_registry.len())
-            .filter(|i| eligible(*i))
-            .collect();
-        eligable_indices.sort_by_key(|i| self.validator_registry[*i].exit_epoch);
-
-        for (withdrawn_so_far, index) in eligable_indices.iter().enumerate() {
-            if withdrawn_so_far as u64 >= spec.max_exit_dequeues_per_epoch {
-                break;
-            }
-            self.prepare_validator_for_withdrawal(*index, spec);
-        }
-    }
-
-    /// Update validator registry, activating/exiting validators if possible.
-    ///
-    /// Note: Utilizes the cache and will fail if the appropriate cache is not initialized.
-    ///
-    /// Spec v0.4.0
-    pub fn update_validator_registry(&mut self, spec: &ChainSpec) -> Result<(), Error> {
-        let current_epoch = self.current_epoch(spec);
-        let active_validator_indices = self.get_active_validator_indices(current_epoch, spec)?;
-        let total_balance = self.get_total_balance(&active_validator_indices[..], spec)?;
-
-        let max_balance_churn = std::cmp::max(
-            spec.max_deposit_amount,
-            total_balance / (2 * spec.max_balance_churn_quotient),
-        );
-
-        let mut balance_churn = 0;
-        for index in 0..self.validator_registry.len() {
-            let validator = &self.validator_registry[index];
-
-            if (validator.activation_epoch == spec.far_future_epoch)
-                & (self.validator_balances[index] == spec.max_deposit_amount)
-            {
-                balance_churn += self.get_effective_balance(index, spec)?;
-                if balance_churn > max_balance_churn {
-                    break;
-                }
-                self.activate_validator(index, false, spec);
-            }
-        }
-
-        let mut balance_churn = 0;
-        for index in 0..self.validator_registry.len() {
-            let validator = &self.validator_registry[index];
-
-            if (validator.exit_epoch == spec.far_future_epoch) & (validator.initiated_exit) {
-                balance_churn += self.get_effective_balance(index, spec)?;
-                if balance_churn > max_balance_churn {
-                    break;
-                }
-
-                self.exit_validator(index, spec);
-            }
-        }
-
-        self.validator_registry_update_epoch = current_epoch;
-
-        Ok(())
-    }
-
-    /// Iterate through the validator registry and eject active validators with balance below
-    /// ``EJECTION_BALANCE``.
-    ///
-    /// Spec v0.5.0
-    pub fn process_ejections(&mut self, spec: &ChainSpec) -> Result<(), Error> {
-        // There is an awkward double (triple?) loop here because we can't loop across the borrowed
-        // active validator indices and mutate state in the one loop.
-        let exitable: Vec<usize> = self
-            .get_active_validator_indices(self.current_epoch(spec), spec)?
-            .iter()
-            .filter_map(|&i| {
-                if self.validator_balances[i as usize] < spec.ejection_balance {
-                    Some(i)
-                } else {
-                    None
-                }
-            })
-            .collect();
-
-        for validator_index in exitable {
-            self.exit_validator(validator_index, spec)
-        }
-
-        Ok(())
-    }
-
-    /// Return the combined effective balance of an array of validators.
-    ///
-    /// Spec v0.5.0
-    pub fn get_total_balance(
-        &self,
-        validator_indices: &[usize],
-        spec: &ChainSpec,
-    ) -> Result<u64, Error> {
-        validator_indices.iter().try_fold(0_u64, |acc, i| {
-            self.get_effective_balance(*i, spec)
-                .and_then(|bal| Ok(bal + acc))
-        })
-    }
 }
 
 impl From<RelativeEpochError> for Error {

From 37b8e9f39a50737bd7d74f984fc614d6bf6e5f49 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Tue, 19 Mar 2019 09:09:57 +1100
Subject: [PATCH 54/60] Move `get_active_validator_indices` to state

---
 eth2/fork_choice/src/bitwise_lmd_ghost.rs     |  11 +-
 eth2/fork_choice/src/optimized_lmd_ghost.rs   |  11 +-
 eth2/fork_choice/src/slow_lmd_ghost.rs        |  10 +-
 eth2/fork_choice/tests/tests.rs               |   3 +-
 .../state_processing/src/get_genesis_state.rs |   2 +-
 .../src/per_epoch_processing.rs               |  21 +--
 .../per_epoch_processing/process_ejections.rs |   2 +-
 .../per_epoch_processing/process_slashings.rs |   3 +-
 .../process_validator_registry.rs             |   4 +-
 .../update_validator_registry.rs              |   3 +-
 eth2/types/src/beacon_state.rs                |  27 +--
 .../src/beacon_state/epoch_cache/tests.rs     |   9 +-
 eth2/types/src/beacon_state/pubkey_cache.rs   |  11 +-
 eth2/types/src/chain_spec.rs                  |   2 +-
 eth2/types/src/lib.rs                         |   1 -
 eth2/types/src/transfer.rs                    |   2 +-
 eth2/types/src/validator_registry.rs          | 174 ------------------
 17 files changed, 57 insertions(+), 239 deletions(-)
 delete mode 100644 eth2/types/src/validator_registry.rs

diff --git a/eth2/fork_choice/src/bitwise_lmd_ghost.rs b/eth2/fork_choice/src/bitwise_lmd_ghost.rs
index 9410fd2034..8ae0251d26 100644
--- a/eth2/fork_choice/src/bitwise_lmd_ghost.rs
+++ b/eth2/fork_choice/src/bitwise_lmd_ghost.rs
@@ -10,10 +10,7 @@ use db::{
 use log::{debug, trace};
 use std::collections::HashMap;
 use std::sync::Arc;
-use types::{
-    validator_registry::get_active_validator_indices, BeaconBlock, ChainSpec, Hash256, Slot,
-    SlotHeight,
-};
+use types::{BeaconBlock, ChainSpec, Hash256, Slot, SlotHeight};
 
 //TODO: Pruning - Children
 //TODO: Handle Syncing
@@ -93,10 +90,8 @@ where
             .get_deserialized(&state_root)?
             .ok_or_else(|| ForkChoiceError::MissingBeaconState(*state_root))?;
 
-        let active_validator_indices = get_active_validator_indices(
-            &current_state.validator_registry[..],
-            block_slot.epoch(spec.slots_per_epoch),
-        );
+        let active_validator_indices =
+            current_state.get_active_validator_indices(block_slot.epoch(spec.slots_per_epoch));
 
         for index in active_validator_indices {
             let balance = std::cmp::min(
diff --git a/eth2/fork_choice/src/optimized_lmd_ghost.rs b/eth2/fork_choice/src/optimized_lmd_ghost.rs
index e1b8914a63..ee2919e856 100644
--- a/eth2/fork_choice/src/optimized_lmd_ghost.rs
+++ b/eth2/fork_choice/src/optimized_lmd_ghost.rs
@@ -10,10 +10,7 @@ use log::{debug, trace};
 use std::cmp::Ordering;
 use std::collections::HashMap;
 use std::sync::Arc;
-use types::{
-    validator_registry::get_active_validator_indices, BeaconBlock, ChainSpec, Hash256, Slot,
-    SlotHeight,
-};
+use types::{BeaconBlock, ChainSpec, Hash256, Slot, SlotHeight};
 
 //TODO: Pruning - Children
 //TODO: Handle Syncing
@@ -93,10 +90,8 @@ where
             .get_deserialized(&state_root)?
             .ok_or_else(|| ForkChoiceError::MissingBeaconState(*state_root))?;
 
-        let active_validator_indices = get_active_validator_indices(
-            &current_state.validator_registry[..],
-            block_slot.epoch(spec.slots_per_epoch),
-        );
+        let active_validator_indices =
+            current_state.get_active_validator_indices(block_slot.epoch(spec.slots_per_epoch));
 
         for index in active_validator_indices {
             let balance = std::cmp::min(
diff --git a/eth2/fork_choice/src/slow_lmd_ghost.rs b/eth2/fork_choice/src/slow_lmd_ghost.rs
index af58aa7b83..25d137089e 100644
--- a/eth2/fork_choice/src/slow_lmd_ghost.rs
+++ b/eth2/fork_choice/src/slow_lmd_ghost.rs
@@ -8,9 +8,7 @@ use db::{
 use log::{debug, trace};
 use std::collections::HashMap;
 use std::sync::Arc;
-use types::{
-    validator_registry::get_active_validator_indices, BeaconBlock, ChainSpec, Hash256, Slot,
-};
+use types::{BeaconBlock, ChainSpec, Hash256, Slot};
 
 //TODO: Pruning and syncing
 
@@ -61,10 +59,8 @@ where
             .get_deserialized(&state_root)?
             .ok_or_else(|| ForkChoiceError::MissingBeaconState(*state_root))?;
 
-        let active_validator_indices = get_active_validator_indices(
-            &current_state.validator_registry[..],
-            block_slot.epoch(spec.slots_per_epoch),
-        );
+        let active_validator_indices =
+            current_state.get_active_validator_indices(block_slot.epoch(spec.slots_per_epoch));
 
         for index in active_validator_indices {
             let balance = std::cmp::min(
diff --git a/eth2/fork_choice/tests/tests.rs b/eth2/fork_choice/tests/tests.rs
index 80fbbbe209..3ce63eeb77 100644
--- a/eth2/fork_choice/tests/tests.rs
+++ b/eth2/fork_choice/tests/tests.rs
@@ -242,8 +242,9 @@ fn setup_inital_state(
 
     let spec = ChainSpec::foundation();
 
-    let state_builder =
+    let mut state_builder =
         TestingBeaconStateBuilder::from_single_keypair(num_validators, &Keypair::random(), &spec);
+    state_builder.build_caches(&spec).unwrap();
     let (state, _keypairs) = state_builder.build();
 
     let state_root = state.canonical_root();
diff --git a/eth2/state_processing/src/get_genesis_state.rs b/eth2/state_processing/src/get_genesis_state.rs
index bfcf822164..7c4d4cafd0 100644
--- a/eth2/state_processing/src/get_genesis_state.rs
+++ b/eth2/state_processing/src/get_genesis_state.rs
@@ -34,7 +34,7 @@ pub fn get_genesis_state(
 
     // Set all the active index roots to be the genesis active index root.
     let active_validator_indices = state
-        .get_active_validator_indices(spec.genesis_epoch, spec)?
+        .get_cached_active_validator_indices(RelativeEpoch::Current, spec)?
         .to_vec();
     let genesis_active_index_root = Hash256::from_slice(&active_validator_indices.hash_tree_root());
     state.fill_active_index_roots_with(genesis_active_index_root, spec);
diff --git a/eth2/state_processing/src/per_epoch_processing.rs b/eth2/state_processing/src/per_epoch_processing.rs
index 97a0e9987f..8e03457d3e 100644
--- a/eth2/state_processing/src/per_epoch_processing.rs
+++ b/eth2/state_processing/src/per_epoch_processing.rs
@@ -7,7 +7,7 @@ use process_validator_registry::process_validator_registry;
 use rayon::prelude::*;
 use ssz::TreeHash;
 use std::collections::HashMap;
-use types::{validator_registry::get_active_validator_indices, *};
+use types::*;
 use validator_statuses::{TotalBalances, ValidatorStatuses};
 use winning_root::{winning_root, WinningRoot};
 
@@ -70,16 +70,6 @@ pub fn per_epoch_processing(state: &mut BeaconState, spec: &ChainSpec) -> Result
     Ok(())
 }
 
-/// Returns a list of active validator indices for the state's current epoch.
-///
-/// Spec v0.5.0
-pub fn calculate_active_validator_indices(state: &BeaconState, spec: &ChainSpec) -> Vec<usize> {
-    get_active_validator_indices(
-        &state.validator_registry,
-        state.slot.epoch(spec.slots_per_epoch),
-    )
-}
-
 /// Calculates various sets of attesters, including:
 ///
 /// - current epoch attesters
@@ -454,11 +444,10 @@ pub fn update_active_tree_index_roots(
 ) -> Result<(), Error> {
     let next_epoch = state.next_epoch(spec);
 
-    let active_tree_root = get_active_validator_indices(
-        &state.validator_registry,
-        next_epoch + Epoch::from(spec.activation_exit_delay),
-    )
-    .hash_tree_root();
+    let active_tree_root = state
+        .get_active_validator_indices(next_epoch + Epoch::from(spec.activation_exit_delay))
+        .to_vec()
+        .hash_tree_root();
 
     state.set_active_index_root(next_epoch, Hash256::from_slice(&active_tree_root[..]), spec)?;
 
diff --git a/eth2/state_processing/src/per_epoch_processing/process_ejections.rs b/eth2/state_processing/src/per_epoch_processing/process_ejections.rs
index 27dd37479d..a60d92187c 100644
--- a/eth2/state_processing/src/per_epoch_processing/process_ejections.rs
+++ b/eth2/state_processing/src/per_epoch_processing/process_ejections.rs
@@ -9,7 +9,7 @@ pub fn process_ejections(state: &mut BeaconState, spec: &ChainSpec) -> Result<()
     // There is an awkward double (triple?) loop here because we can't loop across the borrowed
     // active validator indices and mutate state in the one loop.
     let exitable: Vec<usize> = state
-        .get_active_validator_indices(state.current_epoch(spec), spec)?
+        .get_cached_active_validator_indices(RelativeEpoch::Current, spec)?
         .iter()
         .filter_map(|&i| {
             if state.validator_balances[i as usize] < spec.ejection_balance {
diff --git a/eth2/state_processing/src/per_epoch_processing/process_slashings.rs b/eth2/state_processing/src/per_epoch_processing/process_slashings.rs
index b14a9ee373..19c1e519b3 100644
--- a/eth2/state_processing/src/per_epoch_processing/process_slashings.rs
+++ b/eth2/state_processing/src/per_epoch_processing/process_slashings.rs
@@ -7,7 +7,8 @@ use types::{BeaconStateError as Error, *};
 /// Spec v0.4.0
 pub fn process_slashings(state: &mut BeaconState, spec: &ChainSpec) -> Result<(), Error> {
     let current_epoch = state.current_epoch(spec);
-    let active_validator_indices = state.get_active_validator_indices(current_epoch, spec)?;
+    let active_validator_indices =
+        state.get_cached_active_validator_indices(RelativeEpoch::Current, spec)?;
     let total_balance = state.get_total_balance(&active_validator_indices[..], spec)?;
 
     for (index, validator) in state.validator_registry.iter().enumerate() {
diff --git a/eth2/state_processing/src/per_epoch_processing/process_validator_registry.rs b/eth2/state_processing/src/per_epoch_processing/process_validator_registry.rs
index 2eb39711d2..85d6c37f63 100644
--- a/eth2/state_processing/src/per_epoch_processing/process_validator_registry.rs
+++ b/eth2/state_processing/src/per_epoch_processing/process_validator_registry.rs
@@ -21,7 +21,7 @@ pub fn process_validator_registry(state: &mut BeaconState, spec: &ChainSpec) ->
         state.current_shuffling_start_shard = (state.current_shuffling_start_shard
             + spec.get_epoch_committee_count(
                 state
-                    .get_active_validator_indices(current_epoch, spec)?
+                    .get_cached_active_validator_indices(RelativeEpoch::Current, spec)?
                     .len(),
             ) as u64)
             % spec.shard_count;
@@ -53,7 +53,7 @@ pub fn should_update_validator_registry(
     }
 
     let num_active_validators = state
-        .get_active_validator_indices(state.current_epoch(spec), spec)?
+        .get_cached_active_validator_indices(RelativeEpoch::Current, spec)?
         .len();
     let current_epoch_committee_count = spec.get_epoch_committee_count(num_active_validators);
 
diff --git a/eth2/state_processing/src/per_epoch_processing/update_validator_registry.rs b/eth2/state_processing/src/per_epoch_processing/update_validator_registry.rs
index 8b612c3463..ecf05ce6f0 100644
--- a/eth2/state_processing/src/per_epoch_processing/update_validator_registry.rs
+++ b/eth2/state_processing/src/per_epoch_processing/update_validator_registry.rs
@@ -8,7 +8,8 @@ use types::{BeaconStateError as Error, *};
 /// Spec v0.4.0
 pub fn update_validator_registry(state: &mut BeaconState, spec: &ChainSpec) -> Result<(), Error> {
     let current_epoch = state.current_epoch(spec);
-    let active_validator_indices = state.get_active_validator_indices(current_epoch, spec)?;
+    let active_validator_indices =
+        state.get_cached_active_validator_indices(RelativeEpoch::Current, spec)?;
     let total_balance = state.get_total_balance(&active_validator_indices[..], spec)?;
 
     let max_balance_churn = std::cmp::max(
diff --git a/eth2/types/src/beacon_state.rs b/eth2/types/src/beacon_state.rs
index 30f95c02c2..22e7c6ecf0 100644
--- a/eth2/types/src/beacon_state.rs
+++ b/eth2/types/src/beacon_state.rs
@@ -1,4 +1,4 @@
-use self::epoch_cache::{EpochCache, Error as EpochCacheError};
+use self::epoch_cache::{get_active_validator_indices, EpochCache, Error as EpochCacheError};
 use crate::test_utils::TestRandom;
 use crate::*;
 use int_to_bytes::int_to_bytes32;
@@ -234,28 +234,31 @@ impl BeaconState {
     /// Returns the active validator indices for the given epoch, assuming there is no validator
     /// registry update in the next epoch.
     ///
+    /// This uses the cache, so it saves an iteration over the validator registry, however it can
+    /// not return a result for any epoch before the previous epoch.
+    ///
     /// Note: Utilizes the cache and will fail if the appropriate cache is not initialized.
     ///
     /// Spec v0.5.0
-    pub fn get_active_validator_indices(
+    pub fn get_cached_active_validator_indices(
         &self,
-        epoch: Epoch,
+        relative_epoch: RelativeEpoch,
         spec: &ChainSpec,
     ) -> Result<&[usize], Error> {
-        // If the slot is in the next epoch, assume there was no validator registry update.
-        let relative_epoch =
-            match RelativeEpoch::from_epoch(self.slot.epoch(spec.slots_per_epoch), epoch) {
-                Err(RelativeEpochError::AmbiguiousNextEpoch) => {
-                    Ok(RelativeEpoch::NextWithoutRegistryChange)
-                }
-                e => e,
-            }?;
-
         let cache = self.cache(relative_epoch, spec)?;
 
         Ok(&cache.active_validator_indices)
     }
 
+    /// Returns the active validator indices for the given epoch.
+    ///
+    /// Does not utilize the cache, performs a full iteration over the validator registry.
+    ///
+    /// Spec v0.5.0
+    pub fn get_active_validator_indices(&self, epoch: Epoch) -> Vec<usize> {
+        get_active_validator_indices(&self.validator_registry, epoch)
+    }
+
     /// Returns the crosslink committees for some slot.
     ///
     /// Note: Utilizes the cache and will fail if the appropriate cache is not initialized.
diff --git a/eth2/types/src/beacon_state/epoch_cache/tests.rs b/eth2/types/src/beacon_state/epoch_cache/tests.rs
index 10df635f28..5643776e2b 100644
--- a/eth2/types/src/beacon_state/epoch_cache/tests.rs
+++ b/eth2/types/src/beacon_state/epoch_cache/tests.rs
@@ -7,15 +7,19 @@ use swap_or_not_shuffle::shuffle_list;
 fn do_sane_cache_test(
     state: BeaconState,
     epoch: Epoch,
+    relative_epoch: RelativeEpoch,
     validator_count: usize,
     expected_seed: Hash256,
     expected_shuffling_start: u64,
     spec: &ChainSpec,
 ) {
     let active_indices: Vec<usize> = (0..validator_count).collect();
+
     assert_eq!(
         &active_indices[..],
-        state.get_active_validator_indices(epoch, &spec).unwrap(),
+        state
+            .get_cached_active_validator_indices(relative_epoch, &spec)
+            .unwrap(),
         "Validator indices mismatch"
     );
 
@@ -101,6 +105,7 @@ fn builds_sane_current_epoch_cache() {
     do_sane_cache_test(
         state.clone(),
         state.current_epoch(&spec),
+        RelativeEpoch::Current,
         validator_count as usize,
         state.current_shuffling_seed,
         state.current_shuffling_start_shard,
@@ -117,6 +122,7 @@ fn builds_sane_previous_epoch_cache() {
     do_sane_cache_test(
         state.clone(),
         state.previous_epoch(&spec),
+        RelativeEpoch::Previous,
         validator_count as usize,
         state.previous_shuffling_seed,
         state.previous_shuffling_start_shard,
@@ -134,6 +140,7 @@ fn builds_sane_next_without_update_epoch_cache() {
     do_sane_cache_test(
         state.clone(),
         state.next_epoch(&spec),
+        RelativeEpoch::NextWithoutRegistryChange,
         validator_count as usize,
         state.current_shuffling_seed,
         state.current_shuffling_start_shard,
diff --git a/eth2/types/src/beacon_state/pubkey_cache.rs b/eth2/types/src/beacon_state/pubkey_cache.rs
index 340bdb3119..4632a2d9c1 100644
--- a/eth2/types/src/beacon_state/pubkey_cache.rs
+++ b/eth2/types/src/beacon_state/pubkey_cache.rs
@@ -6,13 +6,17 @@ type ValidatorIndex = usize;
 
 #[derive(Debug, PartialEq, Clone, Default, Serialize, Deserialize)]
 pub struct PubkeyCache {
+    /// Maintain the number of keys added to the map. It is not sufficient to just use the HashMap
+    /// len, as it does not increase when duplicate keys are added. Duplicate keys are used during
+    /// testing.
+    len: usize,
     map: HashMap<PublicKey, ValidatorIndex>,
 }
 
 impl PubkeyCache {
-    /// Returns the number of validator indices already in the map.
+    /// Returns the number of validator indices added to the map so far.
     pub fn len(&self) -> ValidatorIndex {
-        self.map.len()
+        self.len
     }
 
     /// Inserts a validator index into the map.
@@ -20,8 +24,9 @@ impl PubkeyCache {
     /// The added index must equal the number of validators already added to the map. This ensures
     /// that an index is never skipped.
     pub fn insert(&mut self, pubkey: PublicKey, index: ValidatorIndex) -> bool {
-        if index == self.map.len() {
+        if index == self.len {
             self.map.insert(pubkey, index);
+            self.len += 1;
             true
         } else {
             false
diff --git a/eth2/types/src/chain_spec.rs b/eth2/types/src/chain_spec.rs
index e9ade2c913..cfb88bcb83 100644
--- a/eth2/types/src/chain_spec.rs
+++ b/eth2/types/src/chain_spec.rs
@@ -117,7 +117,7 @@ pub struct ChainSpec {
 impl ChainSpec {
     /// Return the number of committees in one epoch.
     ///
-    /// Spec v0.4.0
+    /// Spec v0.5.0
     pub fn get_epoch_committee_count(&self, active_validator_count: usize) -> u64 {
         std::cmp::max(
             1,
diff --git a/eth2/types/src/lib.rs b/eth2/types/src/lib.rs
index 05f8254d5c..30b0e4a132 100644
--- a/eth2/types/src/lib.rs
+++ b/eth2/types/src/lib.rs
@@ -34,7 +34,6 @@ pub mod relative_epoch;
 pub mod slot_epoch;
 pub mod slot_height;
 pub mod validator;
-pub mod validator_registry;
 
 use ethereum_types::{H160, H256, U256};
 use std::collections::HashMap;
diff --git a/eth2/types/src/transfer.rs b/eth2/types/src/transfer.rs
index 1c99687029..2570d7b3f9 100644
--- a/eth2/types/src/transfer.rs
+++ b/eth2/types/src/transfer.rs
@@ -9,7 +9,7 @@ use test_random_derive::TestRandom;
 
 /// The data submitted to the deposit contract.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 #[derive(
     Debug,
     PartialEq,
diff --git a/eth2/types/src/validator_registry.rs b/eth2/types/src/validator_registry.rs
deleted file mode 100644
index db35ae9936..0000000000
--- a/eth2/types/src/validator_registry.rs
+++ /dev/null
@@ -1,174 +0,0 @@
-/// Contains logic to manipulate a `&[Validator]`.
-/// For now, we avoid defining a newtype and just have flat functions here.
-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> {
-    let mut active = Vec::with_capacity(validators.len());
-
-    for (index, validator) in validators.iter().enumerate() {
-        if validator.is_active_at(epoch) {
-            active.push(index)
-        }
-    }
-
-    active.shrink_to_fit();
-
-    active
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-
-    #[test]
-    fn can_get_empty_active_validator_indices() {
-        let mut rng = XorShiftRng::from_seed([42; 16]);
-
-        let validators = vec![];
-        let some_epoch = Epoch::random_for_test(&mut rng);
-        let indices = get_active_validator_indices(&validators, some_epoch);
-        assert_eq!(indices, vec![]);
-    }
-
-    #[test]
-    fn can_get_no_active_validator_indices() {
-        let mut rng = XorShiftRng::from_seed([42; 16]);
-        let mut validators = vec![];
-        let count_validators = 10;
-        for _ in 0..count_validators {
-            validators.push(Validator::default())
-        }
-
-        let some_epoch = Epoch::random_for_test(&mut rng);
-        let indices = get_active_validator_indices(&validators, some_epoch);
-        assert_eq!(indices, vec![]);
-    }
-
-    #[test]
-    fn can_get_all_active_validator_indices() {
-        let mut rng = XorShiftRng::from_seed([42; 16]);
-        let count_validators = 10;
-        let some_epoch = Epoch::random_for_test(&mut rng);
-
-        let mut validators = (0..count_validators)
-            .into_iter()
-            .map(|_| {
-                let mut validator = Validator::default();
-
-                let activation_offset = u64::random_for_test(&mut rng);
-                let exit_offset = u64::random_for_test(&mut rng);
-
-                validator.activation_epoch = some_epoch - activation_offset;
-                validator.exit_epoch = some_epoch + exit_offset;
-
-                validator
-            })
-            .collect::<Vec<_>>();
-
-        // test boundary condition by ensuring that at least one validator in the list just activated
-        if let Some(validator) = validators.get_mut(0) {
-            validator.activation_epoch = some_epoch;
-        }
-
-        let indices = get_active_validator_indices(&validators, some_epoch);
-        assert_eq!(
-            indices,
-            (0..count_validators).into_iter().collect::<Vec<_>>()
-        );
-    }
-
-    fn set_validators_to_default_entry_exit(validators: &mut [Validator]) {
-        for validator in validators.iter_mut() {
-            validator.activation_epoch = Epoch::max_value();
-            validator.exit_epoch = Epoch::max_value();
-        }
-    }
-
-    // sets all `validators` to be active as of some epoch prior to `epoch`. returns the activation epoch.
-    fn set_validators_to_activated(validators: &mut [Validator], epoch: Epoch) -> Epoch {
-        let activation_epoch = epoch - 10;
-        for validator in validators.iter_mut() {
-            validator.activation_epoch = activation_epoch;
-        }
-        activation_epoch
-    }
-
-    // sets all `validators` to be exited as of some epoch before `epoch`.
-    fn set_validators_to_exited(
-        validators: &mut [Validator],
-        epoch: Epoch,
-        activation_epoch: Epoch,
-    ) {
-        assert!(activation_epoch < epoch);
-        let mut exit_epoch = activation_epoch + 10;
-        while exit_epoch >= epoch {
-            exit_epoch -= 1;
-        }
-        assert!(activation_epoch < exit_epoch && exit_epoch < epoch);
-
-        for validator in validators.iter_mut() {
-            validator.exit_epoch = exit_epoch;
-        }
-    }
-
-    #[test]
-    fn can_get_some_active_validator_indices() {
-        let mut rng = XorShiftRng::from_seed([42; 16]);
-        const COUNT_PARTITIONS: usize = 3;
-        const COUNT_VALIDATORS: usize = 3 * COUNT_PARTITIONS;
-        let some_epoch: Epoch = Epoch::random_for_test(&mut rng);
-
-        let mut validators = (0..COUNT_VALIDATORS)
-            .into_iter()
-            .map(|_| {
-                let mut validator = Validator::default();
-
-                let activation_offset = Epoch::random_for_test(&mut rng);
-                let exit_offset = Epoch::random_for_test(&mut rng);
-
-                validator.activation_epoch = some_epoch - activation_offset;
-                validator.exit_epoch = some_epoch + exit_offset;
-
-                validator
-            })
-            .collect::<Vec<_>>();
-
-        // we partition the set into partitions based on lifecycle:
-        for (i, chunk) in validators.chunks_exact_mut(COUNT_PARTITIONS).enumerate() {
-            match i {
-                0 => {
-                    // 1. not activated (Default::default())
-                    set_validators_to_default_entry_exit(chunk);
-                }
-                1 => {
-                    // 2. activated, but not exited
-                    set_validators_to_activated(chunk, some_epoch);
-                    // test boundary condition by ensuring that at least one validator in the list just activated
-                    if let Some(validator) = chunk.get_mut(0) {
-                        validator.activation_epoch = some_epoch;
-                    }
-                }
-                2 => {
-                    // 3. exited
-                    let activation_epoch = set_validators_to_activated(chunk, some_epoch);
-                    set_validators_to_exited(chunk, some_epoch, activation_epoch);
-                    // test boundary condition by ensuring that at least one validator in the list just exited
-                    if let Some(validator) = chunk.get_mut(0) {
-                        validator.exit_epoch = some_epoch;
-                    }
-                }
-                _ => unreachable!(
-                    "constants local to this test not in sync with generation of test case"
-                ),
-            }
-        }
-
-        let indices = get_active_validator_indices(&validators, some_epoch);
-        assert_eq!(indices, vec![3, 4, 5]);
-    }
-}

From d20fb93f0cd927526881dbaad439c3d827e2d644 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Tue, 19 Mar 2019 17:16:33 +1100
Subject: [PATCH 55/60] Update rewards processing to v0.5.0

---
 .../src/per_epoch_processing.rs               | 309 +++--------------
 .../src/per_epoch_processing/apply_rewards.rs | 317 ++++++++++++++++++
 .../src/per_epoch_processing/errors.rs        |   1 +
 .../validator_statuses.rs                     |  41 ++-
 4 files changed, 393 insertions(+), 275 deletions(-)
 create mode 100644 eth2/state_processing/src/per_epoch_processing/apply_rewards.rs

diff --git a/eth2/state_processing/src/per_epoch_processing.rs b/eth2/state_processing/src/per_epoch_processing.rs
index 8e03457d3e..24f4a1e1ff 100644
--- a/eth2/state_processing/src/per_epoch_processing.rs
+++ b/eth2/state_processing/src/per_epoch_processing.rs
@@ -1,16 +1,16 @@
+use apply_rewards::apply_rewards;
 use errors::EpochProcessingError as Error;
-use integer_sqrt::IntegerSquareRoot;
 use process_ejections::process_ejections;
 use process_exit_queue::process_exit_queue;
 use process_slashings::process_slashings;
 use process_validator_registry::process_validator_registry;
-use rayon::prelude::*;
 use ssz::TreeHash;
 use std::collections::HashMap;
 use types::*;
 use validator_statuses::{TotalBalances, ValidatorStatuses};
 use winning_root::{winning_root, WinningRoot};
 
+pub mod apply_rewards;
 pub mod errors;
 pub mod get_attestation_participants;
 pub mod inclusion_distance;
@@ -43,13 +43,13 @@ pub fn per_epoch_processing(state: &mut BeaconState, spec: &ChainSpec) -> Result
 
     process_eth1_data(state, spec);
 
-    process_justification(state, &statuses.total_balances, spec);
+    update_justification_and_finalization(state, &statuses.total_balances, spec)?;
 
     // Crosslinks
     let winning_root_for_shards = process_crosslinks(state, spec)?;
 
     // Rewards and Penalities
-    process_rewards_and_penalities(state, &mut statuses, &winning_root_for_shards, spec)?;
+    apply_rewards(state, &mut statuses, &winning_root_for_shards, spec)?;
 
     // Ejections
     process_ejections(state, spec)?;
@@ -62,7 +62,7 @@ pub fn per_epoch_processing(state: &mut BeaconState, spec: &ChainSpec) -> Result
     // Final updates
     update_active_tree_index_roots(state, spec)?;
     update_latest_slashed_balances(state, spec)?;
-    clean_attestations(state);
+    state.previous_epoch_attestations = vec![];
 
     // Rotate the epoch caches to suit the epoch transition.
     state.advance_caches();
@@ -113,83 +113,68 @@ pub fn process_eth1_data(state: &mut BeaconState, spec: &ChainSpec) {
 /// - `justified_epoch`
 /// - `previous_justified_epoch`
 ///
-/// Spec v0.4.0
-pub fn process_justification(
+/// Spec v0.5.0
+pub fn update_justification_and_finalization(
     state: &mut BeaconState,
     total_balances: &TotalBalances,
     spec: &ChainSpec,
-) {
+) -> Result<(), Error> {
     let previous_epoch = state.previous_epoch(spec);
     let current_epoch = state.current_epoch(spec);
 
     let mut new_justified_epoch = state.current_justified_epoch;
+    let mut new_finalized_epoch = state.finalized_epoch;
+
+    // Rotate the justification bitfield up one epoch to make room for the current 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 * total_balances.previous_epoch_boundary_attesters) >= (2 * total_balances.previous_epoch)
+    // If the previous epoch gets justified, full the second last bit.
+    if (total_balances.previous_epoch_boundary_attesters * 3) >= (total_balances.previous_epoch * 2)
     {
-        state.justification_bitfield |= 2;
         new_justified_epoch = previous_epoch;
+        state.justification_bitfield |= 2;
     }
-    // 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 * total_balances.current_epoch_boundary_attesters) >= (2 * total_balances.current_epoch) {
-        state.justification_bitfield |= 1;
+    // If the current epoch gets justified, fill the last bit.
+    if (total_balances.current_epoch_boundary_attesters * 3) >= (total_balances.current_epoch * 2) {
         new_justified_epoch = current_epoch;
+        state.justification_bitfield |= 1;
     }
 
-    // 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;
+    let bitfield = state.justification_bitfield;
+
+    // The 2nd/3rd/4th most recent epochs are all justified, the 2nd using the 4th as source.
+    if ((bitfield >> 1) % 8 == 0b111) & (state.previous_justified_epoch == current_epoch - 3) {
+        new_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;
+    // The 2nd/3rd most recent epochs are both justified, the 2nd using the 3rd as source.
+    if ((bitfield >> 1) % 4 == 0b11) & (state.previous_justified_epoch == current_epoch - 2) {
+        new_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.current_justified_epoch == previous_epoch - 1)
-    {
-        state.finalized_epoch = state.current_justified_epoch;
+    // The 1st/2nd/3rd most recent epochs are all justified, the 1st using the 2nd as source.
+    if (bitfield % 8 == 0b111) & (state.current_justified_epoch == current_epoch - 2) {
+        new_finalized_epoch = state.current_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.current_justified_epoch == previous_epoch)
-    {
-        state.finalized_epoch = state.current_justified_epoch;
+    // The 1st/2nd most recent epochs are both justified, the 1st using the 2nd as source.
+    if (bitfield % 4 == 0b11) & (state.current_justified_epoch == current_epoch - 1) {
+        new_finalized_epoch = state.current_justified_epoch;
     }
 
     state.previous_justified_epoch = state.current_justified_epoch;
-    state.current_justified_epoch = new_justified_epoch;
+    state.previous_justified_root = state.current_justified_root;
+
+    if new_justified_epoch != state.current_justified_epoch {
+        state.current_justified_epoch = new_justified_epoch;
+        state.current_justified_root =
+            *state.get_block_root(new_justified_epoch.start_slot(spec.slots_per_epoch), spec)?;
+    }
+
+    if new_finalized_epoch != state.finalized_epoch {
+        state.finalized_epoch = new_finalized_epoch;
+        state.finalized_root =
+            *state.get_block_root(new_finalized_epoch.start_slot(spec.slots_per_epoch), spec)?;
+    }
+
+    Ok(())
 }
 
 /// Updates the following fields on the `BeaconState`:
@@ -239,201 +224,6 @@ pub fn process_crosslinks(
     Ok(winning_root_for_shards)
 }
 
-/// Updates the following fields on the BeaconState:
-///
-/// - `validator_balances`
-///
-/// Spec v0.4.0
-pub fn process_rewards_and_penalities(
-    state: &mut BeaconState,
-    statuses: &mut ValidatorStatuses,
-    winning_root_for_shards: &WinningRootHashSet,
-    spec: &ChainSpec,
-) -> Result<(), Error> {
-    let next_epoch = state.next_epoch(spec);
-
-    statuses.process_winning_roots(state, winning_root_for_shards, spec)?;
-
-    let total_balances = &statuses.total_balances;
-
-    let base_reward_quotient =
-        total_balances.previous_epoch.integer_sqrt() / spec.base_reward_quotient;
-
-    // Guard against a divide-by-zero during the validator balance update.
-    if base_reward_quotient == 0 {
-        return Err(Error::BaseRewardQuotientIsZero);
-    }
-    // Guard against a divide-by-zero during the validator balance update.
-    if total_balances.previous_epoch == 0 {
-        return Err(Error::PreviousTotalBalanceIsZero);
-    }
-    // Guard against an out-of-bounds during the validator balance update.
-    if statuses.statuses.len() != state.validator_balances.len() {
-        return Err(Error::ValidatorStatusesInconsistent);
-    }
-
-    // Justification and finalization
-
-    let epochs_since_finality = next_epoch - state.finalized_epoch;
-
-    state.validator_balances = state
-        .validator_balances
-        .par_iter()
-        .enumerate()
-        .map(|(index, &balance)| {
-            let mut balance = balance;
-            let status = &statuses.statuses[index];
-            let base_reward = get_base_reward(state, index, total_balances.previous_epoch, spec)
-                .expect(
-                    "Cannot fail to access a validator balance when iterating validator balances.",
-                );
-
-            if epochs_since_finality <= 4 {
-                // Expected FFG source
-                if status.is_previous_epoch_attester {
-                    safe_add_assign!(
-                        balance,
-                        base_reward * total_balances.previous_epoch_attesters
-                            / total_balances.previous_epoch
-                    );
-                } else if status.is_active_in_previous_epoch {
-                    safe_sub_assign!(balance, base_reward);
-                }
-
-                // Expected FFG target
-                if status.is_previous_epoch_boundary_attester {
-                    safe_add_assign!(
-                        balance,
-                        base_reward * total_balances.previous_epoch_boundary_attesters
-                            / total_balances.previous_epoch
-                    );
-                } else if status.is_active_in_previous_epoch {
-                    safe_sub_assign!(balance, base_reward);
-                }
-
-                // Expected beacon chain head
-                if status.is_previous_epoch_head_attester {
-                    safe_add_assign!(
-                        balance,
-                        base_reward * total_balances.previous_epoch_head_attesters
-                            / total_balances.previous_epoch
-                    );
-                } else if status.is_active_in_previous_epoch {
-                    safe_sub_assign!(balance, base_reward);
-                };
-            } else {
-                let inactivity_penalty = get_inactivity_penalty(
-                    state,
-                    index,
-                    epochs_since_finality.as_u64(),
-                    total_balances.previous_epoch,
-                    spec,
-                )
-                .expect(
-                    "Cannot fail to access a validator balance when iterating validator balances.",
-                );
-
-                if status.is_active_in_previous_epoch {
-                    if !status.is_previous_epoch_attester {
-                        safe_sub_assign!(balance, inactivity_penalty);
-                    }
-                    if !status.is_previous_epoch_boundary_attester {
-                        safe_sub_assign!(balance, inactivity_penalty);
-                    }
-                    if !status.is_previous_epoch_head_attester {
-                        safe_sub_assign!(balance, inactivity_penalty);
-                    }
-
-                    if state.validator_registry[index].slashed {
-                        let base_reward =
-                            get_base_reward(state, index, total_balances.previous_epoch, spec).expect(
-                                "Cannot fail to access a validator balance when iterating validator balances.",
-                            );
-                        safe_sub_assign!(balance, 2 * inactivity_penalty + base_reward);
-                    }
-                }
-            }
-
-            // Crosslinks
-
-            if let Some(ref info) = status.winning_root_info {
-                safe_add_assign!(
-                    balance,
-                    base_reward * info.total_attesting_balance / info.total_committee_balance
-                );
-            } else {
-                safe_sub_assign!(balance, base_reward);
-            }
-
-            balance
-        })
-        .collect();
-
-    // Attestation inclusion
-
-    // Guard against an out-of-bounds during the attester inclusion balance update.
-    if statuses.statuses.len() != state.validator_registry.len() {
-        return Err(Error::ValidatorStatusesInconsistent);
-    }
-
-    for (index, _validator) in state.validator_registry.iter().enumerate() {
-        let status = &statuses.statuses[index];
-
-        if status.is_previous_epoch_attester {
-            let proposer_index = status.inclusion_info.proposer_index;
-            let inclusion_distance = status.inclusion_info.distance;
-
-            let base_reward =
-                get_base_reward(state, proposer_index, total_balances.previous_epoch, spec).expect(
-                    "Cannot fail to access a validator balance when iterating validator balances.",
-                );
-
-            if inclusion_distance > 0 && inclusion_distance < Slot::max_value() {
-                safe_add_assign!(
-                    state.validator_balances[proposer_index],
-                    base_reward * spec.min_attestation_inclusion_delay
-                        / inclusion_distance.as_u64()
-                )
-            }
-        }
-    }
-
-    Ok(())
-}
-
-/// Returns the base reward for some validator.
-///
-/// Spec v0.5.0
-pub fn get_base_reward(
-    state: &BeaconState,
-    index: usize,
-    previous_total_balance: u64,
-    spec: &ChainSpec,
-) -> Result<u64, BeaconStateError> {
-    if previous_total_balance == 0 {
-        Ok(0)
-    } else {
-        let adjusted_quotient = previous_total_balance.integer_sqrt() / spec.base_reward_quotient;
-        Ok(state.get_effective_balance(index, spec)? / adjusted_quotient / 5)
-    }
-}
-
-/// Returns the inactivity penalty for some validator.
-///
-/// Spec v0.5.0
-pub fn get_inactivity_penalty(
-    state: &BeaconState,
-    index: usize,
-    epochs_since_finality: u64,
-    previous_total_balance: u64,
-    spec: &ChainSpec,
-) -> Result<u64, BeaconStateError> {
-    Ok(get_base_reward(state, index, previous_total_balance, spec)?
-        + state.get_effective_balance(index, spec)? * epochs_since_finality
-            / spec.inactivity_penalty_quotient
-            / 2)
-}
-
 /// Updates the state's `latest_active_index_roots` field with a tree hash the active validator
 /// indices for the next epoch.
 ///
@@ -472,10 +262,3 @@ pub fn update_latest_slashed_balances(
 
     Ok(())
 }
-
-/// Removes all pending attestations from the previous epoch.
-///
-/// Spec v0.4.0
-pub fn clean_attestations(state: &mut BeaconState) {
-    state.previous_epoch_attestations = vec![];
-}
diff --git a/eth2/state_processing/src/per_epoch_processing/apply_rewards.rs b/eth2/state_processing/src/per_epoch_processing/apply_rewards.rs
new file mode 100644
index 0000000000..5254e0710e
--- /dev/null
+++ b/eth2/state_processing/src/per_epoch_processing/apply_rewards.rs
@@ -0,0 +1,317 @@
+use super::validator_statuses::{TotalBalances, ValidatorStatus, ValidatorStatuses};
+use super::{Error, WinningRootHashSet};
+use integer_sqrt::IntegerSquareRoot;
+use types::*;
+
+#[derive(Default, Clone)]
+pub struct Delta {
+    pub rewards: u64,
+    pub penalties: u64,
+}
+
+impl std::ops::AddAssign for Delta {
+    /// Use wrapping addition as that is how it's defined in the spec.
+    fn add_assign(&mut self, other: Delta) {
+        self.rewards += other.rewards;
+        self.penalties += other.penalties;
+    }
+}
+
+/// Apply attester and proposer rewards.
+///
+/// Spec v0.5.0
+pub fn apply_rewards(
+    state: &mut BeaconState,
+    validator_statuses: &mut ValidatorStatuses,
+    winning_root_for_shards: &WinningRootHashSet,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    // Guard against an out-of-bounds during the validator balance update.
+    if validator_statuses.statuses.len() != state.validator_balances.len() {
+        return Err(Error::ValidatorStatusesInconsistent);
+    }
+    // Guard against an out-of-bounds during the attester inclusion balance update.
+    if validator_statuses.statuses.len() != state.validator_registry.len() {
+        return Err(Error::ValidatorStatusesInconsistent);
+    }
+
+    let mut deltas = vec![Delta::default(); state.validator_balances.len()];
+
+    get_justification_and_finalization_deltas(&mut deltas, state, &validator_statuses, spec)?;
+    get_crosslink_deltas(&mut deltas, state, &validator_statuses, spec)?;
+
+    // Apply the proposer deltas if we are finalizing normally.
+    //
+    // This is executed slightly differently to the spec because of the way our functions are
+    // structured. It should be functionally equivalent.
+    if epochs_since_finality(state, spec) <= 4 {
+        get_proposer_deltas(
+            &mut deltas,
+            state,
+            validator_statuses,
+            winning_root_for_shards,
+            spec,
+        )?;
+    }
+
+    // Apply the deltas, over-flowing but not under-flowing (saturating at 0 instead).
+    for (i, delta) in deltas.iter().enumerate() {
+        state.validator_balances[i] += delta.rewards;
+        state.validator_balances[i] = state.validator_balances[i].saturating_sub(delta.penalties);
+    }
+
+    Ok(())
+}
+
+/// Applies the attestation inclusion reward to each proposer for every validator who included an
+/// attestation in the previous epoch.
+///
+/// Spec v0.5.0
+fn get_proposer_deltas(
+    deltas: &mut Vec<Delta>,
+    state: &mut BeaconState,
+    validator_statuses: &mut ValidatorStatuses,
+    winning_root_for_shards: &WinningRootHashSet,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    // Update statuses with the information from winning roots.
+    validator_statuses.process_winning_roots(state, winning_root_for_shards, spec)?;
+
+    for (index, validator) in validator_statuses.statuses.iter().enumerate() {
+        let mut delta = Delta::default();
+
+        if validator.is_previous_epoch_attester {
+            let inclusion = validator
+                .inclusion_info
+                .expect("It is a logic error for an attester not to have an inclusion distance.");
+
+            let base_reward = get_base_reward(
+                state,
+                inclusion.proposer_index,
+                validator_statuses.total_balances.previous_epoch,
+                spec,
+            )?;
+
+            if inclusion.proposer_index >= deltas.len() {
+                return Err(Error::ValidatorStatusesInconsistent);
+            }
+
+            delta.rewards += base_reward / spec.attestation_inclusion_reward_quotient;
+        }
+
+        deltas[index] += delta;
+    }
+
+    Ok(())
+}
+
+/// Apply rewards for participation in attestations during the previous epoch.
+///
+/// Spec v0.5.0
+fn get_justification_and_finalization_deltas(
+    deltas: &mut Vec<Delta>,
+    state: &BeaconState,
+    validator_statuses: &ValidatorStatuses,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    let epochs_since_finality = epochs_since_finality(state, spec);
+
+    for (index, validator) in validator_statuses.statuses.iter().enumerate() {
+        let base_reward = get_base_reward(
+            state,
+            index,
+            validator_statuses.total_balances.previous_epoch,
+            spec,
+        )?;
+        let inactivity_penalty = get_inactivity_penalty(
+            state,
+            index,
+            epochs_since_finality.as_u64(),
+            validator_statuses.total_balances.previous_epoch,
+            spec,
+        )?;
+
+        let delta = if epochs_since_finality <= 4 {
+            compute_normal_justification_and_finalization_delta(
+                &validator,
+                &validator_statuses.total_balances,
+                base_reward,
+                spec,
+            )
+        } else {
+            compute_inactivity_leak_delta(&validator, base_reward, inactivity_penalty, spec)
+        };
+
+        deltas[index] += delta;
+    }
+
+    Ok(())
+}
+
+/// Determine the delta for a single validator, if the chain is finalizing normally.
+///
+/// Spec v0.5.0
+fn compute_normal_justification_and_finalization_delta(
+    validator: &ValidatorStatus,
+    total_balances: &TotalBalances,
+    base_reward: u64,
+    spec: &ChainSpec,
+) -> Delta {
+    let mut delta = Delta::default();
+
+    let boundary_attesting_balance = total_balances.previous_epoch_boundary_attesters;
+    let total_balance = total_balances.previous_epoch;
+    let total_attesting_balance = total_balances.previous_epoch_attesters;
+    let matching_head_balance = total_balances.previous_epoch_boundary_attesters;
+
+    // Expected FFG source.
+    if validator.is_previous_epoch_attester {
+        delta.rewards += base_reward * total_attesting_balance / total_balance;
+        // Inclusion speed bonus
+        let inclusion = validator
+            .inclusion_info
+            .expect("It is a logic error for an attester not to have an inclusion distance.");
+        delta.rewards +=
+            base_reward * spec.min_attestation_inclusion_delay / inclusion.distance.as_u64();
+    } else if validator.is_active_in_previous_epoch {
+        delta.penalties += base_reward;
+    }
+
+    // Expected FFG target.
+    if validator.is_previous_epoch_boundary_attester {
+        delta.rewards += base_reward / boundary_attesting_balance / total_balance;
+    } else if validator.is_active_in_previous_epoch {
+        delta.penalties += base_reward;
+    }
+
+    // Expected head.
+    if validator.is_previous_epoch_head_attester {
+        delta.rewards += base_reward * matching_head_balance / total_balance;
+    } else if validator.is_active_in_previous_epoch {
+        delta.penalties += base_reward;
+    };
+
+    // Proposer bonus is handled in `apply_proposer_deltas`.
+    //
+    // This function only computes the delta for a single validator, so it cannot also return a
+    // delta for a validator.
+
+    delta
+}
+
+/// Determine the delta for a single delta, assuming the chain is _not_ finalizing normally.
+///
+/// Spec v0.5.0
+fn compute_inactivity_leak_delta(
+    validator: &ValidatorStatus,
+    base_reward: u64,
+    inactivity_penalty: u64,
+    spec: &ChainSpec,
+) -> Delta {
+    let mut delta = Delta::default();
+
+    if validator.is_active_in_previous_epoch {
+        if !validator.is_previous_epoch_attester {
+            delta.penalties += inactivity_penalty;
+        } else {
+            // If a validator did attest, apply a small penalty for getting attestations included
+            // late.
+            let inclusion = validator
+                .inclusion_info
+                .expect("It is a logic error for an attester not to have an inclusion distance.");
+            delta.rewards +=
+                base_reward * spec.min_attestation_inclusion_delay / inclusion.distance.as_u64();
+            delta.penalties += base_reward;
+        }
+
+        if !validator.is_previous_epoch_boundary_attester {
+            delta.penalties += inactivity_penalty;
+        }
+
+        if !validator.is_previous_epoch_head_attester {
+            delta.penalties += inactivity_penalty;
+        }
+    }
+
+    // Penalize slashed-but-inactive validators as though they were active but offline.
+    if !validator.is_active_in_previous_epoch
+        & validator.is_slashed
+        & !validator.is_withdrawable_in_current_epoch
+    {
+        delta.penalties += 2 * inactivity_penalty + base_reward;
+    }
+
+    delta
+}
+
+/// Calculate the deltas based upon the winning roots for attestations during the previous epoch.
+///
+/// Spec v0.5.0
+fn get_crosslink_deltas(
+    deltas: &mut Vec<Delta>,
+    state: &BeaconState,
+    validator_statuses: &ValidatorStatuses,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    for (index, validator) in validator_statuses.statuses.iter().enumerate() {
+        let mut delta = Delta::default();
+
+        let base_reward = get_base_reward(
+            state,
+            index,
+            validator_statuses.total_balances.previous_epoch,
+            spec,
+        )?;
+
+        if let Some(ref winning_root) = validator.winning_root_info {
+            delta.rewards += base_reward * winning_root.total_attesting_balance
+                / winning_root.total_committee_balance
+        } else {
+            delta.penalties += base_reward;
+        }
+
+        deltas[index] += delta;
+    }
+
+    Ok(())
+}
+
+/// Returns the base reward for some validator.
+///
+/// Spec v0.5.0
+fn get_base_reward(
+    state: &BeaconState,
+    index: usize,
+    previous_total_balance: u64,
+    spec: &ChainSpec,
+) -> Result<u64, BeaconStateError> {
+    if previous_total_balance == 0 {
+        Ok(0)
+    } else {
+        let adjusted_quotient = previous_total_balance.integer_sqrt() / spec.base_reward_quotient;
+        Ok(state.get_effective_balance(index, spec)? / adjusted_quotient / 5)
+    }
+}
+
+/// Returns the inactivity penalty for some validator.
+///
+/// Spec v0.5.0
+fn get_inactivity_penalty(
+    state: &BeaconState,
+    index: usize,
+    epochs_since_finality: u64,
+    previous_total_balance: u64,
+    spec: &ChainSpec,
+) -> Result<u64, BeaconStateError> {
+    Ok(get_base_reward(state, index, previous_total_balance, spec)?
+        + state.get_effective_balance(index, spec)? * epochs_since_finality
+            / spec.inactivity_penalty_quotient
+            / 2)
+}
+
+/// Returns the epochs since the last finalized epoch.
+///
+/// Spec v0.5.0
+fn epochs_since_finality(state: &BeaconState, spec: &ChainSpec) -> Epoch {
+    state.current_epoch(spec) + 1 - state.finalized_epoch
+}
diff --git a/eth2/state_processing/src/per_epoch_processing/errors.rs b/eth2/state_processing/src/per_epoch_processing/errors.rs
index 94fc0cca5b..4632e83bb5 100644
--- a/eth2/state_processing/src/per_epoch_processing/errors.rs
+++ b/eth2/state_processing/src/per_epoch_processing/errors.rs
@@ -9,6 +9,7 @@ pub enum EpochProcessingError {
     PreviousTotalBalanceIsZero,
     InclusionDistanceZero,
     ValidatorStatusesInconsistent,
+    DeltasInconsistent,
     /// Unable to get the inclusion distance for a validator that should have an inclusion
     /// distance. This indicates an internal inconsistency.
     ///
diff --git a/eth2/state_processing/src/per_epoch_processing/validator_statuses.rs b/eth2/state_processing/src/per_epoch_processing/validator_statuses.rs
index bcbca82440..50f3ec3727 100644
--- a/eth2/state_processing/src/per_epoch_processing/validator_statuses.rs
+++ b/eth2/state_processing/src/per_epoch_processing/validator_statuses.rs
@@ -23,7 +23,7 @@ pub struct WinningRootInfo {
 }
 
 /// The information required to reward a block producer for including an attestation in a block.
-#[derive(Clone)]
+#[derive(Clone, Copy)]
 pub struct InclusionInfo {
     /// The earliest slot a validator had an attestation included in the previous epoch.
     pub slot: Slot,
@@ -59,7 +59,11 @@ impl InclusionInfo {
 
 /// Information required to reward some validator during the current and previous epoch.
 #[derive(Default, Clone)]
-pub struct AttesterStatus {
+pub struct ValidatorStatus {
+    /// True if the validator has been slashed, ever.
+    pub is_slashed: bool,
+    /// True if the validator can withdraw in the current epoch.
+    pub is_withdrawable_in_current_epoch: bool,
     /// True if the validator was active in the state's _current_ epoch.
     pub is_active_in_current_epoch: bool,
     /// True if the validator was active in the state's _previous_ epoch.
@@ -81,14 +85,14 @@ pub struct AttesterStatus {
 
     /// Information used to reward the block producer of this validators earliest-included
     /// attestation.
-    pub inclusion_info: InclusionInfo,
+    pub inclusion_info: Option<InclusionInfo>,
     /// Information used to reward/penalize the validator if they voted in the super-majority for
     /// some shard block.
     pub winning_root_info: Option<WinningRootInfo>,
 }
 
-impl AttesterStatus {
-    /// Accepts some `other` `AttesterStatus` and updates `self` if required.
+impl ValidatorStatus {
+    /// Accepts some `other` `ValidatorStatus` and updates `self` if required.
     ///
     /// Will never set one of the `bool` fields to `false`, it will only set it to `true` if other
     /// contains a `true` field.
@@ -97,6 +101,8 @@ impl AttesterStatus {
     pub fn update(&mut self, other: &Self) {
         // Update all the bool fields, only updating `self` if `other` is true (never setting
         // `self` to false).
+        set_self_if_other_is_true!(self, other, is_slashed);
+        set_self_if_other_is_true!(self, other, is_withdrawable_in_current_epoch);
         set_self_if_other_is_true!(self, other, is_active_in_current_epoch);
         set_self_if_other_is_true!(self, other, is_active_in_previous_epoch);
         set_self_if_other_is_true!(self, other, is_current_epoch_attester);
@@ -105,7 +111,13 @@ impl AttesterStatus {
         set_self_if_other_is_true!(self, other, is_previous_epoch_boundary_attester);
         set_self_if_other_is_true!(self, other, is_previous_epoch_head_attester);
 
-        self.inclusion_info.update(&other.inclusion_info);
+        if let Some(other_info) = other.inclusion_info {
+            if let Some(self_info) = self.inclusion_info.as_mut() {
+                self_info.update(&other_info);
+            } else {
+                self.inclusion_info = other.inclusion_info;
+            }
+        }
     }
 }
 
@@ -137,7 +149,7 @@ pub struct TotalBalances {
 #[derive(Clone)]
 pub struct ValidatorStatuses {
     /// Information about each individual validator from the state's validator registy.
-    pub statuses: Vec<AttesterStatus>,
+    pub statuses: Vec<ValidatorStatus>,
     /// Summed balances for various sets of validators.
     pub total_balances: TotalBalances,
 }
@@ -154,7 +166,12 @@ impl ValidatorStatuses {
         let mut total_balances = TotalBalances::default();
 
         for (i, validator) in state.validator_registry.iter().enumerate() {
-            let mut status = AttesterStatus::default();
+            let mut status = ValidatorStatus {
+                is_slashed: validator.slashed,
+                is_withdrawable_in_current_epoch: validator
+                    .is_withdrawable_at(state.current_epoch(spec)),
+                ..ValidatorStatus::default()
+            };
 
             if validator.is_active_at(state.current_epoch(spec)) {
                 status.is_active_in_current_epoch = true;
@@ -193,10 +210,10 @@ impl ValidatorStatuses {
                 get_attestation_participants(state, &a.data, &a.aggregation_bitfield, spec)?;
             let attesting_balance = state.get_total_balance(&attesting_indices, spec)?;
 
-            let mut status = AttesterStatus::default();
+            let mut status = ValidatorStatus::default();
 
             // Profile this attestation, updating the total balances and generating an
-            // `AttesterStatus` object that applies to all participants in the attestation.
+            // `ValidatorStatus` object that applies to all participants in the attestation.
             if is_from_epoch(a, state.current_epoch(spec), spec) {
                 self.total_balances.current_epoch_attesters += attesting_balance;
                 status.is_current_epoch_attester = true;
@@ -211,7 +228,7 @@ impl ValidatorStatuses {
 
                 // The inclusion slot and distance are only required for previous epoch attesters.
                 let relative_epoch = RelativeEpoch::from_slot(state.slot, a.data.slot, spec)?;
-                status.inclusion_info = InclusionInfo {
+                status.inclusion_info = Some(InclusionInfo {
                     slot: a.inclusion_slot,
                     distance: inclusion_distance(a),
                     proposer_index: state.get_beacon_proposer_index(
@@ -219,7 +236,7 @@ impl ValidatorStatuses {
                         relative_epoch,
                         spec,
                     )?,
-                };
+                });
 
                 if has_common_epoch_boundary_root(a, state, state.previous_epoch(spec), spec)? {
                     self.total_balances.previous_epoch_boundary_attesters += attesting_balance;

From 61f6fe25e7760ef60d1ee58207211a7493096a66 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Tue, 19 Mar 2019 17:26:20 +1100
Subject: [PATCH 56/60] Tidy reward processing

---
 .../src/per_epoch_processing/apply_rewards.rs | 59 ++++++++++++-------
 1 file changed, 38 insertions(+), 21 deletions(-)

diff --git a/eth2/state_processing/src/per_epoch_processing/apply_rewards.rs b/eth2/state_processing/src/per_epoch_processing/apply_rewards.rs
index 5254e0710e..ce5fccb210 100644
--- a/eth2/state_processing/src/per_epoch_processing/apply_rewards.rs
+++ b/eth2/state_processing/src/per_epoch_processing/apply_rewards.rs
@@ -3,10 +3,23 @@ use super::{Error, WinningRootHashSet};
 use integer_sqrt::IntegerSquareRoot;
 use types::*;
 
+/// Use to track the changes to a validators balance.
 #[derive(Default, Clone)]
 pub struct Delta {
-    pub rewards: u64,
-    pub penalties: u64,
+    rewards: u64,
+    penalties: u64,
+}
+
+impl Delta {
+    /// Reward the validator with the `reward`.
+    pub fn reward(&mut self, reward: u64) {
+        self.rewards += reward;
+    }
+
+    /// Penalize the validator with the `penalty`.
+    pub fn penalize(&mut self, penalty: u64) {
+        self.penalties += penalty;
+    }
 }
 
 impl std::ops::AddAssign for Delta {
@@ -96,7 +109,7 @@ fn get_proposer_deltas(
                 return Err(Error::ValidatorStatusesInconsistent);
             }
 
-            delta.rewards += base_reward / spec.attestation_inclusion_reward_quotient;
+            delta.reward(base_reward / spec.attestation_inclusion_reward_quotient);
         }
 
         deltas[index] += delta;
@@ -166,29 +179,30 @@ fn compute_normal_justification_and_finalization_delta(
 
     // Expected FFG source.
     if validator.is_previous_epoch_attester {
-        delta.rewards += base_reward * total_attesting_balance / total_balance;
+        delta.reward(base_reward * total_attesting_balance / total_balance);
         // Inclusion speed bonus
         let inclusion = validator
             .inclusion_info
             .expect("It is a logic error for an attester not to have an inclusion distance.");
-        delta.rewards +=
-            base_reward * spec.min_attestation_inclusion_delay / inclusion.distance.as_u64();
+        delta.reward(
+            base_reward * spec.min_attestation_inclusion_delay / inclusion.distance.as_u64(),
+        );
     } else if validator.is_active_in_previous_epoch {
-        delta.penalties += base_reward;
+        delta.penalize(base_reward);
     }
 
     // Expected FFG target.
     if validator.is_previous_epoch_boundary_attester {
-        delta.rewards += base_reward / boundary_attesting_balance / total_balance;
+        delta.reward(base_reward / boundary_attesting_balance / total_balance);
     } else if validator.is_active_in_previous_epoch {
-        delta.penalties += base_reward;
+        delta.penalize(base_reward);
     }
 
     // Expected head.
     if validator.is_previous_epoch_head_attester {
-        delta.rewards += base_reward * matching_head_balance / total_balance;
+        delta.reward(base_reward * matching_head_balance / total_balance);
     } else if validator.is_active_in_previous_epoch {
-        delta.penalties += base_reward;
+        delta.penalize(base_reward);
     };
 
     // Proposer bonus is handled in `apply_proposer_deltas`.
@@ -212,24 +226,25 @@ fn compute_inactivity_leak_delta(
 
     if validator.is_active_in_previous_epoch {
         if !validator.is_previous_epoch_attester {
-            delta.penalties += inactivity_penalty;
+            delta.penalize(inactivity_penalty);
         } else {
             // If a validator did attest, apply a small penalty for getting attestations included
             // late.
             let inclusion = validator
                 .inclusion_info
                 .expect("It is a logic error for an attester not to have an inclusion distance.");
-            delta.rewards +=
-                base_reward * spec.min_attestation_inclusion_delay / inclusion.distance.as_u64();
-            delta.penalties += base_reward;
+            delta.reward(
+                base_reward * spec.min_attestation_inclusion_delay / inclusion.distance.as_u64(),
+            );
+            delta.penalize(base_reward);
         }
 
         if !validator.is_previous_epoch_boundary_attester {
-            delta.penalties += inactivity_penalty;
+            delta.reward(inactivity_penalty);
         }
 
         if !validator.is_previous_epoch_head_attester {
-            delta.penalties += inactivity_penalty;
+            delta.penalize(inactivity_penalty);
         }
     }
 
@@ -238,7 +253,7 @@ fn compute_inactivity_leak_delta(
         & validator.is_slashed
         & !validator.is_withdrawable_in_current_epoch
     {
-        delta.penalties += 2 * inactivity_penalty + base_reward;
+        delta.penalize(2 * inactivity_penalty + base_reward);
     }
 
     delta
@@ -264,10 +279,12 @@ fn get_crosslink_deltas(
         )?;
 
         if let Some(ref winning_root) = validator.winning_root_info {
-            delta.rewards += base_reward * winning_root.total_attesting_balance
-                / winning_root.total_committee_balance
+            delta.reward(
+                base_reward * winning_root.total_attesting_balance
+                    / winning_root.total_committee_balance,
+            );
         } else {
-            delta.penalties += base_reward;
+            delta.penalize(base_reward);
         }
 
         deltas[index] += delta;

From 35b90728c72dfc043ed4aacba8919014f01a4c08 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Tue, 19 Mar 2019 19:27:10 +1100
Subject: [PATCH 57/60] Push more epoch processing fns to 0.5.0

---
 .../src/common/verify_bitfield.rs             |   2 +-
 .../src/per_epoch_processing.rs               | 122 +++++++-------
 .../process_validator_registry.rs             |  70 --------
 .../update_registry_and_shuffling_data.rs     | 151 ++++++++++++++++++
 .../update_validator_registry.rs              |  52 ------
 eth2/types/src/beacon_state.rs                |  74 +++++----
 6 files changed, 252 insertions(+), 219 deletions(-)
 delete mode 100644 eth2/state_processing/src/per_epoch_processing/process_validator_registry.rs
 create mode 100644 eth2/state_processing/src/per_epoch_processing/update_registry_and_shuffling_data.rs
 delete mode 100644 eth2/state_processing/src/per_epoch_processing/update_validator_registry.rs

diff --git a/eth2/state_processing/src/common/verify_bitfield.rs b/eth2/state_processing/src/common/verify_bitfield.rs
index 8ff5c96ca3..03fcdbb671 100644
--- a/eth2/state_processing/src/common/verify_bitfield.rs
+++ b/eth2/state_processing/src/common/verify_bitfield.rs
@@ -4,7 +4,7 @@ use types::*;
 ///
 /// Is title `verify_bitfield` in spec.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 pub fn verify_bitfield_length(bitfield: &Bitfield, committee_size: usize) -> bool {
     if bitfield.num_bytes() != ((committee_size + 7) / 8) {
         return false;
diff --git a/eth2/state_processing/src/per_epoch_processing.rs b/eth2/state_processing/src/per_epoch_processing.rs
index 24f4a1e1ff..b917510f2e 100644
--- a/eth2/state_processing/src/per_epoch_processing.rs
+++ b/eth2/state_processing/src/per_epoch_processing.rs
@@ -3,10 +3,10 @@ use errors::EpochProcessingError as Error;
 use process_ejections::process_ejections;
 use process_exit_queue::process_exit_queue;
 use process_slashings::process_slashings;
-use process_validator_registry::process_validator_registry;
 use ssz::TreeHash;
 use std::collections::HashMap;
 use types::*;
+use update_registry_and_shuffling_data::update_registry_and_shuffling_data;
 use validator_statuses::{TotalBalances, ValidatorStatuses};
 use winning_root::{winning_root, WinningRoot};
 
@@ -17,9 +17,8 @@ pub mod inclusion_distance;
 pub mod process_ejections;
 pub mod process_exit_queue;
 pub mod process_slashings;
-pub mod process_validator_registry;
 pub mod tests;
-pub mod update_validator_registry;
+pub mod update_registry_and_shuffling_data;
 pub mod validator_statuses;
 pub mod winning_root;
 
@@ -39,30 +38,34 @@ pub fn per_epoch_processing(state: &mut BeaconState, spec: &ChainSpec) -> Result
     state.build_epoch_cache(RelativeEpoch::Previous, spec)?;
     state.build_epoch_cache(RelativeEpoch::Current, spec)?;
 
-    let mut statuses = initialize_validator_statuses(&state, spec)?;
+    // Load the struct we use to assign validators into sets based on their participation.
+    //
+    // E.g., attestation in the previous epoch, attested to the head, etc.
+    let mut statuses = ValidatorStatuses::new(state, spec)?;
+    statuses.process_attestations(&state, spec)?;
 
     process_eth1_data(state, spec);
 
     update_justification_and_finalization(state, &statuses.total_balances, spec)?;
 
-    // Crosslinks
+    // Crosslinks.
     let winning_root_for_shards = process_crosslinks(state, spec)?;
 
-    // Rewards and Penalities
+    // Rewards and Penalities.
     apply_rewards(state, &mut statuses, &winning_root_for_shards, spec)?;
 
-    // Ejections
+    // Ejections.
     process_ejections(state, spec)?;
 
-    // Validator Registry
-    process_validator_registry(state, spec)?;
+    // Validator Registry.
+    update_registry_and_shuffling_data(state, statuses.total_balances.current_epoch, spec)?;
+
+    // Slashings and exit queue.
     process_slashings(state, spec)?;
     process_exit_queue(state, spec);
 
-    // Final updates
-    update_active_tree_index_roots(state, spec)?;
-    update_latest_slashed_balances(state, spec)?;
-    state.previous_epoch_attestations = vec![];
+    // Final updates.
+    finish_epoch_update(state, spec)?;
 
     // Rotate the epoch caches to suit the epoch transition.
     state.advance_caches();
@@ -70,25 +73,6 @@ pub fn per_epoch_processing(state: &mut BeaconState, spec: &ChainSpec) -> Result
     Ok(())
 }
 
-/// Calculates various sets of attesters, including:
-///
-/// - current epoch attesters
-/// - current epoch boundary attesters
-/// - previous epoch attesters
-/// - etc.
-///
-/// Spec v0.5.0
-pub fn initialize_validator_statuses(
-    state: &BeaconState,
-    spec: &ChainSpec,
-) -> Result<ValidatorStatuses, BeaconStateError> {
-    let mut statuses = ValidatorStatuses::new(state, spec)?;
-
-    statuses.process_attestations(&state, spec)?;
-
-    Ok(statuses)
-}
-
 /// Maybe resets the eth1 period.
 ///
 /// Spec v0.5.0
@@ -224,41 +208,53 @@ pub fn process_crosslinks(
     Ok(winning_root_for_shards)
 }
 
-/// Updates the state's `latest_active_index_roots` field with a tree hash the active validator
-/// indices for the next epoch.
+/// Finish up an epoch update.
 ///
-/// Spec v0.4.0
-pub fn update_active_tree_index_roots(
-    state: &mut BeaconState,
-    spec: &ChainSpec,
-) -> Result<(), Error> {
-    let next_epoch = state.next_epoch(spec);
-
-    let active_tree_root = state
-        .get_active_validator_indices(next_epoch + Epoch::from(spec.activation_exit_delay))
-        .to_vec()
-        .hash_tree_root();
-
-    state.set_active_index_root(next_epoch, Hash256::from_slice(&active_tree_root[..]), spec)?;
-
-    Ok(())
-}
-
-/// Advances the state's `latest_slashed_balances` field.
-///
-/// Spec v0.4.0
-pub fn update_latest_slashed_balances(
-    state: &mut BeaconState,
-    spec: &ChainSpec,
-) -> Result<(), Error> {
+/// Spec v0.5.0
+pub fn finish_epoch_update(state: &mut BeaconState, spec: &ChainSpec) -> Result<(), Error> {
     let current_epoch = state.current_epoch(spec);
     let next_epoch = state.next_epoch(spec);
 
-    state.set_slashed_balance(
-        next_epoch,
-        state.get_slashed_balance(current_epoch, spec)?,
-        spec,
-    )?;
+    // This is a hack to allow us to update index roots and slashed balances for the next epoch.
+    //
+    // The indentation here is to make it obvious where the weird stuff happens.
+    {
+        state.slot += 1;
+
+        // Set active index root
+        let active_index_root = Hash256::from_slice(
+            &state
+                .get_active_validator_indices(next_epoch + spec.activation_exit_delay)
+                .hash_tree_root()[..],
+        );
+        state.set_active_index_root(next_epoch, active_index_root, spec)?;
+
+        // Set total slashed balances
+        state.set_slashed_balance(
+            next_epoch,
+            state.get_slashed_balance(current_epoch, spec)?,
+            spec,
+        )?;
+
+        // Set randao mix
+        state.set_randao_mix(
+            next_epoch,
+            *state.get_randao_mix(current_epoch, spec)?,
+            spec,
+        )?;
+
+        state.slot -= 1;
+    }
+
+    if next_epoch.as_u64() % (spec.slots_per_historical_root as u64 / spec.slots_per_epoch) == 0 {
+        let historical_batch: HistoricalBatch = state.historical_batch();
+        state
+            .historical_roots
+            .push(Hash256::from_slice(&historical_batch.hash_tree_root()[..]));
+    }
+
+    state.previous_epoch_attestations = state.current_epoch_attestations.clone();
+    state.current_epoch_attestations = vec![];
 
     Ok(())
 }
diff --git a/eth2/state_processing/src/per_epoch_processing/process_validator_registry.rs b/eth2/state_processing/src/per_epoch_processing/process_validator_registry.rs
deleted file mode 100644
index 85d6c37f63..0000000000
--- a/eth2/state_processing/src/per_epoch_processing/process_validator_registry.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-use super::update_validator_registry::update_validator_registry;
-use super::Error;
-use types::*;
-
-/// Peforms a validator registry update, if required.
-///
-/// Spec v0.4.0
-pub 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;
-
-    if should_update_validator_registry(state, spec)? {
-        update_validator_registry(state, spec)?;
-
-        state.current_shuffling_epoch = next_epoch;
-        state.current_shuffling_start_shard = (state.current_shuffling_start_shard
-            + spec.get_epoch_committee_count(
-                state
-                    .get_cached_active_validator_indices(RelativeEpoch::Current, spec)?
-                    .len(),
-            ) 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)?
-        }
-    }
-
-    Ok(())
-}
-
-/// Returns `true` if the validator registry should be updated during an epoch processing.
-///
-/// Spec v0.5.0
-pub fn should_update_validator_registry(
-    state: &BeaconState,
-    spec: &ChainSpec,
-) -> Result<bool, BeaconStateError> {
-    if state.finalized_epoch <= state.validator_registry_update_epoch {
-        return Ok(false);
-    }
-
-    let num_active_validators = state
-        .get_cached_active_validator_indices(RelativeEpoch::Current, spec)?
-        .len();
-    let current_epoch_committee_count = spec.get_epoch_committee_count(num_active_validators);
-
-    for shard in (0..current_epoch_committee_count)
-        .into_iter()
-        .map(|i| (state.current_shuffling_start_shard + i as u64) % spec.shard_count)
-    {
-        if state.latest_crosslinks[shard as usize].epoch <= state.validator_registry_update_epoch {
-            return Ok(false);
-        }
-    }
-
-    Ok(true)
-}
diff --git a/eth2/state_processing/src/per_epoch_processing/update_registry_and_shuffling_data.rs b/eth2/state_processing/src/per_epoch_processing/update_registry_and_shuffling_data.rs
new file mode 100644
index 0000000000..286ad81408
--- /dev/null
+++ b/eth2/state_processing/src/per_epoch_processing/update_registry_and_shuffling_data.rs
@@ -0,0 +1,151 @@
+use super::super::common::exit_validator;
+use super::Error;
+use types::*;
+
+/// Peforms a validator registry update, if required.
+///
+/// Spec v0.5.0
+pub fn update_registry_and_shuffling_data(
+    state: &mut BeaconState,
+    current_total_balance: u64,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    // First set previous shuffling data to current shuffling data.
+    state.previous_shuffling_epoch = state.current_shuffling_epoch;
+    state.previous_shuffling_start_shard = state.previous_shuffling_start_shard;
+    state.previous_shuffling_seed = state.previous_shuffling_seed;
+
+    let current_epoch = state.current_epoch(spec);
+    let next_epoch = current_epoch + 1;
+
+    // Check we should update, and if so, update.
+    if should_update_validator_registry(state, spec)? {
+        update_validator_registry(state, current_total_balance, spec)?;
+
+        // If we update the registry, update the shuffling data and shards as well.
+        state.current_shuffling_epoch = next_epoch;
+        state.current_shuffling_start_shard = {
+            let active_validators =
+                state.get_cached_active_validator_indices(RelativeEpoch::Current, spec)?;
+            let epoch_committee_count = spec.get_epoch_committee_count(active_validators.len());
+
+            (state.current_shuffling_start_shard + epoch_committee_count) % spec.shard_count
+        };
+        state.current_shuffling_seed = state.generate_seed(state.current_shuffling_epoch, spec)?;
+    } else {
+        // If processing at least on crosslink keeps failing, the reshuffle every power of two, but
+        // don't update the current_shuffling_start_shard.
+        let epochs_since_last_update = current_epoch - state.validator_registry_update_epoch;
+
+        if epochs_since_last_update > 1 && epochs_since_last_update.is_power_of_two() {
+            state.current_shuffling_epoch = next_epoch;
+            state.current_shuffling_seed =
+                state.generate_seed(state.current_shuffling_epoch, spec)?;
+        }
+    }
+
+    Ok(())
+}
+
+/// Returns `true` if the validator registry should be updated during an epoch processing.
+///
+/// Spec v0.5.0
+pub fn should_update_validator_registry(
+    state: &BeaconState,
+    spec: &ChainSpec,
+) -> Result<bool, BeaconStateError> {
+    if state.finalized_epoch <= state.validator_registry_update_epoch {
+        return Ok(false);
+    }
+
+    let num_active_validators = state
+        .get_cached_active_validator_indices(RelativeEpoch::Current, spec)?
+        .len();
+    let current_epoch_committee_count = spec.get_epoch_committee_count(num_active_validators);
+
+    for shard in (0..current_epoch_committee_count)
+        .into_iter()
+        .map(|i| (state.current_shuffling_start_shard + i as u64) % spec.shard_count)
+    {
+        if state.latest_crosslinks[shard as usize].epoch <= state.validator_registry_update_epoch {
+            return Ok(false);
+        }
+    }
+
+    Ok(true)
+}
+
+/// Update validator registry, activating/exiting validators if possible.
+///
+/// Note: Utilizes the cache and will fail if the appropriate cache is not initialized.
+///
+/// Spec v0.5.0
+pub fn update_validator_registry(
+    state: &mut BeaconState,
+    current_total_balance: u64,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    let current_epoch = state.current_epoch(spec);
+
+    let max_balance_churn = std::cmp::max(
+        spec.max_deposit_amount,
+        current_total_balance / (2 * spec.max_balance_churn_quotient),
+    );
+
+    // Activate validators within the allowable balance churn.
+    let mut balance_churn = 0;
+    for index in 0..state.validator_registry.len() {
+        let not_activated =
+            state.validator_registry[index].activation_epoch == spec.far_future_epoch;
+        let has_enough_balance = state.validator_balances[index] >= spec.max_deposit_amount;
+
+        if not_activated && has_enough_balance {
+            // Check the balance churn would be within the allowance.
+            balance_churn += state.get_effective_balance(index, spec)?;
+            if balance_churn > max_balance_churn {
+                break;
+            }
+
+            activate_validator(state, index, false, spec);
+        }
+    }
+
+    // Exit validators within the allowable balance churn.
+    let mut balance_churn = 0;
+    for index in 0..state.validator_registry.len() {
+        let not_exited = state.validator_registry[index].exit_epoch == spec.far_future_epoch;
+        let has_initiated_exit = state.validator_registry[index].initiated_exit;
+
+        if not_exited && has_initiated_exit {
+            // Check the balance churn would be within the allowance.
+            balance_churn += state.get_effective_balance(index, spec)?;
+            if balance_churn > max_balance_churn {
+                break;
+            }
+
+            exit_validator(state, index, spec)?;
+        }
+    }
+
+    state.validator_registry_update_epoch = current_epoch;
+
+    Ok(())
+}
+
+/// Activate the validator of the given ``index``.
+///
+/// Spec v0.5.0
+pub fn activate_validator(
+    state: &mut BeaconState,
+    validator_index: usize,
+    is_genesis: bool,
+    spec: &ChainSpec,
+) {
+    let current_epoch = state.current_epoch(spec);
+
+    state.validator_registry[validator_index].activation_epoch = if is_genesis {
+        spec.genesis_epoch
+    } else {
+        state.get_delayed_activation_exit_epoch(current_epoch, spec)
+    }
+}
diff --git a/eth2/state_processing/src/per_epoch_processing/update_validator_registry.rs b/eth2/state_processing/src/per_epoch_processing/update_validator_registry.rs
deleted file mode 100644
index ecf05ce6f0..0000000000
--- a/eth2/state_processing/src/per_epoch_processing/update_validator_registry.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-use crate::common::exit_validator;
-use types::{BeaconStateError as Error, *};
-
-/// Update validator registry, activating/exiting validators if possible.
-///
-/// Note: Utilizes the cache and will fail if the appropriate cache is not initialized.
-///
-/// Spec v0.4.0
-pub fn update_validator_registry(state: &mut BeaconState, spec: &ChainSpec) -> Result<(), Error> {
-    let current_epoch = state.current_epoch(spec);
-    let active_validator_indices =
-        state.get_cached_active_validator_indices(RelativeEpoch::Current, spec)?;
-    let total_balance = state.get_total_balance(&active_validator_indices[..], spec)?;
-
-    let max_balance_churn = std::cmp::max(
-        spec.max_deposit_amount,
-        total_balance / (2 * spec.max_balance_churn_quotient),
-    );
-
-    let mut balance_churn = 0;
-    for index in 0..state.validator_registry.len() {
-        let validator = &state.validator_registry[index];
-
-        if (validator.activation_epoch == spec.far_future_epoch)
-            & (state.validator_balances[index] == spec.max_deposit_amount)
-        {
-            balance_churn += state.get_effective_balance(index, spec)?;
-            if balance_churn > max_balance_churn {
-                break;
-            }
-            state.activate_validator(index, false, spec);
-        }
-    }
-
-    let mut balance_churn = 0;
-    for index in 0..state.validator_registry.len() {
-        let validator = &state.validator_registry[index];
-
-        if (validator.exit_epoch == spec.far_future_epoch) & (validator.initiated_exit) {
-            balance_churn += state.get_effective_balance(index, spec)?;
-            if balance_churn > max_balance_churn {
-                break;
-            }
-
-            exit_validator(state, index, spec)?;
-        }
-    }
-
-    state.validator_registry_update_epoch = current_epoch;
-
-    Ok(())
-}
diff --git a/eth2/types/src/beacon_state.rs b/eth2/types/src/beacon_state.rs
index 22e7c6ecf0..1a165c9a9a 100644
--- a/eth2/types/src/beacon_state.rs
+++ b/eth2/types/src/beacon_state.rs
@@ -193,6 +193,13 @@ impl BeaconState {
         Hash256::from_slice(&self.hash_tree_root()[..])
     }
 
+    pub fn historical_batch(&self) -> HistoricalBatch {
+        HistoricalBatch {
+            block_roots: self.latest_block_roots.clone(),
+            state_roots: self.latest_state_roots.clone(),
+        }
+    }
+
     /// If a validator pubkey exists in the validator registry, returns `Some(i)`, otherwise
     /// returns `None`.
     ///
@@ -382,6 +389,26 @@ impl BeaconState {
         Ok(self.latest_block_roots[i] = block_root)
     }
 
+    /// Safely obtains the index for `latest_randao_mixes`
+    ///
+    /// Spec v0.5.0
+    fn get_randao_mix_index(&self, epoch: Epoch, spec: &ChainSpec) -> Result<usize, Error> {
+        let current_epoch = self.current_epoch(spec);
+
+        if (current_epoch - (spec.latest_randao_mixes_length as u64) < epoch)
+            & (epoch <= current_epoch)
+        {
+            let i = epoch.as_usize() % spec.latest_randao_mixes_length;
+            if i < self.latest_randao_mixes.len() {
+                Ok(i)
+            } else {
+                Err(Error::InsufficientRandaoMixes)
+            }
+        } else {
+            Err(Error::EpochOutOfBounds)
+        }
+    }
+
     /// XOR-assigns the existing `epoch` randao mix with the hash of the `signature`.
     ///
     /// # Errors:
@@ -406,24 +433,23 @@ impl BeaconState {
 
     /// Return the randao mix at a recent ``epoch``.
     ///
-    /// # Errors:
-    /// - `InsufficientRandaoMixes` if `self.latest_randao_mixes` is shorter than
-    /// `spec.latest_randao_mixes_length`.
-    /// - `EpochOutOfBounds` if the state no longer stores randao mixes for the given `epoch`.
-    ///
     /// Spec v0.5.0
     pub fn get_randao_mix(&self, epoch: Epoch, spec: &ChainSpec) -> Result<&Hash256, Error> {
-        let current_epoch = self.current_epoch(spec);
+        let i = self.get_randao_mix_index(epoch, spec)?;
+        Ok(&self.latest_randao_mixes[i])
+    }
 
-        if (current_epoch - (spec.latest_randao_mixes_length as u64) < epoch)
-            & (epoch <= current_epoch)
-        {
-            self.latest_randao_mixes
-                .get(epoch.as_usize() % spec.latest_randao_mixes_length)
-                .ok_or_else(|| Error::InsufficientRandaoMixes)
-        } else {
-            Err(Error::EpochOutOfBounds)
-        }
+    /// Set the randao mix at a recent ``epoch``.
+    ///
+    /// Spec v0.5.0
+    pub fn set_randao_mix(
+        &mut self,
+        epoch: Epoch,
+        mix: Hash256,
+        spec: &ChainSpec,
+    ) -> Result<(), Error> {
+        let i = self.get_randao_mix_index(epoch, spec)?;
+        Ok(self.latest_randao_mixes[i] = mix)
     }
 
     /// Safely obtains the index for `latest_active_index_roots`, given some `epoch`.
@@ -588,24 +614,6 @@ impl BeaconState {
         epoch + 1 + spec.activation_exit_delay
     }
 
-    /// Activate the validator of the given ``index``.
-    ///
-    /// Spec v0.5.0
-    pub fn activate_validator(
-        &mut self,
-        validator_index: usize,
-        is_genesis: bool,
-        spec: &ChainSpec,
-    ) {
-        let current_epoch = self.current_epoch(spec);
-
-        self.validator_registry[validator_index].activation_epoch = if is_genesis {
-            spec.genesis_epoch
-        } else {
-            self.get_delayed_activation_exit_epoch(current_epoch, spec)
-        }
-    }
-
     /// Initiate an exit for the validator of the given `index`.
     ///
     /// Spec v0.5.0

From baca2c90abacfc8fafcaf3bfa590242a0ca8f084 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Tue, 19 Mar 2019 19:43:31 +1100
Subject: [PATCH 58/60] Add last of 0.5.0 upgrades. Woo!

---
 .../src/per_epoch_processing.rs               | 31 ++++++++++------
 .../process_exit_queue.rs                     |  4 +--
 .../per_epoch_processing/process_slashings.rs | 36 +++++++++----------
 3 files changed, 40 insertions(+), 31 deletions(-)

diff --git a/eth2/state_processing/src/per_epoch_processing.rs b/eth2/state_processing/src/per_epoch_processing.rs
index b917510f2e..fcdc668f40 100644
--- a/eth2/state_processing/src/per_epoch_processing.rs
+++ b/eth2/state_processing/src/per_epoch_processing.rs
@@ -32,7 +32,7 @@ pub type WinningRootHashSet = HashMap<u64, WinningRoot>;
 /// Mutates the given `BeaconState`, returning early if an error is encountered. If an error is
 /// returned, a state might be "half-processed" and therefore in an invalid state.
 ///
-/// Spec v0.4.0
+/// Spec v0.5.0
 pub fn per_epoch_processing(state: &mut BeaconState, spec: &ChainSpec) -> Result<(), Error> {
     // Ensure the previous and next epoch caches are built.
     state.build_epoch_cache(RelativeEpoch::Previous, spec)?;
@@ -41,27 +41,38 @@ pub fn per_epoch_processing(state: &mut BeaconState, spec: &ChainSpec) -> Result
     // Load the struct we use to assign validators into sets based on their participation.
     //
     // E.g., attestation in the previous epoch, attested to the head, etc.
-    let mut statuses = ValidatorStatuses::new(state, spec)?;
-    statuses.process_attestations(&state, spec)?;
+    let mut validator_statuses = ValidatorStatuses::new(state, spec)?;
+    validator_statuses.process_attestations(&state, spec)?;
 
-    process_eth1_data(state, spec);
-
-    update_justification_and_finalization(state, &statuses.total_balances, spec)?;
+    // Justification.
+    update_justification_and_finalization(state, &validator_statuses.total_balances, spec)?;
 
     // Crosslinks.
     let winning_root_for_shards = process_crosslinks(state, spec)?;
 
+    // Eth1 data.
+    maybe_reset_eth1_period(state, spec);
+
     // Rewards and Penalities.
-    apply_rewards(state, &mut statuses, &winning_root_for_shards, spec)?;
+    apply_rewards(
+        state,
+        &mut validator_statuses,
+        &winning_root_for_shards,
+        spec,
+    )?;
 
     // Ejections.
     process_ejections(state, spec)?;
 
     // Validator Registry.
-    update_registry_and_shuffling_data(state, statuses.total_balances.current_epoch, spec)?;
+    update_registry_and_shuffling_data(
+        state,
+        validator_statuses.total_balances.current_epoch,
+        spec,
+    )?;
 
     // Slashings and exit queue.
-    process_slashings(state, spec)?;
+    process_slashings(state, validator_statuses.total_balances.current_epoch, spec)?;
     process_exit_queue(state, spec);
 
     // Final updates.
@@ -76,7 +87,7 @@ pub fn per_epoch_processing(state: &mut BeaconState, spec: &ChainSpec) -> Result
 /// Maybe resets the eth1 period.
 ///
 /// Spec v0.5.0
-pub fn process_eth1_data(state: &mut BeaconState, spec: &ChainSpec) {
+pub fn maybe_reset_eth1_period(state: &mut BeaconState, spec: &ChainSpec) {
     let next_epoch = state.next_epoch(spec);
     let voting_period = spec.epochs_per_eth1_voting_period;
 
diff --git a/eth2/state_processing/src/per_epoch_processing/process_exit_queue.rs b/eth2/state_processing/src/per_epoch_processing/process_exit_queue.rs
index f672c97be3..074db1d08e 100644
--- a/eth2/state_processing/src/per_epoch_processing/process_exit_queue.rs
+++ b/eth2/state_processing/src/per_epoch_processing/process_exit_queue.rs
@@ -21,8 +21,8 @@ pub fn process_exit_queue(state: &mut BeaconState, spec: &ChainSpec) {
         .collect();
     eligable_indices.sort_by_key(|i| state.validator_registry[*i].exit_epoch);
 
-    for (withdrawn_so_far, index) in eligable_indices.iter().enumerate() {
-        if withdrawn_so_far as u64 >= spec.max_exit_dequeues_per_epoch {
+    for (dequeues, index) in eligable_indices.iter().enumerate() {
+        if dequeues as u64 >= spec.max_exit_dequeues_per_epoch {
             break;
         }
         prepare_validator_for_withdrawal(state, *index, spec);
diff --git a/eth2/state_processing/src/per_epoch_processing/process_slashings.rs b/eth2/state_processing/src/per_epoch_processing/process_slashings.rs
index 19c1e519b3..88777472c3 100644
--- a/eth2/state_processing/src/per_epoch_processing/process_slashings.rs
+++ b/eth2/state_processing/src/per_epoch_processing/process_slashings.rs
@@ -2,34 +2,32 @@ use types::{BeaconStateError as Error, *};
 
 /// Process slashings.
 ///
-/// Note: Utilizes the cache and will fail if the appropriate cache is not initialized.
-///
-/// Spec v0.4.0
-pub fn process_slashings(state: &mut BeaconState, spec: &ChainSpec) -> Result<(), Error> {
+/// Spec v0.5.0
+pub fn process_slashings(
+    state: &mut BeaconState,
+    current_total_balance: u64,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
     let current_epoch = state.current_epoch(spec);
-    let active_validator_indices =
-        state.get_cached_active_validator_indices(RelativeEpoch::Current, spec)?;
-    let total_balance = state.get_total_balance(&active_validator_indices[..], spec)?;
+
+    let total_at_start = state.get_slashed_balance(current_epoch + 1, spec)?;
+    let total_at_end = state.get_slashed_balance(current_epoch, spec)?;
+    let total_penalities = total_at_end - total_at_start;
 
     for (index, validator) in state.validator_registry.iter().enumerate() {
-        if validator.slashed
-            && (current_epoch
-                == validator.withdrawable_epoch - Epoch::from(spec.latest_slashed_exit_length / 2))
-        {
-            // TODO: check the following two lines are correct.
-            let total_at_start = state.get_slashed_balance(current_epoch + 1, spec)?;
-            let total_at_end = state.get_slashed_balance(current_epoch, spec)?;
-
-            let total_penalities = total_at_end.saturating_sub(total_at_start);
+        let should_penalize = current_epoch.as_usize()
+            == validator.withdrawable_epoch.as_usize() - spec.latest_slashed_exit_length / 2;
 
+        if validator.slashed && should_penalize {
             let effective_balance = state.get_effective_balance(index, spec)?;
+
             let penalty = std::cmp::max(
-                effective_balance * std::cmp::min(total_penalities * 3, total_balance)
-                    / total_balance,
+                effective_balance * std::cmp::min(total_penalities * 3, current_total_balance)
+                    / current_total_balance,
                 effective_balance / spec.min_penalty_quotient,
             );
 
-            safe_sub_assign!(state.validator_balances[index], penalty);
+            state.validator_balances[index] -= penalty;
         }
     }
 

From 8f23aefb29f997e46de59ce8b571196b203c3ef6 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Tue, 19 Mar 2019 19:55:17 +1100
Subject: [PATCH 59/60] Adds comments to new epoch cache fns.

---
 eth2/types/src/beacon_state/epoch_cache.rs | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/eth2/types/src/beacon_state/epoch_cache.rs b/eth2/types/src/beacon_state/epoch_cache.rs
index ca8bcc70e9..6eebf1da3a 100644
--- a/eth2/types/src/beacon_state/epoch_cache.rs
+++ b/eth2/types/src/beacon_state/epoch_cache.rs
@@ -107,6 +107,7 @@ impl EpochCache {
         })
     }
 
+    /// Return a vec of `CrosslinkCommittee` for a given slot.
     pub fn get_crosslink_committees_at_slot(
         &self,
         slot: Slot,
@@ -116,6 +117,8 @@ impl EpochCache {
             .get_crosslink_committees_at_slot(slot, spec)
     }
 
+    /// Return `Some(CrosslinkCommittee)` if the given shard has a committee during the given
+    /// `epoch`.
     pub fn get_crosslink_committee_for_shard(
         &self,
         shard: Shard,
@@ -131,6 +134,10 @@ impl EpochCache {
     }
 }
 
+/// Returns a list of all `validator_registry` indices where the validator is active at the given
+/// `epoch`.
+///
+/// Spec v0.5.0
 pub fn get_active_validator_indices(validators: &[Validator], epoch: Epoch) -> Vec<usize> {
     let mut active = Vec::with_capacity(validators.len());
 
@@ -145,13 +152,17 @@ pub fn get_active_validator_indices(validators: &[Validator], epoch: Epoch) -> V
     active
 }
 
+/// Contains all `CrosslinkCommittees` for an epoch.
 #[derive(Debug, Default, PartialEq, Clone, Serialize, Deserialize)]
 pub struct EpochCrosslinkCommittees {
+    /// The epoch the committees are present in.
     epoch: Epoch,
+    /// Each commitee for each slot of the epoch.
     pub crosslink_committees: Vec<Vec<CrosslinkCommittee>>,
 }
 
 impl EpochCrosslinkCommittees {
+    /// Return a new instances where all slots have zero committees.
     fn new(epoch: Epoch, spec: &ChainSpec) -> Self {
         Self {
             epoch,
@@ -159,6 +170,7 @@ impl EpochCrosslinkCommittees {
         }
     }
 
+    /// Return a vec of `CrosslinkCommittee` for a given slot.
     fn get_crosslink_committees_at_slot(
         &self,
         slot: Slot,
@@ -176,6 +188,7 @@ impl EpochCrosslinkCommittees {
     }
 }
 
+/// Builds an `EpochCrosslinkCommittees` object.
 pub struct EpochCrosslinkCommitteesBuilder {
     epoch: Epoch,
     shuffling_start_shard: Shard,
@@ -185,6 +198,7 @@ pub struct EpochCrosslinkCommitteesBuilder {
 }
 
 impl EpochCrosslinkCommitteesBuilder {
+    /// Instantiates a builder that will build for the `state`'s previous epoch.
     pub fn for_previous_epoch(
         state: &BeaconState,
         active_validator_indices: Vec<usize>,
@@ -199,6 +213,7 @@ impl EpochCrosslinkCommitteesBuilder {
         }
     }
 
+    /// Instantiates a builder that will build for the `state`'s next epoch.
     pub fn for_current_epoch(
         state: &BeaconState,
         active_validator_indices: Vec<usize>,
@@ -213,6 +228,10 @@ impl EpochCrosslinkCommitteesBuilder {
         }
     }
 
+    /// Instantiates a builder that will build for the `state`'s next epoch.
+    ///
+    /// Note: there are two possible epoch builds for the next epoch, one where there is a registry
+    /// change and one where there is not.
     pub fn for_next_epoch(
         state: &BeaconState,
         active_validator_indices: Vec<usize>,
@@ -257,6 +276,7 @@ impl EpochCrosslinkCommitteesBuilder {
         })
     }
 
+    /// Consumes the builder, returning a fully-build `EpochCrosslinkCommittee`.
     pub fn build(self, spec: &ChainSpec) -> Result<EpochCrosslinkCommittees, Error> {
         // The shuffler fails on a empty list, so if there are no active validator indices, simply
         // return an empty list.

From 84f373fcc2ca1619dc0e3c708dbaa7a04bfa03b8 Mon Sep 17 00:00:00 2001
From: Paul Hauner <paul@paulhauner.com>
Date: Wed, 20 Mar 2019 10:51:53 +1100
Subject: [PATCH 60/60] Fix clippy lints

---
 beacon_node/beacon_chain/src/beacon_chain.rs  |  8 ++---
 eth2/fork_choice/src/slow_lmd_ghost.rs        |  6 ++--
 .../src/per_block_processing.rs               |  4 +--
 .../validate_attestation.rs                   | 34 ++++++-------------
 .../per_block_processing/verify_deposit.rs    |  4 +--
 .../get_attestation_participants.rs           |  2 +-
 .../update_registry_and_shuffling_data.rs     |  1 -
 eth2/types/src/beacon_block.rs                |  6 ++--
 eth2/types/src/beacon_state.rs                | 17 ++++++----
 eth2/types/src/beacon_state/epoch_cache.rs    |  1 -
 eth2/types/src/relative_epoch.rs              |  2 +-
 .../testing_beacon_state_builder.rs           |  2 +-
 .../src/test_utils/testing_deposit_builder.rs |  2 +-
 13 files changed, 38 insertions(+), 51 deletions(-)

diff --git a/beacon_node/beacon_chain/src/beacon_chain.rs b/beacon_node/beacon_chain/src/beacon_chain.rs
index 01787f95bc..816a570c0f 100644
--- a/beacon_node/beacon_chain/src/beacon_chain.rs
+++ b/beacon_node/beacon_chain/src/beacon_chain.rs
@@ -82,7 +82,7 @@ where
         let state_root = genesis_state.canonical_root();
         state_store.put(&state_root, &ssz_encode(&genesis_state)[..])?;
 
-        let block_root = genesis_block.into_header().canonical_root();
+        let block_root = genesis_block.block_header().canonical_root();
         block_store.put(&block_root, &ssz_encode(&genesis_block)[..])?;
 
         let finalized_head = RwLock::new(CheckPoint::new(
@@ -189,7 +189,7 @@ where
     pub fn advance_state(&self, slot: Slot) -> Result<(), SlotProcessingError> {
         let state_slot = self.state.read().slot;
 
-        let latest_block_header = self.head().beacon_block.into_header();
+        let latest_block_header = self.head().beacon_block.block_header();
 
         for _ in state_slot.as_u64()..slot.as_u64() {
             per_slot_processing(&mut *self.state.write(), &latest_block_header, &self.spec)?;
@@ -561,7 +561,7 @@ where
     pub fn process_block(&self, block: BeaconBlock) -> Result<BlockProcessingOutcome, Error> {
         debug!("Processing block with slot {}...", block.slot);
 
-        let block_root = block.into_header().canonical_root();
+        let block_root = block.block_header().canonical_root();
 
         let present_slot = self.present_slot();
 
@@ -596,7 +596,7 @@ where
 
         // Transition the parent state to the present slot.
         let mut state = parent_state;
-        let previous_block_header = parent_block.into_header();
+        let previous_block_header = parent_block.block_header();
         for _ in state.slot.as_u64()..present_slot.as_u64() {
             if let Err(e) = per_slot_processing(&mut state, &previous_block_header, &self.spec) {
                 return Ok(BlockProcessingOutcome::InvalidBlock(
diff --git a/eth2/fork_choice/src/slow_lmd_ghost.rs b/eth2/fork_choice/src/slow_lmd_ghost.rs
index 25d137089e..4b236cba45 100644
--- a/eth2/fork_choice/src/slow_lmd_ghost.rs
+++ b/eth2/fork_choice/src/slow_lmd_ghost.rs
@@ -215,10 +215,8 @@ impl<T: ClientDB + Sized> ForkChoice for SlowLMDGhost<T> {
                     head_vote_count = vote_count;
                 }
                 // resolve ties - choose smaller hash
-                else if vote_count == head_vote_count {
-                    if *child_hash < head_hash {
-                        head_hash = *child_hash;
-                    }
+                else if vote_count == head_vote_count && *child_hash < head_hash {
+                    head_hash = *child_hash;
                 }
             }
         }
diff --git a/eth2/state_processing/src/per_block_processing.rs b/eth2/state_processing/src/per_block_processing.rs
index 33f953b711..dc83abb3f3 100644
--- a/eth2/state_processing/src/per_block_processing.rs
+++ b/eth2/state_processing/src/per_block_processing.rs
@@ -109,7 +109,7 @@ pub fn process_block_header(
         Invalid::ParentBlockRootMismatch
     );
 
-    state.latest_block_header = block.into_temporary_header(spec);
+    state.latest_block_header = block.temporary_block_header(spec);
 
     Ok(())
 }
@@ -388,7 +388,7 @@ pub fn process_deposits(
             // Create a new validator.
             let validator = Validator {
                 pubkey: deposit_input.pubkey.clone(),
-                withdrawal_credentials: deposit_input.withdrawal_credentials.clone(),
+                withdrawal_credentials: deposit_input.withdrawal_credentials,
                 activation_epoch: spec.far_future_epoch,
                 exit_epoch: spec.far_future_epoch,
                 withdrawable_epoch: spec.far_future_epoch,
diff --git a/eth2/state_processing/src/per_block_processing/validate_attestation.rs b/eth2/state_processing/src/per_block_processing/validate_attestation.rs
index 113dbc4ced..2143988a46 100644
--- a/eth2/state_processing/src/per_block_processing/validate_attestation.rs
+++ b/eth2/state_processing/src/per_block_processing/validate_attestation.rs
@@ -176,17 +176,7 @@ fn validate_attestation_signature_optional(
     );
 
     if verify_signature {
-        let attestation_epoch = attestation.data.slot.epoch(spec.slots_per_epoch);
-        verify_attestation_signature(
-            state,
-            committee,
-            attestation_epoch,
-            &attestation.aggregation_bitfield,
-            &attestation.custody_bitfield,
-            &attestation.data,
-            &attestation.aggregate_signature,
-            spec,
-        )?;
+        verify_attestation_signature(state, committee, attestation, spec)?;
     }
 
     // Crosslink data root is zero (to be removed in phase 1).
@@ -210,32 +200,29 @@ fn validate_attestation_signature_optional(
 fn verify_attestation_signature(
     state: &BeaconState,
     committee: &[usize],
-    attestation_epoch: Epoch,
-    aggregation_bitfield: &Bitfield,
-    custody_bitfield: &Bitfield,
-    attestation_data: &AttestationData,
-    aggregate_signature: &AggregateSignature,
+    a: &Attestation,
     spec: &ChainSpec,
 ) -> Result<(), Error> {
     let mut aggregate_pubs = vec![AggregatePublicKey::new(); 2];
     let mut message_exists = vec![false; 2];
+    let attestation_epoch = a.data.slot.epoch(spec.slots_per_epoch);
 
     for (i, v) in committee.iter().enumerate() {
-        let validator_signed = aggregation_bitfield.get(i).map_err(|_| {
+        let validator_signed = a.aggregation_bitfield.get(i).map_err(|_| {
             Error::Invalid(Invalid::BadAggregationBitfieldLength {
                 committee_len: committee.len(),
-                bitfield_len: aggregation_bitfield.len(),
+                bitfield_len: a.aggregation_bitfield.len(),
             })
         })?;
 
         if validator_signed {
-            let custody_bit: bool = match custody_bitfield.get(i) {
+            let custody_bit: bool = match a.custody_bitfield.get(i) {
                 Ok(bit) => bit,
                 // Invalidate signature if custody_bitfield.len() < committee
                 Err(_) => {
                     return Err(Error::Invalid(Invalid::BadCustodyBitfieldLength {
                         committee_len: committee.len(),
-                        bitfield_len: aggregation_bitfield.len(),
+                        bitfield_len: a.aggregation_bitfield.len(),
                     }));
                 }
             };
@@ -254,14 +241,14 @@ fn verify_attestation_signature(
 
     // Message when custody bitfield is `false`
     let message_0 = AttestationDataAndCustodyBit {
-        data: attestation_data.clone(),
+        data: a.data.clone(),
         custody_bit: false,
     }
     .hash_tree_root();
 
     // Message when custody bitfield is `true`
     let message_1 = AttestationDataAndCustodyBit {
-        data: attestation_data.clone(),
+        data: a.data.clone(),
         custody_bit: true,
     }
     .hash_tree_root();
@@ -283,7 +270,8 @@ fn verify_attestation_signature(
     let domain = spec.get_domain(attestation_epoch, Domain::Attestation, &state.fork);
 
     verify!(
-        aggregate_signature.verify_multiple(&messages[..], domain, &keys[..]),
+        a.aggregate_signature
+            .verify_multiple(&messages[..], domain, &keys[..]),
         Invalid::BadSignature
     );
 
diff --git a/eth2/state_processing/src/per_block_processing/verify_deposit.rs b/eth2/state_processing/src/per_block_processing/verify_deposit.rs
index 80d8bc24fa..a3a0f5734c 100644
--- a/eth2/state_processing/src/per_block_processing/verify_deposit.rs
+++ b/eth2/state_processing/src/per_block_processing/verify_deposit.rs
@@ -71,9 +71,7 @@ pub fn get_existing_validator_index(
 ) -> Result<Option<u64>, Error> {
     let deposit_input = &deposit.deposit_data.deposit_input;
 
-    let validator_index = state
-        .get_validator_index(&deposit_input.pubkey)?
-        .and_then(|i| Some(i));
+    let validator_index = state.get_validator_index(&deposit_input.pubkey)?;
 
     match validator_index {
         None => Ok(None),
diff --git a/eth2/state_processing/src/per_epoch_processing/get_attestation_participants.rs b/eth2/state_processing/src/per_epoch_processing/get_attestation_participants.rs
index 3e52776b10..52ba0274b5 100644
--- a/eth2/state_processing/src/per_epoch_processing/get_attestation_participants.rs
+++ b/eth2/state_processing/src/per_epoch_processing/get_attestation_participants.rs
@@ -28,7 +28,7 @@ pub fn get_attestation_participants(
     let mut participants = Vec::with_capacity(committee.len());
     for (i, validator_index) in committee.iter().enumerate() {
         match bitfield.get(i) {
-            Ok(bit) if bit == true => participants.push(*validator_index),
+            Ok(bit) if bit => participants.push(*validator_index),
             _ => {}
         }
     }
diff --git a/eth2/state_processing/src/per_epoch_processing/update_registry_and_shuffling_data.rs b/eth2/state_processing/src/per_epoch_processing/update_registry_and_shuffling_data.rs
index 286ad81408..0b18c25712 100644
--- a/eth2/state_processing/src/per_epoch_processing/update_registry_and_shuffling_data.rs
+++ b/eth2/state_processing/src/per_epoch_processing/update_registry_and_shuffling_data.rs
@@ -64,7 +64,6 @@ pub fn should_update_validator_registry(
     let current_epoch_committee_count = spec.get_epoch_committee_count(num_active_validators);
 
     for shard in (0..current_epoch_committee_count)
-        .into_iter()
         .map(|i| (state.current_shuffling_start_shard + i as u64) % spec.shard_count)
     {
         if state.latest_crosslinks[shard as usize].epoch <= state.validator_registry_update_epoch {
diff --git a/eth2/types/src/beacon_block.rs b/eth2/types/src/beacon_block.rs
index b966751ed8..6a3f1a354a 100644
--- a/eth2/types/src/beacon_block.rs
+++ b/eth2/types/src/beacon_block.rs
@@ -71,7 +71,7 @@ impl BeaconBlock {
     /// Note: performs a full tree-hash of `self.body`.
     ///
     /// Spec v0.5.0
-    pub fn into_header(&self) -> BeaconBlockHeader {
+    pub fn block_header(&self) -> BeaconBlockHeader {
         BeaconBlockHeader {
             slot: self.slot,
             previous_block_root: self.previous_block_root,
@@ -84,11 +84,11 @@ impl BeaconBlock {
     /// Returns a "temporary" header, where the `state_root` is `spec.zero_hash`.
     ///
     /// Spec v0.5.0
-    pub fn into_temporary_header(&self, spec: &ChainSpec) -> BeaconBlockHeader {
+    pub fn temporary_block_header(&self, spec: &ChainSpec) -> BeaconBlockHeader {
         BeaconBlockHeader {
             state_root: spec.zero_hash,
             signature: spec.empty_signature.clone(),
-            ..self.into_header()
+            ..self.block_header()
         }
     }
 }
diff --git a/eth2/types/src/beacon_state.rs b/eth2/types/src/beacon_state.rs
index 1a165c9a9a..1e52781243 100644
--- a/eth2/types/src/beacon_state.rs
+++ b/eth2/types/src/beacon_state.rs
@@ -162,7 +162,7 @@ impl BeaconState {
             latest_state_roots: vec![spec.zero_hash; spec.slots_per_historical_root],
             latest_active_index_roots: vec![spec.zero_hash; spec.latest_active_index_roots_length],
             latest_slashed_balances: vec![0; spec.latest_slashed_exit_length],
-            latest_block_header: BeaconBlock::empty(spec).into_temporary_header(spec),
+            latest_block_header: BeaconBlock::empty(spec).temporary_block_header(spec),
             historical_roots: vec![],
 
             /*
@@ -386,7 +386,8 @@ impl BeaconState {
         spec: &ChainSpec,
     ) -> Result<(), BeaconStateError> {
         let i = self.get_latest_block_roots_index(slot, spec)?;
-        Ok(self.latest_block_roots[i] = block_root)
+        self.latest_block_roots[i] = block_root;
+        Ok(())
     }
 
     /// Safely obtains the index for `latest_randao_mixes`
@@ -449,7 +450,8 @@ impl BeaconState {
         spec: &ChainSpec,
     ) -> Result<(), Error> {
         let i = self.get_randao_mix_index(epoch, spec)?;
-        Ok(self.latest_randao_mixes[i] = mix)
+        self.latest_randao_mixes[i] = mix;
+        Ok(())
     }
 
     /// Safely obtains the index for `latest_active_index_roots`, given some `epoch`.
@@ -492,7 +494,8 @@ impl BeaconState {
         spec: &ChainSpec,
     ) -> Result<(), Error> {
         let i = self.get_active_index_root_index(epoch, spec)?;
-        Ok(self.latest_active_index_roots[i] = index_root)
+        self.latest_active_index_roots[i] = index_root;
+        Ok(())
     }
 
     /// Replace `active_index_roots` with clones of `index_root`.
@@ -537,7 +540,8 @@ impl BeaconState {
         spec: &ChainSpec,
     ) -> Result<(), Error> {
         let i = self.get_latest_state_roots_index(slot, spec)?;
-        Ok(self.latest_state_roots[i] = state_root)
+        self.latest_state_roots[i] = state_root;
+        Ok(())
     }
 
     /// Safely obtains the index for `latest_slashed_balances`, given some `epoch`.
@@ -573,7 +577,8 @@ impl BeaconState {
         spec: &ChainSpec,
     ) -> Result<(), Error> {
         let i = self.get_slashed_balance_index(epoch, spec)?;
-        Ok(self.latest_slashed_balances[i] = balance)
+        self.latest_slashed_balances[i] = balance;
+        Ok(())
     }
 
     /// Generate a seed for the given `epoch`.
diff --git a/eth2/types/src/beacon_state/epoch_cache.rs b/eth2/types/src/beacon_state/epoch_cache.rs
index 6eebf1da3a..32d9a643e9 100644
--- a/eth2/types/src/beacon_state/epoch_cache.rs
+++ b/eth2/types/src/beacon_state/epoch_cache.rs
@@ -304,7 +304,6 @@ impl EpochCrosslinkCommitteesBuilder {
 
         for (i, slot) in self.epoch.slot_iter(spec.slots_per_epoch).enumerate() {
             for j in (0..committees.len())
-                .into_iter()
                 .skip(i * committees_per_slot)
                 .take(committees_per_slot)
             {
diff --git a/eth2/types/src/relative_epoch.rs b/eth2/types/src/relative_epoch.rs
index 6c135b1a6d..8f895e97a5 100644
--- a/eth2/types/src/relative_epoch.rs
+++ b/eth2/types/src/relative_epoch.rs
@@ -33,7 +33,7 @@ impl RelativeEpoch {
     /// Returns the `epoch` that `self` refers to, with respect to the `base` epoch.
     ///
     /// Spec v0.5.0
-    pub fn into_epoch(&self, base: Epoch) -> Epoch {
+    pub fn into_epoch(self, base: Epoch) -> Epoch {
         match self {
             RelativeEpoch::Previous => base - 1,
             RelativeEpoch::Current => base,
diff --git a/eth2/types/src/test_utils/testing_beacon_state_builder.rs b/eth2/types/src/test_utils/testing_beacon_state_builder.rs
index e76a01e49b..6945769aa3 100644
--- a/eth2/types/src/test_utils/testing_beacon_state_builder.rs
+++ b/eth2/types/src/test_utils/testing_beacon_state_builder.rs
@@ -214,7 +214,7 @@ impl TestingBeaconStateBuilder {
             - spec.min_attestation_inclusion_delay;
         let last_slot = std::cmp::min(state.slot.as_u64(), last_slot);
 
-        for slot in first_slot..last_slot + 1 {
+        for slot in first_slot..=last_slot {
             let slot = Slot::from(slot);
 
             let committees = state
diff --git a/eth2/types/src/test_utils/testing_deposit_builder.rs b/eth2/types/src/test_utils/testing_deposit_builder.rs
index ee258e7fe7..326858c31a 100644
--- a/eth2/types/src/test_utils/testing_deposit_builder.rs
+++ b/eth2/types/src/test_utils/testing_deposit_builder.rs
@@ -47,7 +47,7 @@ impl TestingDepositBuilder {
         self.deposit
             .deposit_data
             .deposit_input
-            .withdrawal_credentials = withdrawal_credentials.clone();
+            .withdrawal_credentials = withdrawal_credentials;
 
         self.deposit.deposit_data.deposit_input.proof_of_possession = self
             .deposit