Changes for fusaka-devnet-1 (#7559)

ethDreamer · web-flow · commit b08d49c4cb34 · 2025-06-09T09:10:08.000Z
Changes for [fusaka-devnet-1](https://notes.ethereum.org/@ethpandaops/fusaka-devnet-1) [Consensus Specs v1.6.0-alpha.1](ethereum/consensus-specs#4346) * [EIP-7917: Deterministic Proposer Lookahead](https://eips.ethereum.org/EIPS/eip-7917) * [EIP-7892: Blob Parameter Only Hardforks](https://eips.ethereum.org/EIPS/eip-7892)
diff --git a/beacon_node/beacon_chain/src/beacon_proposer_cache.rs b/beacon_node/beacon_chain/src/beacon_proposer_cache.rs
@@ -181,7 +181,7 @@ pub fn compute_proposer_duties_from_head<T: BeaconChainTypes>(
     ensure_state_is_in_epoch(&mut state, head_state_root, request_epoch, &chain.spec)?;
 
     let indices = state
-        .get_beacon_proposer_indices(&chain.spec)
+        .get_beacon_proposer_indices(request_epoch, &chain.spec)
         .map_err(BeaconChainError::from)?;
 
     let dependent_root = state
diff --git a/beacon_node/beacon_chain/src/blob_verification.rs b/beacon_node/beacon_chain/src/blob_verification.rs
@@ -523,7 +523,8 @@ pub fn validate_blob_sidecar_for_gossip<T: BeaconChainTypes, O: ObservationStrat
             &chain.spec,
         )?;
 
-        let proposers = state.get_beacon_proposer_indices(&chain.spec)?;
+        let epoch = state.current_epoch();
+        let proposers = state.get_beacon_proposer_indices(epoch, &chain.spec)?;
         let proposer_index = *proposers
             .get(blob_slot.as_usize() % T::EthSpec::slots_per_epoch() as usize)
             .ok_or_else(|| BeaconChainError::NoProposerForSlot(blob_slot))?;
diff --git a/beacon_node/beacon_chain/src/block_verification.rs b/beacon_node/beacon_chain/src/block_verification.rs
@@ -962,7 +962,8 @@ impl<T: BeaconChainTypes> GossipVerifiedBlock<T> {
                 &chain.spec,
             )?;
 
-            let proposers = state.get_beacon_proposer_indices(&chain.spec)?;
+            let epoch = state.current_epoch();
+            let proposers = state.get_beacon_proposer_indices(epoch, &chain.spec)?;
             let proposer_index = *proposers
                 .get(block.slot().as_usize() % T::EthSpec::slots_per_epoch() as usize)
                 .ok_or_else(|| BeaconChainError::NoProposerForSlot(block.slot()))?;
diff --git a/beacon_node/beacon_chain/src/data_column_verification.rs b/beacon_node/beacon_chain/src/data_column_verification.rs
@@ -669,7 +669,8 @@ fn verify_proposer_and_signature<T: BeaconChainTypes>(
             &chain.spec,
         )?;
 
-        let proposers = state.get_beacon_proposer_indices(&chain.spec)?;
+        let epoch = state.current_epoch();
+        let proposers = state.get_beacon_proposer_indices(epoch, &chain.spec)?;
         // Prime the proposer shuffling cache with the newly-learned value.
         Ok::<_, GossipDataColumnError>(EpochBlockProposers {
             epoch: column_epoch,
diff --git a/beacon_node/beacon_chain/src/state_advance_timer.rs b/beacon_node/beacon_chain/src/state_advance_timer.rs
@@ -377,7 +377,7 @@ fn advance_head<T: BeaconChainTypes>(beacon_chain: &Arc<BeaconChain<T>>) -> Resu
                 state.current_epoch(),
                 head_block_root,
                 state
-                    .get_beacon_proposer_indices(&beacon_chain.spec)
+                    .get_beacon_proposer_indices(state.current_epoch(), &beacon_chain.spec)
                     .map_err(BeaconChainError::from)?,
                 state.fork(),
             )
diff --git a/beacon_node/beacon_chain/tests/tests.rs b/beacon_node/beacon_chain/tests/tests.rs
@@ -9,6 +9,7 @@ use beacon_chain::{
     BeaconChain, ChainConfig, NotifyExecutionLayer, StateSkipConfig, WhenSlotSkipped,
 };
 use operation_pool::PersistedOperationPool;
+use state_processing::EpochProcessingError;
 use state_processing::{per_slot_processing, per_slot_processing::Error as SlotProcessingError};
 use std::sync::LazyLock;
 use types::{
@@ -67,11 +68,23 @@ fn massive_skips() {
     };
 
     assert!(state.slot() > 1, "the state should skip at least one slot");
-    assert_eq!(
-        error,
-        SlotProcessingError::BeaconStateError(BeaconStateError::InsufficientValidators),
-        "should return error indicating that validators have been slashed out"
-    )
+
+    if state.fork_name_unchecked().fulu_enabled() {
+        // post-fulu this is done in per_epoch_processing
+        assert_eq!(
+            error,
+            SlotProcessingError::EpochProcessingError(EpochProcessingError::BeaconStateError(
+                BeaconStateError::InsufficientValidators
+            )),
+            "should return error indicating that validators have been slashed out"
+        )
+    } else {
+        assert_eq!(
+            error,
+            SlotProcessingError::BeaconStateError(BeaconStateError::InsufficientValidators),
+            "should return error indicating that validators have been slashed out"
+        )
+    }
 }
 
 #[tokio::test]
diff --git a/beacon_node/beacon_chain/tests/validator_monitor.rs b/beacon_node/beacon_chain/tests/validator_monitor.rs
@@ -81,7 +81,7 @@ async fn missed_blocks_across_epochs() {
                 epoch,
                 decision_root,
                 state
-                    .get_beacon_proposer_indices(&harness.chain.spec)
+                    .get_beacon_proposer_indices(epoch, &harness.chain.spec)
                     .unwrap(),
                 state.fork(),
             )
@@ -147,7 +147,9 @@ async fn missed_blocks_basic() {
     let mut slot_in_epoch = slot % slots_per_epoch;
     let mut prev_slot = Slot::new(idx - 1);
     let mut duplicate_block_root = *_state.block_roots().get(idx as usize).unwrap();
-    let mut validator_indexes = _state.get_beacon_proposer_indices(&harness1.spec).unwrap();
+    let mut validator_indexes = _state
+        .get_beacon_proposer_indices(epoch, &harness1.spec)
+        .unwrap();
     let mut missed_block_proposer = validator_indexes[slot_in_epoch.as_usize()];
     let mut proposer_shuffling_decision_root = _state
         .proposer_shuffling_decision_root(duplicate_block_root)
@@ -219,7 +221,9 @@ async fn missed_blocks_basic() {
     prev_slot = Slot::new(idx - 1);
     slot_in_epoch = slot % slots_per_epoch;
     duplicate_block_root = *_state2.block_roots().get(idx as usize).unwrap();
-    validator_indexes = _state2.get_beacon_proposer_indices(&harness2.spec).unwrap();
+    validator_indexes = _state2
+        .get_beacon_proposer_indices(epoch, &harness2.spec)
+        .unwrap();
     missed_block_proposer = validator_indexes[slot_in_epoch.as_usize()];
 
     let beacon_proposer_cache = harness2
@@ -317,7 +321,9 @@ async fn missed_blocks_basic() {
     slot_in_epoch = slot % slots_per_epoch;
     prev_slot = Slot::new(idx - 1);
     duplicate_block_root = *_state3.block_roots().get(idx as usize).unwrap();
-    validator_indexes = _state3.get_beacon_proposer_indices(&harness3.spec).unwrap();
+    validator_indexes = _state3
+        .get_beacon_proposer_indices(epoch, &harness3.spec)
+        .unwrap();
     missed_block_proposer = validator_indexes[slot_in_epoch.as_usize()];
     proposer_shuffling_decision_root = _state3
         .proposer_shuffling_decision_root_at_epoch(epoch, duplicate_block_root)
diff --git a/beacon_node/http_api/src/proposer_duties.rs b/beacon_node/http_api/src/proposer_duties.rs
@@ -227,7 +227,7 @@ fn compute_historic_proposer_duties<T: BeaconChainTypes>(
     }
 
     let indices = state
-        .get_beacon_proposer_indices(&chain.spec)
+        .get_beacon_proposer_indices(epoch, &chain.spec)
         .map_err(BeaconChainError::from)
         .map_err(warp_utils::reject::unhandled_error)?;
 
diff --git a/beacon_node/store/src/partial_beacon_state.rs b/beacon_node/store/src/partial_beacon_state.rs
@@ -147,6 +147,8 @@ where
         List<PendingPartialWithdrawal, E::PendingPartialWithdrawalsLimit>,
     #[superstruct(only(Electra, Fulu))]
     pub pending_consolidations: List<PendingConsolidation, E::PendingConsolidationsLimit>,
+    #[superstruct(only(Fulu))]
+    pub proposer_lookahead: Vector<u64, E::ProposerLookaheadSlots>,
 }
 
 impl<E: EthSpec> PartialBeaconState<E> {
@@ -444,7 +446,8 @@ impl<E: EthSpec> TryInto<BeaconState<E>> for PartialBeaconState<E> {
                     earliest_consolidation_epoch,
                     pending_deposits,
                     pending_partial_withdrawals,
-                    pending_consolidations
+                    pending_consolidations,
+                    proposer_lookahead
                 ],
                 [historical_summaries]
             ),
diff --git a/consensus/state_processing/src/per_epoch_processing/errors.rs b/consensus/state_processing/src/per_epoch_processing/errors.rs
@@ -30,6 +30,7 @@ pub enum EpochProcessingError {
     MissingEarliestExitEpoch,
     MissingExitBalanceToConsume,
     PendingDepositsLogicError,
+    ProposerLookaheadOutOfBounds(usize),
 }
 
 impl From<InclusionError> for EpochProcessingError {
diff --git a/consensus/state_processing/src/per_epoch_processing/single_pass.rs b/consensus/state_processing/src/per_epoch_processing/single_pass.rs
@@ -19,7 +19,7 @@ use types::{
     milhouse::Cow,
     ActivationQueue, BeaconState, BeaconStateError, ChainSpec, Checkpoint, DepositData, Epoch,
     EthSpec, ExitCache, ForkName, List, ParticipationFlags, PendingDeposit,
-    ProgressiveBalancesCache, RelativeEpoch, Unsigned, Validator,
+    ProgressiveBalancesCache, RelativeEpoch, Unsigned, Validator, Vector,
 };
 
 pub struct SinglePassConfig {
@@ -30,6 +30,7 @@ pub struct SinglePassConfig {
     pub pending_deposits: bool,
     pub pending_consolidations: bool,
     pub effective_balance_updates: bool,
+    pub proposer_lookahead: bool,
 }
 
 impl Default for SinglePassConfig {
@@ -48,6 +49,7 @@ impl SinglePassConfig {
             pending_deposits: true,
             pending_consolidations: true,
             effective_balance_updates: true,
+            proposer_lookahead: true,
         }
     }
 
@@ -60,6 +62,7 @@ impl SinglePassConfig {
             pending_deposits: false,
             pending_consolidations: false,
             effective_balance_updates: false,
+            proposer_lookahead: false,
         }
     }
 }
@@ -460,9 +463,43 @@ pub fn process_epoch_single_pass<E: EthSpec>(
             next_epoch_cache.into_epoch_cache(next_epoch_activation_queue, spec)?;
     }
 
+    if conf.proposer_lookahead && fork_name.fulu_enabled() {
+        process_proposer_lookahead(state, spec)?;
+    }
+
     Ok(summary)
 }
 
+// TOOO(EIP-7917): use balances cache
+pub fn process_proposer_lookahead<E: EthSpec>(
+    state: &mut BeaconState<E>,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    let mut lookahead = state.proposer_lookahead()?.clone().to_vec();
+
+    // Shift out proposers in the first epoch
+    lookahead.copy_within((E::slots_per_epoch() as usize).., 0);
+
+    let next_epoch = state
+        .current_epoch()
+        .safe_add(spec.min_seed_lookahead.as_u64())?
+        .safe_add(1)?;
+    let last_epoch_proposers = state.get_beacon_proposer_indices(next_epoch, spec)?;
+
+    // Fill in the last epoch with new proposer indices
+    let last_epoch_start = E::proposer_lookahead_slots().safe_sub(E::slots_per_epoch() as usize)?;
+    for (i, proposer) in last_epoch_proposers.into_iter().enumerate() {
+        let index = last_epoch_start.safe_add(i)?;
+        *lookahead
+            .get_mut(index)
+            .ok_or(Error::ProposerLookaheadOutOfBounds(index))? = proposer as u64;
+    }
+
+    *state.proposer_lookahead_mut()? = Vector::new(lookahead)?;
+
+    Ok(())
+}
+
 fn process_single_inactivity_update(
     inactivity_score: &mut Cow<u64>,
     validator_info: &ValidatorInfo,
diff --git a/consensus/state_processing/src/upgrade/fulu.rs b/consensus/state_processing/src/upgrade/fulu.rs
@@ -1,5 +1,8 @@
+use safe_arith::SafeArith;
 use std::mem;
-use types::{BeaconState, BeaconStateError as Error, BeaconStateFulu, ChainSpec, EthSpec, Fork};
+use types::{
+    BeaconState, BeaconStateError as Error, BeaconStateFulu, ChainSpec, EthSpec, Fork, Vector,
+};
 
 /// Transform a `Electra` state into an `Fulu` state.
 pub fn upgrade_to_fulu<E: EthSpec>(
@@ -15,11 +18,32 @@ pub fn upgrade_to_fulu<E: EthSpec>(
     Ok(())
 }
 
+fn initialize_proposer_lookahead<E: EthSpec>(
+    state: &BeaconState<E>,
+    spec: &ChainSpec,
+) -> Result<Vector<u64, E::ProposerLookaheadSlots>, Error> {
+    let current_epoch = state.current_epoch();
+    let mut lookahead = Vec::with_capacity(E::proposer_lookahead_slots());
+    for i in 0..(spec.min_seed_lookahead.safe_add(1)?.as_u64()) {
+        let target_epoch = current_epoch.safe_add(i)?;
+        lookahead.extend(
+            state
+                .get_beacon_proposer_indices(target_epoch, spec)
+                .map(|vec| vec.into_iter().map(|x| x as u64))?,
+        );
+    }
+
+    Vector::new(lookahead).map_err(|e| {
+        Error::PleaseNotifyTheDevs(format!("Failed to initialize proposer lookahead: {:?}", e))
+    })
+}
+
 pub fn upgrade_state_to_fulu<E: EthSpec>(
     pre_state: &mut BeaconState<E>,
     spec: &ChainSpec,
 ) -> Result<BeaconState<E>, Error> {
     let epoch = pre_state.current_epoch();
+    let proposer_lookahead = initialize_proposer_lookahead(pre_state, spec)?;
     let pre = pre_state.as_electra_mut()?;
     // Where possible, use something like `mem::take` to move fields from behind the &mut
     // reference. For other fields that don't have a good default value, use `clone`.
@@ -89,6 +113,7 @@ pub fn upgrade_state_to_fulu<E: EthSpec>(
         exit_cache: mem::take(&mut pre.exit_cache),
         slashings_cache: mem::take(&mut pre.slashings_cache),
         epoch_cache: mem::take(&mut pre.epoch_cache),
+        proposer_lookahead,
     });
     Ok(post)
 }
diff --git a/consensus/types/src/beacon_state.rs b/consensus/types/src/beacon_state.rs
diff --git a/consensus/types/src/eth_spec.rs b/consensus/types/src/eth_spec.rs
diff --git a/testing/ef_tests/Makefile b/testing/ef_tests/Makefile
diff --git a/testing/ef_tests/src/cases/epoch_processing.rs b/testing/ef_tests/src/cases/epoch_processing.rs
diff --git a/testing/ef_tests/src/lib.rs b/testing/ef_tests/src/lib.rs
diff --git a/testing/ef_tests/tests/tests.rs b/testing/ef_tests/tests/tests.rs

Original file line number	Diff line number	Diff line change
`@@ -377,7 +377,7 @@ fn advance_head<T: BeaconChainTypes>(beacon_chain: &Arc<BeaconChain<T>>) -> Resu`
`377`	`377`	`state.current_epoch(),`
`378`	`378`	`head_block_root,`
`379`	`379`	`state`
`380`		`- .get_beacon_proposer_indices(&beacon_chain.spec)`
	`380`	`+ .get_beacon_proposer_indices(state.current_epoch(), &beacon_chain.spec)`
`381`	`381`	`.map_err(BeaconChainError::from)?,`
`382`	`382`	`state.fork(),`
`383`	`383`	`)`
Original file line number	Diff line number	Diff line change
`@@ -227,7 +227,7 @@ fn compute_historic_proposer_duties<T: BeaconChainTypes>(`
`227`	`227`	`}`
`228`	`228`
`229`	`229`	`let indices = state`
`230`		`- .get_beacon_proposer_indices(&chain.spec)`
	`230`	`+ .get_beacon_proposer_indices(epoch, &chain.spec)`
`231`	`231`	`.map_err(BeaconChainError::from)`
`232`	`232`	`.map_err(warp_utils::reject::unhandled_error)?;`
`233`	`233`
Original file line number	Diff line number	Diff line change
`@@ -30,6 +30,7 @@ pub enum EpochProcessingError {`
`30`	`30`	`MissingEarliestExitEpoch,`
`31`	`31`	`MissingExitBalanceToConsume,`
`32`	`32`	`PendingDepositsLogicError,`
	`33`	`+ ProposerLookaheadOutOfBounds(usize),`
`33`	`34`	`}`
`34`	`35`
`35`	`36`	`impl From<InclusionError> for EpochProcessingError {`