mirror of
https://github.com/sigp/lighthouse.git
synced 2026-03-16 03:12:41 +00:00
406 lines
14 KiB
Rust
406 lines
14 KiB
Rust
use crate::chunked_vector::{
|
|
load_variable_list_from_db, load_vector_from_db, BlockRoots, HistoricalRoots, RandaoMixes,
|
|
StateRoots,
|
|
};
|
|
use crate::{get_key_for_col, DBColumn, Error, KeyValueStore, KeyValueStoreOp, StoreConfig};
|
|
use itertools::process_results;
|
|
use ssz::{Decode, DecodeError, Encode};
|
|
use ssz_derive::{Decode, Encode};
|
|
use std::io::Write;
|
|
use std::sync::Arc;
|
|
use types::superstruct;
|
|
use types::*;
|
|
use zstd::Encoder;
|
|
|
|
/// Lightweight variant of the `BeaconState` that is stored in the database.
|
|
///
|
|
/// Utilises lazy-loading from separate storage for its vector fields.
|
|
#[superstruct(
|
|
variants(Base, Altair, Merge),
|
|
variant_attributes(derive(Debug, PartialEq, Clone, Encode, Decode))
|
|
)]
|
|
#[derive(Debug, PartialEq, Clone, Encode)]
|
|
#[ssz(enum_behaviour = "transparent")]
|
|
pub struct PartialBeaconState<T>
|
|
where
|
|
T: EthSpec,
|
|
{
|
|
// Versioning
|
|
pub genesis_time: u64,
|
|
pub genesis_validators_root: Hash256,
|
|
#[superstruct(getter(copy))]
|
|
pub slot: Slot,
|
|
pub fork: Fork,
|
|
|
|
// History
|
|
pub latest_block_header: BeaconBlockHeader,
|
|
|
|
#[ssz(skip_serializing, skip_deserializing)]
|
|
pub block_roots: Option<FixedVector<Hash256, T::SlotsPerHistoricalRoot>>,
|
|
#[ssz(skip_serializing, skip_deserializing)]
|
|
pub state_roots: Option<FixedVector<Hash256, T::SlotsPerHistoricalRoot>>,
|
|
|
|
#[ssz(skip_serializing, skip_deserializing)]
|
|
pub historical_roots: Option<VList<Hash256, T::HistoricalRootsLimit>>,
|
|
|
|
// Ethereum 1.0 chain data
|
|
pub eth1_data: Eth1Data,
|
|
pub eth1_data_votes: VList<Eth1Data, T::SlotsPerEth1VotingPeriod>,
|
|
pub eth1_deposit_index: u64,
|
|
|
|
// Registry
|
|
pub validators: Vec<ValidatorMutable>,
|
|
pub balances: VList<u64, T::ValidatorRegistryLimit>,
|
|
|
|
// Shuffling
|
|
/// Randao value from the current slot, for patching into the per-epoch randao vector.
|
|
pub latest_randao_value: Hash256,
|
|
#[ssz(skip_serializing, skip_deserializing)]
|
|
pub randao_mixes: Option<FixedVector<Hash256, T::EpochsPerHistoricalVector>>,
|
|
|
|
// Slashings
|
|
slashings: FixedVector<u64, T::EpochsPerSlashingsVector>,
|
|
|
|
// Attestations (genesis fork only)
|
|
#[superstruct(only(Base))]
|
|
pub previous_epoch_attestations: VList<PendingAttestation<T>, T::MaxPendingAttestations>,
|
|
#[superstruct(only(Base))]
|
|
pub current_epoch_attestations: VList<PendingAttestation<T>, T::MaxPendingAttestations>,
|
|
|
|
// Participation (Altair and later)
|
|
#[superstruct(only(Altair, Merge))]
|
|
pub previous_epoch_participation: VList<ParticipationFlags, T::ValidatorRegistryLimit>,
|
|
#[superstruct(only(Altair, Merge))]
|
|
pub current_epoch_participation: VList<ParticipationFlags, T::ValidatorRegistryLimit>,
|
|
|
|
// Finality
|
|
pub justification_bits: BitVector<T::JustificationBitsLength>,
|
|
pub previous_justified_checkpoint: Checkpoint,
|
|
pub current_justified_checkpoint: Checkpoint,
|
|
pub finalized_checkpoint: Checkpoint,
|
|
|
|
// Inactivity
|
|
#[superstruct(only(Altair, Merge))]
|
|
pub inactivity_scores: VList<u64, T::ValidatorRegistryLimit>,
|
|
|
|
// Light-client sync committees
|
|
#[superstruct(only(Altair, Merge))]
|
|
pub current_sync_committee: Arc<SyncCommittee<T>>,
|
|
#[superstruct(only(Altair, Merge))]
|
|
pub next_sync_committee: Arc<SyncCommittee<T>>,
|
|
|
|
// Execution
|
|
#[superstruct(only(Merge))]
|
|
pub latest_execution_payload_header: ExecutionPayloadHeader<T>,
|
|
}
|
|
|
|
/// Implement the conversion function from BeaconState -> PartialBeaconState.
|
|
macro_rules! impl_from_state_forgetful {
|
|
($s:ident, $outer:ident, $variant_name:ident, $struct_name:ident, [$($extra_fields:ident),*]) => {
|
|
PartialBeaconState::$variant_name($struct_name {
|
|
// Versioning
|
|
genesis_time: $s.genesis_time,
|
|
genesis_validators_root: $s.genesis_validators_root,
|
|
slot: $s.slot,
|
|
fork: $s.fork,
|
|
|
|
// History
|
|
latest_block_header: $s.latest_block_header.clone(),
|
|
block_roots: None,
|
|
state_roots: None,
|
|
historical_roots: None,
|
|
|
|
// Eth1
|
|
eth1_data: $s.eth1_data.clone(),
|
|
eth1_data_votes: $s.eth1_data_votes.clone(),
|
|
eth1_deposit_index: $s.eth1_deposit_index,
|
|
|
|
// Validator registry
|
|
validators: $s.validators.into_iter().map(|validator| {
|
|
validator.mutable.clone()
|
|
})
|
|
.collect(),
|
|
balances: $s.balances.clone(),
|
|
|
|
// Shuffling
|
|
latest_randao_value: *$outer
|
|
.get_randao_mix($outer.current_epoch())
|
|
.expect("randao at current epoch is OK"),
|
|
randao_mixes: None,
|
|
|
|
// Slashings
|
|
slashings: $s.slashings.clone(),
|
|
|
|
// Finality
|
|
justification_bits: $s.justification_bits.clone(),
|
|
previous_justified_checkpoint: $s.previous_justified_checkpoint,
|
|
current_justified_checkpoint: $s.current_justified_checkpoint,
|
|
finalized_checkpoint: $s.finalized_checkpoint,
|
|
|
|
// Variant-specific fields
|
|
$(
|
|
$extra_fields: $s.$extra_fields.clone()
|
|
),*
|
|
})
|
|
}
|
|
}
|
|
|
|
impl<T: EthSpec> PartialBeaconState<T> {
|
|
/// Convert a `BeaconState` to a `PartialBeaconState`, while dropping the optional fields.
|
|
pub fn from_state_forgetful(outer: &BeaconState<T>) -> Self {
|
|
match outer {
|
|
BeaconState::Base(s) => impl_from_state_forgetful!(
|
|
s,
|
|
outer,
|
|
Base,
|
|
PartialBeaconStateBase,
|
|
[previous_epoch_attestations, current_epoch_attestations]
|
|
),
|
|
BeaconState::Altair(s) => impl_from_state_forgetful!(
|
|
s,
|
|
outer,
|
|
Altair,
|
|
PartialBeaconStateAltair,
|
|
[
|
|
previous_epoch_participation,
|
|
current_epoch_participation,
|
|
current_sync_committee,
|
|
next_sync_committee,
|
|
inactivity_scores
|
|
]
|
|
),
|
|
BeaconState::Merge(s) => impl_from_state_forgetful!(
|
|
s,
|
|
outer,
|
|
Merge,
|
|
PartialBeaconStateMerge,
|
|
[
|
|
previous_epoch_participation,
|
|
current_epoch_participation,
|
|
current_sync_committee,
|
|
next_sync_committee,
|
|
inactivity_scores,
|
|
latest_execution_payload_header
|
|
]
|
|
),
|
|
}
|
|
}
|
|
|
|
/// SSZ decode.
|
|
pub fn from_ssz_bytes(bytes: &[u8], spec: &ChainSpec) -> Result<Self, ssz::DecodeError> {
|
|
// Slot is after genesis_time (u64) and genesis_validators_root (Hash256).
|
|
let slot_offset = <u64 as Decode>::ssz_fixed_len() + <Hash256 as Decode>::ssz_fixed_len();
|
|
let slot_len = <Slot as Decode>::ssz_fixed_len();
|
|
let slot_bytes = bytes.get(slot_offset..slot_offset + slot_len).ok_or(
|
|
DecodeError::InvalidByteLength {
|
|
len: bytes.len(),
|
|
expected: slot_offset + slot_len,
|
|
},
|
|
)?;
|
|
|
|
let slot = Slot::from_ssz_bytes(slot_bytes)?;
|
|
let fork_at_slot = spec.fork_name_at_slot::<T>(slot);
|
|
|
|
Ok(map_fork_name!(
|
|
fork_at_slot,
|
|
Self,
|
|
<_>::from_ssz_bytes(bytes)?
|
|
))
|
|
}
|
|
|
|
/// Prepare the partial state for storage in the KV database.
|
|
pub fn as_kv_store_op(
|
|
&self,
|
|
state_root: Hash256,
|
|
config: &StoreConfig,
|
|
) -> Result<KeyValueStoreOp, Error> {
|
|
let db_key = get_key_for_col(DBColumn::BeaconState.into(), state_root.as_bytes());
|
|
|
|
let ssz_bytes = self.as_ssz_bytes();
|
|
|
|
let mut compressed_value =
|
|
Vec::with_capacity(config.estimate_compressed_size(ssz_bytes.len()));
|
|
let mut encoder = Encoder::new(&mut compressed_value, config.compression_level)
|
|
.map_err(Error::Compression)?;
|
|
encoder.write_all(&ssz_bytes).map_err(Error::Compression)?;
|
|
encoder.finish().map_err(Error::Compression)?;
|
|
|
|
Ok(KeyValueStoreOp::PutKeyValue(db_key, compressed_value))
|
|
}
|
|
|
|
pub fn load_block_roots<S: KeyValueStore<T>>(
|
|
&mut self,
|
|
store: &S,
|
|
spec: &ChainSpec,
|
|
) -> Result<(), Error> {
|
|
if self.block_roots().is_none() {
|
|
*self.block_roots_mut() = Some(load_vector_from_db::<BlockRoots, T, _>(
|
|
store,
|
|
self.slot(),
|
|
spec,
|
|
)?);
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn load_state_roots<S: KeyValueStore<T>>(
|
|
&mut self,
|
|
store: &S,
|
|
spec: &ChainSpec,
|
|
) -> Result<(), Error> {
|
|
if self.state_roots().is_none() {
|
|
*self.state_roots_mut() = Some(load_vector_from_db::<StateRoots, T, _>(
|
|
store,
|
|
self.slot(),
|
|
spec,
|
|
)?);
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn load_historical_roots<S: KeyValueStore<T>>(
|
|
&mut self,
|
|
store: &S,
|
|
spec: &ChainSpec,
|
|
) -> Result<(), Error> {
|
|
if self.historical_roots().is_none() {
|
|
*self.historical_roots_mut() = Some(
|
|
load_variable_list_from_db::<HistoricalRoots, T, _>(store, self.slot(), spec)?,
|
|
);
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn load_randao_mixes<S: KeyValueStore<T>>(
|
|
&mut self,
|
|
store: &S,
|
|
spec: &ChainSpec,
|
|
) -> Result<(), Error> {
|
|
if self.randao_mixes().is_none() {
|
|
// Load the per-epoch values from the database
|
|
let mut randao_mixes =
|
|
load_vector_from_db::<RandaoMixes, T, _>(store, self.slot(), spec)?;
|
|
|
|
// Patch the value for the current slot into the index for the current epoch
|
|
let current_epoch = self.slot().epoch(T::slots_per_epoch());
|
|
let len = randao_mixes.len();
|
|
|
|
*randao_mixes
|
|
.get_mut(current_epoch.as_usize() % len)
|
|
.unwrap() = *self.latest_randao_value();
|
|
|
|
*self.randao_mixes_mut() = Some(randao_mixes)
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
/// Implement the conversion from PartialBeaconState -> BeaconState.
|
|
macro_rules! impl_try_into_beacon_state {
|
|
($inner:ident, $variant_name:ident, $struct_name:ident, $immutable_validators:ident, [$($extra_fields:ident),*]) => {
|
|
BeaconState::$variant_name($struct_name {
|
|
// Versioning
|
|
genesis_time: $inner.genesis_time,
|
|
genesis_validators_root: $inner.genesis_validators_root,
|
|
slot: $inner.slot,
|
|
fork: $inner.fork,
|
|
|
|
// History
|
|
latest_block_header: $inner.latest_block_header,
|
|
block_roots: unpack_field($inner.block_roots)?,
|
|
state_roots: unpack_field($inner.state_roots)?,
|
|
historical_roots: unpack_field($inner.historical_roots)?,
|
|
|
|
// Eth1
|
|
eth1_data: $inner.eth1_data,
|
|
eth1_data_votes: $inner.eth1_data_votes,
|
|
eth1_deposit_index: $inner.eth1_deposit_index,
|
|
|
|
// Validator registry
|
|
validators: process_results($inner.validators.into_iter().enumerate().map(|(i, mutable)| {
|
|
$immutable_validators(i)
|
|
.ok_or(Error::MissingImmutableValidator(i))
|
|
.map(move |immutable| {
|
|
Validator {
|
|
immutable,
|
|
mutable
|
|
}
|
|
})
|
|
}), |iter| VList::try_from_iter(iter))??,
|
|
balances: $inner.balances,
|
|
|
|
// Shuffling
|
|
randao_mixes: unpack_field($inner.randao_mixes)?,
|
|
|
|
// Slashings
|
|
slashings: $inner.slashings,
|
|
|
|
// Finality
|
|
justification_bits: $inner.justification_bits,
|
|
previous_justified_checkpoint: $inner.previous_justified_checkpoint,
|
|
current_justified_checkpoint: $inner.current_justified_checkpoint,
|
|
finalized_checkpoint: $inner.finalized_checkpoint,
|
|
|
|
// Caching
|
|
total_active_balance: <_>::default(),
|
|
committee_caches: <_>::default(),
|
|
pubkey_cache: <_>::default(),
|
|
exit_cache: <_>::default(),
|
|
|
|
// Variant-specific fields
|
|
$(
|
|
$extra_fields: $inner.$extra_fields
|
|
),*
|
|
})
|
|
}
|
|
}
|
|
|
|
fn unpack_field<T>(x: Option<T>) -> Result<T, Error> {
|
|
x.ok_or(Error::PartialBeaconStateError)
|
|
}
|
|
|
|
impl<E: EthSpec> PartialBeaconState<E> {
|
|
pub fn try_into_full_state<F>(self, immutable_validators: F) -> Result<BeaconState<E>, Error>
|
|
where
|
|
F: Fn(usize) -> Option<Arc<ValidatorImmutable>>,
|
|
{
|
|
let state = match self {
|
|
PartialBeaconState::Base(inner) => impl_try_into_beacon_state!(
|
|
inner,
|
|
Base,
|
|
BeaconStateBase,
|
|
immutable_validators,
|
|
[previous_epoch_attestations, current_epoch_attestations]
|
|
),
|
|
PartialBeaconState::Altair(inner) => impl_try_into_beacon_state!(
|
|
inner,
|
|
Altair,
|
|
BeaconStateAltair,
|
|
immutable_validators,
|
|
[
|
|
previous_epoch_participation,
|
|
current_epoch_participation,
|
|
current_sync_committee,
|
|
next_sync_committee,
|
|
inactivity_scores
|
|
]
|
|
),
|
|
PartialBeaconState::Merge(inner) => impl_try_into_beacon_state!(
|
|
inner,
|
|
Merge,
|
|
BeaconStateMerge,
|
|
immutable_validators,
|
|
[
|
|
previous_epoch_participation,
|
|
current_epoch_participation,
|
|
current_sync_committee,
|
|
next_sync_committee,
|
|
inactivity_scores,
|
|
latest_execution_payload_header
|
|
]
|
|
),
|
|
};
|
|
Ok(state)
|
|
}
|
|
}
|