Electra spec changes for v1.5.0-beta.0

beacon_node/execution_layer/src/engine_api/new_payload_request.rs

@@ -128,6 +128,11 @@ impl<'block, E: EthSpec> NewPayloadRequest<'block, E> {
 
         let _timer = metrics::start_timer(&metrics::EXECUTION_LAYER_VERIFY_BLOCK_HASH);
 
+        // Check that no transactions in the payload are zero length
+        if payload.transactions().iter().any(|slice| slice.is_empty()) {
+            return Err(Error::ZeroLengthTransaction);
+        }
+
         let (header_hash, rlp_transactions_root) = calculate_execution_block_hash(
             payload,
             parent_beacon_block_root,

beacon_node/execution_layer/src/lib.rs

@@ -157,6 +157,7 @@ pub enum Error {
         payload: ExecutionBlockHash,
         transactions_root: Hash256,
     },
+    ZeroLengthTransaction,
     PayloadBodiesByRangeNotSupported,
     InvalidJWTSecret(String),
     InvalidForkForPayload,

beacon_node/lighthouse_network/src/rpc/codec.rs

@@ -590,16 +590,14 @@ fn handle_rpc_request<E: EthSpec>(
         ))),
         SupportedProtocol::BlobsByRangeV1 => {
             let req = BlobsByRangeRequest::from_ssz_bytes(decoded_buffer)?;
-            let max_requested_blobs = req
-                .count
-                .saturating_mul(spec.max_blobs_per_block_by_fork(current_fork));
             // TODO(pawan): change this to max_blobs_per_rpc_request in the alpha10 PR
-            if max_requested_blobs > spec.max_request_blob_sidecars {
+            let max_blobs = spec.max_blobs_per_block_by_fork(current_fork);
+            if req.count > max_blobs {
                 return Err(RPCError::ErrorResponse(
                     RpcErrorResponse::InvalidRequest,
                     format!(
                         "requested exceeded limit. allowed: {}, requested: {}",
-                        spec.max_request_blob_sidecars, max_requested_blobs
+                        max_blobs, req.count
                     ),
                 ));
             }

beacon_node/lighthouse_network/src/rpc/protocol.rs

@@ -106,13 +106,15 @@ pub static SIGNED_BEACON_BLOCK_DENEB_MAX: LazyLock<usize> = LazyLock::new(|| {
     *SIGNED_BEACON_BLOCK_CAPELLA_MAX_WITHOUT_PAYLOAD
     + types::ExecutionPayload::<MainnetEthSpec>::max_execution_payload_deneb_size() // adding max size of execution payload (~16gb)
     + ssz::BYTES_PER_LENGTH_OFFSET // Adding the additional offsets for the `ExecutionPayload`
+    + (<types::KzgCommitment as Encode>::ssz_fixed_len() * MainnetEthSpec::default_spec().max_blobs_per_block_by_fork(ForkName::Deneb) as usize)
     + ssz::BYTES_PER_LENGTH_OFFSET
 }); // Length offset for the blob commitments field.
     //
 pub static SIGNED_BEACON_BLOCK_ELECTRA_MAX: LazyLock<usize> = LazyLock::new(|| {
     *SIGNED_BEACON_BLOCK_ELECTRA_MAX_WITHOUT_PAYLOAD
     + types::ExecutionPayload::<MainnetEthSpec>::max_execution_payload_electra_size() // adding max size of execution payload (~16gb)
     + ssz::BYTES_PER_LENGTH_OFFSET // Adding the additional ssz offset for the `ExecutionPayload` field
+    + (<types::KzgCommitment as Encode>::ssz_fixed_len() * MainnetEthSpec::default_spec().max_blobs_per_block_by_fork(ForkName::Electra) as usize)
     + ssz::BYTES_PER_LENGTH_OFFSET
 }); // Length offset for the blob commitments field.
 
@@ -710,7 +712,6 @@ pub fn rpc_blob_limits<E: EthSpec>() -> RpcLimits {
     }
 }
 
-// TODO(peerdas): fix hardcoded max here
 pub fn rpc_data_column_limits<E: EthSpec>(fork_name: ForkName) -> RpcLimits {
     RpcLimits::new(
         DataColumnSidecar::<E>::empty().as_ssz_bytes().len(),

beacon_node/store/src/impls/execution_payload.rs

@@ -4,7 +4,6 @@ use types::{
     EthSpec, ExecutionPayload, ExecutionPayloadBellatrix, ExecutionPayloadCapella,
     ExecutionPayloadDeneb, ExecutionPayloadElectra, ExecutionPayloadFulu,
 };
-
 macro_rules! impl_store_item {
     ($ty_name:ident) => {
         impl<E: EthSpec> StoreItem for $ty_name<E> {

consensus/fork_choice/tests/tests.rs

@@ -10,6 +10,7 @@ use beacon_chain::{
 use fork_choice::{
     ForkChoiceStore, InvalidAttestation, InvalidBlock, PayloadVerificationStatus, QueuedAttestation,
 };
+use state_processing::state_advance::complete_state_advance;
 use std::fmt;
 use std::sync::Mutex;
 use std::time::Duration;
@@ -172,6 +173,20 @@ impl ForkChoiceTest {
         let validators = self.harness.get_all_validators();
         loop {
             let slot = self.harness.get_current_slot();
+
+            // Skip slashed proposers, as we expect validators to get slashed in these tests.
+            // Presently `make_block` will panic if the proposer is slashed, so we just avoid
+            // calling it in this case.
+            complete_state_advance(&mut state, None, slot, &self.harness.spec).unwrap();
+            state.build_caches(&self.harness.spec).unwrap();
+            let proposer_index = state
+                .get_beacon_proposer_index(slot, &self.harness.chain.spec)
+                .unwrap();
+            if state.validators().get(proposer_index).unwrap().slashed {
+                self.harness.advance_slot();
+                continue;
+            }
+
             let (block_contents, state_) = self.harness.make_block(state, slot).await;
             state = state_;
             if !predicate(block_contents.0.message(), &state) {
@@ -196,17 +211,20 @@ impl ForkChoiceTest {
     }
 
     /// Apply `count` blocks to the chain (with attestations).
+    ///
+    /// Note that in the case of slashed validators, their proposals will be skipped and the chain
+    /// may be advanced by *more than* `count` slots.
     pub async fn apply_blocks(self, count: usize) -> Self {
-        self.harness.advance_slot();
-        self.harness
-            .extend_chain(
-                count,
-                BlockStrategy::OnCanonicalHead,
-                AttestationStrategy::AllValidators,
-            )
-            .await;
-
-        self
+        // Use `Self::apply_blocks_while` which gracefully handles slashed validators.
+        let mut blocks_applied = 0;
+        self.apply_blocks_while(|_, _| {
+            // Blocks are applied after the predicate is called, so continue applying the block if
+            // less than *or equal* to the count.
+            blocks_applied += 1;
+            blocks_applied <= count
+        })
+        .await
+        .unwrap()
     }
 
     /// Slash a validator from the previous epoch committee.
@@ -244,6 +262,7 @@ impl ForkChoiceTest {
 
     /// Apply `count` blocks to the chain (without attestations).
     pub async fn apply_blocks_without_new_attestations(self, count: usize) -> Self {
+        // This function does not gracefully handle slashed proposers, but may need to in future.
         self.harness.advance_slot();
         self.harness
             .extend_chain(
@@ -1226,14 +1245,6 @@ async fn progressive_balances_cache_attester_slashing() {
         .apply_blocks_while(|_, state| state.finalized_checkpoint().epoch == 0)
         .await
         .unwrap()
-        // Note: This test may fail if the shuffling used changes, right now it re-runs with
-        // deterministic shuffling. A shuffling change my cause the slashed proposer to propose
-        // again in the next epoch, which results in a block processing failure
-        // (`HeaderInvalid::ProposerSlashed`). The harness should be re-worked to successfully skip
-        // the slot in this scenario rather than panic-ing. The same applies to
-        // `progressive_balances_cache_proposer_slashing`.
-        .apply_blocks(2)
-        .await
         .add_previous_epoch_attester_slashing()
         .await
         // expect fork choice to import blocks successfully after a previous epoch attester is
@@ -1244,7 +1255,7 @@ async fn progressive_balances_cache_attester_slashing() {
         // expect fork choice to import another epoch of blocks successfully - the slashed
         // attester's balance should be excluded from the current epoch total balance in
         // `ProgressiveBalancesCache` as well.
-        .apply_blocks(MainnetEthSpec::slots_per_epoch() as usize)
+        .apply_blocks(E::slots_per_epoch() as usize)
         .await;
 }
 
@@ -1257,15 +1268,7 @@ async fn progressive_balances_cache_proposer_slashing() {
         .apply_blocks_while(|_, state| state.finalized_checkpoint().epoch == 0)
         .await
         .unwrap()
-        // Note: This test may fail if the shuffling used changes, right now it re-runs with
-        // deterministic shuffling. A shuffling change may cause the slashed proposer to propose
-        // again in the next epoch, which results in a block processing failure
-        // (`HeaderInvalid::ProposerSlashed`). The harness should be re-worked to successfully skip
-        // the slot in this scenario rather than panic-ing. The same applies to
-        // `progressive_balances_cache_attester_slashing`.
-        .apply_blocks(1)
-        .await
-        .add_previous_epoch_proposer_slashing(MainnetEthSpec::slots_per_epoch())
+        .add_previous_epoch_proposer_slashing(E::slots_per_epoch())
         .await
         // expect fork choice to import blocks successfully after a previous epoch proposer is
         // slashed, i.e. the slashed proposer's balance is correctly excluded from
@@ -1275,6 +1278,6 @@ async fn progressive_balances_cache_proposer_slashing() {
         // expect fork choice to import another epoch of blocks successfully - the slashed
         // proposer's balance should be excluded from the current epoch total balance in
         // `ProgressiveBalancesCache` as well.
-        .apply_blocks(MainnetEthSpec::slots_per_epoch() as usize)
+        .apply_blocks(E::slots_per_epoch() as usize)
         .await;
 }

consensus/state_processing/src/per_block_processing.rs

@@ -1,7 +1,7 @@
 use crate::consensus_context::ConsensusContext;
 use errors::{BlockOperationError, BlockProcessingError, HeaderInvalid};
 use rayon::prelude::*;
-use safe_arith::{ArithError, SafeArith};
+use safe_arith::{ArithError, SafeArith, SafeArithIter};
 use signature_sets::{block_proposal_signature_set, get_pubkey_from_state, randao_signature_set};
 use std::borrow::Cow;
 use tree_hash::TreeHash;
@@ -509,7 +509,7 @@ pub fn compute_timestamp_at_slot<E: EthSpec>(
 
 /// Compute the next batch of withdrawals which should be included in a block.
 ///
-/// https://github.com/ethereum/consensus-specs/blob/dev/specs/capella/beacon-chain.md#new-get_expected_withdrawals
+/// https://github.com/ethereum/consensus-specs/blob/dev/specs/electra/beacon-chain.md#new-get_expected_withdrawals
 pub fn get_expected_withdrawals<E: EthSpec>(
     state: &BeaconState<E>,
     spec: &ChainSpec,
@@ -522,18 +522,18 @@ pub fn get_expected_withdrawals<E: EthSpec>(
 
     // [New in Electra:EIP7251]
     // Consume pending partial withdrawals
-    let partial_withdrawals_count =
+    let processed_partial_withdrawals_count =
         if let Ok(partial_withdrawals) = state.pending_partial_withdrawals() {
-            let mut partial_withdrawals_count = 0;
+            let mut processed_partial_withdrawals_count = 0;
             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 withdrawal_balance = state.get_balance(withdrawal.validator_index as usize)?;
+                let validator = state.get_validator(withdrawal.validator_index as usize)?;
 
                 let has_sufficient_effective_balance =
                     validator.effective_balance >= spec.min_activation_balance;
@@ -549,17 +549,17 @@ pub fn get_expected_withdrawals<E: EthSpec>(
                     );
                     withdrawals.push(Withdrawal {
                         index: withdrawal_index,
-                        validator_index: withdrawal.index,
+                        validator_index: withdrawal.validator_index,
                         address: validator
                             .get_execution_withdrawal_address(spec)
                             .ok_or(BeaconStateError::NonExecutionAddresWithdrawalCredential)?,
                         amount: withdrawable_balance,
                     });
                     withdrawal_index.safe_add_assign(1)?;
                 }
-                partial_withdrawals_count.safe_add_assign(1)?;
+                processed_partial_withdrawals_count.safe_add_assign(1)?;
             }
-            Some(partial_withdrawals_count)
+            Some(processed_partial_withdrawals_count)
         } else {
             None
         };
@@ -570,9 +570,19 @@ pub fn get_expected_withdrawals<E: EthSpec>(
     );
     for _ in 0..bound {
         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),
-        )?;
+        let partially_withdrawn_balance = withdrawals
+            .iter()
+            .filter_map(|withdrawal| {
+                (withdrawal.validator_index == validator_index).then_some(withdrawal.amount)
+            })
+            .safe_sum()?;
+        let balance = state
+            .balances()
+            .get(validator_index as usize)
+            .ok_or(BeaconStateError::BalancesOutOfBounds(
+                validator_index as usize,
+            ))?
+            .safe_sub(partially_withdrawn_balance)?;
         if validator.is_fully_withdrawable_at(balance, epoch, spec, fork_name) {
             withdrawals.push(Withdrawal {
                 index: withdrawal_index,
@@ -604,7 +614,7 @@ pub fn get_expected_withdrawals<E: EthSpec>(
             .safe_rem(state.validators().len() as u64)?;
     }
 
-    Ok((withdrawals.into(), partial_withdrawals_count))
+    Ok((withdrawals.into(), processed_partial_withdrawals_count))
 }
 
 /// Apply withdrawals to the state.

consensus/state_processing/src/per_block_processing/process_operations.rs

@@ -507,11 +507,11 @@ pub fn process_withdrawal_requests<E: EthSpec>(
         }
 
         // Verify pubkey exists
-        let Some(index) = state.pubkey_cache().get(&request.validator_pubkey) else {
+        let Some(validator_index) = state.pubkey_cache().get(&request.validator_pubkey) else {
             continue;
         };
 
-        let validator = state.get_validator(index)?;
+        let validator = state.get_validator(validator_index)?;
         // Verify withdrawal credentials
         let has_correct_credential = validator.has_execution_withdrawal_credential(spec);
         let is_correct_source_address = validator
@@ -542,16 +542,16 @@ pub fn process_withdrawal_requests<E: EthSpec>(
             continue;
         }
 
-        let pending_balance_to_withdraw = state.get_pending_balance_to_withdraw(index)?;
+        let pending_balance_to_withdraw = state.get_pending_balance_to_withdraw(validator_index)?;
         if is_full_exit_request {
             // Only exit validator if it has no pending withdrawals in the queue
             if pending_balance_to_withdraw == 0 {
-                initiate_validator_exit(state, index, spec)?
+                initiate_validator_exit(state, validator_index, spec)?
             }
             continue;
         }
 
-        let balance = state.get_balance(index)?;
+        let balance = state.get_balance(validator_index)?;
         let has_sufficient_effective_balance =
             validator.effective_balance >= spec.min_activation_balance;
         let has_excess_balance = balance
@@ -576,7 +576,7 @@ pub fn process_withdrawal_requests<E: EthSpec>(
             state
                 .pending_partial_withdrawals_mut()?
                 .push(PendingPartialWithdrawal {
-                    index: index as u64,
+                    validator_index: validator_index as u64,
                     amount: to_withdraw,
                     withdrawable_epoch,
                 })?;
@@ -739,8 +739,8 @@ pub fn process_consolidation_request<E: EthSpec>(
     }
 
     let target_validator = state.get_validator(target_index)?;
-    // Verify the target has execution withdrawal credentials
-    if !target_validator.has_execution_withdrawal_credential(spec) {
+    // Verify the target has compounding withdrawal credentials
+    if !target_validator.has_compounding_withdrawal_credential(spec) {
         return Ok(());
     }
 
@@ -757,6 +757,18 @@ pub fn process_consolidation_request<E: EthSpec>(
     {
         return Ok(());
     }
+    // Verify the source has been active long enough
+    if current_epoch
+        < source_validator
+            .activation_epoch
+            .safe_add(spec.shard_committee_period)?
+    {
+        return Ok(());
+    }
+    // Verify the source has no pending withdrawals in the queue
+    if state.get_pending_balance_to_withdraw(source_index)? > 0 {
+        return Ok(());
+    }
 
     // Initiate source validator exit and append pending consolidation
     let source_exit_epoch = state
@@ -772,10 +784,5 @@ pub fn process_consolidation_request<E: EthSpec>(
             target_index: target_index as u64,
         })?;
 
-    let target_validator = state.get_validator(target_index)?;
-    // Churn any target excess active balance of target and raise its max
-    if target_validator.has_eth1_withdrawal_credential(spec) {
-        state.switch_to_compounding_validator(target_index, spec)?;
-    }
     Ok(())
 }

consensus/state_processing/src/per_epoch_processing/single_pass.rs

@@ -1057,14 +1057,12 @@ fn process_pending_consolidations<E: EthSpec>(
         }
 
         // Calculate the consolidated balance
-        let max_effective_balance =
-            source_validator.get_max_effective_balance(spec, state_ctxt.fork_name);
         let source_effective_balance = std::cmp::min(
             *state
                 .balances()
                 .get(source_index)
                 .ok_or(BeaconStateError::UnknownValidator(source_index))?,
-            max_effective_balance,
+            source_validator.effective_balance,
         );
 
         // Move active balance to target. Excess balance is withdrawable.

consensus/state_processing/src/upgrade/electra.rs

@@ -14,13 +14,15 @@ pub fn upgrade_to_electra<E: EthSpec>(
 ) -> Result<(), Error> {
     let epoch = pre_state.current_epoch();
 
+    let activation_exit_epoch = spec.compute_activation_exit_epoch(epoch)?;
     let earliest_exit_epoch = pre_state
         .validators()
         .iter()
         .filter(|v| v.exit_epoch != spec.far_future_epoch)
         .map(|v| v.exit_epoch)
         .max()
-        .unwrap_or(epoch)
+        .unwrap_or(activation_exit_epoch)
+        .max(activation_exit_epoch)
         .safe_add(1)?;
 
     // The total active balance cache must be built before the consolidation churn limit