gnosis/lighthouse
1
0
Fork 0
mirror of https://github.com/sigp/lighthouse.git synced 2026-03-15 02:42:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

Block processing electra (#5741)

Browse Source 
* Attestation superstruct changes for EIP 7549 (#5644)

* update

* experiment

* superstruct changes

* revert

* superstruct changes

* fix tests

* indexed attestation

* indexed attestation superstruct

* updated TODOs

* `superstruct` the `AttesterSlashing` (#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 (#5713)

* Finish EF Test Fork Agnostic (#5714)

* Superstruct `AggregateAndProof` (#5715)

* Upgrade `superstruct` to `0.8.0`

* superstruct `AggregateAndProof`

* Merge remote-tracking branch 'sigp/unstable' into electra_attestation_changes

* cargo fmt

* Merge pull request #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` (#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 (#5739)

* Merge branch 'electra_attestation_changes' of https://github.com/sigp/lighthouse into block-processing-electra

* cargo fmt (#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 (#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 (#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 (#5754)

* Fix Aggregation Pool for Electra

* Remove Outdated Interface

* fix ssz (#5755)

* Get `electra_op_pool` up to date (#5756)

* fix get attesting indices (#5742)

* fix get attesting indices

* better errors

* fix compile

* only get committee index once

* Ef test fixes (#5753)

* attestation related ef test fixes

* delete commented out stuff

* Fix Aggregation Pool for Electra (#5754)

* Fix Aggregation Pool for Electra

* Remove Outdated Interface

* fix ssz (#5755)

---------

Co-authored-by: realbigsean <sean@sigmaprime.io>

* Revert "Get `electra_op_pool` up to date (#5756)" (#5757)

This reverts commit ab9e58aa3d.

* 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 (#5752)

* add compute_on_chain_agg impl to op pool changes

* fmt

* get op pool tests to pass

* update the naive agg pool interface (#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 #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 (#5764)

* Fix Electra Fork Choice Tests (#5764)

* Merge branch 'electra_attestation_changes' of https://github.com/sigp/lighthouse into block-processing-electra

* Fix Consolidation Sigs & Withdrawals

* Merge pull request #5766 from ethDreamer/two_fixes

Fix Consolidation Sigs & Withdrawals

* Subscribe to the correct subnets for electra attestations (#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 (#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 #5832 from ethDreamer/electra_attestation_changes_merge_unstable

Merge `unstable` into `electra_attestation_changes`

* Merge pull request #5835 from realbigsean/fix-validator-logic

Fix validator logic

* Merge pull request #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 (#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 (#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 (#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 (#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 (#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 (#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 #5940 from dapplion/electra_attestation_changes_lionreview

Electra attestations #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 (#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 (#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 #5980 from dapplion/electra-lightclient

Add electra lightclient types

* Merge pull request #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
This commit is contained in:
realbigsean
2024-06-26 06:29:27 -07:00
committed by GitHub
parent c52c598f69
commit 858b01f4e3
22 changed files with 799 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
consensus/state_processing/src/common/initiate_validator_exit.rs
View File

@@ -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)?;
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)?;
}
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)?;

4
consensus/state_processing/src/common/slash_validator.rs
View File

@@ -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(_)

5
consensus/state_processing/src/genesis.rs
View File

@@ -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)?;

74
consensus/state_processing/src/per_block_processing.rs
View File

@@ -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(()),
}
}

22
consensus/state_processing/src/per_block_processing/block_signature_verifier.rs
View File

@@ -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.
///

46
consensus/state_processing/src/per_block_processing/errors.rs
View File

@@ -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)]

402
consensus/state_processing/src/per_block_processing/process_operations.rs
View File

@@ -4,8 +4,11 @@ use crate::common::{
slash_validator,
};
use crate::per_block_processing::errors::{BlockProcessingError, IntoWithIndex};
use crate::signature_sets::consolidation_signature_set;
use crate::VerifySignatures;
use types::consts::altair::{PARTICIPATION_FLAG_WEIGHTS, PROPOSER_WEIGHT, WEIGHT_DENOMINATOR};
use types::typenum::U33;
use types::validator::is_compounding_withdrawal_credential;
pub fn process_operations<E: EthSpec, Payload: AbstractExecPayload<E>>(
state: &mut BeaconState<E>,
@@ -36,6 +39,18 @@ pub fn process_operations<E: EthSpec, Payload: AbstractExecPayload<E>>(
process_bls_to_execution_changes(state, bls_to_execution_changes, verify_signatures, spec)?;
}
if state.fork_name_unchecked().electra_enabled() {
let requests = block_body.execution_payload()?.withdrawal_requests()?;
if let Some(requests) = requests {
process_execution_layer_withdrawal_requests(state, &requests, spec)?;
}
let receipts = block_body.execution_payload()?.deposit_receipts()?;
if let Some(receipts) = receipts {
process_deposit_receipts(state, &receipts, spec)?;
}
process_consolidations(state, block_body.consolidations()?, verify_signatures, spec)?;
}
Ok(())
}
@@ -354,17 +369,34 @@ pub fn process_deposits<E: EthSpec>(
deposits: &[Deposit],
spec: &ChainSpec,
) -> Result<(), BlockProcessingError> {
let expected_deposit_len = std::cmp::min(
E::MaxDeposits::to_u64(),
state.get_outstanding_deposit_len()?,
);
block_verify!(
deposits.len() as u64 == expected_deposit_len,
BlockProcessingError::DepositCountInvalid {
expected: expected_deposit_len as usize,
found: deposits.len(),
}
);
// [Modified in Electra:EIP6110]
// Disable former deposit mechanism once all prior deposits are processed
//
// If `deposit_receipts_start_index` does not exist as a field on `state`, electra is disabled
// which means we always want to use the old check, so this field defaults to `u64::MAX`.
let eth1_deposit_index_limit = state.deposit_receipts_start_index().unwrap_or(u64::MAX);
if state.eth1_deposit_index() < eth1_deposit_index_limit {
let expected_deposit_len = std::cmp::min(
E::MaxDeposits::to_u64(),
state.get_outstanding_deposit_len()?,
);
block_verify!(
deposits.len() as u64 == expected_deposit_len,
BlockProcessingError::DepositCountInvalid {
expected: expected_deposit_len as usize,
found: deposits.len(),
}
);
} else {
block_verify!(
deposits.len() as u64 == 0,
BlockProcessingError::DepositCountInvalid {
expected: 0,
found: deposits.len(),
}
);
}
// Verify merkle proofs in parallel.
deposits
@@ -382,60 +414,96 @@ pub fn process_deposits<E: EthSpec>(
// Update the state in series.
for deposit in deposits {
apply_deposit(state, deposit, spec, false)?;
apply_deposit(state, deposit.data.clone(), None, true, spec)?;
}
Ok(())
}
/// Process a single deposit, optionally verifying its merkle proof.
/// Process a single deposit, verifying its merkle proof if provided.
pub fn apply_deposit<E: EthSpec>(
state: &mut BeaconState<E>,
deposit: &Deposit,
deposit_data: DepositData,
proof: Option<FixedVector<Hash256, U33>>,
increment_eth1_deposit_index: bool,
spec: &ChainSpec,
verify_merkle_proof: bool,
) -> Result<(), BlockProcessingError> {
let deposit_index = state.eth1_deposit_index() as usize;
if verify_merkle_proof {
verify_deposit_merkle_proof(state, deposit, state.eth1_deposit_index(), spec)
if let Some(proof) = proof {
let deposit = Deposit {
proof,
data: deposit_data.clone(),
};
verify_deposit_merkle_proof(state, &deposit, state.eth1_deposit_index(), spec)
.map_err(|e| e.into_with_index(deposit_index))?;
}
state.eth1_deposit_index_mut().safe_add_assign(1)?;
if increment_eth1_deposit_index {
state.eth1_deposit_index_mut().safe_add_assign(1)?;
}
// Get an `Option<u64>` where `u64` is the validator index if this deposit public key
// already exists in the beacon_state.
let validator_index = get_existing_validator_index(state, &deposit.data.pubkey)
let validator_index = get_existing_validator_index(state, &deposit_data.pubkey)
.map_err(|e| e.into_with_index(deposit_index))?;
let amount = deposit.data.amount;
let amount = deposit_data.amount;
if let Some(index) = validator_index {
// Update the existing validator balance.
increase_balance(state, index as usize, amount)?;
// [Modified in Electra:EIP7251]
if let Ok(pending_balance_deposits) = state.pending_balance_deposits_mut() {
pending_balance_deposits.push(PendingBalanceDeposit { index, amount })?;
let validator = state
.validators()
.get(index as usize)
.ok_or(BeaconStateError::UnknownValidator(index as usize))?;
if is_compounding_withdrawal_credential(deposit_data.withdrawal_credentials, spec)
&& validator.has_eth1_withdrawal_credential(spec)
&& is_valid_deposit_signature(&deposit_data, spec).is_ok()
{
state.switch_to_compounding_validator(index as usize, spec)?;
}
} else {
// Update the existing validator balance.
increase_balance(state, index as usize, amount)?;
}
} else {
// The signature should be checked for new validators. Return early for a bad
// signature.
if verify_deposit_signature(&deposit.data, spec).is_err() {
if is_valid_deposit_signature(&deposit_data, spec).is_err() {
return Ok(());
}
let new_validator_index = state.validators().len();
// [Modified in Electra:EIP7251]
let (effective_balance, state_balance) = if state.fork_name_unchecked() >= ForkName::Electra
{
(0, 0)
} else {
(
std::cmp::min(
amount.safe_sub(amount.safe_rem(spec.effective_balance_increment)?)?,
spec.max_effective_balance,
),
amount,
)
};
// Create a new validator.
let validator = Validator {
pubkey: deposit.data.pubkey,
withdrawal_credentials: deposit.data.withdrawal_credentials,
pubkey: deposit_data.pubkey,
withdrawal_credentials: deposit_data.withdrawal_credentials,
activation_eligibility_epoch: spec.far_future_epoch,
activation_epoch: spec.far_future_epoch,
exit_epoch: spec.far_future_epoch,
withdrawable_epoch: spec.far_future_epoch,
effective_balance: std::cmp::min(
amount.safe_sub(amount.safe_rem(spec.effective_balance_increment)?)?,
spec.max_effective_balance,
),
effective_balance,
slashed: false,
};
state.validators_mut().push(validator)?;
state.balances_mut().push(deposit.data.amount)?;
state.balances_mut().push(state_balance)?;
// Altair or later initializations.
if let Ok(previous_epoch_participation) = state.previous_epoch_participation_mut() {
@@ -447,6 +515,280 @@ pub fn apply_deposit<E: EthSpec>(
if let Ok(inactivity_scores) = state.inactivity_scores_mut() {
inactivity_scores.push(0)?;
}
// [New in Electra:EIP7251]
if let Ok(pending_balance_deposits) = state.pending_balance_deposits_mut() {
pending_balance_deposits.push(PendingBalanceDeposit {
index: new_validator_index as u64,
amount,
})?;
}
}
Ok(())
}
pub fn process_execution_layer_withdrawal_requests<E: EthSpec>(
state: &mut BeaconState<E>,
requests: &[ExecutionLayerWithdrawalRequest],
spec: &ChainSpec,
) -> Result<(), BlockProcessingError> {
for request in requests {
let amount = request.amount;
let is_full_exit_request = amount == spec.full_exit_request_amount;
// If partial withdrawal queue is full, only full exits are processed
if state.pending_partial_withdrawals()?.len() == E::pending_partial_withdrawals_limit()
&& !is_full_exit_request
{
continue;
}
// Verify pubkey exists
let index_opt = state.get_validator_index(&request.validator_pubkey)?;
let Some(index) = index_opt else {
continue;
};
let validator = state.get_validator(index)?;
// Verify withdrawal credentials
let has_correct_credential = validator.has_execution_withdrawal_credential(spec);
let is_correct_source_address = validator
.get_execution_withdrawal_address(spec)
.map(|addr| addr == request.source_address)
.unwrap_or(false);
if !(has_correct_credential && is_correct_source_address) {
continue;
}
// Verify the validator is active
if !validator.is_active_at(state.current_epoch()) {
continue;
}
// Verify exit has not been initiated
if validator.exit_epoch != spec.far_future_epoch {
continue;
}
// Verify the validator has been active long enough
if state.current_epoch()
< validator
.activation_epoch
.safe_add(spec.shard_committee_period)?
{
continue;
}
let pending_balance_to_withdraw = state.get_pending_balance_to_withdraw(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)?
}
continue;
}
let balance = state.get_balance(index)?;
let has_sufficient_effective_balance =
validator.effective_balance >= spec.min_activation_balance;
let has_excess_balance = balance
> spec
.min_activation_balance
.safe_add(pending_balance_to_withdraw)?;
// Only allow partial withdrawals with compounding withdrawal credentials
if validator.has_compounding_withdrawal_credential(spec)
&& has_sufficient_effective_balance
&& has_excess_balance
{
let to_withdraw = std::cmp::min(
balance
.safe_sub(spec.min_activation_balance)?
.safe_sub(pending_balance_to_withdraw)?,
amount,
);
let exit_queue_epoch = state.compute_exit_epoch_and_update_churn(to_withdraw, spec)?;
let withdrawable_epoch =
exit_queue_epoch.safe_add(spec.min_validator_withdrawability_delay)?;
state
.pending_partial_withdrawals_mut()?
.push(PendingPartialWithdrawal {
index: index as u64,
amount: to_withdraw,
withdrawable_epoch,
})?;
}
}
Ok(())
}
pub fn process_deposit_receipts<E: EthSpec>(
state: &mut BeaconState<E>,
receipts: &[DepositReceipt],
spec: &ChainSpec,
) -> Result<(), BlockProcessingError> {
for receipt in receipts {
// Set deposit receipt start index
if state.deposit_receipts_start_index()? == spec.unset_deposit_receipts_start_index {
*state.deposit_receipts_start_index_mut()? = receipt.index
}
let deposit_data = DepositData {
pubkey: receipt.pubkey,
withdrawal_credentials: receipt.withdrawal_credentials,
amount: receipt.amount,
signature: receipt.signature.clone().into(),
};
apply_deposit(state, deposit_data, None, false, spec)?
}
Ok(())
}
pub fn process_consolidations<E: EthSpec>(
state: &mut BeaconState<E>,
consolidations: &[SignedConsolidation],
verify_signatures: VerifySignatures,
spec: &ChainSpec,
) -> Result<(), BlockProcessingError> {
if consolidations.is_empty() {
return Ok(());
}
// If the pending consolidations queue is full, no consolidations are allowed in the block
let pending_consolidations = state.pending_consolidations()?.len();
let pending_consolidations_limit = E::pending_consolidations_limit();
block_verify! {
pending_consolidations < pending_consolidations_limit,
BlockProcessingError::TooManyPendingConsolidations {
consolidations: pending_consolidations,
limit: pending_consolidations_limit
}
}
// If there is too little available consolidation churn limit, no consolidations are allowed in the block
let churn_limit = state.get_consolidation_churn_limit(spec)?;
block_verify! {
churn_limit > spec.min_activation_balance,
BlockProcessingError::ConsolidationChurnLimitTooLow {
churn_limit,
minimum: spec.min_activation_balance
}
}
for signed_consolidation in consolidations {
let consolidation = signed_consolidation.message.clone();
// Verify that source != target, so a consolidation cannot be used as an exit.
block_verify! {
consolidation.source_index != consolidation.target_index,
BlockProcessingError::MatchingSourceTargetConsolidation {
index: consolidation.source_index
}
}
let source_validator = state.get_validator(consolidation.source_index as usize)?;
let target_validator = state.get_validator(consolidation.target_index as usize)?;
// Verify the source and the target are active
let current_epoch = state.current_epoch();
block_verify! {
source_validator.is_active_at(current_epoch),
BlockProcessingError::InactiveConsolidationSource{
index: consolidation.source_index,
current_epoch
}
}
block_verify! {
target_validator.is_active_at(current_epoch),
BlockProcessingError::InactiveConsolidationTarget{
index: consolidation.target_index,
current_epoch
}
}
// Verify exits for source and target have not been initiated
block_verify! {
source_validator.exit_epoch == spec.far_future_epoch,
BlockProcessingError::SourceValidatorExiting{
index: consolidation.source_index,
}
}
block_verify! {
target_validator.exit_epoch == spec.far_future_epoch,
BlockProcessingError::TargetValidatorExiting{
index: consolidation.target_index,
}
}
// Consolidations must specify an epoch when they become valid; they are not valid before then
block_verify! {
current_epoch >= consolidation.epoch,
BlockProcessingError::FutureConsolidationEpoch {
current_epoch,
consolidation_epoch: consolidation.epoch
}
}
// Verify the source and the target have Execution layer withdrawal credentials
block_verify! {
source_validator.has_execution_withdrawal_credential(spec),
BlockProcessingError::NoSourceExecutionWithdrawalCredential {
index: consolidation.source_index,
}
}
block_verify! {
target_validator.has_execution_withdrawal_credential(spec),
BlockProcessingError::NoTargetExecutionWithdrawalCredential {
index: consolidation.target_index,
}
}
// Verify the same withdrawal address
let source_address = source_validator
.get_execution_withdrawal_address(spec)
.ok_or(BeaconStateError::NonExecutionAddresWithdrawalCredential)?;
let target_address = target_validator
.get_execution_withdrawal_address(spec)
.ok_or(BeaconStateError::NonExecutionAddresWithdrawalCredential)?;
block_verify! {
source_address == target_address,
BlockProcessingError::MismatchedWithdrawalCredentials {
source_address,
target_address
}
}
if verify_signatures.is_true() {
let signature_set = consolidation_signature_set(
state,
|i| get_pubkey_from_state(state, i),
signed_consolidation,
spec,
)?;
block_verify! {
signature_set.verify(),
BlockProcessingError::InavlidConsolidationSignature
}
}
let exit_epoch = state.compute_consolidation_epoch_and_update_churn(
source_validator.effective_balance,
spec,
)?;
let source_validator = state.get_validator_mut(consolidation.source_index as usize)?;
// Initiate source validator exit and append pending consolidation
source_validator.exit_epoch = exit_epoch;
source_validator.withdrawable_epoch = source_validator
.exit_epoch
.safe_add(spec.min_validator_withdrawability_delay)?;
state
.pending_consolidations_mut()?
.push(PendingConsolidation {
source_index: consolidation.source_index,
target_index: consolidation.target_index,
})?;
}
Ok(())

38
consensus/state_processing/src/per_block_processing/signature_sets.rs
View File

@@ -11,8 +11,8 @@ use types::{
BeaconStateError, ChainSpec, DepositData, Domain, Epoch, EthSpec, Fork, Hash256,
InconsistentFork, IndexedAttestation, IndexedAttestationRef, ProposerSlashing, PublicKey,
PublicKeyBytes, Signature, SignedAggregateAndProof, SignedBeaconBlock, SignedBeaconBlockHeader,
SignedBlsToExecutionChange, SignedContributionAndProof, SignedRoot, SignedVoluntaryExit,
SigningData, Slot, SyncAggregate, SyncAggregatorSelectionData, Unsigned,
SignedBlsToExecutionChange, SignedConsolidation, SignedContributionAndProof, SignedRoot,
SignedVoluntaryExit, SigningData, Slot, SyncAggregate, SyncAggregatorSelectionData, Unsigned,
};
pub type Result<T> = std::result::Result<T, Error>;
@@ -664,3 +664,37 @@ where
message,
)))
}
/// Returns two signature sets, one for the source and one for the target validator
/// in the `SignedConsolidation`.
pub fn consolidation_signature_set<'a, E, F>(
state: &'a BeaconState<E>,
get_pubkey: F,
consolidation: &'a SignedConsolidation,
spec: &'a ChainSpec,
) -> Result<SignatureSet<'a>>
where
E: EthSpec,
F: Fn(usize) -> Option<Cow<'a, PublicKey>>,
{
let source_index = consolidation.message.source_index as usize;
let target_index = consolidation.message.target_index as usize;
let domain = spec.compute_domain(
Domain::Consolidation,
spec.genesis_fork_version,
state.genesis_validators_root(),
);
let message = consolidation.message.signing_root(domain);
let source_pubkey =
get_pubkey(source_index).ok_or(Error::ValidatorUnknown(source_index as u64))?;
let target_pubkey =
get_pubkey(target_index).ok_or(Error::ValidatorUnknown(target_index as u64))?;
Ok(SignatureSet::multiple_pubkeys(
&consolidation.signature,
vec![source_pubkey, target_pubkey],
message,
))
}

18
consensus/state_processing/src/per_block_processing/verify_attestation.rs
View File

@@ -68,10 +68,20 @@ pub fn verify_attestation_for_state<'ctxt, E: EthSpec>(
) -> Result<IndexedAttestationRef<'ctxt, E>> {
let data = attestation.data();
verify!(
data.index < state.get_committee_count_at_slot(data.slot)?,
Invalid::BadCommitteeIndex
);
// TODO(electra) choosing a validation based on the attestation's fork
// rather than the state's fork makes this simple, but technically the spec
// defines this verification based on the state's fork.
match attestation {
AttestationRef::Base(_) => {
verify!(
data.index < state.get_committee_count_at_slot(data.slot)?,
Invalid::BadCommitteeIndex
);
}
AttestationRef::Electra(_) => {
verify!(data.index == 0, Invalid::BadCommitteeIndex);
}
}
// Verify the Casper FFG vote.
verify_casper_ffg_vote(attestation, state)?;

2
consensus/state_processing/src/per_block_processing/verify_deposit.rs
View File

@@ -14,7 +14,7 @@ fn error(reason: DepositInvalid) -> BlockOperationError<DepositInvalid> {
/// Verify `Deposit.pubkey` signed `Deposit.signature`.
///
/// Spec v0.12.1
pub fn verify_deposit_signature(deposit_data: &DepositData, spec: &ChainSpec) -> Result<()> {
pub fn is_valid_deposit_signature(deposit_data: &DepositData, spec: &ChainSpec) -> Result<()> {
let (public_key, signature, msg) = deposit_pubkey_signature_message(deposit_data, spec)
.ok_or_else(|| error(DepositInvalid::BadBlsBytes))?;

11
consensus/state_processing/src/per_block_processing/verify_exit.rs
View File

@@ -79,5 +79,16 @@ pub fn verify_exit<E: EthSpec>(
);
}
// [New in Electra:EIP7251]
// Only exit validator if it has no pending withdrawals in the queue
if let Ok(pending_balance_to_withdraw) =
state.get_pending_balance_to_withdraw(exit.validator_index as usize)
{
verify!(
pending_balance_to_withdraw == 0,
ExitInvalid::PendingWithdrawalInQueue(exit.validator_index)
);
}
Ok(())
}