Block processing electra

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -4538,6 +4538,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         let proposal_epoch = proposal_slot.epoch(T::EthSpec::slots_per_epoch());
         if head_state.current_epoch() == proposal_epoch {
             return get_expected_withdrawals(&unadvanced_state, &self.spec)
+                .map(|(withdrawals, _)| withdrawals)
                 .map_err(Error::PrepareProposerFailed);
         }
 
@@ -4555,7 +4556,9 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             proposal_epoch.start_slot(T::EthSpec::slots_per_epoch()),
             &self.spec,
         )?;
-        get_expected_withdrawals(&advanced_state, &self.spec).map_err(Error::PrepareProposerFailed)
+        get_expected_withdrawals(&advanced_state, &self.spec)
+            .map(|(withdrawals, _)| withdrawals)
+            .map_err(Error::PrepareProposerFailed)
     }
 
     /// Determine whether a fork choice update to the execution layer should be overridden.

beacon_node/beacon_chain/src/execution_payload.rs

@@ -413,7 +413,7 @@ pub fn get_execution_payload<T: BeaconChainTypes>(
         state.latest_execution_payload_header()?.block_hash();
     let withdrawals = match state {
         &BeaconState::Capella(_) | &BeaconState::Deneb(_) | &BeaconState::Electra(_) => {
-            Some(get_expected_withdrawals(state, spec)?.into())
+            Some(get_expected_withdrawals(state, spec)?.0.into())
         }
         &BeaconState::Bellatrix(_) => None,
         // These shouldn't happen but they're here to make the pattern irrefutable

beacon_node/genesis/src/eth1_genesis_service.rs

@@ -432,8 +432,14 @@ impl Eth1GenesisService {
                 // Such an optimization would only be useful in a scenario where `MIN_GENESIS_TIME`
                 // is reached _prior_ to `MIN_ACTIVE_VALIDATOR_COUNT`. I suspect this won't be the
                 // case for mainnet, so we defer this optimization.
+                let Deposit { proof, data } = deposit;
+                let proof = if PROOF_VERIFICATION {
+                    Some(proof)
+                } else {
+                    None
+                };
 
-                apply_deposit(&mut state, &deposit, spec, PROOF_VERIFICATION)
+                apply_deposit(&mut state, data, proof, true, spec)
                     .map_err(|e| format!("Error whilst processing deposit: {:?}", e))
             })?;
 

beacon_node/http_api/src/builder_states.rs

@@ -33,7 +33,7 @@ pub fn get_next_withdrawals<T: BeaconChainTypes>(
     }
 
     match get_expected_withdrawals(&state, &chain.spec) {
-        Ok(withdrawals) => Ok(withdrawals),
+        Ok((withdrawals, _)) => Ok(withdrawals),
         Err(e) => Err(warp_utils::reject::custom_server_error(format!(
             "failed to get expected withdrawal: {:?}",
             e

beacon_node/http_api/tests/interactive_tests.rs

@@ -610,6 +610,7 @@ pub async fn proposer_boost_re_org_test(
     assert_eq!(state_b.slot(), slot_b);
     let pre_advance_withdrawals = get_expected_withdrawals(&state_b, &harness.chain.spec)
         .unwrap()
+        .0
         .to_vec();
     complete_state_advance(&mut state_b, None, slot_c, &harness.chain.spec).unwrap();
 
@@ -696,6 +697,7 @@ pub async fn proposer_boost_re_org_test(
         get_expected_withdrawals(&state_b, &harness.chain.spec)
     }
     .unwrap()
+    .0
     .to_vec();
     let payload_attribs_withdrawals = payload_attribs.withdrawals().unwrap();
     assert_eq!(expected_withdrawals, *payload_attribs_withdrawals);

beacon_node/http_api/tests/tests.rs

@@ -5471,7 +5471,9 @@ impl ApiTester {
                 &self.chain.spec,
             );
         }
-        let expected_withdrawals = get_expected_withdrawals(&state, &self.chain.spec).unwrap();
+        let expected_withdrawals = get_expected_withdrawals(&state, &self.chain.spec)
+            .unwrap()
+            .0;
 
         // fetch expected withdrawals from the client
         let result = self.client.get_expected_withdrawals(&state_id).await;

consensus/state_processing/src/common/initiate_validator_exit.rs

@@ -19,16 +19,22 @@ pub fn initiate_validator_exit<E: EthSpec>(
     state.build_exit_cache(spec)?;
 
     // Compute exit queue epoch
-    let delayed_epoch = state.compute_activation_exit_epoch(state.current_epoch(), spec)?;
-    let mut exit_queue_epoch = state
-        .exit_cache()
-        .max_epoch()?
-        .map_or(delayed_epoch, |epoch| max(epoch, delayed_epoch));
-    let exit_queue_churn = state.exit_cache().get_churn_at(exit_queue_epoch)?;
-
-    if exit_queue_churn >= state.get_validator_churn_limit(spec)? {
-        exit_queue_epoch.safe_add_assign(1)?;
-    }
+    let exit_queue_epoch = if state.fork_name_unchecked() >= ForkName::Electra {
+        let effective_balance = state.get_validator(index)?.effective_balance;
+        state.compute_exit_epoch_and_update_churn(effective_balance, spec)?
+    } else {
+        let delayed_epoch = state.compute_activation_exit_epoch(state.current_epoch(), spec)?;
+        let mut exit_queue_epoch = state
+            .exit_cache()
+            .max_epoch()?
+            .map_or(delayed_epoch, |epoch| max(epoch, delayed_epoch));
+        let exit_queue_churn = state.exit_cache().get_churn_at(exit_queue_epoch)?;
+
+        if exit_queue_churn >= state.get_validator_churn_limit(spec)? {
+            exit_queue_epoch.safe_add_assign(1)?;
+        }
+        exit_queue_epoch
+    };
 
     let validator = state.get_validator_cow(index)?;
 

consensus/state_processing/src/common/slash_validator.rs

@@ -53,8 +53,8 @@ pub fn slash_validator<E: EthSpec>(
     // Apply proposer and whistleblower rewards
     let proposer_index = ctxt.get_proposer_index(state, spec)? as usize;
     let whistleblower_index = opt_whistleblower_index.unwrap_or(proposer_index);
-    let whistleblower_reward =
-        validator_effective_balance.safe_div(spec.whistleblower_reward_quotient)?;
+    let whistleblower_reward = validator_effective_balance
+        .safe_div(spec.whistleblower_reward_quotient_for_state(state))?;
     let proposer_reward = match state {
         BeaconState::Base(_) => whistleblower_reward.safe_div(spec.proposer_reward_quotient)?,
         BeaconState::Altair(_)

consensus/state_processing/src/genesis.rs

@@ -32,12 +32,13 @@ pub fn initialize_beacon_state_from_eth1<E: EthSpec>(
 
     let mut deposit_tree = DepositDataTree::create(&[], 0, DEPOSIT_TREE_DEPTH);
 
-    for deposit in deposits.iter() {
+    for deposit in deposits.into_iter() {
         deposit_tree
             .push_leaf(deposit.data.tree_hash_root())
             .map_err(BlockProcessingError::MerkleTreeError)?;
         state.eth1_data_mut().deposit_root = deposit_tree.root();
-        apply_deposit(&mut state, deposit, spec, true)?;
+        let Deposit { proof, data } = deposit;
+        apply_deposit(&mut state, data, Some(proof), true, spec)?;
     }
 
     process_activations(&mut state, spec)?;

consensus/state_processing/src/per_block_processing.rs

@@ -20,7 +20,7 @@ pub use verify_attestation::{
 };
 pub use verify_bls_to_execution_change::verify_bls_to_execution_change;
 pub use verify_deposit::{
-    get_existing_validator_index, verify_deposit_merkle_proof, verify_deposit_signature,
+    get_existing_validator_index, is_valid_deposit_signature, verify_deposit_merkle_proof,
 };
 pub use verify_exit::verify_exit;
 
@@ -503,13 +503,55 @@ pub fn compute_timestamp_at_slot<E: EthSpec>(
 pub fn get_expected_withdrawals<E: EthSpec>(
     state: &BeaconState<E>,
     spec: &ChainSpec,
-) -> Result<Withdrawals<E>, BlockProcessingError> {
+) -> Result<(Withdrawals<E>, Option<usize>), BlockProcessingError> {
     let epoch = state.current_epoch();
     let mut withdrawal_index = state.next_withdrawal_index()?;
     let mut validator_index = state.next_withdrawal_validator_index()?;
     let mut withdrawals = vec![];
     let fork_name = state.fork_name_unchecked();
 
+    // [New in Electra:EIP7251]
+    // Consume pending partial withdrawals
+    let partial_withdrawals_count =
+        if let Ok(partial_withdrawals) = state.pending_partial_withdrawals() {
+            for withdrawal in partial_withdrawals {
+                if withdrawal.withdrawable_epoch > epoch
+                    || withdrawals.len() == spec.max_pending_partials_per_withdrawals_sweep as usize
+                {
+                    break;
+                }
+
+                let withdrawal_balance = state.get_balance(withdrawal.index as usize)?;
+                let validator = state.get_validator(withdrawal.index as usize)?;
+
+                let has_sufficient_effective_balance =
+                    validator.effective_balance >= spec.min_activation_balance;
+                let has_excess_balance = withdrawal_balance > spec.min_activation_balance;
+
+                if validator.exit_epoch == spec.far_future_epoch
+                    && has_sufficient_effective_balance
+                    && has_excess_balance
+                {
+                    let withdrawable_balance = std::cmp::min(
+                        withdrawal_balance.safe_sub(spec.min_activation_balance)?,
+                        withdrawal.amount,
+                    );
+                    withdrawals.push(Withdrawal {
+                        index: withdrawal_index,
+                        validator_index: withdrawal.index,
+                        address: validator
+                            .get_execution_withdrawal_address(spec)
+                            .ok_or(BeaconStateError::NonExecutionAddresWithdrawalCredential)?,
+                        amount: withdrawable_balance,
+                    });
+                    withdrawal_index.safe_add_assign(1)?;
+                }
+            }
+            Some(withdrawals.len())
+        } else {
+            None
+        };
+
     let bound = std::cmp::min(
         state.validators().len() as u64,
         spec.max_validators_per_withdrawals_sweep,
@@ -524,7 +566,7 @@ pub fn get_expected_withdrawals<E: EthSpec>(
                 index: withdrawal_index,
                 validator_index,
                 address: validator
-                    .get_eth1_withdrawal_address(spec)
+                    .get_execution_withdrawal_address(spec)
                     .ok_or(BlockProcessingError::WithdrawalCredentialsInvalid)?,
                 amount: balance,
             });
@@ -534,9 +576,12 @@ pub fn get_expected_withdrawals<E: EthSpec>(
                 index: withdrawal_index,
                 validator_index,
                 address: validator
-                    .get_eth1_withdrawal_address(spec)
+                    .get_execution_withdrawal_address(spec)
                     .ok_or(BlockProcessingError::WithdrawalCredentialsInvalid)?,
-                amount: balance.safe_sub(spec.max_effective_balance)?,
+                amount: balance.safe_sub(
+                    validator
+                        .get_validator_max_effective_balance(spec, state.fork_name_unchecked()),
+                )?,
             });
             withdrawal_index.safe_add_assign(1)?;
         }
@@ -548,7 +593,7 @@ pub fn get_expected_withdrawals<E: EthSpec>(
             .safe_rem(state.validators().len() as u64)?;
     }
 
-    Ok(withdrawals.into())
+    Ok((withdrawals.into(), partial_withdrawals_count))
 }
 
 /// Apply withdrawals to the state.
@@ -558,9 +603,9 @@ pub fn process_withdrawals<E: EthSpec, Payload: AbstractExecPayload<E>>(
     spec: &ChainSpec,
 ) -> Result<(), BlockProcessingError> {
     match state {
-        BeaconState::Bellatrix(_) => Ok(()),
         BeaconState::Capella(_) | BeaconState::Deneb(_) | BeaconState::Electra(_) => {
-            let expected_withdrawals = get_expected_withdrawals(state, spec)?;
+            let (expected_withdrawals, partial_withdrawals_count) =
+                get_expected_withdrawals(state, spec)?;
             let expected_root = expected_withdrawals.tree_hash_root();
             let withdrawals_root = payload.withdrawals_root()?;
 
@@ -579,6 +624,17 @@ pub fn process_withdrawals<E: EthSpec, Payload: AbstractExecPayload<E>>(
                 )?;
             }
 
+            // Update pending partial withdrawals [New in Electra:EIP7251]
+            if let Some(partial_withdrawals_count) = partial_withdrawals_count {
+                // TODO(electra): Use efficient pop_front after milhouse release https://github.com/sigp/milhouse/pull/38
+                let new_partial_withdrawals = state
+                    .pending_partial_withdrawals()?
+                    .iter_from(partial_withdrawals_count)?
+                    .cloned()
+                    .collect::<Vec<_>>();
+                *state.pending_partial_withdrawals_mut()? = List::new(new_partial_withdrawals)?;
+            }
+
             // Update the next withdrawal index if this block contained withdrawals
             if let Some(latest_withdrawal) = expected_withdrawals.last() {
                 *state.next_withdrawal_index_mut()? = latest_withdrawal.index.safe_add(1)?;
@@ -606,6 +662,6 @@ pub fn process_withdrawals<E: EthSpec, Payload: AbstractExecPayload<E>>(
             Ok(())
         }
         // these shouldn't even be encountered but they're here for completeness
-        BeaconState::Base(_) | BeaconState::Altair(_) => Ok(()),
+        BeaconState::Base(_) | BeaconState::Altair(_) | BeaconState::Bellatrix(_) => Ok(()),
     }
 }

consensus/state_processing/src/per_block_processing/block_signature_verifier.rs

@@ -171,6 +171,7 @@ where
         self.include_exits(block)?;
         self.include_sync_aggregate(block)?;
         self.include_bls_to_execution_changes(block)?;
+        self.include_consolidations(block)?;
 
         Ok(())
     }
@@ -359,6 +360,27 @@ where
         Ok(())
     }
 
+    /// Includes all signatures in `self.block.body.consolidations` for verification.
+    pub fn include_consolidations<Payload: AbstractExecPayload<E>>(
+        &mut self,
+        block: &'a SignedBeaconBlock<E, Payload>,
+    ) -> Result<()> {
+        if let Ok(consolidations) = block.message().body().consolidations() {
+            self.sets.sets.reserve(consolidations.len());
+            for consolidation in consolidations {
+                let set = consolidation_signature_set(
+                    self.state,
+                    self.get_pubkey.clone(),
+                    consolidation,
+                    self.spec,
+                )?;
+
+                self.sets.push(set);
+            }
+        }
+        Ok(())
+    }
+
     /// Verify all the signatures that have been included in `self`, returning `true` if and only if
     /// all the signatures are valid.
     ///

consensus/state_processing/src/per_block_processing/errors.rs

@@ -89,6 +89,46 @@ pub enum BlockProcessingError {
         found: Hash256,
     },
     WithdrawalCredentialsInvalid,
+    TooManyPendingConsolidations {
+        consolidations: usize,
+        limit: usize,
+    },
+    ConsolidationChurnLimitTooLow {
+        churn_limit: u64,
+        minimum: u64,
+    },
+    MatchingSourceTargetConsolidation {
+        index: u64,
+    },
+    InactiveConsolidationSource {
+        index: u64,
+        current_epoch: Epoch,
+    },
+    InactiveConsolidationTarget {
+        index: u64,
+        current_epoch: Epoch,
+    },
+    SourceValidatorExiting {
+        index: u64,
+    },
+    TargetValidatorExiting {
+        index: u64,
+    },
+    FutureConsolidationEpoch {
+        current_epoch: Epoch,
+        consolidation_epoch: Epoch,
+    },
+    NoSourceExecutionWithdrawalCredential {
+        index: u64,
+    },
+    NoTargetExecutionWithdrawalCredential {
+        index: u64,
+    },
+    MismatchedWithdrawalCredentials {
+        source_address: Address,
+        target_address: Address,
+    },
+    InavlidConsolidationSignature,
     PendingAttestationInElectra,
 }
 
@@ -412,7 +452,10 @@ pub enum ExitInvalid {
     /// The specified validator has already initiated exit.
     AlreadyInitiatedExit(u64),
     /// The exit is for a future epoch.
-    FutureEpoch { state: Epoch, exit: Epoch },
+    FutureEpoch {
+        state: Epoch,
+        exit: Epoch,
+    },
     /// The validator has not been active for long enough.
     TooYoungToExit {
         current_epoch: Epoch,
@@ -423,6 +466,7 @@ pub enum ExitInvalid {
     /// There was an error whilst attempting to get a set of signatures. The signatures may have
     /// been invalid or an internal error occurred.
     SignatureSetError(SignatureSetError),
+    PendingWithdrawalInQueue(u64),
 }
 
 #[derive(Debug, PartialEq, Clone)]