[Merged by Bors] - Cache target attester balances for unrealized FFG progression calculation

beacon_node/store/src/partial_beacon_state.rs

@@ -373,6 +373,7 @@ macro_rules! impl_try_into_beacon_state {
 
             // Caching
             total_active_balance: <_>::default(),
+            progressive_balances_cache: <_>::default(),
             committee_caches: <_>::default(),
             pubkey_cache: <_>::default(),
             exit_cache: <_>::default(),

consensus/fork_choice/src/fork_choice.rs

@@ -5,13 +5,15 @@ use proto_array::{
 };
 use slog::{crit, debug, warn, Logger};
 use ssz_derive::{Decode, Encode};
+use state_processing::per_epoch_processing::altair::ParticipationCache;
 use state_processing::{
     per_block_processing::errors::AttesterSlashingValidationError, per_epoch_processing,
 };
 use std::cmp::Ordering;
 use std::collections::BTreeSet;
 use std::marker::PhantomData;
 use std::time::Duration;
+use types::ProgressiveBalancesCache;
 use types::{
     consts::merge::INTERVALS_PER_SLOT, AbstractExecPayload, AttestationShufflingId,
     AttesterSlashing, BeaconBlockRef, BeaconState, BeaconStateError, ChainSpec, Checkpoint, Epoch,
@@ -758,9 +760,15 @@ where
                         BeaconBlockRef::Capella(_)
                         | BeaconBlockRef::Merge(_)
                         | BeaconBlockRef::Altair(_) => {
-                            let participation_cache =
-                                per_epoch_processing::altair::ParticipationCache::new(state, spec)
-                                    .map_err(Error::ParticipationCacheBuild)?;
+                            let participation_cache = ParticipationCache::new(state, spec)
+                                .map_err(Error::ParticipationCacheBuild)?;
+
+                            check_progressive_balances_cache(
+                                state.progressive_balances_cache(),
+                                &participation_cache,
+                                spec,
+                            );
+
                             per_epoch_processing::altair::process_justification_and_finalization(
                                 state,
                                 &participation_cache,
@@ -1520,6 +1528,63 @@ where
     }
 }
 
+/// Check the `ProgressiveBalancesCache` values against the computed `ParticipationCache`.
+///
+/// ## Panics  
+///
+/// In debug mode (`debug_assertions` set to `true`), this function panics if the cached progressive
+/// balances doesn't match computed values from `ParticipationCache`, or if it fails to perform the
+/// check.
+fn check_progressive_balances_cache(
+    progressive_balances_cache: &ProgressiveBalancesCache,
+    participation_cache: &ParticipationCache,
+    spec: &ChainSpec,
+) {
+    let do_check = || {
+        // FIXME[JC]: Converts value to 0 if it is the same as `EFFECTIVE_BALANCE_INCREMENT`.
+        // `ParticipationCache` methods return `EFFECTIVE_BALANCE_INCREMENT` (1,000,000,000)
+        // when the balance is 0, and this breaks our calculation.
+        let handle_zero_effective_balance = |val| {
+            if val == spec.effective_balance_increment {
+                0
+            } else {
+                val
+            }
+        };
+
+        let previous_target_balance = participation_cache
+            .previous_epoch_target_attesting_balance()
+            .map_err(|e| BeaconStateError::ParticipationCacheError(format!("{:?}", e)))?;
+        let cached_previous_target_balance =
+            progressive_balances_cache.previous_epoch_target_attesting_balance()?;
+
+        debug_assert!(
+            handle_zero_effective_balance(previous_target_balance) == cached_previous_target_balance,
+            "Previous epoch target attesting balance from progressive cache does not match computed value."
+        );
+
+        let current_target_balance = participation_cache
+            .current_epoch_target_attesting_balance()
+            .map_err(|e| BeaconStateError::ParticipationCacheError(format!("{:?}", e)))?;
+        let cached_current_target_balance =
+            progressive_balances_cache.current_epoch_target_attesting_balance()?;
+
+        debug_assert!(
+            handle_zero_effective_balance(current_target_balance) == cached_current_target_balance,
+            "Current epoch target attesting balance from progressive cache does not match computed value."
+        );
+
+        Ok(())
+    };
+
+    let result: Result<(), BeaconStateError> = do_check();
+    debug_assert!(
+        result.is_ok(),
+        "An error occurred while checking progressive balances: {:?}",
+        result.err()
+    );
+}
+
 /// Helper struct that is used to encode/decode the state of the `ForkChoice` as SSZ bytes.
 ///
 /// This is used when persisting the state of the fork choice to disk.

consensus/state_processing/src/common/initialize_progressive_balances_cache.rs

@@ -0,0 +1,61 @@
+use crate::per_epoch_processing::altair::ParticipationCache;
+use std::borrow::Cow;
+use types::{BeaconState, BeaconStateError, ChainSpec, EthSpec};
+
+/// Initializes the `ProgressiveBalancesCache` cache using balance values from the
+/// `ParticipationCache`. If the optional `&ParticipationCache` is not supplied, it will be computed
+/// from the `BeaconState`.
+pub fn initialize_progressive_balances_cache<E: EthSpec>(
+    state: &mut BeaconState<E>,
+    maybe_participation_cache: Option<&ParticipationCache>,
+    spec: &ChainSpec,
+) -> Result<(), BeaconStateError> {
+    if !is_progressive_balances_enabled(state)
+        || state.progressive_balances_cache().is_initialized()
+    {
+        return Ok(());
+    }
+
+    let participation_cache = match maybe_participation_cache {
+        Some(cache) => Cow::Borrowed(cache),
+        None => Cow::Owned(ParticipationCache::new(state, spec)?),
+    };
+
+    // FIXME[JC]: Converts value to 0 if it is the same as `EFFECTIVE_BALANCE_INCREMENT`.
+    // `ParticipationCache` methods return `EFFECTIVE_BALANCE_INCREMENT` (1,000,000,000)
+    // when the balance is 0, and this breaks our calculation.
+    let handle_zero_effective_balance = |val| {
+        if val == spec.effective_balance_increment {
+            0
+        } else {
+            val
+        }
+    };
+
+    let previous_epoch_target_attesting_balance = participation_cache
+        .previous_epoch_target_attesting_balance()
+        .map(handle_zero_effective_balance)
+        .map_err(|e| BeaconStateError::ParticipationCacheError(format!("{:?}", e)))?;
+
+    let current_epoch_target_attesting_balance = participation_cache
+        .current_epoch_target_attesting_balance()
+        .map(handle_zero_effective_balance)
+        .map_err(|e| BeaconStateError::ParticipationCacheError(format!("{:?}", e)))?;
+
+    let current_epoch = state.current_epoch();
+    state.progressive_balances_cache_mut().initialize(
+        current_epoch,
+        previous_epoch_target_attesting_balance,
+        current_epoch_target_attesting_balance,
+    );
+
+    Ok(())
+}
+
+/// `ProgressiveBalancesCache` is only enabled from `Altair` as it requires `ParticipationCache`.
+fn is_progressive_balances_enabled<E: EthSpec>(state: &BeaconState<E>) -> bool {
+    match state {
+        BeaconState::Base(_) => false,
+        BeaconState::Altair(_) | BeaconState::Merge(_) | BeaconState::Capella(_) => true,
+    }
+}

consensus/state_processing/src/common/mod.rs

@@ -7,6 +7,7 @@ mod slash_validator;
 
 pub mod altair;
 pub mod base;
+pub mod initialize_progressive_balances_cache;
 
 pub use deposit_data_tree::DepositDataTree;
 pub use get_attestation_participation::get_attestation_participation_flag_indices;

consensus/state_processing/src/genesis.rs

@@ -115,7 +115,7 @@ pub fn process_activations<T: EthSpec>(
     state: &mut BeaconState<T>,
     spec: &ChainSpec,
 ) -> Result<(), Error> {
-    let (validators, balances) = state.validators_and_balances_mut();
+    let (validators, balances, _) = state.validators_and_balances_and_progressive_balances_mut();
     for (index, validator) in validators.iter_mut().enumerate() {
         let balance = balances
             .get(index)

consensus/state_processing/src/per_block_processing.rs

@@ -41,6 +41,7 @@ mod verify_proposer_slashing;
 use crate::common::decrease_balance;
 use crate::StateProcessingStrategy;
 
+use crate::common::initialize_progressive_balances_cache::initialize_progressive_balances_cache;
 #[cfg(feature = "arbitrary-fuzz")]
 use arbitrary::Arbitrary;
 
@@ -114,6 +115,8 @@ pub fn per_block_processing<T: EthSpec, Payload: AbstractExecPayload<T>>(
         .fork_name(spec)
         .map_err(BlockProcessingError::InconsistentStateFork)?;
 
+    initialize_progressive_balances_cache(state, None, spec)?;
+
     let verify_signatures = match block_signature_strategy {
         BlockSignatureStrategy::VerifyBulk => {
             // Verify all signatures in the block at once.

consensus/state_processing/src/per_block_processing/errors.rs

@@ -1,6 +1,8 @@
 use super::signature_sets::Error as SignatureSetError;
+use crate::per_epoch_processing::altair::participation_cache;
 use crate::ContextError;
 use merkle_proof::MerkleTreeError;
+use participation_cache::Error as ParticipationCacheError;
 use safe_arith::ArithError;
 use ssz::DecodeError;
 use types::*;
@@ -83,6 +85,7 @@ pub enum BlockProcessingError {
         found: Hash256,
     },
     WithdrawalCredentialsInvalid,
+    ParticipationCacheError(ParticipationCacheError),
 }
 
 impl From<BeaconStateError> for BlockProcessingError {
@@ -140,6 +143,12 @@ impl From<BlockOperationError<HeaderInvalid>> for BlockProcessingError {
     }
 }
 
+impl From<ParticipationCacheError> for BlockProcessingError {
+    fn from(e: ParticipationCacheError) -> Self {
+        BlockProcessingError::ParticipationCacheError(e)
+    }
+}
+
 /// A conversion that consumes `self` and adds an `index` variable to resulting struct.
 ///
 /// Used here to allow converting an error into an upstream error that points to the object that

consensus/state_processing/src/per_block_processing/process_operations.rs

@@ -7,7 +7,9 @@ use crate::common::{
 use crate::per_block_processing::errors::{BlockProcessingError, IntoWithIndex};
 use crate::VerifySignatures;
 use safe_arith::SafeArith;
-use types::consts::altair::{PARTICIPATION_FLAG_WEIGHTS, PROPOSER_WEIGHT, WEIGHT_DENOMINATOR};
+use types::consts::altair::{
+    PARTICIPATION_FLAG_WEIGHTS, PROPOSER_WEIGHT, TIMELY_TARGET_FLAG_INDEX, WEIGHT_DENOMINATOR,
+};
 
 pub fn process_operations<T: EthSpec, Payload: AbstractExecPayload<T>>(
     state: &mut BeaconState<T>,
@@ -97,6 +99,7 @@ pub mod base {
 
 pub mod altair {
     use super::*;
+    use types::consts::altair::TIMELY_TARGET_FLAG_INDEX;
 
     pub fn process_attestations<T: EthSpec>(
         state: &mut BeaconState<T>,
@@ -163,6 +166,15 @@ pub mod altair {
                         get_base_reward(state, index, base_reward_per_increment, spec)?
                             .safe_mul(weight)?,
                     )?;
+                    if flag_index == TIMELY_TARGET_FLAG_INDEX {
+                        let validator_effective_balance = state.get_effective_balance(index)?;
+                        state
+                            .progressive_balances_cache_mut()
+                            .on_new_target_attestation(
+                                data.target.epoch,
+                                validator_effective_balance,
+                            )?;
+                    }
                 }
             }
         }
@@ -230,11 +242,34 @@ pub fn process_attester_slashings<T: EthSpec>(
 
         for i in slashable_indices {
             slash_validator(state, i as usize, None, ctxt, spec)?;
+            update_progressive_balances_cache(state, i as usize)?;
         }
     }
 
     Ok(())
 }
+
+fn update_progressive_balances_cache<T: EthSpec>(
+    state: &mut BeaconState<T>,
+    validator_index: usize,
+) -> Result<(), BlockProcessingError> {
+    if let Ok(current_epoch_participation) = state.current_epoch_participation() {
+        let current_epoch_participation = current_epoch_participation;
+        let participation_flags = current_epoch_participation
+            .get(validator_index)
+            .ok_or(BeaconStateError::UnknownValidator(validator_index))?;
+        let is_current_epoch_target_attester =
+            participation_flags.has_flag(TIMELY_TARGET_FLAG_INDEX)?;
+        let validator_effective_balance = state.get_effective_balance(validator_index)?;
+        state.progressive_balances_cache_mut().on_slashing(
+            is_current_epoch_target_attester,
+            validator_effective_balance,
+        )?;
+    }
+
+    Ok(())
+}
+
 /// Wrapper function to handle calling the correct version of `process_attestations` based on
 /// the fork.
 pub fn process_attestations<T: EthSpec, Payload: AbstractExecPayload<T>>(

consensus/state_processing/src/per_epoch_processing/altair.rs

@@ -1,4 +1,5 @@
 use super::{process_registry_updates, process_slashings, EpochProcessingSummary, Error};
+use crate::common::initialize_progressive_balances_cache::initialize_progressive_balances_cache;
 use crate::per_epoch_processing::{
     effective_balance_updates::process_effective_balance_updates,
     historical_roots_update::process_historical_roots_update,
@@ -31,6 +32,7 @@ pub fn process_epoch<T: EthSpec>(
     // Pre-compute participating indices and total balances.
     let 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 =
@@ -56,7 +58,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)?;
@@ -75,6 +77,11 @@ pub fn process_epoch<T: EthSpec>(
     // Rotate the epoch caches to suit the epoch transition.
     state.advance_caches(spec)?;
 
+    // Update progressive total balances
+    state
+        .progressive_balances_cache_mut()
+        .on_epoch_transition()?;
+
     Ok(EpochProcessingSummary::Altair {
         participation_cache,
         sync_committee,

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

@@ -20,7 +20,7 @@ use types::{
     BeaconState, BeaconStateError, ChainSpec, Epoch, EthSpec, ParticipationFlags, RelativeEpoch,
 };
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone)]
 pub enum Error {
     InvalidFlagIndex(usize),
     InvalidValidatorIndex(usize),
@@ -53,7 +53,7 @@ impl Balance {
 }
 
 /// Caches the participation values for one epoch (either the previous or current).
-#[derive(PartialEq, Debug)]
+#[derive(PartialEq, Debug, Clone)]
 struct SingleEpochParticipationCache {
     /// Maps an active validator index to their participation flags.
     ///
@@ -173,7 +173,7 @@ impl SingleEpochParticipationCache {
 }
 
 /// 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`.

consensus/state_processing/src/per_epoch_processing/base.rs

@@ -52,7 +52,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)?;