diff --git a/specs/_features/eip7251/beacon-chain.md b/specs/_features/eip7251/beacon-chain.md index ca49de8ed..ef61e3d3a 100644 --- a/specs/_features/eip7251/beacon-chain.md +++ b/specs/_features/eip7251/beacon-chain.md @@ -8,6 +8,7 @@ - [Introduction](#introduction) - [Constants](#constants) + - [Misc](#misc) - [Withdrawal prefixes](#withdrawal-prefixes) - [Domains](#domains) - [Presets](#presets) @@ -29,6 +30,8 @@ - [Extended Containers](#extended-containers) - [`BeaconState`](#beaconstate) - [`BeaconBlockBody`](#beaconblockbody) + - [`ExecutionPayload`](#executionpayload) + - [`ExecutionPayloadHeader`](#executionpayloadheader) - [Helpers](#helpers) - [Predicates](#predicates) - [Updated `is_eligible_for_activation_queue`](#updated-is_eligible_for_activation_queue) @@ -43,9 +46,9 @@ - [New `get_activation_exit_churn_limit`](#new-get_activation_exit_churn_limit) - [New `get_consolidation_churn_limit`](#new-get_consolidation_churn_limit) - [New `get_active_balance`](#new-get_active_balance) + - [New `get_pending_balance_to_withdraw`](#new-get_pending_balance_to_withdraw) - [Beacon state mutators](#beacon-state-mutators) - [Updated `initiate_validator_exit`](#updated--initiate_validator_exit) - - [New `set_compounding_withdrawal_credentials`](#new-set_compounding_withdrawal_credentials) - [New `switch_to_compounding_validator`](#new-switch_to_compounding_validator) - [New `queue_excess_active_balance`](#new-queue_excess_active_balance) - [New `compute_exit_epoch_and_update_churn`](#new-compute_exit_epoch_and_update_churn) @@ -72,13 +75,16 @@ - [New `process_execution_layer_withdraw_request`](#new-process_execution_layer_withdraw_request) - [Consolidations](#consolidations) - [New `process_consolidation`](#new-process_consolidation) + - [Voluntary exits](#voluntary-exits) + - [Updated `process_voluntary_exit`](#updated-process_voluntary_exit) +- [Testing](#testing) ## Introduction -See [a modest proposal](https://notes.ethereum.org/@mikeneuder/increase-maxeb), the [diff view](https://github.com/michaelneuder/consensus-specs/pull/3/files) and +See [a modest proposal](https://notes.ethereum.org/@mikeneuder/increase-maxeb), the [diff view](https://github.com/michaelneuder/consensus-specs/pull/3/files) and [security considerations](https://notes.ethereum.org/@fradamt/meb-increase-security). *Note:* This specification is built upon [Deneb](../../deneb/beacon-chain.md). @@ -87,6 +93,12 @@ See [a modest proposal](https://notes.ethereum.org/@mikeneuder/increase-maxeb), The following values are (non-configurable) constants used throughout the specification. +### Misc + +| Name | Value | +| - | - | +| `FULL_EXIT_REQUEST_AMOUNT` | `uint64(0)` | + ### Withdrawal prefixes | Name | Value | @@ -127,6 +139,7 @@ The following values are (non-configurable) constants used throughout the specif | Name | Value | Description | | - | - | - | +| `MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD` | `uint64(16)` | | `MAX_PARTIAL_WITHDRAWALS_PER_PAYLOAD` | `uint64(2**3)` (= 8) | Maximum amount of partial withdrawals allowed in each payload | ### State list lengths @@ -273,12 +286,64 @@ class BeaconBlockBody(Container): voluntary_exits: List[SignedVoluntaryExit, MAX_VOLUNTARY_EXITS] sync_aggregate: SyncAggregate # Execution - execution_payload: ExecutionPayload + execution_payload: ExecutionPayload bls_to_execution_changes: List[SignedBLSToExecutionChange, MAX_BLS_TO_EXECUTION_CHANGES] blob_kzg_commitments: List[KZGCommitment, MAX_BLOB_COMMITMENTS_PER_BLOCK] consolidations: List[SignedConsolidation, MAX_CONSOLIDATIONS] # [New in EIP-7251] ``` +#### `ExecutionPayload` + +```python +class ExecutionPayload(Container): + # Execution block header fields + parent_hash: Hash32 + fee_recipient: ExecutionAddress # 'beneficiary' in the yellow paper + state_root: Bytes32 + receipts_root: Bytes32 + logs_bloom: ByteVector[BYTES_PER_LOGS_BLOOM] + prev_randao: Bytes32 # 'difficulty' in the yellow paper + block_number: uint64 # 'number' in the yellow paper + gas_limit: uint64 + gas_used: uint64 + timestamp: uint64 + extra_data: ByteList[MAX_EXTRA_DATA_BYTES] + base_fee_per_gas: uint256 + # Extra payload fields + block_hash: Hash32 # Hash of execution block + transactions: List[Transaction, MAX_TRANSACTIONS_PER_PAYLOAD] + withdrawals: List[Withdrawal, MAX_WITHDRAWALS_PER_PAYLOAD] + blob_gas_used: uint64 + excess_blob_gas: uint64 + withdraw_requests: List[ExecutionLayerWithdrawRequest, MAX_WITHDRAWAL_REQUESTS_PER_PAYLOAD] # [New in EIP-7251] +``` + +#### `ExecutionPayloadHeader` + +```python +class ExecutionPayloadHeader(Container): + # Execution block header fields + parent_hash: Hash32 + fee_recipient: ExecutionAddress + state_root: Bytes32 + receipts_root: Bytes32 + logs_bloom: ByteVector[BYTES_PER_LOGS_BLOOM] + prev_randao: Bytes32 + block_number: uint64 + gas_limit: uint64 + gas_used: uint64 + timestamp: uint64 + extra_data: ByteList[MAX_EXTRA_DATA_BYTES] + base_fee_per_gas: uint256 + # Extra payload fields + block_hash: Hash32 # Hash of execution block + transactions_root: Root + withdrawals_root: Root + blob_gas_used: uint64 + excess_blob_gas: uint64 + withdraw_requests_root: Root # [New in EIP-7251] +``` + ## Helpers ### Predicates @@ -377,7 +442,7 @@ def get_churn_limit(state: BeaconState) -> Gwei: Return the churn limit for the current epoch. """ churn = max( - MIN_PER_EPOCH_CHURN_LIMIT_EIP7251, + MIN_PER_EPOCH_CHURN_LIMIT_EIP7251, get_total_active_balance(state) // CHURN_LIMIT_QUOTIENT ) return churn - churn % EFFECTIVE_BALANCE_INCREMENT @@ -408,6 +473,14 @@ def get_active_balance(state: BeaconState, validator_index: ValidatorIndex) -> G return min(state.balances[validator_index], max_effective_balance) ``` +#### New `get_pending_balance_to_withdraw` + +```python +def get_pending_balance_to_withdraw(state: BeaconState, validator_index: ValidatorIndex) -> Gwei: + return sum( + withdrawal.amount for withdrawal in state.pending_partial_withdrawals if withdrawal.index == validator_index) +``` + ### Beacon state mutators #### Updated `initiate_validator_exit` @@ -430,15 +503,6 @@ def initiate_validator_exit(state: BeaconState, index: ValidatorIndex) -> None: validator.withdrawable_epoch = Epoch(validator.exit_epoch + MIN_VALIDATOR_WITHDRAWABILITY_DELAY) ``` -#### New `set_compounding_withdrawal_credentials` - -```python -def set_compounding_withdrawal_credentials(state: BeaconState, index: ValidatorIndex) -> None: - validator = state.validators[index] - if has_eth1_withdrawal_credential(validator): - validator.withdrawal_credentials[:1] = COMPOUNDING_WITHDRAWAL_PREFIX -``` - #### New `switch_to_compounding_validator` ```python @@ -464,7 +528,6 @@ def queue_excess_active_balance(state: BeaconState, index: ValidatorIndex) -> No #### New `compute_exit_epoch_and_update_churn` - ```python def compute_exit_epoch_and_update_churn(state: BeaconState, exit_balance: Gwei) -> Epoch: earliest_exit_epoch = compute_activation_exit_epoch(get_current_epoch(state)) @@ -558,16 +621,23 @@ def process_epoch(state: BeaconState) -> None: process_effective_balance_updates(state) # [Modified in EIP7251] process_slashings_reset(state) process_randao_mixes_reset(state) + process_historical_summaries_update(state) + process_participation_flag_updates(state) + process_sync_committee_updates(state) ``` #### Updated `process_registry_updates` +`process_registry_updates` uses the updated definition of `initiate_validator_exit` +and changes how the activation epochs are computed for eligible validators. + ```python def process_registry_updates(state: BeaconState) -> None: # Process activation eligibility and ejections for index, validator in enumerate(state.validators): if is_eligible_for_activation_queue(validator): validator.activation_eligibility_epoch = get_current_epoch(state) + 1 + if ( is_active_validator(validator, get_current_epoch(state)) and validator.effective_balance <= EJECTION_BALANCE @@ -599,7 +669,7 @@ def process_pending_balance_deposits(state: BeaconState) -> None: state.pending_balance_deposits = state.pending_balance_deposits[next_deposit_index:] if len(state.pending_balance_deposits) == 0: - state.deposit_balance_to_consume = 0 + state.deposit_balance_to_consume = Gwei(0) else: state.deposit_balance_to_consume = available_for_processing - processed_amount ``` @@ -630,6 +700,8 @@ def process_pending_consolidations(state: BeaconState) -> None: #### Updated `process_effective_balance_updates` +`process_effective_balance_updates` is updated with a new limit for the maximum effective balance. + ```python def process_effective_balance_updates(state: BeaconState) -> None: # Update effective balances with hysteresis @@ -678,7 +750,9 @@ def get_expected_withdrawals(state: BeaconState) -> Tuple[Sequence[Withdrawal], break validator = state.validators[withdrawal.index] - if validator.exit_epoch == FAR_FUTURE_EPOCH and state.balances[withdrawal.index] > MIN_ACTIVATION_BALANCE: + has_sufficient_effective_balance = validator.effective_balance >= MIN_ACTIVATION_BALANCE + has_excess_balance = state.balances[withdrawal.index] > MIN_ACTIVATION_BALANCE + if validator.exit_epoch == FAR_FUTURE_EPOCH and has_sufficient_effective_balance and has_excess_balance: withdrawable_balance = min(state.balances[withdrawal.index] - MIN_ACTIVATION_BALANCE, withdrawal.amount) withdrawals.append(Withdrawal( index=withdrawal_index, @@ -750,7 +824,7 @@ def process_withdrawals(state: BeaconState, payload: ExecutionPayload) -> None: state.next_withdrawal_validator_index = next_validator_index ``` -#### Operations +#### Operations ##### Updated `process_operations` @@ -767,16 +841,18 @@ def process_operations(state: BeaconState, body: BeaconBlockBody) -> None: for_ops(body.attester_slashings, process_attester_slashing) for_ops(body.attestations, process_attestation) for_ops(body.deposits, process_deposit) # [Modified in EIP7251] - for_ops(body.voluntary_exits, process_voluntary_exit) + for_ops(body.voluntary_exits, process_voluntary_exit) # [Modified in EIP7251] for_ops(body.bls_to_execution_changes, process_bls_to_execution_change) - for_ops(body.execution_payload.withdraw_requests, process_execution_layer_withdraw_request) # New in EIP7251 - for_ops(body.consolidations, process_consolidation) # New in EIP7251 + for_ops(body.execution_payload.withdraw_requests, process_execution_layer_withdraw_request) # [New in EIP7251] + for_ops(body.consolidations, process_consolidation) # [New in EIP7251] ``` ##### Deposits ###### Updated `apply_deposit` +*NOTE*: `process_deposit` is updated with a new definition of `apply_deposit`. + ```python def apply_deposit(state: BeaconState, pubkey: BLSPubkey, @@ -809,7 +885,7 @@ def apply_deposit(state: BeaconState, def is_valid_deposit_signature(pubkey: BLSPubkey, withdrawal_credentials: Bytes32, amount: uint64, - signature: BLSSignature) -> None: + signature: BLSSignature) -> bool: deposit_message = DepositMessage( pubkey=pubkey, withdrawal_credentials=withdrawal_credentials, @@ -852,7 +928,7 @@ def get_validator_from_deposit(pubkey: BLSPubkey, withdrawal_credentials: Bytes3 ) ``` -##### Withdrawals +##### Withdrawals ###### New `process_execution_layer_withdraw_request` @@ -862,8 +938,9 @@ def process_execution_layer_withdraw_request( execution_layer_withdraw_request: ExecutionLayerWithdrawRequest ) -> None: amount = execution_layer_withdraw_request.amount - is_full_exit_request = amount == 0 - # If partial withdrawal queue is full, only full exits are processed + is_full_exit_request = amount == FULL_EXIT_REQUEST_AMOUNT + + # If partial withdrawal queue is full, only full exits are processed if len(state.pending_partial_withdrawals) >= PENDING_PARTIAL_WITHDRAWALS_LIMIT and not is_full_exit_request: return @@ -884,20 +961,21 @@ def process_execution_layer_withdraw_request( and get_current_epoch(state) >= validator.activation_epoch + SHARD_COMMITTEE_PERIOD ): return - # New condition: only allow partial withdrawals with compounding withdrawal credentials - if not (is_full_exit_request or has_compounding_withdrawal_credential(validator)): - return - pending_balance_to_withdraw = sum( - item.amount for item in state.pending_partial_withdrawals if item.index == index - ) - # only exit validator if it has no pending withdrawals in the queue - if is_full_exit_request and pending_balance_to_withdraw > 0: - return + pending_balance_to_withdraw = get_pending_balance_to_withdraw(state, index) if is_full_exit_request: - initiate_validator_exit(state, index) - elif state.balances[index] > MIN_ACTIVATION_BALANCE + pending_balance_to_withdraw: + # Only exit validator if it has no pending withdrawals in the queue + if pending_balance_to_withdraw == 0: + initiate_validator_exit(state, index) + + return + + has_sufficient_effective_balance = validator.effective_balance >= MIN_ACTIVATION_BALANCE + has_excess_balance = state.balances[index] > MIN_ACTIVATION_BALANCE + pending_balance_to_withdraw + + # Only allow partial withdrawals with compounding withdrawal credentials + if has_compounding_withdrawal_credential(validator) and has_sufficient_effective_balance and has_excess_balance: to_withdraw = min( state.balances[index] - MIN_ACTIVATION_BALANCE - pending_balance_to_withdraw, amount @@ -935,13 +1013,13 @@ def process_consolidation(state: BeaconState, signed_consolidation: SignedConsol assert source_validator.exit_epoch == FAR_FUTURE_EPOCH assert target_validator.exit_epoch == FAR_FUTURE_EPOCH # Consolidations must specify an epoch when they become valid; they are not valid before then - assert current_epoch >= consolidation.epoch + assert current_epoch >= consolidation.epoch # Verify the source and the target have Execution layer withdrawal credentials assert has_execution_withdrawal_credential(source_validator) assert has_execution_withdrawal_credential(target_validator) # Verify the same withdrawal address - assert source_validator.withdrawal_credentials[1:] == target_validator.withdrawal_credentials[1:] + assert source_validator.withdrawal_credentials[12:] == target_validator.withdrawal_credentials[12:] # Verify consolidation is signed by the source and the target domain = compute_domain(DOMAIN_CONSOLIDATION, genesis_validators_root=state.genesis_validators_root) @@ -950,8 +1028,8 @@ def process_consolidation(state: BeaconState, signed_consolidation: SignedConsol assert bls.FastAggregateVerify(pubkeys, signing_root, signed_consolidation.signature) # Initiate source validator exit and append pending consolidation - active_balance = get_active_balance(state, consolidation.source_index) - source_validator.exit_epoch = compute_consolidation_epoch_and_update_churn(state, active_balance) + source_validator.exit_epoch = compute_consolidation_epoch_and_update_churn( + state, source_validator.effective_balance) source_validator.withdrawable_epoch = Epoch( source_validator.exit_epoch + MIN_VALIDATOR_WITHDRAWABILITY_DELAY ) @@ -961,3 +1039,86 @@ def process_consolidation(state: BeaconState, signed_consolidation: SignedConsol )) ``` +##### Voluntary exits + +###### Updated `process_voluntary_exit` + +```python +def process_voluntary_exit(state: BeaconState, signed_voluntary_exit: SignedVoluntaryExit) -> None: + voluntary_exit = signed_voluntary_exit.message + validator = state.validators[voluntary_exit.validator_index] + # Verify the validator is active + assert is_active_validator(validator, get_current_epoch(state)) + # Verify exit has not been initiated + assert validator.exit_epoch == FAR_FUTURE_EPOCH + # Exits must specify an epoch when they become valid; they are not valid before then + assert get_current_epoch(state) >= voluntary_exit.epoch + # Verify the validator has been active long enough + assert get_current_epoch(state) >= validator.activation_epoch + SHARD_COMMITTEE_PERIOD + # Only exit validator if it has no pending withdrawals in the queue + assert get_pending_balance_to_withdraw(state, voluntary_exit.validator_index) == 0 # [New in EIP7251] + # Verify signature + domain = compute_domain(DOMAIN_VOLUNTARY_EXIT, CAPELLA_FORK_VERSION, state.genesis_validators_root) + signing_root = compute_signing_root(voluntary_exit, domain) + assert bls.Verify(validator.pubkey, signing_root, signed_voluntary_exit.signature) + # Initiate exit + initiate_validator_exit(state, voluntary_exit.validator_index) +``` + +## Testing + +*Note*: The function `initialize_beacon_state_from_eth1` is modified for pure EIP-7251 testing only. + +```python +def initialize_beacon_state_from_eth1(eth1_block_hash: Hash32, + eth1_timestamp: uint64, + deposits: Sequence[Deposit], + execution_payload_header: ExecutionPayloadHeader=ExecutionPayloadHeader() + ) -> BeaconState: + fork = Fork( + previous_version=EIP7251_FORK_VERSION, # [Modified in EIP-7251] for testing only + current_version=EIP7251_FORK_VERSION, # [Modified in EIP-7251] + epoch=GENESIS_EPOCH, + ) + state = BeaconState( + genesis_time=eth1_timestamp + GENESIS_DELAY, + fork=fork, + eth1_data=Eth1Data(block_hash=eth1_block_hash, deposit_count=uint64(len(deposits))), + latest_block_header=BeaconBlockHeader(body_root=hash_tree_root(BeaconBlockBody())), + randao_mixes=[eth1_block_hash] * EPOCHS_PER_HISTORICAL_VECTOR, # Seed RANDAO with Eth1 entropy + ) + + # Process deposits + leaves = list(map(lambda deposit: deposit.data, deposits)) + for index, deposit in enumerate(deposits): + deposit_data_list = List[DepositData, 2**DEPOSIT_CONTRACT_TREE_DEPTH](*leaves[:index + 1]) + state.eth1_data.deposit_root = hash_tree_root(deposit_data_list) + process_deposit(state, deposit) + + # Process deposit balance updates + for deposit in state.pending_balance_deposits: + increase_balance(state, deposit.index, deposit.amount) + state.pending_balance_deposits = [] + + # Process activations + for index, validator in enumerate(state.validators): + balance = state.balances[index] + validator.effective_balance = min(balance - balance % EFFECTIVE_BALANCE_INCREMENT, MAX_EFFECTIVE_BALANCE) + if validator.effective_balance == MAX_EFFECTIVE_BALANCE: + validator.activation_eligibility_epoch = GENESIS_EPOCH + validator.activation_epoch = GENESIS_EPOCH + + # Set genesis validators root for domain separation and chain versioning + state.genesis_validators_root = hash_tree_root(state.validators) + + # Fill in sync committees + # Note: A duplicate committee is assigned for the current and next committee at genesis + state.current_sync_committee = get_next_sync_committee(state) + state.next_sync_committee = get_next_sync_committee(state) + + # Initialize the execution payload header + # If empty, will initialize a chain that has not yet gone through the Merge transition + state.latest_execution_payload_header = execution_payload_header + + return state +``` diff --git a/specs/_features/eip7251/fork.md b/specs/_features/eip7251/fork.md index 609b4f3f8..49e01ea7e 100644 --- a/specs/_features/eip7251/fork.md +++ b/specs/_features/eip7251/fork.md @@ -129,11 +129,9 @@ def upgrade_to_eip7251(pre: deneb.BeaconState) -> BeaconState: ) # Ensure early adopters of compounding credentials go through the activation churn - queue_excess_active_balance(post) for index, validator in enumerate(post.validators): if has_compounding_withdrawal_credential(validator): - queue_excess_active_balance(post, index) + queue_excess_active_balance(post, ValidatorIndex(index)) return post ``` - diff --git a/specs/_features/eip7251/validator.md b/specs/_features/eip7251/validator.md new file mode 100644 index 000000000..455699383 --- /dev/null +++ b/specs/_features/eip7251/validator.md @@ -0,0 +1,73 @@ +# EIP-7251 -- Honest Validator + +## Table of contents + + + + + +- [Introduction](#introduction) +- [Prerequisites](#prerequisites) +- [Beacon chain responsibilities](#beacon-chain-responsibilities) + - [Block and sidecar proposal](#block-and-sidecar-proposal) + - [Constructing the `BeaconBlockBody`](#constructing-the-beaconblockbody) + - [ExecutionPayload](#executionpayload) + + + + +## Introduction + +This document represents the changes to be made in the code of an "honest validator". + +## Prerequisites + +This document is an extension of the [Deneb -- Honest Validator](../deneb/validator.md) guide. +All behaviors and definitions defined in this document, and documents it extends, carry over unless explicitly noted or overridden. + +All terminology, constants, functions, and protocol mechanics defined in the updated [Beacon Chain doc of EIP-7251](./beacon-chain.md) are requisite for this document and used throughout. +Please see related Beacon Chain doc before continuing and use them as a reference throughout. + +## Beacon chain responsibilities + +All validator responsibilities remain unchanged other than those noted below. + +### Block and sidecar proposal + +#### Constructing the `BeaconBlockBody` + +##### ExecutionPayload + +`prepare_execution_payload` is updated from the Deneb specs. + +*Note*: In this section, `state` is the state of the slot for the block proposal _without_ the block yet applied. +That is, `state` is the `previous_state` processed through any empty slots up to the assigned slot using `process_slots(previous_state, slot)`. + +*Note*: The only change to `prepare_execution_payload` is the new definition of `get_expected_withdrawals`. + +```python +def prepare_execution_payload(state: BeaconState, + safe_block_hash: Hash32, + finalized_block_hash: Hash32, + suggested_fee_recipient: ExecutionAddress, + execution_engine: ExecutionEngine) -> Optional[PayloadId]: + # Verify consistency of the parent hash with respect to the previous execution payload header + parent_hash = state.latest_execution_payload_header.block_hash + + # Set the forkchoice head and initiate the payload build process + withdrawals, _ = get_expected_withdrawals(state) # [Modified in EIP-7251] + + payload_attributes = PayloadAttributes( + timestamp=compute_timestamp_at_slot(state, state.slot), + prev_randao=get_randao_mix(state, get_current_epoch(state)), + suggested_fee_recipient=suggested_fee_recipient, + withdrawals=withdrawals, + parent_beacon_block_root=hash_tree_root(state.latest_block_header), + ) + return execution_engine.notify_forkchoice_updated( + head_block_hash=parent_hash, + safe_block_hash=safe_block_hash, + finalized_block_hash=finalized_block_hash, + payload_attributes=payload_attributes, + ) +``` diff --git a/specs/electra/beacon-chain.md b/specs/electra/beacon-chain.md index 9c9066c3e..cbfce0c93 100644 --- a/specs/electra/beacon-chain.md +++ b/specs/electra/beacon-chain.md @@ -260,7 +260,11 @@ def process_deposit_receipt(state: BeaconState, deposit_receipt: DepositReceipt) ```python def process_execution_layer_exit(state: BeaconState, execution_layer_exit: ExecutionLayerExit) -> None: validator_pubkeys = [v.pubkey for v in state.validators] - validator_index = ValidatorIndex(validator_pubkeys.index(execution_layer_exit.validator_pubkey)) + # Verify pubkey exists + pubkey_to_exit = execution_layer_exit.validator_pubkey + if pubkey_to_exit not in validator_pubkeys: + return + validator_index = ValidatorIndex(validator_pubkeys.index(pubkey_to_exit)) validator = state.validators[validator_index] # Verify withdrawal credentials diff --git a/tests/core/pyspec/eth2spec/test/bellatrix/fork_choice/test_should_override_forkchoice_update.py b/tests/core/pyspec/eth2spec/test/bellatrix/fork_choice/test_should_override_forkchoice_update.py index b40cc5bbe..6c8e33e95 100644 --- a/tests/core/pyspec/eth2spec/test/bellatrix/fork_choice/test_should_override_forkchoice_update.py +++ b/tests/core/pyspec/eth2spec/test/bellatrix/fork_choice/test_should_override_forkchoice_update.py @@ -7,7 +7,7 @@ from eth2spec.test.helpers.constants import ( MINIMAL, ) from eth2spec.test.helpers.attestations import ( - get_valid_attestation_at_slot, + get_valid_attestations_at_slot, ) from eth2spec.test.helpers.block import ( build_empty_block_for_next_slot, @@ -109,7 +109,7 @@ def test_should_override_forkchoice_update__true(spec, state): # Fill a slot with attestations to its parent block = build_empty_block_for_next_slot(spec, state) parent_block_slot = block.slot - 1 - block.body.attestations = get_valid_attestation_at_slot( + block.body.attestations = get_valid_attestations_at_slot( state, spec, parent_block_slot, @@ -135,7 +135,7 @@ def test_should_override_forkchoice_update__true(spec, state): # Add attestations to the parent block temp_state = state.copy() next_slot(spec, temp_state) - attestations = get_valid_attestation_at_slot( + attestations = get_valid_attestations_at_slot( temp_state, spec, slot_to_attest=temp_state.slot - 1, diff --git a/tests/core/pyspec/eth2spec/test/helpers/attestations.py b/tests/core/pyspec/eth2spec/test/helpers/attestations.py index 528de7f67..916a7ca00 100644 --- a/tests/core/pyspec/eth2spec/test/helpers/attestations.py +++ b/tests/core/pyspec/eth2spec/test/helpers/attestations.py @@ -84,7 +84,6 @@ def build_attestation_data(spec, state, slot, index, beacon_block_root=None, sha target=spec.Checkpoint(epoch=spec.compute_epoch_at_slot(slot), root=epoch_boundary_root), ) - # if spec.fork == SHARDING # TODO: add extra data for shard voting return data @@ -95,8 +94,12 @@ def get_valid_attestation(spec, filter_participant_set=None, beacon_block_root=None, signed=False): - # If filter_participant_set filters everything, the attestation has 0 participants, and cannot be signed. - # Thus strictly speaking invalid when no participant is added later. + """ + Return a valid attestation at `slot` and committee index `index`. + + If filter_participant_set filters everything, the attestation has 0 participants, and cannot be signed. + Thus strictly speaking invalid when no participant is added later. + """ if slot is None: slot = state.slot if index is None: @@ -104,18 +107,8 @@ def get_valid_attestation(spec, attestation_data = build_attestation_data(spec, state, slot=slot, index=index, beacon_block_root=beacon_block_root) - beacon_committee = spec.get_beacon_committee(state, slot, index) + attestation = spec.Attestation(data=attestation_data) - if is_post_eip7549(spec): - # will fill aggregation_bits later - attestation = spec.Attestation(data=attestation_data) - else: - committee_size = len(beacon_committee) - aggregation_bits = Bitlist[spec.MAX_VALIDATORS_PER_COMMITTEE](*([0] * committee_size)) - attestation = spec.Attestation( - aggregation_bits=aggregation_bits, - data=attestation_data, - ) # fill the attestation with (optionally filtered) participants, and optionally sign it fill_aggregate_attestation(spec, state, attestation, signed=signed, filter_participant_set=filter_participant_set, committee_index=index) @@ -132,7 +125,7 @@ def sign_aggregate_attestation(spec, state, attestation_data, participants: List spec, state, attestation_data, - privkey + privkey, ) ) return bls.Aggregate(signatures) @@ -180,11 +173,16 @@ def fill_aggregate_attestation(spec, state, attestation, committee_index, signed if filter_participant_set is not None: participants = filter_participant_set(participants) + # initialize `aggregation_bits` if is_post_eip7549(spec): - attestation.committee_bits = spec.Bitvector[spec.MAX_COMMITTEES_PER_SLOT]() attestation.committee_bits[committee_index] = True attestation.aggregation_bits = get_empty_eip7549_aggregation_bits( spec, state, attestation.committee_bits, attestation.data.slot) + else: + committee_size = len(beacon_committee) + attestation.aggregation_bits = Bitlist[spec.MAX_VALIDATORS_PER_COMMITTEE](*([0] * committee_size)) + + # fill in the `aggregation_bits` for i in range(len(beacon_committee)): if is_post_eip7549(spec): offset = get_eip7549_aggregation_bits_offset( @@ -205,7 +203,10 @@ def add_attestations_to_state(spec, state, attestations, slot): spec.process_attestation(state, attestation) -def get_valid_attestation_at_slot(state, spec, slot_to_attest, participation_fn=None, beacon_block_root=None): +def get_valid_attestations_at_slot(state, spec, slot_to_attest, participation_fn=None, beacon_block_root=None): + """ + Return attestations at slot `slot_to_attest`. + """ committees_per_slot = spec.get_committee_count_per_slot(state, spec.compute_epoch_at_slot(slot_to_attest)) for index in range(committees_per_slot): def participants_filter(comm): @@ -213,7 +214,6 @@ def get_valid_attestation_at_slot(state, spec, slot_to_attest, participation_fn= return comm else: return participation_fn(state.slot, index, comm) - # if spec.fork == SHARDING: TODO: add shard data to attestation, include shard headers in block yield get_valid_attestation( spec, state, @@ -225,6 +225,78 @@ def get_valid_attestation_at_slot(state, spec, slot_to_attest, participation_fn= ) +def _get_aggregate_committee_indices(spec, attestations): + """ + Aggregate all unique committee indices from the given attestations. + """ + all_committee_indices = set() + for attestation in attestations: + committee_indices = spec.get_committee_indices(attestation.committee_bits) + assert len(committee_indices) == 1 + all_committee_indices.add(committee_indices[0]) + + return all_committee_indices + + +def _aggregate_aggregation_bits_and_signatures(spec, state, slot, aggregate, attestations): + """ + Aggregate the aggregation bits and signatures from the attestations, + incorporating the calculation of aggregation bits offset directly. + """ + # initialize aggregation bits for the aggregate attestation + aggregate.aggregation_bits = get_empty_eip7549_aggregation_bits( + spec, state, aggregate.committee_bits, slot) + + signatures = [] + + offset = 0 + attestations = sorted(attestations, key=lambda att: spec.get_committee_indices(att.committee_bits)[0]) + for attestation in attestations: + # retrieve the single committee index for the attestation. + committee_index = spec.get_committee_indices(attestation.committee_bits)[0] + + # update the aggregate's aggregation bits based on each attestation. + for i, bit in enumerate(attestation.aggregation_bits): + aggregate.aggregation_bits[offset + i] = bit + + # collect signatures for aggregation. + signatures.append(attestation.signature) + + # update offset + committee = spec.get_beacon_committee(state, slot, committee_index) + offset += len(committee) + + # aggregate signatures from all attestations. + aggregate.signature = bls.Aggregate(signatures) + + +def get_valid_attestation_at_slot(state, spec, slot_to_attest, participation_fn=None, beacon_block_root=None): + """ + Return the aggregate attestation post EIP-7549. + Note: this EIP supports dense packing of on-chain aggregates so we can just return a single `Attestation`. + """ + assert is_post_eip7549(spec) + attestations = list(get_valid_attestations_at_slot( + state, spec, slot_to_attest, + participation_fn=participation_fn, + beacon_block_root=beacon_block_root, + )) + if not attestations: + return None + + # initialize the aggregate attestation. + aggregate = spec.Attestation(data=attestations[0].data) + + # fill in committee_bits + all_committee_indices = _get_aggregate_committee_indices(spec, attestations) + for committee_index in all_committee_indices: + aggregate.committee_bits[committee_index] = True + + _aggregate_aggregation_bits_and_signatures(spec, state, slot_to_attest, aggregate, attestations) + + return aggregate + + def next_slots_with_attestations(spec, state, slot_count, @@ -249,6 +321,26 @@ def next_slots_with_attestations(spec, return state, signed_blocks, post_state +def _add_valid_attestations(spec, state, block, slot_to_attest, participation_fn=None): + if is_post_eip7549(spec): + attestation = get_valid_attestation_at_slot( + state, + spec, + slot_to_attest, + participation_fn=participation_fn, + ) + block.body.attestations.append(attestation) + else: + attestations = get_valid_attestations_at_slot( + state, + spec, + slot_to_attest, + participation_fn=participation_fn, + ) + for attestation in attestations: + block.body.attestations.append(attestation) + + def next_epoch_with_attestations(spec, state, fill_cur_epoch, @@ -281,24 +373,10 @@ def state_transition_with_full_block(spec, if fill_cur_epoch and state.slot >= spec.MIN_ATTESTATION_INCLUSION_DELAY: slot_to_attest = state.slot - spec.MIN_ATTESTATION_INCLUSION_DELAY + 1 if slot_to_attest >= spec.compute_start_slot_at_epoch(spec.get_current_epoch(state)): - attestations = get_valid_attestation_at_slot( - state, - spec, - slot_to_attest, - participation_fn=participation_fn - ) - for attestation in attestations: - block.body.attestations.append(attestation) + _add_valid_attestations(spec, state, block, slot_to_attest, participation_fn=participation_fn) if fill_prev_epoch and state.slot >= spec.SLOTS_PER_EPOCH: slot_to_attest = state.slot - spec.SLOTS_PER_EPOCH + 1 - attestations = get_valid_attestation_at_slot( - state, - spec, - slot_to_attest, - participation_fn=participation_fn - ) - for attestation in attestations: - block.body.attestations.append(attestation) + _add_valid_attestations(spec, state, block, slot_to_attest, participation_fn=participation_fn) if sync_aggregate is not None: block.body.sync_aggregate = sync_aggregate @@ -319,7 +397,7 @@ def state_transition_with_full_attestations_block(spec, state, fill_cur_epoch, f slots = state.slot % spec.SLOTS_PER_EPOCH for slot_offset in range(slots): target_slot = state.slot - slot_offset - attestations += get_valid_attestation_at_slot( + attestations += get_valid_attestations_at_slot( state, spec, target_slot, @@ -330,7 +408,7 @@ def state_transition_with_full_attestations_block(spec, state, fill_cur_epoch, f slots = spec.SLOTS_PER_EPOCH - state.slot % spec.SLOTS_PER_EPOCH for slot_offset in range(1, slots): target_slot = state.slot - (state.slot % spec.SLOTS_PER_EPOCH) - slot_offset - attestations += get_valid_attestation_at_slot( + attestations += get_valid_attestations_at_slot( state, spec, target_slot, @@ -423,6 +501,9 @@ def get_empty_eip7549_aggregation_bits(spec, state, committee_bits, slot): def get_eip7549_aggregation_bits_offset(spec, state, slot, committee_bits, committee_index): + """ + Calculate the offset for the aggregation bits based on the committee index. + """ committee_indices = spec.get_committee_indices(committee_bits) assert committee_index in committee_indices offset = 0 diff --git a/tests/core/pyspec/eth2spec/test/phase0/epoch_processing/test_process_registry_updates.py b/tests/core/pyspec/eth2spec/test/phase0/epoch_processing/test_process_registry_updates.py index b7a7be76a..3cb73086c 100644 --- a/tests/core/pyspec/eth2spec/test/phase0/epoch_processing/test_process_registry_updates.py +++ b/tests/core/pyspec/eth2spec/test/phase0/epoch_processing/test_process_registry_updates.py @@ -114,7 +114,7 @@ def test_activation_queue_sorting(spec, state): assert state.validators[mock_activations - 2].activation_epoch == spec.FAR_FUTURE_EPOCH # the one at churn_limit did not make it, it was out-prioritized assert state.validators[churn_limit].activation_epoch == spec.FAR_FUTURE_EPOCH - # but the the one in front of the above did + # but the one in front of the above did assert state.validators[churn_limit - 1].activation_epoch != spec.FAR_FUTURE_EPOCH diff --git a/tests/core/pyspec/eth2spec/test/phase0/fork_choice/test_get_proposer_head.py b/tests/core/pyspec/eth2spec/test/phase0/fork_choice/test_get_proposer_head.py index 9419a18df..81e5b4f56 100644 --- a/tests/core/pyspec/eth2spec/test/phase0/fork_choice/test_get_proposer_head.py +++ b/tests/core/pyspec/eth2spec/test/phase0/fork_choice/test_get_proposer_head.py @@ -4,7 +4,7 @@ from eth2spec.test.context import ( with_altair_and_later, ) from eth2spec.test.helpers.attestations import ( - get_valid_attestation_at_slot, + get_valid_attestations_at_slot, ) from eth2spec.test.helpers.block import ( build_empty_block_for_next_slot, @@ -101,7 +101,7 @@ def test_basic_is_parent_root(spec, state): # Fill a slot with attestations to its parent block = build_empty_block_for_next_slot(spec, state) parent_block_slot = block.slot - 1 - block.body.attestations = get_valid_attestation_at_slot( + block.body.attestations = get_valid_attestations_at_slot( state, spec, parent_block_slot, @@ -128,7 +128,7 @@ def test_basic_is_parent_root(spec, state): slot = state.slot # Add attestations to the parent block - attestations = get_valid_attestation_at_slot( + attestations = get_valid_attestations_at_slot( state, spec, slot_to_attest=slot - 1, diff --git a/tests/core/pyspec/eth2spec/test/phase0/fork_choice/test_reorg.py b/tests/core/pyspec/eth2spec/test/phase0/fork_choice/test_reorg.py index ca9b483f8..983a8ee66 100644 --- a/tests/core/pyspec/eth2spec/test/phase0/fork_choice/test_reorg.py +++ b/tests/core/pyspec/eth2spec/test/phase0/fork_choice/test_reorg.py @@ -9,7 +9,7 @@ from eth2spec.test.helpers.constants import ( from eth2spec.test.helpers.attestations import ( state_transition_with_full_block, get_valid_attestation, - get_valid_attestation_at_slot, + get_valid_attestations_at_slot, ) from eth2spec.test.helpers.block import ( build_empty_block, @@ -218,7 +218,7 @@ def _run_delayed_justification(spec, state, attemped_reorg, is_justifying_previo # add attestations of y temp_state = state.copy() next_slot(spec, temp_state) - attestations_for_y = list(get_valid_attestation_at_slot(temp_state, spec, signed_block_y.message.slot)) + attestations_for_y = list(get_valid_attestations_at_slot(temp_state, spec, signed_block_y.message.slot)) current_time = temp_state.slot * spec.config.SECONDS_PER_SLOT + store.genesis_time on_tick_and_append_step(spec, store, current_time, test_steps) yield from add_attestations(spec, store, attestations_for_y, test_steps) @@ -345,10 +345,10 @@ def _run_include_votes_of_another_empty_chain(spec, state, enough_ffg, is_justif # create 2/3 votes for the empty chain attestations_for_y = [] # target_is_current = not is_justifying_previous_epoch - attestations = list(get_valid_attestation_at_slot(state, spec, state_a.slot)) + attestations = list(get_valid_attestations_at_slot(state, spec, state_a.slot)) attestations_for_y.append(attestations) for state in states_of_empty_chain: - attestations = list(get_valid_attestation_at_slot(state, spec, state.slot)) + attestations = list(get_valid_attestations_at_slot(state, spec, state.slot)) attestations_for_y.append(attestations) state = state_a.copy()