mirror of
https://gitlab.com/pulsechaincom/lighthouse-pulse.git
synced 2024-12-24 20:47:17 +00:00
80359d8ddb
## Issue Addressed When requesting an index which is not active during `start_epoch`, Lighthouse returns: ``` curl "http://localhost:5052/lighthouse/analysis/attestation_performance/999999999?start_epoch=100000&end_epoch=100000" ``` ```json { "code": 500, "message": "INTERNAL_SERVER_ERROR: ParticipationCache(InvalidValidatorIndex(999999999))", "stacktraces": [] } ``` This error occurs even when the index in question becomes active before `end_epoch` which is undesirable as it can prevent larger queries from completing. ## Proposed Changes In the event the index is out-of-bounds (has not yet been activated), simply return all fields as `false`: ``` -> curl "http://localhost:5052/lighthouse/analysis/attestation_performance/999999999?start_epoch=100000&end_epoch=100000" ``` ```json [ { "index": 999999999, "epochs": { "100000": { "active": false, "head": false, "target": false, "source": false } } } ] ``` By doing this, we cover the case where a validator becomes active sometime between `start_epoch` and `end_epoch`. ## Additional Info Note that this error only occurs for epochs after the Altair hard fork.
221 lines
8.3 KiB
Rust
221 lines
8.3 KiB
Rust
use beacon_chain::{BeaconChain, BeaconChainError, BeaconChainTypes};
|
|
use eth2::lighthouse::{
|
|
AttestationPerformance, AttestationPerformanceQuery, AttestationPerformanceStatistics,
|
|
};
|
|
use state_processing::{
|
|
per_epoch_processing::altair::participation_cache::Error as ParticipationCacheError,
|
|
per_epoch_processing::EpochProcessingSummary, BlockReplayError, BlockReplayer,
|
|
};
|
|
use std::sync::Arc;
|
|
use types::{BeaconState, BeaconStateError, EthSpec, Hash256};
|
|
use warp_utils::reject::{beacon_chain_error, custom_bad_request, custom_server_error};
|
|
|
|
const MAX_REQUEST_RANGE_EPOCHS: usize = 100;
|
|
const BLOCK_ROOT_CHUNK_SIZE: usize = 100;
|
|
|
|
#[derive(Debug)]
|
|
enum AttestationPerformanceError {
|
|
BlockReplay(BlockReplayError),
|
|
BeaconState(BeaconStateError),
|
|
ParticipationCache(ParticipationCacheError),
|
|
UnableToFindValidator(usize),
|
|
}
|
|
|
|
impl From<BlockReplayError> for AttestationPerformanceError {
|
|
fn from(e: BlockReplayError) -> Self {
|
|
Self::BlockReplay(e)
|
|
}
|
|
}
|
|
|
|
impl From<BeaconStateError> for AttestationPerformanceError {
|
|
fn from(e: BeaconStateError) -> Self {
|
|
Self::BeaconState(e)
|
|
}
|
|
}
|
|
|
|
impl From<ParticipationCacheError> for AttestationPerformanceError {
|
|
fn from(e: ParticipationCacheError) -> Self {
|
|
Self::ParticipationCache(e)
|
|
}
|
|
}
|
|
|
|
pub fn get_attestation_performance<T: BeaconChainTypes>(
|
|
target: String,
|
|
query: AttestationPerformanceQuery,
|
|
chain: Arc<BeaconChain<T>>,
|
|
) -> Result<Vec<AttestationPerformance>, warp::Rejection> {
|
|
let spec = &chain.spec;
|
|
// We increment by 2 here so that when we build the state from the `prior_slot` it is
|
|
// still 1 epoch ahead of the first epoch we want to analyse.
|
|
// This ensures the `.is_previous_epoch_X` functions on `EpochProcessingSummary` return results
|
|
// for the correct epoch.
|
|
let start_epoch = query.start_epoch + 2;
|
|
let start_slot = start_epoch.start_slot(T::EthSpec::slots_per_epoch());
|
|
let prior_slot = start_slot - 1;
|
|
|
|
let end_epoch = query.end_epoch + 2;
|
|
let end_slot = end_epoch.end_slot(T::EthSpec::slots_per_epoch());
|
|
|
|
// Ensure end_epoch is smaller than the current epoch - 1.
|
|
let current_epoch = chain.epoch().map_err(beacon_chain_error)?;
|
|
if query.end_epoch >= current_epoch - 1 {
|
|
return Err(custom_bad_request(format!(
|
|
"end_epoch must be less than the current epoch - 1. current: {}, end: {}",
|
|
current_epoch, query.end_epoch
|
|
)));
|
|
}
|
|
|
|
// Check query is valid.
|
|
if start_epoch > end_epoch {
|
|
return Err(custom_bad_request(format!(
|
|
"start_epoch must not be larger than end_epoch. start: {}, end: {}",
|
|
query.start_epoch, query.end_epoch
|
|
)));
|
|
}
|
|
|
|
// The response size can grow exceptionally large therefore we should check that the
|
|
// query is within permitted bounds to prevent potential OOM errors.
|
|
if (end_epoch - start_epoch).as_usize() > MAX_REQUEST_RANGE_EPOCHS {
|
|
return Err(custom_bad_request(format!(
|
|
"end_epoch must not exceed start_epoch by more than 100 epochs. start: {}, end: {}",
|
|
query.start_epoch, query.end_epoch
|
|
)));
|
|
}
|
|
|
|
// Either use the global validator set, or the specified index.
|
|
//
|
|
// Does no further validation of the indices, so in the event an index has not yet been
|
|
// activated or does not yet exist (according to the head state), it will return all fields as
|
|
// `false`.
|
|
let index_range = if target.to_lowercase() == "global" {
|
|
chain
|
|
.with_head(|head| Ok((0..head.beacon_state.validators().len() as u64).collect()))
|
|
.map_err(beacon_chain_error)?
|
|
} else {
|
|
vec![target.parse::<u64>().map_err(|_| {
|
|
custom_bad_request(format!(
|
|
"Invalid validator index: {:?}",
|
|
target.to_lowercase()
|
|
))
|
|
})?]
|
|
};
|
|
|
|
// Load block roots.
|
|
let mut block_roots: Vec<Hash256> = chain
|
|
.forwards_iter_block_roots_until(start_slot, end_slot)
|
|
.map_err(beacon_chain_error)?
|
|
.map(|res| res.map(|(root, _)| root))
|
|
.collect::<Result<Vec<Hash256>, _>>()
|
|
.map_err(beacon_chain_error)?;
|
|
block_roots.dedup();
|
|
|
|
// Load first block so we can get its parent.
|
|
let first_block_root = block_roots.first().ok_or_else(|| {
|
|
custom_server_error(
|
|
"No blocks roots could be loaded. Ensure the beacon node is synced.".to_string(),
|
|
)
|
|
})?;
|
|
let first_block = chain
|
|
.get_blinded_block(first_block_root)
|
|
.and_then(|maybe_block| {
|
|
maybe_block.ok_or(BeaconChainError::MissingBeaconBlock(*first_block_root))
|
|
})
|
|
.map_err(beacon_chain_error)?;
|
|
|
|
// Load the block of the prior slot which will be used to build the starting state.
|
|
let prior_block = chain
|
|
.get_blinded_block(&first_block.parent_root())
|
|
.and_then(|maybe_block| {
|
|
maybe_block
|
|
.ok_or_else(|| BeaconChainError::MissingBeaconBlock(first_block.parent_root()))
|
|
})
|
|
.map_err(beacon_chain_error)?;
|
|
|
|
// Load state for block replay.
|
|
let state_root = prior_block.state_root();
|
|
let state = chain
|
|
.get_state(&state_root, Some(prior_slot))
|
|
.and_then(|maybe_state| maybe_state.ok_or(BeaconChainError::MissingBeaconState(state_root)))
|
|
.map_err(beacon_chain_error)?;
|
|
|
|
// Allocate an AttestationPerformance vector for each validator in the range.
|
|
let mut perfs: Vec<AttestationPerformance> =
|
|
AttestationPerformance::initialize(index_range.clone());
|
|
|
|
let post_slot_hook = |state: &mut BeaconState<T::EthSpec>,
|
|
summary: Option<EpochProcessingSummary<T::EthSpec>>,
|
|
_is_skip_slot: bool|
|
|
-> Result<(), AttestationPerformanceError> {
|
|
// If a `summary` was not output then an epoch boundary was not crossed
|
|
// so we move onto the next slot.
|
|
if let Some(summary) = summary {
|
|
for (position, i) in index_range.iter().enumerate() {
|
|
let index = *i as usize;
|
|
|
|
let val = perfs
|
|
.get_mut(position)
|
|
.ok_or(AttestationPerformanceError::UnableToFindValidator(index))?;
|
|
|
|
// We are two epochs ahead since the summary is generated for
|
|
// `state.previous_epoch()` then `summary.is_previous_epoch_X` functions return
|
|
// data for the epoch before that.
|
|
let epoch = state.previous_epoch().as_u64() - 1;
|
|
|
|
let is_active = summary.is_active_unslashed_in_previous_epoch(index);
|
|
|
|
let received_source_reward = summary.is_previous_epoch_source_attester(index)?;
|
|
|
|
let received_head_reward = summary.is_previous_epoch_head_attester(index)?;
|
|
|
|
let received_target_reward = summary.is_previous_epoch_target_attester(index)?;
|
|
|
|
let inclusion_delay = summary
|
|
.previous_epoch_inclusion_info(index)
|
|
.map(|info| info.delay);
|
|
|
|
let perf = AttestationPerformanceStatistics {
|
|
active: is_active,
|
|
head: received_head_reward,
|
|
target: received_target_reward,
|
|
source: received_source_reward,
|
|
delay: inclusion_delay,
|
|
};
|
|
|
|
val.epochs.insert(epoch, perf);
|
|
}
|
|
}
|
|
Ok(())
|
|
};
|
|
|
|
// Initialize block replayer
|
|
let mut replayer = BlockReplayer::new(state, spec)
|
|
.no_state_root_iter()
|
|
.no_signature_verification()
|
|
.minimal_block_root_verification()
|
|
.post_slot_hook(Box::new(post_slot_hook));
|
|
|
|
// Iterate through block roots in chunks to reduce load on memory.
|
|
for block_root_chunks in block_roots.chunks(BLOCK_ROOT_CHUNK_SIZE) {
|
|
// Load blocks from the block root chunks.
|
|
let blocks = block_root_chunks
|
|
.iter()
|
|
.map(|root| {
|
|
chain
|
|
.get_blinded_block(root)
|
|
.and_then(|maybe_block| {
|
|
maybe_block.ok_or(BeaconChainError::MissingBeaconBlock(*root))
|
|
})
|
|
.map_err(beacon_chain_error)
|
|
})
|
|
.collect::<Result<Vec<_>, _>>()?;
|
|
|
|
replayer = replayer
|
|
.apply_blocks(blocks, None)
|
|
.map_err(|e| custom_server_error(format!("{:?}", e)))?;
|
|
}
|
|
|
|
drop(replayer);
|
|
|
|
Ok(perfs)
|
|
}
|