Merge remote-tracking branch 'origin/unstable' into tree-states

consensus/state_processing/src/per_epoch_processing/altair.rs

@@ -1,4 +1,7 @@
 use super::{process_registry_updates, process_slashings, EpochProcessingSummary, Error};
+use crate::common::update_progressive_balances_cache::{
+    initialize_progressive_balances_cache, update_progressive_balances_on_epoch_transition,
+};
 use crate::epoch_cache::initialize_epoch_cache;
 use crate::per_epoch_processing::{
     effective_balance_updates::process_effective_balance_updates,
@@ -34,6 +37,7 @@ pub fn process_epoch<T: EthSpec>(
     // Pre-compute participating indices and total balances.
     let mut participation_cache = ParticipationCache::new(state, spec)?;
     let sync_committee = state.current_sync_committee()?.clone();
+    initialize_progressive_balances_cache::<T>(state, Some(&participation_cache), spec)?;
 
     // Justification and finalization.
     let justification_and_finalization_state =
@@ -60,7 +64,7 @@ pub fn process_epoch<T: EthSpec>(
     process_eth1_data_reset(state)?;
 
     // Update effective balances with hysteresis (lag).
-    process_effective_balance_updates(state, spec)?;
+    process_effective_balance_updates(state, Some(&participation_cache), spec)?;
 
     // Reset slashings
     process_slashings_reset(state)?;
@@ -80,6 +84,8 @@ pub fn process_epoch<T: EthSpec>(
     state.advance_caches(spec)?;
     initialize_epoch_cache(state, state.next_epoch()?, spec)?;
 
+    update_progressive_balances_on_epoch_transition(state, spec)?;
+
     Ok(EpochProcessingSummary::Altair {
         participation_cache,
         sync_committee,

consensus/state_processing/src/per_epoch_processing/altair/participation_cache.rs

@@ -19,12 +19,12 @@ use types::{
         NUM_FLAG_INDICES, TIMELY_HEAD_FLAG_INDEX, TIMELY_SOURCE_FLAG_INDEX,
         TIMELY_TARGET_FLAG_INDEX,
     },
-    BeaconState, BeaconStateError, ChainSpec, Epoch, EthSpec, ParticipationFlags, RelativeEpoch,
-    Unsigned, Validator,
+    Balance, BeaconState, BeaconStateError, ChainSpec, Epoch, EthSpec, ParticipationFlags,
+    RelativeEpoch, Unsigned, Validator,
 };
 use vec_map::VecMap;
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone)]
 pub enum Error {
     InvalidFlagIndex(usize),
     NoUnslashedParticipatingIndices,
@@ -47,34 +47,8 @@ impl From<ArithError> for Error {
     }
 }
 
-/// A balance which will never be below the specified `minimum`.
-///
-/// This is an effort to ensure the `EFFECTIVE_BALANCE_INCREMENT` minimum is always respected.
-#[derive(PartialEq, Debug, Clone, Copy)]
-struct Balance {
-    raw: u64,
-    minimum: u64,
-}
-
-impl Balance {
-    /// Initialize the balance to `0`, or the given `minimum`.
-    pub fn zero(minimum: u64) -> Self {
-        Self { raw: 0, minimum }
-    }
-
-    /// Returns the balance with respect to the initialization `minimum`.
-    pub fn get(&self) -> u64 {
-        std::cmp::max(self.raw, self.minimum)
-    }
-
-    /// Add-assign to the balance.
-    pub fn safe_add_assign(&mut self, other: u64) -> Result<(), ArithError> {
-        self.raw.safe_add_assign(other)
-    }
-}
-
 /// Caches the participation values for one epoch (either the previous or current).
-#[derive(PartialEq, Debug)]
+#[derive(PartialEq, Debug, Clone)]
 struct SingleEpochParticipationCache {
     /// Stores the sum of the balances for all validators in `self.unslashed_participating_indices`
     /// for all flags in `NUM_FLAG_INDICES`.
@@ -104,6 +78,14 @@ impl SingleEpochParticipationCache {
             .ok_or(Error::InvalidFlagIndex(flag_index))
     }
 
+    /// Returns the raw total balance of attesters who have `flag_index` set.
+    fn total_flag_balance_raw(&self, flag_index: usize) -> Result<Balance, Error> {
+        self.total_flag_balances
+            .get(flag_index)
+            .copied()
+            .ok_or(Error::InvalidFlagIndex(flag_index))
+    }
+
     /// Process an **active** validator, reading from the `epoch_participation` with respect to the
     /// `relative_epoch`.
     ///
@@ -170,7 +152,7 @@ impl ValidatorInfo {
 }
 
 /// Single `HashMap` for validator info relevant to `process_epoch`.
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone)]
 struct ValidatorInfoCache {
     info: Vec<Option<ValidatorInfo>>,
 }
@@ -184,7 +166,7 @@ impl ValidatorInfoCache {
 }
 
 /// Maintains a cache to be used during `altair::process_epoch`.
-#[derive(PartialEq, Debug)]
+#[derive(PartialEq, Debug, Clone)]
 pub struct ParticipationCache {
     current_epoch: Epoch,
     /// Caches information about active validators pertaining to `self.current_epoch`.
@@ -381,6 +363,11 @@ impl ParticipationCache {
             .total_flag_balance(TIMELY_TARGET_FLAG_INDEX)
     }
 
+    pub fn current_epoch_target_attesting_balance_raw(&self) -> Result<Balance, Error> {
+        self.current_epoch_participation
+            .total_flag_balance_raw(TIMELY_TARGET_FLAG_INDEX)
+    }
+
     pub fn previous_epoch_total_active_balance(&self) -> u64 {
         self.previous_epoch_participation.total_active_balance.get()
     }
@@ -389,6 +376,11 @@ impl ParticipationCache {
         self.previous_epoch_flag_attesting_balance(TIMELY_TARGET_FLAG_INDEX)
     }
 
+    pub fn previous_epoch_target_attesting_balance_raw(&self) -> Result<Balance, Error> {
+        self.previous_epoch_participation
+            .total_flag_balance_raw(TIMELY_TARGET_FLAG_INDEX)
+    }
+
     pub fn previous_epoch_source_attesting_balance(&self) -> Result<u64, Error> {
         self.previous_epoch_flag_attesting_balance(TIMELY_SOURCE_FLAG_INDEX)
     }

consensus/state_processing/src/per_epoch_processing/base.rs

@@ -56,7 +56,7 @@ pub fn process_epoch<T: EthSpec>(
     process_eth1_data_reset(state)?;
 
     // Update effective balances with hysteresis (lag).
-    process_effective_balance_updates(state, spec)?;
+    process_effective_balance_updates(state, None, spec)?;
 
     // Reset slashings
     process_slashings_reset(state)?;

consensus/state_processing/src/per_epoch_processing/capella.rs

@@ -11,6 +11,9 @@ use crate::per_epoch_processing::{
 };
 use types::{BeaconState, ChainSpec, EthSpec, RelativeEpoch};
 
+use crate::common::update_progressive_balances_cache::{
+    initialize_progressive_balances_cache, update_progressive_balances_on_epoch_transition,
+};
 use crate::epoch_cache::initialize_epoch_cache;
 pub use historical_summaries_update::process_historical_summaries_update;
 
@@ -30,6 +33,7 @@ pub fn process_epoch<T: EthSpec>(
     // Pre-compute participating indices and total balances.
     let mut participation_cache = ParticipationCache::new(state, spec)?;
     let sync_committee = state.current_sync_committee()?.clone();
+    initialize_progressive_balances_cache(state, Some(&participation_cache), spec)?;
 
     // Justification and finalization.
     let justification_and_finalization_state =
@@ -56,7 +60,7 @@ pub fn process_epoch<T: EthSpec>(
     process_eth1_data_reset(state)?;
 
     // Update effective balances with hysteresis (lag).
-    process_effective_balance_updates(state, spec)?;
+    process_effective_balance_updates(state, Some(&participation_cache), spec)?;
 
     // Reset slashings
     process_slashings_reset(state)?;
@@ -76,6 +80,8 @@ pub fn process_epoch<T: EthSpec>(
     state.advance_caches(spec)?;
     initialize_epoch_cache(state, state.next_epoch()?, spec)?;
 
+    update_progressive_balances_on_epoch_transition(state, spec)?;
+
     Ok(EpochProcessingSummary::Altair {
         participation_cache,
         sync_committee,

consensus/state_processing/src/per_epoch_processing/effective_balance_updates.rs

@@ -1,11 +1,13 @@
 use super::errors::EpochProcessingError;
+use crate::per_epoch_processing::altair::ParticipationCache;
 use safe_arith::SafeArith;
 use types::beacon_state::BeaconState;
 use types::chain_spec::ChainSpec;
-use types::{BeaconStateError, EthSpec};
+use types::{BeaconStateError, EthSpec, ProgressiveBalancesCache};
 
 pub fn process_effective_balance_updates<T: EthSpec>(
     state: &mut BeaconState<T>,
+    maybe_participation_cache: Option<&ParticipationCache>,
     spec: &ChainSpec,
 ) -> Result<(), EpochProcessingError> {
     // Compute new total active balance for the next epoch as a side-effect of iterating the
@@ -18,7 +20,8 @@ pub fn process_effective_balance_updates<T: EthSpec>(
         .safe_div(spec.hysteresis_quotient)?;
     let downward_threshold = hysteresis_increment.safe_mul(spec.hysteresis_downward_multiplier)?;
     let upward_threshold = hysteresis_increment.safe_mul(spec.hysteresis_upward_multiplier)?;
-    let (validators, balances) = state.validators_and_balances_mut();
+    let (validators, balances, progressive_balances_cache) =
+        state.validators_and_balances_and_progressive_balances_mut();
     let mut validators_iter = validators.iter_cow();
 
     while let Some((index, validator)) = validators_iter.next_cow() {
@@ -44,7 +47,18 @@ pub fn process_effective_balance_updates<T: EthSpec>(
         }
 
         if new_effective_balance != validator.effective_balance() {
+            let old_effective_balance = validator.effective_balance();
             validator.to_mut().mutable.effective_balance = new_effective_balance;
+
+            if let Some(participation_cache) = maybe_participation_cache {
+                update_progressive_balances(
+                    participation_cache,
+                    progressive_balances_cache,
+                    index,
+                    old_effective_balance,
+                    new_effective_balance,
+                )?;
+            }
         }
     }
 
@@ -52,3 +66,22 @@ pub fn process_effective_balance_updates<T: EthSpec>(
 
     Ok(())
 }
+
+fn update_progressive_balances(
+    participation_cache: &ParticipationCache,
+    progressive_balances_cache: &mut ProgressiveBalancesCache,
+    index: usize,
+    old_effective_balance: u64,
+    new_effective_balance: u64,
+) -> Result<(), EpochProcessingError> {
+    if old_effective_balance != new_effective_balance {
+        let is_current_epoch_target_attester =
+            participation_cache.is_current_epoch_timely_target_attester(index)?;
+        progressive_balances_cache.on_effective_balance_change(
+            is_current_epoch_target_attester,
+            old_effective_balance,
+            new_effective_balance,
+        )?;
+    }
+    Ok(())
+}