Merge conflicts from master

eth2/state_processing/src/block_processable.rs

@@ -4,9 +4,8 @@ use int_to_bytes::int_to_bytes32;
 use log::{debug, trace};
 use ssz::{ssz_encode, TreeHash};
 use types::{
-    beacon_state::{AttestationParticipantsError, BeaconStateError},
-    AggregatePublicKey, Attestation, BeaconBlock, BeaconState, ChainSpec, Crosslink, Epoch, Exit,
-    Fork, Hash256, PendingAttestation, PublicKey, Signature,
+    AggregatePublicKey, Attestation, BeaconBlock, BeaconState, BeaconStateError, ChainSpec,
+    Crosslink, Epoch, Exit, Fork, Hash256, PendingAttestation, PublicKey, RelativeEpoch, Signature,
 };
 
 // TODO: define elsehwere.
@@ -27,7 +26,6 @@ pub enum Error {
     MissingBeaconBlock(Hash256),
     InvalidBeaconBlock(Hash256),
     MissingParentBlock(Hash256),
-    NoBlockProducer,
     StateSlotMismatch,
     BadBlockSignature,
     BadRandaoSignature,
@@ -56,7 +54,7 @@ pub enum AttestationValidationError {
     BadSignature,
     ShardBlockRootNotZero,
     NoBlockRoot,
-    AttestationParticipantsError(AttestationParticipantsError),
+    BeaconStateError(BeaconStateError),
 }
 
 macro_rules! ensure {
@@ -98,12 +96,15 @@ fn per_block_processing_signature_optional(
 ) -> Result<(), Error> {
     ensure!(block.slot == state.slot, Error::StateSlotMismatch);
 
+    // Building the previous epoch could be delayed until an attestation from a previous epoch is
+    // included. This is left for future optimisation.
+    state.build_epoch_cache(RelativeEpoch::Previous, spec)?;
+    state.build_epoch_cache(RelativeEpoch::Current, spec)?;
+
     /*
      * Proposer Signature
      */
-    let block_proposer_index = state
-        .get_beacon_proposer_index(block.slot, spec)
-        .map_err(|_| Error::NoBlockProducer)?;
+    let block_proposer_index = state.get_beacon_proposer_index(block.slot, spec)?;
     let block_proposer = &state.validator_registry[block_proposer_index];
 
     if verify_block_signature {
@@ -361,6 +362,12 @@ fn validate_attestation_signature_optional(
             &attestation.aggregation_bitfield,
             spec,
         )?;
+        trace!(
+            "slot: {}, shard: {}, participants: {:?}",
+            attestation.data.slot,
+            attestation.data.shard,
+            participants
+        );
         let mut group_public_key = AggregatePublicKey::new();
         for participant in participants {
             group_public_key.add(
@@ -415,8 +422,8 @@ impl From<SlotProcessingError> for Error {
     }
 }
 
-impl From<AttestationParticipantsError> for AttestationValidationError {
-    fn from(e: AttestationParticipantsError) -> AttestationValidationError {
-        AttestationValidationError::AttestationParticipantsError(e)
+impl From<BeaconStateError> for AttestationValidationError {
+    fn from(e: BeaconStateError) -> AttestationValidationError {
+        AttestationValidationError::BeaconStateError(e)
     }
 }

eth2/state_processing/src/epoch_processable.rs

@@ -5,9 +5,8 @@ use ssz::TreeHash;
 use std::collections::{HashMap, HashSet};
 use std::iter::FromIterator;
 use types::{
-    beacon_state::{AttestationParticipantsError, BeaconStateError, InclusionError},
-    validator_registry::get_active_validator_indices,
-    BeaconState, ChainSpec, Crosslink, Epoch, Hash256, PendingAttestation,
+    validator_registry::get_active_validator_indices, BeaconState, BeaconStateError, ChainSpec,
+    Crosslink, Epoch, Hash256, InclusionError, PendingAttestation, RelativeEpoch,
 };
 
 macro_rules! safe_add_assign {
@@ -28,7 +27,6 @@ pub enum Error {
     BaseRewardQuotientIsZero,
     NoRandaoSeed,
     BeaconStateError(BeaconStateError),
-    AttestationParticipantsError(AttestationParticipantsError),
     InclusionError(InclusionError),
     WinningRootError(WinningRootError),
 }
@@ -36,7 +34,7 @@ pub enum Error {
 #[derive(Debug, PartialEq)]
 pub enum WinningRootError {
     NoWinningRoot,
-    AttestationParticipantsError(AttestationParticipantsError),
+    BeaconStateError(BeaconStateError),
 }
 
 #[derive(Clone)]
@@ -66,6 +64,11 @@ impl EpochProcessable for BeaconState {
             self.current_epoch(spec)
         );
 
+        // Ensure all of the caches are built.
+        self.build_epoch_cache(RelativeEpoch::Previous, spec)?;
+        self.build_epoch_cache(RelativeEpoch::Current, spec)?;
+        self.build_epoch_cache(RelativeEpoch::Next, spec)?;
+
         /*
          * Validators attesting during the current epoch.
          */
@@ -322,8 +325,11 @@ impl EpochProcessable for BeaconState {
                 slot,
                 slot.epoch(spec.epoch_length)
             );
+
+            // Clone is used to remove the borrow. It becomes an issue later when trying to mutate
+            // `self.balances`.
             let crosslink_committees_at_slot =
-                self.get_crosslink_committees_at_slot(slot, false, spec)?;
+                self.get_crosslink_committees_at_slot(slot, spec)?.clone();
 
             for (crosslink_committee, shard) in crosslink_committees_at_slot {
                 let shard = shard as u64;
@@ -499,8 +505,10 @@ impl EpochProcessable for BeaconState {
          * Crosslinks
          */
         for slot in self.previous_epoch(spec).slot_iter(spec.epoch_length) {
+            // Clone is used to remove the borrow. It becomes an issue later when trying to mutate
+            // `self.balances`.
             let crosslink_committees_at_slot =
-                self.get_crosslink_committees_at_slot(slot, false, spec)?;
+                self.get_crosslink_committees_at_slot(slot, spec)?.clone();
 
             for (_crosslink_committee, shard) in crosslink_committees_at_slot {
                 let shard = shard as u64;
@@ -609,6 +617,12 @@ impl EpochProcessable for BeaconState {
             .cloned()
             .collect();
 
+        /*
+         * Manage the beacon state caches
+         */
+        self.advance_caches();
+        self.build_epoch_cache(RelativeEpoch::Next, spec)?;
+
         debug!("Epoch transition complete.");
 
         Ok(())
@@ -644,20 +658,18 @@ fn winning_root(
             continue;
         }
 
-        // TODO: `cargo fmt` makes this rather ugly; tidy up.
-        let attesting_validator_indices = attestations.iter().try_fold::<_, _, Result<
-            _,
-            AttestationParticipantsError,
-        >>(vec![], |mut acc, a| {
-            if (a.data.shard == shard) && (a.data.shard_block_root == *shard_block_root) {
-                acc.append(&mut state.get_attestation_participants(
-                    &a.data,
-                    &a.aggregation_bitfield,
-                    spec,
-                )?);
-            }
-            Ok(acc)
-        })?;
+        let attesting_validator_indices = attestations
+            .iter()
+            .try_fold::<_, _, Result<_, BeaconStateError>>(vec![], |mut acc, a| {
+                if (a.data.shard == shard) && (a.data.shard_block_root == *shard_block_root) {
+                    acc.append(&mut state.get_attestation_participants(
+                        &a.data,
+                        &a.aggregation_bitfield,
+                        spec,
+                    )?);
+                }
+                Ok(acc)
+            })?;
 
         let total_balance: u64 = attesting_validator_indices
             .iter()
@@ -708,15 +720,9 @@ impl From<BeaconStateError> for Error {
     }
 }
 
-impl From<AttestationParticipantsError> for Error {
-    fn from(e: AttestationParticipantsError) -> Error {
-        Error::AttestationParticipantsError(e)
-    }
-}
-
-impl From<AttestationParticipantsError> for WinningRootError {
-    fn from(e: AttestationParticipantsError) -> WinningRootError {
-        WinningRootError::AttestationParticipantsError(e)
+impl From<BeaconStateError> for WinningRootError {
+    fn from(e: BeaconStateError) -> WinningRootError {
+        WinningRootError::BeaconStateError(e)
     }
 }
 

eth2/state_processing/src/slot_processable.rs

@@ -1,5 +1,5 @@
 use crate::{EpochProcessable, EpochProcessingError};
-use types::{beacon_state::BeaconStateError, BeaconState, ChainSpec, Hash256};
+use types::{BeaconState, BeaconStateError, ChainSpec, Hash256};
 
 #[derive(Debug, PartialEq)]
 pub enum Error {