Allow state processing to compile under v0.5.0

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> {

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(|| {

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) {
+    if (state.justification_bitfield % 8 == 0b111)
-        state.finalized_epoch = state.justified_epoch;
+        & (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) {
+    if (state.justification_bitfield % 4 == 0b11)
-        state.finalized_epoch = state.justified_epoch;
+        & (state.current_justified_epoch == previous_epoch)
+    {
+        state.finalized_epoch = state.current_justified_epoch;
     }
 
-    state.previous_justified_epoch = state.justified_epoch;
+    state.previous_justified_epoch = state.current_justified_epoch;
-    state.justified_epoch = new_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 {
+        for c in crosslink_committees_at_slot {
-            let shard = shard as u64;
+            let shard = c.shard as u64;
 
-            let winning_root = winning_root(
+            let winning_root = winning_root(state, shard, spec)?;
-                state,
-                shard,
-                &current_epoch_attestations[..],
-                &previous_epoch_attestations[..],
-                spec,
-            )?;
 
             if let Some(winning_root) = winning_root {
-                let total_committee_balance = state.get_total_balance(&crosslink_committee, spec);
+                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,
+                    epochs_since_finality.as_u64(),
-                    base_reward_quotient,
+                    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
+/// Spec v0.5.0
-pub fn process_validator_registry(state: &mut BeaconState, spec: &ChainSpec) -> Result<(), Error> {
+pub fn get_base_reward(
-    let current_epoch = state.current_epoch(spec);
+    state: &BeaconState,
-    let next_epoch = state.next_epoch(spec);
+    index: usize,
-
+    previous_total_balance: u64,
-    state.previous_shuffling_epoch = state.current_shuffling_epoch;
+    spec: &ChainSpec,
-    state.previous_shuffling_start_shard = state.current_shuffling_start_shard;
+) -> Result<u64, BeaconStateError> {
-
+    if previous_total_balance == 0 {
-    state.previous_shuffling_seed = state.current_shuffling_seed;
+        Ok(0)
-
-    let should_update_validator_registy = if state.finalized_epoch
-        > state.validator_registry_update_epoch
-    {
-        (0..state.get_current_epoch_committee_count(spec)).all(|i| {
-            let shard = (state.current_shuffling_start_shard + i as u64) % spec.shard_count;
-            state.latest_crosslinks[shard as usize].epoch > state.validator_registry_update_epoch
-        })
     } else {
-        false
+        let adjusted_quotient = previous_total_balance.integer_sqrt() / spec.base_reward_quotient;
-    };
+        Ok(state.get_effective_balance(index, spec)? / adjusted_quotient / 5)
-
-    if should_update_validator_registy {
-        state.update_validator_registry(spec);
-
-        state.current_shuffling_epoch = next_epoch;
-        state.current_shuffling_start_shard = (state.current_shuffling_start_shard
-            + state.get_current_epoch_committee_count(spec) as u64)
-            % spec.shard_count;
-        state.current_shuffling_seed = state.generate_seed(state.current_shuffling_epoch, spec)?
-    } else {
-        let epochs_since_last_registry_update =
-            current_epoch - state.validator_registry_update_epoch;
-        if (epochs_since_last_registry_update > 1)
-            & epochs_since_last_registry_update.is_power_of_two()
-        {
-            state.current_shuffling_epoch = next_epoch;
-            state.current_shuffling_seed =
-                state.generate_seed(state.current_shuffling_epoch, spec)?
     }
 }
 
-    state.process_slashings(spec);
+/// Returns the inactivity penalty for some validator.
-    state.process_exit_queue(spec);
+///
-
+/// Spec v0.5.0
-    Ok(())
+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.previous_epoch_attestations = vec![];
-
-    state.latest_attestations = state
-        .latest_attestations
-        .iter()
-        .filter(|a| a.data.slot.epoch(spec.slots_per_epoch) >= current_epoch)
-        .cloned()
-        .collect();
 }

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)
+}

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.5.0
-///
-/// Spec v0.4.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.5.0
-///
-/// Spec v0.4.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.5.0
-///
-/// Spec v0.4.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);
         }

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)
+}

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
+    /// Spec v0.5.0
-    pub fn new(state: &BeaconState, spec: &ChainSpec) -> Self {
+    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)?;
+                get_attestation_participants(state, &a.data, &a.aggregation_bitfield, spec)?;
-            let attesting_balance = state.get_total_balance(&attesting_indices, 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) {
+                if let Some(winning_root) = winning_roots.get(&c.shard) {
-                    let total_committee_balance =
+                    let total_committee_balance = state.get_total_balance(&c.committee, spec)?;
-                        state.get_total_balance(&crosslink_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
+    let state_boundary_root = *state.get_block_root(slot, spec)?;
-        .get_block_root(slot, spec)
-        .ok_or_else(|| BeaconStateError::InsufficientBlockRoots)?;
 
-    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
+    let state_block_root = *state.get_block_root(a.data.slot, spec)?;
-        .get_block_root(a.data.slot, spec)
-        .ok_or_else(|| BeaconStateError::InsufficientBlockRoots)?;
 
     Ok(a.data.beacon_block_root == state_block_root)
 }

eth2/state_processing/src/per_epoch_processing/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(
+        let attesting_validator_indices =
-            state,
+            get_attesting_validator_indices(state, shard, &crosslink_data_root, spec)?;
-            shard,
-            current_epoch_attestations,
-            previous_epoch_attestations,
-            &crosslink_data_root,
-            spec,
-        )?;
 
-        let total_attesting_balance: u64 = attesting_validator_indices
+        let total_attesting_balance: u64 =
+            attesting_validator_indices
                 .iter()
-            .fold(0, |acc, i| acc + state.get_effective_balance(*i, spec));
+                .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));
+    }
+}

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)?;
+        let cache = self.cache(relative_epoch, spec)?;
-        trace!(
+
-            "get_beacon_proposer_index: slot: {}, committees_count: {}",
+        let committees = cache
-            slot,
+            .get_crosslink_committees_at_slot(slot, spec)
-            committees.len()
+            .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 =
+        let active_validator_indices = self.get_active_validator_indices(current_epoch, spec)?;
-            get_active_validator_indices(&self.validator_registry, current_epoch);
         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 =
+        let active_validator_indices = self.get_active_validator_indices(current_epoch, spec)?;
-            get_active_validator_indices(&self.validator_registry, current_epoch);
         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
+    /// Spec v0.5.0
-    pub fn process_ejections(&mut self, spec: &ChainSpec) {
+    pub fn process_ejections(&mut self, spec: &ChainSpec) -> Result<(), Error> {
-        for validator_index in
+        // There is an awkward double (triple?) loop here because we can't loop across the borrowed
-            get_active_validator_indices(&self.validator_registry, self.current_epoch(spec))
+        // active validator indices and mutate state in the one loop.
-        {
+        let exitable: Vec<usize> = self
-            if self.validator_balances[validator_index] < spec.ejection_balance {
+            .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.
+        Ok(())
-    ///
-    /// 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)
     }
 
     /// 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],

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)?;
+        if shard > self.shard_committee_indices.len() as u64 {
-        let slot_committees = self.get_crosslink_committees_at_slot(*slot, spec)?;
+            None
-        slot_committees.get(*committee)
+        } 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),
                 };

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>,
 }

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, spec)? {
-            for crosslink_committee in
-                state.get_crosslink_committees_at_slot(slot, relative_epoch, spec)?
-            {
                 if attestations_added >= num_attestations {
                     break;
                 }

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();