Update to v0.8.3

eth2/state_processing/src/common/get_attesting_indices.rs

@@ -17,11 +17,9 @@ pub fn get_attesting_indices<T: EthSpec>(
         target_relative_epoch,
     )?;
 
-    /* TODO(freeze): re-enable this?
-    if bitlist.len() > committee.committee.len() {
+    if bitlist.len() != committee.committee.len() {
         return Err(BeaconStateError::InvalidBitfield);
     }
-    */
 
     Ok(committee
         .committee

eth2/state_processing/src/common/get_compact_committees_root.rs

@@ -3,36 +3,21 @@ use types::*;
 
 /// Return the compact committee root at `relative_epoch`.
 ///
-/// Spec v0.8.0
+/// Spec v0.8.3
 pub fn get_compact_committees_root<T: EthSpec>(
     state: &BeaconState<T>,
     relative_epoch: RelativeEpoch,
     spec: &ChainSpec,
 ) -> Result<Hash256, BeaconStateError> {
     let mut committees =
         FixedVector::<_, T::ShardCount>::from_elem(CompactCommittee::<T>::default());
-    // FIXME: this is a spec bug, whereby the start shard for the epoch after the next epoch
-    // is mistakenly used. The start shard from the cache SHOULD work.
-    // Waiting on a release to fix https://github.com/ethereum/eth2.0-specs/issues/1315
-    let start_shard = if relative_epoch == RelativeEpoch::Next {
-        state.next_epoch_start_shard(spec)?
-    } else {
-        state.get_epoch_start_shard(relative_epoch)?
-    };
+    let start_shard = state.get_epoch_start_shard(relative_epoch)?;
 
     for committee_number in 0..state.get_committee_count(relative_epoch)? {
         let shard = (start_shard + committee_number) % T::ShardCount::to_u64();
-        // FIXME: this is a partial workaround for the above, but it only works in the case
-        // where there's a committee for every shard in every epoch. It works for the minimal
-        // tests but not the mainnet ones.
-        let fake_shard = if relative_epoch == RelativeEpoch::Next {
-            (shard + 1) % T::ShardCount::to_u64()
-        } else {
-            shard
-        };
 
         for &index in state
-            .get_crosslink_committee_for_shard(fake_shard, relative_epoch)?
+            .get_crosslink_committee_for_shard(shard, relative_epoch)?
             .committee
         {
             let validator = state

eth2/state_processing/src/common/get_indexed_attestation.rs

@@ -11,6 +11,8 @@ pub fn get_indexed_attestation<T: EthSpec>(
     state: &BeaconState<T>,
     attestation: &Attestation<T>,
 ) -> Result<IndexedAttestation<T>> {
+    // Note: we rely on both calls to `get_attesting_indices` to check the bitfield lengths
+    // against the committee length
     let attesting_indices =
         get_attesting_indices(state, &attestation.data, &attestation.aggregation_bits)?;
 

eth2/state_processing/src/per_epoch_processing.rs

@@ -1,8 +1,5 @@
 use crate::common::get_compact_committees_root;
-use apply_rewards::process_rewards_and_penalties;
 use errors::EpochProcessingError as Error;
-use process_slashings::process_slashings;
-use registry_updates::process_registry_updates;
 use std::collections::HashMap;
 use tree_hash::TreeHash;
 use types::*;
@@ -17,6 +14,10 @@ pub mod tests;
 pub mod validator_statuses;
 pub mod winning_root;
 
+pub use apply_rewards::process_rewards_and_penalties;
+pub use process_slashings::process_slashings;
+pub use registry_updates::process_registry_updates;
+
 /// Maps a shard to a winning root.
 ///
 /// It is generated during crosslink processing and later used to reward/penalize validators.
@@ -218,45 +219,29 @@ pub fn process_final_updates<T: EthSpec>(
         }
     }
 
-    // Update start shard.
-    state.start_shard = state.next_epoch_start_shard(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 index_epoch = next_epoch + spec.activation_exit_delay;
-        let indices_list = VariableList::<usize, T::ValidatorRegistryLimit>::from(
-            state.get_active_validator_indices(index_epoch),
-        );
-        state.set_active_index_root(
-            index_epoch,
-            Hash256::from_slice(&indices_list.tree_hash_root()),
-            spec,
-        )?;
-
-        // Reset slashings
-        state.set_slashings(next_epoch, 0)?;
-
-        // Set randao mix
-        state.set_randao_mix(next_epoch, *state.get_randao_mix(current_epoch)?)?;
-
-        state.slot -= 1;
-    }
+    // Set active index root
+    let index_epoch = next_epoch + spec.activation_exit_delay;
+    let indices_list = VariableList::<usize, T::ValidatorRegistryLimit>::from(
+        state.get_active_validator_indices(index_epoch),
+    );
+    state.set_active_index_root(
+        index_epoch,
+        Hash256::from_slice(&indices_list.tree_hash_root()),
+        spec,
+    )?;
 
     // Set committees root
-    // Note: we do this out-of-order w.r.t. to the spec, because we don't want the slot to be
-    // incremented. It's safe because the updates to slashings and the RANDAO mix (above) don't
-    // affect this.
     state.set_compact_committee_root(
         next_epoch,
         get_compact_committees_root(state, RelativeEpoch::Next, spec)?,
-        spec,
     )?;
 
+    // Reset slashings
+    state.set_slashings(next_epoch, 0)?;
+
+    // Set randao mix
+    state.set_randao_mix(next_epoch, *state.get_randao_mix(current_epoch)?)?;
+
     // Set historical root accumulator
     if next_epoch.as_u64() % (T::SlotsPerHistoricalRoot::to_u64() / T::slots_per_epoch()) == 0 {
         let historical_batch = state.historical_batch();
@@ -265,6 +250,9 @@ pub fn process_final_updates<T: EthSpec>(
             .push(Hash256::from_slice(&historical_batch.tree_hash_root()))?;
     }
 
+    // Update start shard.
+    state.start_shard = state.get_epoch_start_shard(RelativeEpoch::Next)?;
+
     // Rotate current/previous epoch attestations
     state.previous_epoch_attestations =
         std::mem::replace(&mut state.current_epoch_attestations, VariableList::empty());

eth2/types/src/attestation_data.rs

@@ -4,25 +4,13 @@ use crate::{Checkpoint, Crosslink, Hash256};
 use serde_derive::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
 use test_random_derive::TestRandom;
-use tree_hash::TreeHash;
-use tree_hash_derive::{SignedRoot, TreeHash};
+use tree_hash_derive::TreeHash;
 
 /// The data upon which an attestation is based.
 ///
 /// Spec v0.8.0
 #[derive(
-    Debug,
-    Clone,
-    PartialEq,
-    Eq,
-    Serialize,
-    Deserialize,
-    Hash,
-    Encode,
-    Decode,
-    TreeHash,
-    TestRandom,
-    SignedRoot,
+    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Hash, Encode, Decode, TreeHash, TestRandom,
 )]
 pub struct AttestationData {
     // LMD GHOST vote