add process_builder_pending_payments to epoch processing

Author: shane-moore

consensus/state_processing/src/per_epoch_processing/altair.rs

@@ -12,13 +12,15 @@ use crate::per_epoch_processing::{
 pub use inactivity_updates::process_inactivity_updates_slow;
 pub use justification_and_finalization::process_justification_and_finalization;
 pub use participation_flag_updates::process_participation_flag_updates;
+pub use process_builder_pending_payments::process_builder_pending_payments;
 pub use rewards_and_penalties::process_rewards_and_penalties_slow;
 pub use sync_committee_updates::process_sync_committee_updates;
 use types::{BeaconState, ChainSpec, EthSpec, RelativeEpoch};
 
 pub mod inactivity_updates;
 pub mod justification_and_finalization;
 pub mod participation_flag_updates;
+pub mod process_builder_pending_payments;
 pub mod rewards_and_penalties;
 pub mod sync_committee_updates;
 
@@ -77,6 +79,10 @@ pub fn process_epoch<E: EthSpec>(
 
     process_sync_committee_updates(state, spec)?;
 
+    if state.fork_name_unchecked().gloas_enabled() {
+        process_builder_pending_payments(state, spec)?;
+    }
+
     // Rotate the epoch caches to suit the epoch transition.
     state.advance_caches()?;
     update_progressive_balances_on_epoch_transition(state, spec)?;

consensus/state_processing/src/per_epoch_processing/altair/process_builder_pending_payments.rs

@@ -0,0 +1,62 @@
+use super::Error;
+use safe_arith::SafeArith;
+use types::{BeaconState, BuilderPendingPayment, ChainSpec, EthSpec, Vector};
+
+pub fn process_builder_pending_payments<E: EthSpec>(
+    state: &mut BeaconState<E>,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    let quorum = get_builder_payment_quorum_threshold(state, spec)?;
+
+    // Collect qualifying payments
+    let qualifying_payments = state
+        .builder_pending_payments()?
+        .iter()
+        .take(E::slots_per_epoch() as usize)
+        .filter(|payment| payment.weight > quorum)
+        .cloned()
+        .collect::<Vec<_>>();
+
+    // Update `builder_pending_withdrawals` with qualifying `builder_pending_payments`
+    qualifying_payments
+        .into_iter()
+        .try_for_each(|payment| -> Result<(), Error> {
+            let exit_queue_epoch =
+                state.compute_exit_epoch_and_update_churn(payment.withdrawal.amount, spec)?;
+            let withdrawable_epoch =
+                exit_queue_epoch.safe_add(spec.min_validator_withdrawability_delay)?;
+
+            let mut withdrawal = payment.withdrawal.clone();
+            withdrawal.withdrawable_epoch = withdrawable_epoch;
+            state.builder_pending_withdrawals_mut()?.push(withdrawal)?;
+            Ok(())
+        })?;
+
+    // Move remaining `builder_pending_payments` to start of list and set the rest to default
+    let new_payments = state
+        .builder_pending_payments()?
+        .iter()
+        .skip(E::slots_per_epoch() as usize)
+        .cloned()
+        .chain((0..E::slots_per_epoch() as usize).map(|_| BuilderPendingPayment::default()))
+        .collect::<Vec<_>>();
+
+    *state.builder_pending_payments_mut()? = Vector::new(new_payments)?;
+
+    Ok(())
+}
+
+pub fn get_builder_payment_quorum_threshold<E: EthSpec>(
+    state: &BeaconState<E>,
+    spec: &ChainSpec,
+) -> Result<u64, Error> {
+    let total_active_balance = state.get_total_active_balance()?;
+
+    let quorum = total_active_balance
+        .safe_div(E::slots_per_epoch())?
+        .safe_mul(spec.builder_payment_threshold_numerator)?;
+
+    quorum
+        .safe_div(spec.builder_payment_threshold_denominator)
+        .map_err(Error::from)
+}