gnosis/lighthouse
1
0
Fork 0
mirror of https://github.com/sigp/lighthouse.git synced 2026-05-31 13:17:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update to spec v1.7.0-alpha.4 (#9046)

Browse Source 
Update our consensus code to v1.7.0-alpha.4


Co-Authored-By: Michael Sproul <michael@sigmaprime.io>
This commit is contained in:
Michael Sproul
2026-03-31 16:59:36 +11:00
committed by GitHub
parent bc5d8c9f90
commit d92efc1e0f
12 changed files with 279 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
consensus/state_processing/src/per_epoch_processing/altair.rs
View File

@@ -51,8 +51,8 @@ pub fn process_epoch<E: EthSpec>(
// without loss of correctness.
let current_epoch_progressive_balances = state.progressive_balances_cache().clone();
let current_epoch_total_active_balance = state.get_total_active_balance()?;
let participation_summary =
process_epoch_single_pass(state, spec, SinglePassConfig::default())?;
let epoch_result = process_epoch_single_pass(state, spec, SinglePassConfig::default())?;
let participation_summary = epoch_result.summary;
// Reset eth1 data votes.
process_eth1_data_reset(state)?;
@@ -79,6 +79,13 @@ pub fn process_epoch<E: EthSpec>(
// Rotate the epoch caches to suit the epoch transition.
state.advance_caches()?;
// Install the lookahead committee cache (built during PTC window processing) as the Next
// cache. After advance_caches, the lookahead epoch becomes the Next relative epoch.
if let Some(cache) = epoch_result.lookahead_committee_cache {
state.set_committee_cache(RelativeEpoch::Next, cache)?;
}
update_progressive_balances_on_epoch_transition(state, spec)?;
Ok(EpochProcessingSummary::Altair {

76
consensus/state_processing/src/per_epoch_processing/single_pass.rs
View File

@@ -12,12 +12,13 @@ use milhouse::{Cow, List, Vector};
use safe_arith::{SafeArith, SafeArithIter};
use std::cmp::{max, min};
use std::collections::{BTreeSet, HashMap};
use std::sync::Arc;
use tracing::instrument;
use typenum::Unsigned;
use types::{
ActivationQueue, BeaconState, BeaconStateError, BuilderPendingPayment, ChainSpec, Checkpoint,
DepositData, Epoch, EthSpec, ExitCache, ForkName, ParticipationFlags, PendingDeposit,
ProgressiveBalancesCache, RelativeEpoch, Validator,
CommitteeCache, DepositData, Epoch, EthSpec, ExitCache, ForkName, ParticipationFlags,
PendingDeposit, ProgressiveBalancesCache, RelativeEpoch, Validator,
consts::altair::{
NUM_FLAG_INDICES, PARTICIPATION_FLAG_WEIGHTS, TIMELY_HEAD_FLAG_INDEX,
TIMELY_TARGET_FLAG_INDEX, WEIGHT_DENOMINATOR,
@@ -34,6 +35,7 @@ pub struct SinglePassConfig {
pub effective_balance_updates: bool,
pub proposer_lookahead: bool,
pub builder_pending_payments: bool,
pub ptc_window: bool,
}
impl Default for SinglePassConfig {
@@ -54,6 +56,7 @@ impl SinglePassConfig {
effective_balance_updates: true,
proposer_lookahead: true,
builder_pending_payments: true,
ptc_window: true,
}
}
@@ -68,6 +71,7 @@ impl SinglePassConfig {
effective_balance_updates: false,
proposer_lookahead: false,
builder_pending_payments: false,
ptc_window: false,
}
}
}
@@ -139,12 +143,20 @@ impl ValidatorInfo {
}
}
/// Result of single-pass epoch processing.
pub struct SinglePassEpochResult<E: EthSpec> {
pub summary: ParticipationEpochSummary<E>,
/// Committee cache for the lookahead epoch, built during PTC window processing.
/// Can be installed as the Next committee cache after `advance_caches`.
pub lookahead_committee_cache: Option<Arc<CommitteeCache>>,
}
#[instrument(skip_all)]
pub fn process_epoch_single_pass<E: EthSpec>(
state: &mut BeaconState<E>,
spec: &ChainSpec,
conf: SinglePassConfig,
) -> Result<ParticipationEpochSummary<E>, Error> {
) -> Result<SinglePassEpochResult<E>, Error> {
initialize_epoch_cache(state, spec)?;
initialize_progressive_balances_cache(state, spec)?;
state.build_exit_cache(spec)?;
@@ -479,7 +491,16 @@ pub fn process_epoch_single_pass<E: EthSpec>(
process_proposer_lookahead(state, spec)?;
}
Ok(summary)
let lookahead_committee_cache = if conf.ptc_window && fork_name.gloas_enabled() {
Some(process_ptc_window(state, spec)?)
} else {
None
};
Ok(SinglePassEpochResult {
summary,
lookahead_committee_cache,
})
}
// TOOO(EIP-7917): use balances cache
@@ -512,6 +533,53 @@ pub fn process_proposer_lookahead<E: EthSpec>(
Ok(())
}
/// Process the PTC window, returning the committee cache built for the lookahead epoch.
///
/// The returned cache can be injected into the state's Next committee cache slot after
/// `advance_caches` is called during the epoch transition, avoiding redundant recomputation.
pub fn process_ptc_window<E: EthSpec>(
state: &mut BeaconState<E>,
spec: &ChainSpec,
) -> Result<Arc<CommitteeCache>, Error> {
let slots_per_epoch = E::slots_per_epoch() as usize;
// Convert Vector -> List to use tree-efficient pop_front.
let ptc_window = state.ptc_window()?.clone();
let mut window: List<_, E::PtcWindowLength> = List::from(ptc_window);
// Drop the oldest epoch from the front (reuses shared tree nodes).
window
.pop_front(slots_per_epoch)
.map_err(|e| Error::BeaconStateError(BeaconStateError::MilhouseError(e)))?;
// Compute PTC for the new lookahead epoch
let next_epoch = state
.current_epoch()
.safe_add(spec.min_seed_lookahead.as_u64())?
.safe_add(1)?;
let start_slot = next_epoch.start_slot(E::slots_per_epoch());
// Build a committee cache for the lookahead epoch (beyond the normal Next bound)
let committee_cache = state.initialize_committee_cache_for_lookahead(next_epoch, spec)?;
for i in 0..slots_per_epoch {
let slot = start_slot.safe_add(i as u64)?;
let ptc = state.compute_ptc_with_cache(slot, &committee_cache, spec)?;
let ptc_u64: Vec<u64> = ptc.into_iter().map(|v| v as u64).collect();
let entry = ssz_types::FixedVector::new(ptc_u64)
.map_err(|e| Error::BeaconStateError(BeaconStateError::SszTypesError(e)))?;
window
.push(entry)
.map_err(|e| Error::BeaconStateError(BeaconStateError::MilhouseError(e)))?;
}
// Convert List back to Vector.
*state.ptc_window_mut()? = Vector::try_from(window)
.map_err(|e| Error::BeaconStateError(BeaconStateError::MilhouseError(e)))?;
Ok(committee_cache)
}
/// Calculate the quorum threshold for builder payments based on total active balance.
fn get_builder_payment_quorum_threshold<E: EthSpec>(
state_ctxt: &StateContext,

43
consensus/state_processing/src/upgrade/gloas.rs
View File

@@ -2,7 +2,9 @@ use crate::per_block_processing::{
is_valid_deposit_signature, process_operations::apply_deposit_for_builder,
};
use milhouse::{List, Vector};
use safe_arith::SafeArith;
use ssz_types::BitVector;
use ssz_types::FixedVector;
use std::collections::HashSet;
use std::mem;
use typenum::Unsigned;
@@ -102,13 +104,11 @@ pub fn upgrade_state_to_gloas<E: EthSpec>(
vec![0xFFu8; E::SlotsPerHistoricalRoot::to_usize() / 8].into(),
)
.map_err(|_| Error::InvalidBitfield)?,
builder_pending_payments: Vector::new(vec![
BuilderPendingPayment::default();
E::builder_pending_payments_limit()
])?,
builder_pending_payments: Vector::from_elem(BuilderPendingPayment::default())?,
builder_pending_withdrawals: List::default(), // Empty list initially,
latest_block_hash: pre.latest_execution_payload_header.block_hash,
payload_expected_withdrawals: List::default(),
ptc_window: Vector::from_elem(FixedVector::from_elem(0))?, // placeholder, will be initialized below
// Caches
total_active_balance: pre.total_active_balance,
progressive_balances_cache: mem::take(&mut pre.progressive_balances_cache),
@@ -120,10 +120,45 @@ pub fn upgrade_state_to_gloas<E: EthSpec>(
});
// [New in Gloas:EIP7732]
onboard_builders_from_pending_deposits(&mut post, spec)?;
initialize_ptc_window(&mut post, spec)?;
Ok(post)
}
/// Initialize the `ptc_window` field in the beacon state at fork transition.
///
/// The window contains:
/// - One epoch of empty entries (previous epoch)
/// - Computed PTC for the current epoch through `1 + MIN_SEED_LOOKAHEAD` epochs
fn initialize_ptc_window<E: EthSpec>(
state: &mut BeaconState<E>,
spec: &ChainSpec,
) -> Result<(), Error> {
let slots_per_epoch = E::slots_per_epoch() as usize;
let empty_previous_epoch = vec![FixedVector::<u64, E::PTCSize>::from_elem(0); slots_per_epoch];
let mut ptcs = empty_previous_epoch;
// Compute PTC for current epoch + lookahead epochs
let current_epoch = state.current_epoch();
for e in 0..=spec.min_seed_lookahead.as_u64() {
let epoch = current_epoch.safe_add(e)?;
let committee_cache = state.initialize_committee_cache_for_lookahead(epoch, spec)?;
let start_slot = epoch.start_slot(E::slots_per_epoch());
for i in 0..slots_per_epoch {
let slot = start_slot.safe_add(i as u64)?;
let ptc = state.compute_ptc_with_cache(slot, &committee_cache, spec)?;
let ptc_u64: Vec<u64> = ptc.into_iter().map(|v| v as u64).collect();
let entry = FixedVector::new(ptc_u64)?;
ptcs.push(entry);
}
}
*state.ptc_window_mut()? = Vector::new(ptcs)?;
Ok(())
}
/// Applies any pending deposit for builders, effectively onboarding builders at the fork.
fn onboard_builders_from_pending_deposits<E: EthSpec>(
state: &mut BeaconState<E>,

20
consensus/types/src/core/eth_spec.rs
View File

@@ -6,9 +6,9 @@ use std::{
use safe_arith::{ArithError, SafeArith};
use serde::{Deserialize, Serialize};
use typenum::{
U0, U1, U2, U4, U8, U16, U17, U32, U64, U128, U256, U512, U625, U1024, U2048, U4096, U8192,
U16384, U65536, U131072, U262144, U1048576, U16777216, U33554432, U134217728, U1073741824,
U1099511627776, UInt, Unsigned, bit::B0,
U0, U1, U2, U4, U8, U16, U17, U24, U32, U48, U64, U96, U128, U256, U512, U625, U1024, U2048,
U4096, U8192, U16384, U65536, U131072, U262144, U1048576, U16777216, U33554432, U134217728,
U1073741824, U1099511627776, UInt, Unsigned, bit::B0,
};
use crate::core::{ChainSpec, Epoch};
@@ -176,6 +176,7 @@ pub trait EthSpec: 'static + Default + Sync + Send + Clone + Debug + PartialEq +
* New in Gloas
*/
type PTCSize: Unsigned + Clone + Sync + Send + Debug + PartialEq;
type PtcWindowLength: Unsigned + Clone + Sync + Send + Debug + PartialEq;
type MaxPayloadAttestations: Unsigned + Clone + Sync + Send + Debug + PartialEq;
type BuilderPendingPaymentsLimit: Unsigned + Clone + Sync + Send + Debug + PartialEq;
type BuilderPendingWithdrawalsLimit: Unsigned + Clone + Sync + Send + Debug + PartialEq;
@@ -428,6 +429,11 @@ pub trait EthSpec: 'static + Default + Sync + Send + Clone + Debug + PartialEq +
Self::PTCSize::to_usize()
}
/// Returns the `PtcWindowLength` constant for this specification.
fn ptc_window_length() -> usize {
Self::PtcWindowLength::to_usize()
}
/// Returns the `MaxPayloadAttestations` constant for this specification.
fn max_payload_attestations() -> usize {
Self::MaxPayloadAttestations::to_usize()
@@ -515,6 +521,7 @@ impl EthSpec for MainnetEthSpec {
type MaxWithdrawalRequestsPerPayload = U16;
type MaxPendingDepositsPerEpoch = U16;
type PTCSize = U512;
type PtcWindowLength = U96; // (2 + MIN_SEED_LOOKAHEAD) * SLOTS_PER_EPOCH
type MaxPayloadAttestations = U4;
type MaxBuildersPerWithdrawalsSweep = U16384;
@@ -561,6 +568,7 @@ impl EthSpec for MinimalEthSpec {
type ProposerLookaheadSlots = U16; // Derived from (MIN_SEED_LOOKAHEAD + 1) * SLOTS_PER_EPOCH
type BuilderPendingPaymentsLimit = U16; // 2 * SLOTS_PER_EPOCH = 2 * 8 = 16
type PTCSize = U2;
type PtcWindowLength = U24; // (2 + MIN_SEED_LOOKAHEAD) * SLOTS_PER_EPOCH
type MaxBuildersPerWithdrawalsSweep = U16;
params_from_eth_spec!(MainnetEthSpec {
@@ -668,6 +676,7 @@ impl EthSpec for GnosisEthSpec {
type ProposerLookaheadSlots = U32; // Derived from (MIN_SEED_LOOKAHEAD + 1) * SLOTS_PER_EPOCH
type BuilderRegistryLimit = U1099511627776;
type PTCSize = U512;
type PtcWindowLength = U48; // (2 + MIN_SEED_LOOKAHEAD) * SLOTS_PER_EPOCH
type MaxPayloadAttestations = U2;
type MaxBuildersPerWithdrawalsSweep = U16384;
@@ -694,6 +703,11 @@ mod test {
E::proposer_lookahead_slots(),
(spec.min_seed_lookahead.as_usize() + 1) * E::slots_per_epoch() as usize
);
assert_eq!(
E::ptc_window_length(),
(spec.min_seed_lookahead.as_usize() + 2) * E::slots_per_epoch() as usize,
"PtcWindowLength must equal (2 + MIN_SEED_LOOKAHEAD) * SLOTS_PER_EPOCH"
);
}
#[test]

79
consensus/types/src/state/beacon_state.rs
View File

@@ -667,6 +667,11 @@ where
#[superstruct(only(Gloas))]
pub payload_expected_withdrawals: List<Withdrawal, E::MaxWithdrawalsPerPayload>,
#[compare_fields(as_iter)]
#[test_random(default)]
#[superstruct(only(Gloas))]
pub ptc_window: Vector<FixedVector<u64, E::PTCSize>, E::PtcWindowLength>,
// Caching (not in the spec)
#[serde(skip_serializing, skip_deserializing)]
#[ssz(skip_serializing, skip_deserializing)]
@@ -2431,6 +2436,18 @@ impl<E: EthSpec> BeaconState<E> {
CommitteeCache::initialized(self, epoch, spec)
}
/// Like [`initialize_committee_cache`](Self::initialize_committee_cache), but allows epochs
/// beyond `current_epoch + 1`. Only checks that the required randao seed is available.
///
/// Used by PTC window computation which needs shufflings for lookahead epochs.
pub fn initialize_committee_cache_for_lookahead(
&self,
epoch: Epoch,
spec: &ChainSpec,
) -> Result<Arc<CommitteeCache>, BeaconStateError> {
CommitteeCache::initialized_for_lookahead(self, epoch, spec)
}
/// Advances the cache for this state into the next epoch.
///
/// This should be used if the `slot` of this state is advanced beyond an epoch boundary.
@@ -2501,6 +2518,17 @@ impl<E: EthSpec> BeaconState<E> {
.ok_or(BeaconStateError::CommitteeCachesOutOfBounds(index))
}
/// Set the committee cache for the given `relative_epoch` to `cache`.
pub fn set_committee_cache(
&mut self,
relative_epoch: RelativeEpoch,
cache: Arc<CommitteeCache>,
) -> Result<(), BeaconStateError> {
let i = Self::committee_cache_index(relative_epoch);
*self.committee_cache_at_index_mut(i)? = cache;
Ok(())
}
/// Returns the cache for some `RelativeEpoch`. Returns an error if the cache has not been
/// initialized.
pub fn committee_cache(
@@ -3084,12 +3112,55 @@ impl<E: EthSpec> BeaconState<E> {
}
}
/// Get the payload timeliness committee for the given `slot`.
///
/// Requires the committee cache to be initialized.
/// TODO(EIP-7732): definitely gonna have to cache this..
/// Get the payload timeliness committee for the given `slot` from the `ptc_window`.
pub fn get_ptc(&self, slot: Slot, spec: &ChainSpec) -> Result<PTC<E>, BeaconStateError> {
let ptc_window = self.ptc_window()?;
let epoch = slot.epoch(E::slots_per_epoch());
let state_epoch = self.current_epoch();
let slots_per_epoch = E::slots_per_epoch() as usize;
let slot_in_epoch = slot.as_usize().safe_rem(slots_per_epoch)?;
let index = if epoch < state_epoch {
if epoch.safe_add(1)? != state_epoch {
return Err(BeaconStateError::SlotOutOfBounds);
}
slot_in_epoch
} else {
if epoch > state_epoch.safe_add(spec.min_seed_lookahead)? {
return Err(BeaconStateError::SlotOutOfBounds);
}
let offset = epoch
.safe_sub(state_epoch)?
.safe_add(1)?
.as_usize()
.safe_mul(slots_per_epoch)?;
offset.safe_add(slot_in_epoch)?
};
let entry = ptc_window
.get(index)
.ok_or(BeaconStateError::SlotOutOfBounds)?;
// Convert from FixedVector<u64, PTCSize> to PTC<E> (FixedVector<usize, PTCSize>)
let indices: Vec<usize> = entry.iter().map(|&v| v as usize).collect();
Ok(PTC(FixedVector::new(indices)?))
}
/// Compute the payload timeliness committee for the given `slot` from scratch.
///
/// Requires the committee cache to be initialized for the slot's epoch.
pub fn compute_ptc(&self, slot: Slot, spec: &ChainSpec) -> Result<PTC<E>, BeaconStateError> {
let committee_cache = self.committee_cache_at_slot(slot)?;
self.compute_ptc_with_cache(slot, committee_cache, spec)
}
/// Compute the PTC for a slot using a specific committee cache.
pub fn compute_ptc_with_cache(
&self,
slot: Slot,
committee_cache: &CommitteeCache,
spec: &ChainSpec,
) -> Result<PTC<E>, BeaconStateError> {
let committees = committee_cache.get_beacon_committees_at_slot(slot)?;
let seed = self.get_ptc_attester_seed(slot, spec)?;

37
consensus/types/src/state/committee_cache.rs
View File

@@ -62,6 +62,9 @@ fn compare_shuffling_positions(xs: &Vec<NonZeroUsizeOption>, ys: &Vec<NonZeroUsi
impl CommitteeCache {
/// Return a new, fully initialized cache.
///
/// The epoch must be within the range that the state can service: historic epochs with
/// available randao data, up to `current_epoch + 1` (the "next" epoch).
///
/// Spec v0.12.1
pub fn initialized<E: EthSpec>(
state: &BeaconState<E>,
@@ -81,12 +84,44 @@ impl CommitteeCache {
|| epoch
> state
.current_epoch()
.safe_add(1)
.safe_add(1u64)
.map_err(BeaconStateError::ArithError)?
{
return Err(BeaconStateError::EpochOutOfBounds);
}
Self::initialized_unchecked(state, epoch, spec)
}
/// Return a new, fully initialized cache for a lookahead epoch.
///
/// Like [`initialized`](Self::initialized), but allows epochs beyond `current_epoch + 1`.
/// The only bound enforced is that the required randao seed is available in the state.
///
/// This is used by PTC window computation, which needs committee shufflings for
/// `current_epoch + 1 + MIN_SEED_LOOKAHEAD`.
pub fn initialized_for_lookahead<E: EthSpec>(
state: &BeaconState<E>,
epoch: Epoch,
spec: &ChainSpec,
) -> Result<Arc<CommitteeCache>, BeaconStateError> {
let reqd_randao_epoch = epoch
.saturating_sub(spec.min_seed_lookahead)
.saturating_sub(1u64);
if reqd_randao_epoch < state.min_randao_epoch() {
return Err(BeaconStateError::EpochOutOfBounds);
}
Self::initialized_unchecked(state, epoch, spec)
}
/// Core committee cache construction. Callers are responsible for bounds-checking `epoch`.
fn initialized_unchecked<E: EthSpec>(
state: &BeaconState<E>,
epoch: Epoch,
spec: &ChainSpec,
) -> Result<Arc<CommitteeCache>, BeaconStateError> {
// May cause divide-by-zero errors.
if E::slots_per_epoch() == 0 {
return Err(BeaconStateError::ZeroSlotsPerEpoch);