Track slashed indices

beacon_node/beacon_chain/src/beacon_fork_choice_store.rs

@@ -11,6 +11,7 @@ use proto_array::JustifiedBalances;
 use safe_arith::ArithError;
 use ssz_derive::{Decode, Encode};
 use std::collections::BTreeSet;
+use std::iter::FromIterator;
 use std::marker::PhantomData;
 use std::sync::Arc;
 use store::{Error as StoreError, HotColdDB, ItemStore};
@@ -186,6 +187,8 @@ where
         };
         let finalized_checkpoint = justified_checkpoint;
         let justified_balances = JustifiedBalances::from_justified_state(anchor_state)?;
+        let equivocating_indices =
+            BTreeSet::from_iter(justified_balances.slashed_indices.iter().copied());
 
         Ok(Self {
             store,
@@ -198,7 +201,7 @@ where
             unrealized_justified_checkpoint: justified_checkpoint,
             unrealized_finalized_checkpoint: finalized_checkpoint,
             proposer_boost_root: Hash256::zero(),
-            equivocating_indices: BTreeSet::new(),
+            equivocating_indices,
             _phantom: PhantomData,
         })
     }
@@ -328,6 +331,8 @@ where
                 .ok_or_else(|| Error::MissingState(justified_block.state_root()))?;
 
             self.justified_balances = JustifiedBalances::from_justified_state(&state)?;
+            self.equivocating_indices
+                .extend(self.justified_balances.slashed_indices.iter().copied());
         }
 
         Ok(())

consensus/proto_array/src/justified_balances.rs

@@ -1,4 +1,5 @@
 use safe_arith::{ArithError, SafeArith};
+use std::collections::HashSet;
 use types::{BeaconState, EthSpec};
 
 #[derive(Debug, PartialEq, Clone, Default)]
@@ -12,18 +13,26 @@ pub struct JustifiedBalances {
     pub total_effective_balance: u64,
     /// The number of active validators included in `self.effective_balances`.
     pub num_active_validators: u64,
+    /// The set of all slashed validators.
+    pub slashed_indices: HashSet<u64>,
 }
 
 impl JustifiedBalances {
     pub fn from_justified_state<T: EthSpec>(state: &BeaconState<T>) -> Result<Self, ArithError> {
         let current_epoch = state.current_epoch();
         let mut total_effective_balance = 0u64;
         let mut num_active_validators = 0u64;
+        let mut slashed_indices = HashSet::new();
 
         let effective_balances = state
             .validators()
             .iter()
-            .map(|validator| {
+            .enumerate()
+            .map(|(validator_index, validator)| {
+                if validator.slashed {
+                    slashed_indices.insert(validator_index as u64);
+                }
+
                 if validator.is_active_at(current_epoch) {
                     total_effective_balance.safe_add_assign(validator.effective_balance)?;
                     num_active_validators.safe_add_assign(1)?;
@@ -39,6 +48,7 @@ impl JustifiedBalances {
             effective_balances,
             total_effective_balance,
             num_active_validators,
+            slashed_indices,
         })
     }
 
@@ -57,6 +67,8 @@ impl JustifiedBalances {
             effective_balances,
             total_effective_balance,
             num_active_validators,
+            // TODO(paul): is an empty set sensible?
+            slashed_indices: <_>::default(),
         })
     }
 }