Merge branch 'unstable' into blobs-to-val-store

Author: dknopik

beacon_node/beacon_chain/src/block_reward.rs

@@ -1,6 +1,8 @@
 use crate::{BeaconChain, BeaconChainError, BeaconChainTypes};
 use eth2::lighthouse::{AttestationRewards, BlockReward, BlockRewardMeta};
-use operation_pool::{AttMaxCover, MaxCover, RewardCache, SplitAttestation};
+use operation_pool::{
+    AttMaxCover, MaxCover, RewardCache, SplitAttestation, PROPOSER_REWARD_DENOMINATOR,
+};
 use state_processing::{
     common::get_attesting_indices_from_state,
     per_block_processing::altair::sync_committee::compute_sync_aggregate_rewards,
@@ -65,13 +67,10 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         let mut curr_epoch_total = 0;
 
         for cover in &per_attestation_rewards {
-            for &reward in cover.fresh_validators_rewards.values() {
-                if cover.att.data.slot.epoch(T::EthSpec::slots_per_epoch()) == state.current_epoch()
-                {
-                    curr_epoch_total += reward;
-                } else {
-                    prev_epoch_total += reward;
-                }
+            if cover.att.data.slot.epoch(T::EthSpec::slots_per_epoch()) == state.current_epoch() {
+                curr_epoch_total += cover.score() as u64;
+            } else {
+                prev_epoch_total += cover.score() as u64;
             }
         }
 
@@ -80,7 +79,16 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         // Drop the covers.
         let per_attestation_rewards = per_attestation_rewards
             .into_iter()
-            .map(|cover| cover.fresh_validators_rewards)
+            .map(|cover| {
+                // Divide each reward numerator by the denominator. This can lead to the total being
+                // less than the sum of the individual rewards due to the fact that integer division
+                // does not distribute over addition.
+                let mut rewards = cover.fresh_validators_rewards;
+                rewards
+                    .values_mut()
+                    .for_each(|reward| *reward /= PROPOSER_REWARD_DENOMINATOR);
+                rewards
+            })
             .collect();
 
         // Add the attestation data if desired.

beacon_node/http_api/src/lib.rs

@@ -709,7 +709,7 @@ pub fn serve<T: BeaconChainTypes>(
         .clone()
         .and(warp::path("validator_balances"))
         .and(warp::path::end())
-        .and(warp_utils::json::json())
+        .and(warp_utils::json::json_no_body())
         .then(
             |state_id: StateId,
              task_spawner: TaskSpawner<T::EthSpec>,

beacon_node/http_api/src/validators.rs

@@ -81,8 +81,13 @@ pub fn get_beacon_state_validator_balances<T: BeaconChainTypes>(
         .map_state_and_execution_optimistic_and_finalized(
             &chain,
             |state, execution_optimistic, finalized| {
-                let ids_filter_set: Option<HashSet<&ValidatorId>> =
-                    optional_ids.map(|f| HashSet::from_iter(f.iter()));
+                let ids_filter_set: Option<HashSet<&ValidatorId>> = match optional_ids {
+                    // if optional_ids (the request data body) is [], returns a `None`, so that later when calling .is_none_or() will return True
+                    // Hence, all validators will pass through .filter(), and balances of all validators are returned, in accordance to the spec
+                    Some([]) => None,
+                    Some(ids) => Some(HashSet::from_iter(ids.iter())),
+                    None => None,
+                };
 
                 Ok((
                     state

beacon_node/http_api/tests/tests.rs

@@ -927,18 +927,32 @@ impl ApiTester {
                     .map(|res| res.data);
 
                 let expected = state_opt.map(|(state, _execution_optimistic, _finalized)| {
-                    let mut validators = Vec::with_capacity(validator_indices.len());
-
-                    for i in validator_indices {
-                        if i < state.balances().len() as u64 {
-                            validators.push(ValidatorBalanceData {
-                                index: i,
-                                balance: *state.balances().get(i as usize).unwrap(),
-                            });
+                    // If validator_indices is empty, return balances for all validators
+                    if validator_indices.is_empty() {
+                        state
+                            .balances()
+                            .iter()
+                            .enumerate()
+                            .map(|(index, balance)| ValidatorBalanceData {
+                                index: index as u64,
+                                balance: *balance,
+                            })
+                            .collect()
+                    } else {
+                        // Same behaviour as before for the else branch
+                        let mut validators = Vec::with_capacity(validator_indices.len());
+
+                        for i in validator_indices {
+                            if i < state.balances().len() as u64 {
+                                validators.push(ValidatorBalanceData {
+                                    index: i,
+                                    balance: *state.balances().get(i as usize).unwrap(),
+                                });
+                            }
                         }
-                    }
 
-                    validators
+                        validators
+                    }
                 });
 
                 assert_eq!(result_index_ids, expected, "{:?}", state_id);

beacon_node/operation_pool/src/attestation.rs

@@ -7,15 +7,18 @@ use state_processing::common::{
 use std::collections::HashMap;
 use types::{
     beacon_state::BeaconStateBase,
-    consts::altair::{PARTICIPATION_FLAG_WEIGHTS, WEIGHT_DENOMINATOR},
+    consts::altair::{PARTICIPATION_FLAG_WEIGHTS, PROPOSER_WEIGHT, WEIGHT_DENOMINATOR},
     Attestation, BeaconState, BitList, ChainSpec, EthSpec,
 };
 
+pub const PROPOSER_REWARD_DENOMINATOR: u64 =
+    (WEIGHT_DENOMINATOR - PROPOSER_WEIGHT) * WEIGHT_DENOMINATOR / PROPOSER_WEIGHT;
+
 #[derive(Debug, Clone)]
 pub struct AttMaxCover<'a, E: EthSpec> {
     /// Underlying attestation.
     pub att: CompactAttestationRef<'a, E>,
-    /// Mapping of validator indices and their rewards.
+    /// Mapping of validator indices and their reward *numerators*.
     pub fresh_validators_rewards: HashMap<u64, u64>,
 }
 
@@ -30,7 +33,7 @@ impl<'a, E: EthSpec> AttMaxCover<'a, E> {
         if let BeaconState::Base(ref base_state) = state {
             Self::new_for_base(att, state, base_state, total_active_balance, spec)
         } else {
-            Self::new_for_altair_deneb(att, state, reward_cache, spec)
+            Self::new_for_altair_or_later(att, state, reward_cache, spec)
         }
     }
 
@@ -68,7 +71,7 @@ impl<'a, E: EthSpec> AttMaxCover<'a, E> {
     }
 
     /// Initialise an attestation cover object for Altair or later.
-    pub fn new_for_altair_deneb(
+    pub fn new_for_altair_or_later(
         att: CompactAttestationRef<'a, E>,
         state: &BeaconState<E>,
         reward_cache: &'a RewardCache,
@@ -103,10 +106,7 @@ impl<'a, E: EthSpec> AttMaxCover<'a, E> {
                     }
                 }
 
-                let proposer_reward = proposer_reward_numerator
-                    .checked_div(WEIGHT_DENOMINATOR.checked_mul(spec.proposer_reward_quotient)?)?;
-
-                Some((index, proposer_reward)).filter(|_| proposer_reward != 0)
+                Some((index, proposer_reward_numerator)).filter(|_| proposer_reward_numerator != 0)
             })
             .collect();
 
@@ -163,7 +163,7 @@ impl<'a, E: EthSpec> MaxCover for AttMaxCover<'a, E> {
     }
 
     fn score(&self) -> usize {
-        self.fresh_validators_rewards.values().sum::<u64>() as usize
+        (self.fresh_validators_rewards.values().sum::<u64>() / PROPOSER_REWARD_DENOMINATOR) as usize
     }
 }
 

beacon_node/operation_pool/src/lib.rs

@@ -9,7 +9,7 @@ mod reward_cache;
 mod sync_aggregate_id;
 
 pub use crate::bls_to_execution_changes::ReceivedPreCapella;
-pub use attestation::{earliest_attestation_validators, AttMaxCover};
+pub use attestation::{earliest_attestation_validators, AttMaxCover, PROPOSER_REWARD_DENOMINATOR};
 pub use attestation_storage::{CompactAttestationRef, SplitAttestation};
 pub use max_cover::MaxCover;
 pub use persistence::{
@@ -1402,7 +1402,8 @@ mod release_tests {
                 .retain(|validator_index, _| !seen_indices.contains(validator_index));
 
             // Check that rewards are in decreasing order
-            let rewards = fresh_validators_rewards.values().sum();
+            let rewards =
+                fresh_validators_rewards.values().sum::<u64>() / PROPOSER_REWARD_DENOMINATOR;
             assert!(prev_reward >= rewards);
             prev_reward = rewards;
             seen_indices.extend(fresh_validators_rewards.keys());

book/.markdownlint.yml

@@ -25,4 +25,8 @@ MD036: false
 
 # MD040 code blocks should have a language specified: https://github.com/DavidAnson/markdownlint/blob/main/doc/md040.md
 # Set to false as the help_x.md files are code blocks without a language specified, which is fine and does not need to change
-MD040: false
+MD040: false
+
+# MD059 Link text should be descriptive: https://github.com/DavidAnson/markdownlint/blob/main/doc/md059.md
+# Set to false because it is too strict
+MD059: false

book/src/advanced_database_migrations.md

@@ -125,7 +125,7 @@ Several conditions need to be met in order to run `lighthouse db`:
 2. The command must run as the user that owns the beacon node database. If you are using systemd then
    your beacon node might run as a user called `lighthousebeacon`.
 3. The `--datadir` flag must be set to the location of the Lighthouse data directory.
-4. The `--network` flag must be set to the correct network, e.g. `mainnet`, `holesky` or `sepolia`.
+4. The `--network` flag must be set to the correct network, e.g. `mainnet`, `hoodi` or `sepolia`.
 
 The general form for a `lighthouse db` command is:
 

book/src/advanced_release_candidates.md

@@ -40,4 +40,4 @@ There can also be a scenario that a bug has been found and requires an urgent fi
 
 ## When *not* to use a release candidate
 
-Other than the above scenarios, it is generally not recommended to use release candidates for any critical tasks on mainnet (e.g., staking). To test new release candidate features, try one of the testnets (e.g., Holesky).
+Other than the above scenarios, it is generally not recommended to use release candidates for any critical tasks on mainnet (e.g., staking). To test new release candidate features, try one of the testnets (e.g., Hoodi).

book/src/advanced_web3signer.md

@@ -56,3 +56,11 @@ SSL client authentication with the "self-signed" certificate in `/home/paul/my-k
 > with a new timeout in milliseconds. This is the timeout before requests to Web3Signer are
 > considered to be failures. Setting a value that is too long may create contention and late duties
 > in the VC.  Setting it too short will result in failed signatures and therefore missed duties.
+
+## Slashing protection database
+
+Web3signer can be configured with its own slashing protection database. This makes the local slashing protection database by Lighthouse redundant. To disable Lighthouse slashing protection database for web3signer keys, use the flag `--disable-slashing-protection-web3signer` on the validator client.
+
+> Note: DO NOT use this flag unless you are certain that slashing protection is enabled on web3signer.
+
+The `--init-slashing-protection` flag is also required to initialize the slashing protection database locally.