Add EpochCache

Author: paulhauner

consensus/state_processing/src/per_epoch_processing/altair.rs

@@ -5,17 +5,17 @@ use crate::per_epoch_processing::{
     resets::{process_eth1_data_reset, process_randao_mixes_reset, process_slashings_reset},
     validator_statuses::ValidatorStatuses,
 };
+pub use epoch_cache::EpochCache;
 pub use inactivity_updates::process_inactivity_updates;
 pub use justification_and_finalization::process_justification_and_finalization;
-pub use participation_cache::ParticipationCache;
 pub use participation_flag_updates::process_participation_flag_updates;
 pub use rewards_and_penalties::process_rewards_and_penalties;
 pub use sync_committee_updates::process_sync_committee_updates;
 use types::{BeaconState, ChainSpec, EthSpec, RelativeEpoch};
 
+pub mod epoch_cache;
 pub mod inactivity_updates;
 pub mod justification_and_finalization;
-pub mod participation_cache;
 pub mod participation_flag_updates;
 pub mod rewards_and_penalties;
 pub mod sync_committee_updates;
@@ -29,15 +29,15 @@ pub fn process_epoch<T: EthSpec>(
     state.build_committee_cache(RelativeEpoch::Current, spec)?;
     state.build_committee_cache(RelativeEpoch::Next, spec)?;
 
-    let participation_cache = ParticipationCache::altair(state, spec)?;
+    let cache = EpochCache::new(state, spec)?;
 
     // Justification and finalization.
-    process_justification_and_finalization(state, &participation_cache, spec)?;
+    process_justification_and_finalization(state, &cache, spec)?;
 
-    process_inactivity_updates(state, &participation_cache, spec)?;
+    process_inactivity_updates(state, &cache, spec)?;
 
     // Rewards and Penalties.
-    process_rewards_and_penalties(state, &participation_cache, spec)?;
+    process_rewards_and_penalties(state, &cache, spec)?;
 
     // Registry Updates.
     process_registry_updates(state, spec)?;
@@ -81,6 +81,6 @@ pub fn process_epoch<T: EthSpec>(
 
     Ok(EpochProcessingSummary::Altair {
         total_balances: validator_statuses.total_balances,
-        participation_cache,
+        participation_cache: cache.participation,
     })
 }

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

@@ -0,0 +1,19 @@
+pub use participation_cache::ParticipationCache;
+use types::{BeaconState, BeaconStateError, ChainSpec, EthSpec};
+
+mod participation_cache;
+
+pub struct EpochCache {
+    pub participation: ParticipationCache,
+}
+
+impl EpochCache {
+    pub fn new<T: EthSpec>(
+        state: &BeaconState<T>,
+        spec: &ChainSpec,
+    ) -> Result<Self, BeaconStateError> {
+        Ok(Self {
+            participation: ParticipationCache::new(state, spec)?,
+        })
+    }
+}

consensus/state_processing/src/per_epoch_processing/altair/participation_cache.rs renamed to consensus/state_processing/src/per_epoch_processing/altair/epoch_cache/participation_cache.rs

@@ -17,7 +17,7 @@ pub struct ParticipationCache {
 }
 
 impl ParticipationCache {
-    pub fn altair<T: EthSpec>(
+    pub fn new<T: EthSpec>(
         state: &BeaconState<T>,
         spec: &ChainSpec,
     ) -> Result<Self, BeaconStateError> {

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

@@ -1,4 +1,4 @@
-use super::ParticipationCache;
+use super::EpochCache;
 use crate::EpochProcessingError;
 use core::result::Result;
 use core::result::Result::Ok;
@@ -11,15 +11,16 @@ use types::eth_spec::EthSpec;
 
 pub fn process_inactivity_updates<T: EthSpec>(
     state: &mut BeaconState<T>,
-    participation_cache: &ParticipationCache,
+    cache: &EpochCache,
     spec: &ChainSpec,
 ) -> Result<(), EpochProcessingError> {
     // Score updates based on previous epoch participation, skip genesis epoch
     if state.current_epoch() == T::genesis_epoch() {
         return Ok(());
     }
 
-    let unslashed_indices = participation_cache
+    let unslashed_indices = cache
+        .participation
         .get_unslashed_participating_indices(TIMELY_TARGET_FLAG_INDEX, state.previous_epoch())?;
 
     for index in state.get_eligible_validator_indices()? {

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

@@ -1,4 +1,4 @@
-use super::ParticipationCache;
+use super::EpochCache;
 use crate::per_epoch_processing::weigh_justification_and_finalization;
 use crate::per_epoch_processing::Error;
 use safe_arith::SafeArith;
@@ -8,7 +8,7 @@ use types::{BeaconState, ChainSpec, EthSpec};
 /// Update the justified and finalized checkpoints for matching target attestations.
 pub fn process_justification_and_finalization<T: EthSpec>(
     state: &mut BeaconState<T>,
-    participation_cache: &ParticipationCache,
+    cache: &EpochCache,
     spec: &ChainSpec,
 ) -> Result<(), Error> {
     if state.current_epoch() <= T::genesis_epoch().safe_add(1)? {
@@ -17,9 +17,11 @@ pub fn process_justification_and_finalization<T: EthSpec>(
 
     let previous_epoch = state.previous_epoch();
     let current_epoch = state.current_epoch();
-    let previous_indices = participation_cache
+    let previous_indices = cache
+        .participation
         .get_unslashed_participating_indices(TIMELY_TARGET_FLAG_INDEX, previous_epoch)?;
-    let current_indices = participation_cache
+    let current_indices = cache
+        .participation
         .get_unslashed_participating_indices(TIMELY_TARGET_FLAG_INDEX, current_epoch)?;
     let total_active_balance = state.get_total_balance(
         state

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

@@ -1,4 +1,4 @@
-use super::ParticipationCache;
+use super::EpochCache;
 use safe_arith::SafeArith;
 use types::consts::altair::{
     PARTICIPATION_FLAG_WEIGHTS, TIMELY_HEAD_FLAG_INDEX, TIMELY_TARGET_FLAG_INDEX,
@@ -14,7 +14,7 @@ use crate::per_epoch_processing::{Delta, Error};
 /// Spec v1.1.0
 pub fn process_rewards_and_penalties<T: EthSpec>(
     state: &mut BeaconState<T>,
-    participation_cache: &ParticipationCache,
+    cache: &EpochCache,
     spec: &ChainSpec,
 ) -> Result<(), Error> {
     if state.current_epoch() == T::genesis_epoch() {
@@ -31,12 +31,12 @@ pub fn process_rewards_and_penalties<T: EthSpec>(
             state,
             flag_index,
             total_active_balance,
-            participation_cache,
+            cache,
             spec,
         )?;
     }
 
-    get_inactivity_penalty_deltas(&mut deltas, state, participation_cache, spec)?;
+    get_inactivity_penalty_deltas(&mut deltas, state, cache, spec)?;
 
     // Apply the deltas, erroring on overflow above but not on overflow below (saturating at 0
     // instead).
@@ -56,12 +56,13 @@ pub fn get_flag_index_deltas<T: EthSpec>(
     state: &BeaconState<T>,
     flag_index: usize,
     total_active_balance: u64,
-    participation_cache: &ParticipationCache,
+    cache: &EpochCache,
     spec: &ChainSpec,
 ) -> Result<(), Error> {
     let previous_epoch = state.previous_epoch();
-    let unslashed_participating_indices =
-        participation_cache.get_unslashed_participating_indices(flag_index, previous_epoch)?;
+    let unslashed_participating_indices = cache
+        .participation
+        .get_unslashed_participating_indices(flag_index, previous_epoch)?;
     let weight = get_flag_weight(flag_index)?;
     let unslashed_participating_balance =
         state.get_total_balance(&unslashed_participating_indices, spec)?;
@@ -104,11 +105,12 @@ pub fn get_flag_weight(flag_index: usize) -> Result<u64, Error> {
 pub fn get_inactivity_penalty_deltas<T: EthSpec>(
     deltas: &mut Vec<Delta>,
     state: &BeaconState<T>,
-    participation_cache: &ParticipationCache,
+    cache: &EpochCache,
     spec: &ChainSpec,
 ) -> Result<(), Error> {
     let previous_epoch = state.previous_epoch();
-    let matching_target_indices = participation_cache
+    let matching_target_indices = cache
+        .participation
         .get_unslashed_participating_indices(TIMELY_TARGET_FLAG_INDEX, previous_epoch)?;
     for index in state.get_eligible_validator_indices()? {
         let mut delta = Delta::default();

consensus/state_processing/src/per_epoch_processing/epoch_processing_summary.rs

@@ -1,5 +1,5 @@
 use super::{
-    altair::ParticipationCache,
+    altair::epoch_cache::ParticipationCache,
     base::{TotalBalances, ValidatorStatus},
     validator_statuses::InclusionInfo,
 };