merge with upstream

consensus/state_processing/src/per_block_processing.rs

@@ -19,6 +19,8 @@ pub use process_operations::process_operations;
 pub use verify_attestation::{
     verify_attestation_for_block_inclusion, verify_attestation_for_state,
 };
+#[cfg(all(feature = "withdrawals", feature = "withdrawals-processing"))]
+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,
 };
@@ -34,10 +36,15 @@ pub mod signature_sets;
 pub mod tests;
 mod verify_attestation;
 mod verify_attester_slashing;
+#[cfg(all(feature = "withdrawals", feature = "withdrawals-processing"))]
+mod verify_bls_to_execution_change;
 mod verify_deposit;
 mod verify_exit;
 mod verify_proposer_slashing;
 
+#[cfg(feature = "withdrawals-processing")]
+use crate::common::decrease_balance;
+
 #[cfg(feature = "arbitrary-fuzz")]
 use arbitrary::Arbitrary;
 
@@ -161,6 +168,8 @@ pub fn per_block_processing<T: EthSpec, Payload: AbstractExecPayload<T>>(
     // previous block.
     if is_execution_enabled(state, block.body()) {
         let payload = block.body().execution_payload()?;
+        #[cfg(all(feature = "withdrawals", feature = "withdrawals-processing"))]
+        process_withdrawals::<T, Payload>(state, payload, spec)?;
         process_execution_payload::<T, Payload>(state, payload, spec)?;
     }
 
@@ -454,3 +463,100 @@ pub fn compute_timestamp_at_slot<T: EthSpec>(
         .safe_mul(spec.seconds_per_slot)
         .and_then(|since_genesis| state.genesis_time().safe_add(since_genesis))
 }
+
+/// FIXME: add link to this function once the spec is stable
+#[cfg(feature = "withdrawals")]
+pub fn get_expected_withdrawals<T: EthSpec>(
+    state: &BeaconState<T>,
+    spec: &ChainSpec,
+) -> Result<Withdrawals<T>, 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![];
+
+    if cfg!(not(feature = "withdrawals-processing")) {
+        return Ok(withdrawals.into());
+    }
+
+    for _ in 0..state.validators().len() {
+        let validator = state.get_validator(validator_index as usize)?;
+        let balance = *state.balances().get(validator_index as usize).ok_or(
+            BeaconStateError::BalancesOutOfBounds(validator_index as usize),
+        )?;
+        if validator.is_fully_withdrawable_at(balance, epoch, spec) {
+            withdrawals.push(Withdrawal {
+                index: withdrawal_index,
+                validator_index,
+                address: validator
+                    .get_eth1_withdrawal_address(spec)
+                    .ok_or(BlockProcessingError::WithdrawalCredentialsInvalid)?,
+                amount: balance,
+            });
+            withdrawal_index.safe_add_assign(1)?;
+        } else if validator.is_partially_withdrawable_validator(balance, spec) {
+            withdrawals.push(Withdrawal {
+                index: withdrawal_index,
+                validator_index,
+                address: validator
+                    .get_eth1_withdrawal_address(spec)
+                    .ok_or(BlockProcessingError::WithdrawalCredentialsInvalid)?,
+                amount: balance.safe_sub(spec.max_effective_balance)?,
+            });
+            withdrawal_index.safe_add_assign(1)?;
+        }
+        if withdrawals.len() == T::max_withdrawals_per_payload() {
+            break;
+        }
+        validator_index = validator_index
+            .safe_add(1)?
+            .safe_rem(state.validators().len() as u64)?;
+    }
+
+    Ok(withdrawals.into())
+}
+
+/// FIXME: add link to this function once the spec is stable
+#[cfg(all(feature = "withdrawals", feature = "withdrawals-processing"))]
+pub fn process_withdrawals<'payload, T: EthSpec, Payload: AbstractExecPayload<T>>(
+    state: &mut BeaconState<T>,
+    payload: Payload::Ref<'payload>,
+    spec: &ChainSpec,
+) -> Result<(), BlockProcessingError> {
+    match state {
+        BeaconState::Merge(_) => Ok(()),
+        BeaconState::Capella(_) | BeaconState::Eip4844(_) => {
+            let expected_withdrawals = get_expected_withdrawals(state, spec)?;
+            let expected_root = expected_withdrawals.tree_hash_root();
+            let withdrawals_root = payload.withdrawals_root()?;
+
+            if expected_root != withdrawals_root {
+                return Err(BlockProcessingError::WithdrawalsRootMismatch {
+                    expected: expected_root,
+                    found: withdrawals_root,
+                });
+            }
+
+            for withdrawal in expected_withdrawals.iter() {
+                decrease_balance(
+                    state,
+                    withdrawal.validator_index as usize,
+                    withdrawal.amount,
+                )?;
+            }
+
+            if let Some(latest_withdrawal) = expected_withdrawals.last() {
+                *state.next_withdrawal_index_mut()? = latest_withdrawal.index.safe_add(1)?;
+                let next_validator_index = latest_withdrawal
+                    .validator_index
+                    .safe_add(1)?
+                    .safe_rem(state.validators().len() as u64)?;
+                *state.next_withdrawal_validator_index_mut()? = next_validator_index;
+            }
+
+            Ok(())
+        }
+        // these shouldn't even be encountered but they're here for completeness
+        BeaconState::Base(_) | BeaconState::Altair(_) => Ok(()),
+    }
+}