Block processing electra (sigp#5741)

* Attestation superstruct changes for EIP 7549 (sigp#5644) * update * experiment * superstruct changes * revert * superstruct changes * fix tests * indexed attestation * indexed attestation superstruct * updated TODOs * `superstruct` the `AttesterSlashing` (sigp#5636) * `superstruct` Attester Fork Variants * Push a little further * Deal with Encode / Decode of AttesterSlashing * not so sure about this.. * Stop Encode/Decode Bounds from Propagating Out * Tons of Changes.. * More Conversions to AttestationRef * Add AsReference trait (#15) * Add AsReference trait * Fix some snafus * Got it Compiling! :D * Got Tests Building * Get beacon chain tests compiling --------- Co-authored-by: Michael Sproul <micsproul@gmail.com> * Merge remote-tracking branch 'upstream/unstable' into electra_attestation_changes * Make EF Tests Fork-Agnostic (sigp#5713) * Finish EF Test Fork Agnostic (sigp#5714) * Superstruct `AggregateAndProof` (sigp#5715) * Upgrade `superstruct` to `0.8.0` * superstruct `AggregateAndProof` * Merge remote-tracking branch 'sigp/unstable' into electra_attestation_changes * cargo fmt * Merge pull request sigp#5726 from realbigsean/electra_attestation_changes Merge unstable into Electra attestation changes * process withdrawals updates * cleanup withdrawals processing * update `process_operations` deposit length check * add apply_deposit changes * add execution layer withdrawal request processing * process deposit receipts * add consolidation processing * update process operations function * exit updates * clean up * update slash_validator * EIP7549 `get_attestation_indices` (sigp#5657) * get attesting indices electra impl * fmt * get tests to pass * fmt * fix some beacon chain tests * fmt * fix slasher test * fmt got me again * fix more tests * fix tests * Some small changes (sigp#5739) * Merge branch 'electra_attestation_changes' of https://github.com/sigp/lighthouse into block-processing-electra * cargo fmt (sigp#5740) * Merge branch 'electra_attestation_changes' of https://github.com/sigp/lighthouse into block-processing-electra * fix attestation verification * Sketch op pool changes * fix get attesting indices (sigp#5742) * fix get attesting indices * better errors * fix compile * only get committee index once * Merge branch 'electra_attestation_changes' of https://github.com/sigp/lighthouse into block-processing-electra * Ef test fixes (sigp#5753) * attestation related ef test fixes * delete commented out stuff * Merge branch 'electra_attestation_changes' of https://github.com/sigp/lighthouse into block-processing-electra * Fix Aggregation Pool for Electra (sigp#5754) * Fix Aggregation Pool for Electra * Remove Outdated Interface * fix ssz (sigp#5755) * Get `electra_op_pool` up to date (sigp#5756) * fix get attesting indices (sigp#5742) * fix get attesting indices * better errors * fix compile * only get committee index once * Ef test fixes (sigp#5753) * attestation related ef test fixes * delete commented out stuff * Fix Aggregation Pool for Electra (sigp#5754) * Fix Aggregation Pool for Electra * Remove Outdated Interface * fix ssz (sigp#5755) --------- Co-authored-by: realbigsean <sean@sigmaprime.io> * Revert "Get `electra_op_pool` up to date (sigp#5756)" (sigp#5757) This reverts commit ab9e58a. * Merge branch 'electra_attestation_changes' of https://github.com/sigp/lighthouse into electra_op_pool * Merge branch 'electra_attestation_changes' of https://github.com/sigp/lighthouse into block-processing-electra * Compute on chain aggregate impl (sigp#5752) * add compute_on_chain_agg impl to op pool changes * fmt * get op pool tests to pass * update the naive agg pool interface (sigp#5760) * Merge branch 'electra_attestation_changes' of https://github.com/sigp/lighthouse into block-processing-electra * Fix bugs in cross-committee aggregation * Add comment to max cover optimisation * Fix assert * Merge pull request sigp#5749 from sigp/electra_op_pool Optimise Electra op pool aggregation * don't fail on empty consolidations * Merge branch 'electra_attestation_changes' of https://github.com/sigp/lighthouse into block-processing-electra * update committee offset * Merge branch 'electra_attestation_changes' of https://github.com/sigp/lighthouse into block-processing-electra * only increment the state deposit index on old deposit flow * Fix Electra Fork Choice Tests (sigp#5764) * Fix Electra Fork Choice Tests (sigp#5764) * Merge branch 'electra_attestation_changes' of https://github.com/sigp/lighthouse into block-processing-electra * Fix Consolidation Sigs & Withdrawals * Merge pull request sigp#5766 from ethDreamer/two_fixes Fix Consolidation Sigs & Withdrawals * Subscribe to the correct subnets for electra attestations (sigp#5782) * subscribe to the correct att subnets for electra * subscribe to the correct att subnets for electra * cargo fmt * Subscribe to the correct subnets for electra attestations (sigp#5782) * subscribe to the correct att subnets for electra * subscribe to the correct att subnets for electra * cargo fmt * fix slashing handling * Fix Bug In Block Processing with 0x02 Credentials * Merge remote-tracking branch 'upstream/unstable' * Send unagg attestation based on fork * Publish all aggregates * just one more check bro plz.. * Merge pull request sigp#5832 from ethDreamer/electra_attestation_changes_merge_unstable Merge `unstable` into `electra_attestation_changes` * Merge pull request sigp#5835 from realbigsean/fix-validator-logic Fix validator logic * Merge pull request sigp#5816 from realbigsean/electra-attestation-slashing-handling Electra slashing handling * Merge branch 'electra_attestation_changes' of https://github.com/sigp/lighthouse into block-processing-electra * Electra attestation changes rm decode impl (sigp#5856) * Remove Crappy Decode impl for Attestation * Remove Inefficient Attestation Decode impl * Implement Schema Upgrade / Downgrade * Update beacon_node/beacon_chain/src/schema_change/migration_schema_v20.rs Co-authored-by: Michael Sproul <micsproul@gmail.com> --------- Co-authored-by: Michael Sproul <micsproul@gmail.com> * Fix failing attestation tests and misc electra attestation cleanup (sigp#5810) * - get attestation related beacon chain tests to pass - observed attestations are now keyed off of data + committee index - rename op pool attestationref to compactattestationref - remove unwraps in agg pool and use options instead - cherry pick some changes from ef-tests-electra * cargo fmt * fix failing test * Revert dockerfile changes * make committee_index return option * function args shouldnt be a ref to attestation ref * fmt * fix dup imports --------- Co-authored-by: realbigsean <seananderson33@GMAIL.com> * fix some todos (sigp#5817) * Merge branch 'unstable' of https://github.com/sigp/lighthouse into electra_attestation_changes * add consolidations to merkle calc for inclusion proof * Merge branch 'electra_attestation_changes' of https://github.com/sigp/lighthouse into block-processing-electra * Remove Duplicate KZG Commitment Merkle Proof Code (sigp#5874) * Remove Duplicate KZG Commitment Merkle Proof Code * s/tree_lists/fields/ * Merge branch 'unstable' of https://github.com/sigp/lighthouse into electra_attestation_changes * Merge branch 'electra_attestation_changes' of https://github.com/sigp/lighthouse into block-processing-electra * fix compile * Merge branch 'electra_attestation_changes' of https://github.com/sigp/lighthouse into block-processing-electra * Fix slasher tests (sigp#5906) * Fix electra tests * Add electra attestations to double vote tests * Update superstruct to 0.8 * Merge remote-tracking branch 'origin/unstable' into electra_attestation_changes * Small cleanup in slasher tests * Clean up Electra observed aggregates (sigp#5929) * Use consistent key in observed_attestations * Remove unwraps from observed aggregates * Merge branch 'unstable' of https://github.com/sigp/lighthouse into electra_attestation_changes * De-dup attestation constructor logic * Remove unwraps in Attestation construction * Dedup match_attestation_data * Remove outdated TODO * Use ForkName Ord in fork-choice tests * Use ForkName Ord in BeaconBlockBody * Make to_electra not fallible * Remove TestRandom impl for IndexedAttestation * Remove IndexedAttestation faulty Decode impl * Drop TestRandom impl * Add PendingAttestationInElectra * Indexed att on disk (#35) * indexed att on disk * fix lints * Update slasher/src/migrate.rs Co-authored-by: ethDreamer <37123614+ethDreamer@users.noreply.github.com> --------- Co-authored-by: Lion - dapplion <35266934+dapplion@users.noreply.github.com> Co-authored-by: ethDreamer <37123614+ethDreamer@users.noreply.github.com> * add electra fork enabled fn to ForkName impl (#36) * add electra fork enabled fn to ForkName impl * remove inadvertent file * Update common/eth2/src/types.rs Co-authored-by: ethDreamer <37123614+ethDreamer@users.noreply.github.com> * Dedup attestation constructor logic in attester cache * Use if let Ok for committee_bits * Dedup Attestation constructor code * Diff reduction in tests * Fix beacon_chain tests * Diff reduction * Use Ord for ForkName in pubsub * Resolve into_attestation_and_indices todo * Remove stale TODO * Fix beacon_chain tests * Test spec invariant * Use electra_enabled in pubsub * Remove get_indexed_attestation_from_signed_aggregate * Use ok_or instead of if let else * committees are sorted * remove dup method `get_indexed_attestation_from_committees` * Merge pull request sigp#5940 from dapplion/electra_attestation_changes_lionreview Electra attestations sigp#5712 review * update default persisted op pool deserialization * ensure aggregate and proof uses serde untagged on ref * Fork aware ssz static attestation tests * Electra attestation changes from Lions review (sigp#5971) * dedup/cleanup and remove unneeded hashset use * remove irrelevant TODOs * Merge branch 'unstable' of https://github.com/sigp/lighthouse into electra_attestation_changes * Merge branch 'electra_attestation_changes' of https://github.com/sigp/lighthouse into block-processing-electra * Electra attestation changes sean review (sigp#5972) * instantiate empty bitlist in unreachable code * clean up error conversion * fork enabled bool cleanup * remove a couple todos * return bools instead of options in `aggregate` and use the result * delete commented out code * use map macros in simple transformations * remove signers_disjoint_from * get ef tests compiling * get ef tests compiling * update intentionally excluded files * Avoid changing slasher schema for Electra * Delete slasher schema v4 * Fix clippy * Fix compilation of beacon_chain tests * Update database.rs * Update per_block_processing.rs * Add electra lightclient types * Update slasher/src/database.rs * fix imports * Merge pull request sigp#5980 from dapplion/electra-lightclient Add electra lightclient types * Merge pull request sigp#5975 from michaelsproul/electra-slasher-no-migration Avoid changing slasher schema for Electra * Update beacon_node/beacon_chain/src/attestation_verification.rs * Update beacon_node/beacon_chain/src/attestation_verification.rs * Merge branch 'unstable' of https://github.com/sigp/lighthouse into electra_attestation_changes * Merge branch 'electra_attestation_changes' of https://github.com/realbigsean/lighthouse into block-processing-electra * fork enabled electra
dapplion · Jun 26, 2024 · 858b01f · 858b01f
1 parent c52c598
commit 858b01f
Show file tree

Hide file tree

Showing 22 changed files with 800 additions and 79 deletions.
diff --git a/beacon_node/beacon_chain/src/beacon_chain.rs b/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.

diff --git a/beacon_node/beacon_chain/src/execution_payload.rs b/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

diff --git a/beacon_node/genesis/src/eth1_genesis_service.rs b/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))
             })?;
 

diff --git a/beacon_node/http_api/src/builder_states.rs b/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

diff --git a/beacon_node/http_api/tests/interactive_tests.rs b/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);

diff --git a/beacon_node/http_api/tests/tests.rs b/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;

diff --git a/consensus/state_processing/src/common/initiate_validator_exit.rs b/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)?;
 

diff --git a/consensus/state_processing/src/common/slash_validator.rs b/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(_)

diff --git a/consensus/state_processing/src/genesis.rs b/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)?;

diff --git a/consensus/state_processing/src/per_block_processing.rs b/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(()),
     }
 }
diff --git a/consensus/state_processing/src/per_block_processing/block_signature_verifier.rs b/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.
     ///

diff --git a/consensus/state_processing/src/per_block_processing/errors.rs b/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)]