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

@@ -1226,6 +1226,10 @@ async fn progressive_balances_cache_attester_slashing() {
         .apply_blocks_while(|_, state| state.finalized_checkpoint().epoch == 0)
         .await
         .unwrap()
+        // TODO(electra) The shuffling calculations changed between Altair and Electra. Without
+        // skipping slots this test breaks. For some reason `fork_name_unchecked` returns Altair
+        // initially, even though this test harness should be initialized with the most recent fork, i.e. Electra
+        .skip_slots(32)
         // 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
@@ -1257,6 +1261,10 @@ async fn progressive_balances_cache_proposer_slashing() {
         .apply_blocks_while(|_, state| state.finalized_checkpoint().epoch == 0)
         .await
         .unwrap()
+        // TODO(electra) The shuffling calculations changed between Altair and Electra. Without
+        // skipping slots this test breaks. For some reason `fork_name_unchecked` returns Altair
+        // initially, even though this test harness should be initialized with the most recent fork, i.e. Electra
+        .skip_slots(32)
         // 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

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

consensus/types/presets/gnosis/electra.yaml

@@ -10,7 +10,7 @@ MAX_EFFECTIVE_BALANCE_ELECTRA: 2048000000000
 # State list lengths
 # ---------------------------------------------------------------
 # `uint64(2**27)` (= 134,217,728)
-PENDING_BALANCE_DEPOSITS_LIMIT: 134217728
+PENDING_DEPOSITS_LIMIT: 134217728
 # `uint64(2**27)` (= 134,217,728)
 PENDING_PARTIAL_WITHDRAWALS_LIMIT: 134217728
 # `uint64(2**18)` (= 262,144)
@@ -29,12 +29,12 @@ WHISTLEBLOWER_REWARD_QUOTIENT_ELECTRA: 4096
 MAX_ATTESTER_SLASHINGS_ELECTRA: 1
 # `uint64(2**3)` (= 8)
 MAX_ATTESTATIONS_ELECTRA: 8
-# `uint64(2**0)` (= 1)
-MAX_CONSOLIDATION_REQUESTS_PER_PAYLOAD: 1
+# `uint64(2**1)` (= 2)
+MAX_CONSOLIDATION_REQUESTS_PER_PAYLOAD: 2
 
 # Execution
 # ---------------------------------------------------------------
-# 2**13 (= 8192) receipts
+# 2**13 (= 8192) deposit requests
 MAX_DEPOSIT_REQUESTS_PER_PAYLOAD: 8192
 # 2**4 (= 16) withdrawal requests
 MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD: 16
@@ -43,3 +43,8 @@ MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD: 16
 # ---------------------------------------------------------------
 # 2**3 ( = 8) pending withdrawals
 MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP: 8
+
+# Pending deposits processing
+# ---------------------------------------------------------------
+# 2**4 ( = 4) pending deposits
+MAX_PENDING_DEPOSITS_PER_EPOCH: 16

consensus/types/presets/mainnet/altair.yaml

@@ -22,3 +22,5 @@ EPOCHS_PER_SYNC_COMMITTEE_PERIOD: 256
 # ---------------------------------------------------------------
 # 1
 MIN_SYNC_COMMITTEE_PARTICIPANTS: 1
+# SLOTS_PER_EPOCH * EPOCHS_PER_SYNC_COMMITTEE_PERIOD (= 32 * 256)
+UPDATE_TIMEOUT: 8192

consensus/types/presets/mainnet/electra.yaml

@@ -10,7 +10,7 @@ MAX_EFFECTIVE_BALANCE_ELECTRA: 2048000000000
 # State list lengths
 # ---------------------------------------------------------------
 # `uint64(2**27)` (= 134,217,728)
-PENDING_BALANCE_DEPOSITS_LIMIT: 134217728
+PENDING_DEPOSITS_LIMIT: 134217728
 # `uint64(2**27)` (= 134,217,728)
 PENDING_PARTIAL_WITHDRAWALS_LIMIT: 134217728
 # `uint64(2**18)` (= 262,144)
@@ -29,12 +29,12 @@ WHISTLEBLOWER_REWARD_QUOTIENT_ELECTRA: 4096
 MAX_ATTESTER_SLASHINGS_ELECTRA: 1
 # `uint64(2**3)` (= 8)
 MAX_ATTESTATIONS_ELECTRA: 8
-# `uint64(2**0)` (= 1)
-MAX_CONSOLIDATION_REQUESTS_PER_PAYLOAD: 1
+# `uint64(2**1)` (= 2)
+MAX_CONSOLIDATION_REQUESTS_PER_PAYLOAD: 2
 
 # Execution
 # ---------------------------------------------------------------
-# 2**13 (= 8192) receipts
+# 2**13 (= 8192) deposit requests
 MAX_DEPOSIT_REQUESTS_PER_PAYLOAD: 8192
 # 2**4 (= 16) withdrawal requests
 MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD: 16
@@ -43,3 +43,8 @@ MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD: 16
 # ---------------------------------------------------------------
 # 2**3 ( = 8) pending withdrawals
 MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP: 8
+
+# Pending deposits processing
+# ---------------------------------------------------------------
+# 2**4 ( = 4) pending deposits
+MAX_PENDING_DEPOSITS_PER_EPOCH: 16

consensus/types/presets/mainnet/phase0.yaml

@@ -85,4 +85,4 @@ MAX_ATTESTATIONS: 128
 # 2**4 (= 16)
 MAX_DEPOSITS: 16
 # 2**4 (= 16)
-MAX_VOLUNTARY_EXITS: 16
+MAX_VOLUNTARY_EXITS: 16

consensus/types/presets/minimal/altair.yaml

@@ -22,3 +22,5 @@ EPOCHS_PER_SYNC_COMMITTEE_PERIOD: 8
 # ---------------------------------------------------------------
 # 1
 MIN_SYNC_COMMITTEE_PARTICIPANTS: 1
+# SLOTS_PER_EPOCH * EPOCHS_PER_SYNC_COMMITTEE_PERIOD (= 8 * 8)
+UPDATE_TIMEOUT: 64