Implement tree states & hierarchical state DB

account_manager/src/validator/exit.rs

@@ -210,8 +210,8 @@ async fn publish_voluntary_exit<E: EthSpec>(
         let validator_data = get_validator_data(client, &keypair.pk).await?;
         match validator_data.status {
             ValidatorStatus::ActiveExiting => {
-                let exit_epoch = validator_data.validator.exit_epoch;
-                let withdrawal_epoch = validator_data.validator.withdrawable_epoch;
+                let exit_epoch = validator_data.validator.exit_epoch();
+                let withdrawal_epoch = validator_data.validator.withdrawable_epoch();
                 let current_epoch = get_current_epoch::<E>(genesis_data.genesis_time, spec)
                     .ok_or("Failed to get current epoch. Please check your system time")?;
                 eprintln!("Voluntary exit has been accepted into the beacon chain, but not yet finalized. \
@@ -231,7 +231,7 @@ async fn publish_voluntary_exit<E: EthSpec>(
             ValidatorStatus::ExitedSlashed | ValidatorStatus::ExitedUnslashed => {
                 eprintln!(
                     "Validator has exited on epoch: {}",
-                    validator_data.validator.exit_epoch
+                    validator_data.validator.exit_epoch()
                 );
                 break;
             }
@@ -257,7 +257,7 @@ async fn get_validator_index_for_exit(
         ValidatorStatus::ActiveOngoing => {
             let eligible_epoch = validator_data
                 .validator
-                .activation_epoch
+                .activation_epoch()
                 .safe_add(spec.shard_committee_period)
                 .map_err(|e| format!("Failed to calculate eligible epoch, validator activation epoch too high: {:?}", e))?;
 

beacon_node/beacon_chain/Cargo.toml

@@ -60,11 +60,12 @@ strum = { version = "0.24.0", features = ["derive"] }
 logging = { path = "../../common/logging" }
 execution_layer = { path = "../execution_layer" }
 sensitive_url = { path = "../../common/sensitive_url" }
-superstruct = "0.5.0"
+superstruct = "0.7.0"
 hex = "0.4.2"
 exit-future = "0.2.0"
 unused_port = {path = "../../common/unused_port"}
 oneshot_broadcast = { path = "../../common/oneshot_broadcast" }
+crossbeam-channel = "0.5.5"
 
 [[test]]
 name = "beacon_chain_tests"

beacon_node/beacon_chain/src/attestation_rewards.rs

@@ -42,7 +42,8 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             .ok_or(BeaconChainError::MissingBeaconState(state_root))?;
 
         // Calculate ideal_rewards
-        let participation_cache = ParticipationCache::new(&state, spec)?;
+        let participation_cache = ParticipationCache::new(&state, spec)
+            .map_err(|_| BeaconChainError::AttestationRewardsError)?;
 
         let previous_epoch = state.previous_epoch();
 
@@ -52,13 +53,9 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             let weight = get_flag_weight(flag_index)
                 .map_err(|_| BeaconChainError::AttestationRewardsError)?;
 
-            let unslashed_participating_indices = participation_cache
-                .get_unslashed_participating_indices(flag_index, previous_epoch)?;
-
-            let unslashed_participating_balance =
-                unslashed_participating_indices
-                    .total_balance()
-                    .map_err(|_| BeaconChainError::AttestationRewardsError)?;
+            let unslashed_participating_balance = participation_cache
+                .previous_epoch_flag_attesting_balance(flag_index)
+                .map_err(|_| BeaconChainError::AttestationRewardsError)?;
 
             let unslashed_participating_increments =
                 unslashed_participating_balance.safe_div(spec.effective_balance_increment)?;
@@ -112,23 +109,24 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                 .collect::<Result<Vec<_>, _>>()?
         };
 
-        for validator_index in &validators {
-            let eligible = state.is_eligible_validator(previous_epoch, *validator_index)?;
+        for &validator_index in &validators {
+            let validator = participation_cache
+                .get_validator(validator_index)
+                .map_err(|_| BeaconChainError::AttestationRewardsError)?;
+            let eligible = validator.is_eligible;
             let mut head_reward = 0u64;
             let mut target_reward = 0i64;
             let mut source_reward = 0i64;
 
             if eligible {
-                let effective_balance = state.get_effective_balance(*validator_index)?;
+                let effective_balance = validator.effective_balance;
 
                 for flag_index in 0..PARTICIPATION_FLAG_WEIGHTS.len() {
                     let (ideal_reward, penalty) = ideal_rewards_hashmap
                         .get(&(flag_index, effective_balance))
                         .ok_or(BeaconChainError::AttestationRewardsError)?;
-                    let voted_correctly = participation_cache
-                        .get_unslashed_participating_indices(flag_index, previous_epoch)
-                        .map_err(|_| BeaconChainError::AttestationRewardsError)?
-                        .contains(*validator_index)
+                    let voted_correctly = validator
+                        .is_unslashed_participating_index(flag_index)
                         .map_err(|_| BeaconChainError::AttestationRewardsError)?;
                     if voted_correctly {
                         if flag_index == TIMELY_HEAD_FLAG_INDEX {
@@ -148,7 +146,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                 }
             }
             total_rewards.push(TotalAttestationRewards {
-                validator_index: *validator_index as u64,
+                validator_index: validator_index as u64,
                 head: head_reward,
                 target: target_reward,
                 source: source_reward,

beacon_node/beacon_chain/src/beacon_block_reward.rs

@@ -4,12 +4,11 @@ use operation_pool::RewardCache;
 use safe_arith::SafeArith;
 use slog::error;
 use state_processing::{
-    common::{
-        altair, get_attestation_participation_flag_indices, get_attesting_indices_from_state,
-    },
+    common::{get_attestation_participation_flag_indices, get_attesting_indices_from_state},
     per_block_processing::{
         altair::sync_committee::compute_sync_aggregate_rewards, get_slashable_indices,
     },
+    ConsensusContext,
 };
 use store::{
     consts::altair::{PARTICIPATION_FLAG_WEIGHTS, PROPOSER_WEIGHT, WEIGHT_DENOMINATOR},
@@ -124,7 +123,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             proposer_slashing_reward.safe_add_assign(
                 state
                     .get_validator(proposer_slashing.proposer_index() as usize)?
-                    .effective_balance
+                    .effective_balance()
                     .safe_div(self.spec.whistleblower_reward_quotient)?,
             )?;
         }
@@ -146,7 +145,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                 attester_slashing_reward.safe_add_assign(
                     state
                         .get_validator(attester_index as usize)?
-                        .effective_balance
+                        .effective_balance()
                         .safe_div(self.spec.whistleblower_reward_quotient)?,
                 )?;
             }
@@ -178,9 +177,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         block: BeaconBlockRef<'_, T::EthSpec, Payload>,
         state: &mut BeaconState<T::EthSpec>,
     ) -> Result<BeaconBlockSubRewardValue, BeaconChainError> {
-        let total_active_balance = state.get_total_active_balance()?;
-        let base_reward_per_increment =
-            altair::BaseRewardPerIncrement::new(total_active_balance, &self.spec)?;
+        let mut ctxt = ConsensusContext::new(block.slot());
 
         let mut total_proposer_reward = 0;
 
@@ -216,13 +213,9 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                     {
                         validator_participation.add_flag(flag_index)?;
                         proposer_reward_numerator.safe_add_assign(
-                            altair::get_base_reward(
-                                state,
-                                index,
-                                base_reward_per_increment,
-                                &self.spec,
-                            )?
-                            .safe_mul(weight)?,
+                            ctxt.get_base_reward(state, index, &self.spec)
+                                .map_err(|_| BeaconChainError::BlockRewardAttestationError)?
+                                .safe_mul(weight)?,
                         )?;
                     }
                 }

beacon_node/beacon_chain/src/beacon_block_streamer.rs

@@ -429,7 +429,7 @@ impl<T: BeaconChainTypes> BeaconBlockStreamer<T> {
                 continue;
             }
 
-            match self.beacon_chain.store.try_get_full_block(&root) {
+            match self.beacon_chain.store.try_get_full_block(&root, None) {
                 Err(e) => db_blocks.push((root, Err(e.into()))),
                 Ok(opt_block) => db_blocks.push((
                     root,