github/consensus-specs
1
1
Fork 0
mirror of https://github.com/ethereum/consensus-specs.git synced 2026-01-31 15:47:54 -05:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'dev' into init-electra

Browse Source
This commit is contained in:
Hsiao-Wei Wang
2024-04-09 12:26:07 +09:00
parent e64afbc630 93dba675dc
commit ab8815ba10
9 changed files with 407 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

239
specs/_features/eip7251/beacon-chain.md
View File

@@ -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)
<!-- END doctoc generated TOC please keep comment here to allow auto update -->
<!-- /TOC -->
## 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
```

4
specs/_features/eip7251/fork.md
View File

@@ -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
```

73
specs/_features/eip7251/validator.md Normal file
View File

@@ -0,0 +1,73 @@
# EIP-7251 -- Honest Validator
## Table of contents
<!-- TOC -->
<!-- START doctoc generated TOC please keep comment here to allow auto update -->
<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
- [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)
<!-- END doctoc generated TOC please keep comment here to allow auto update -->
<!-- /TOC -->
## 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,
)
```

6
specs/electra/beacon-chain.md
View File

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

6
tests/core/pyspec/eth2spec/test/bellatrix/fork_choice/test_should_override_forkchoice_update.py
View File

@@ -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,

153
tests/core/pyspec/eth2spec/test/helpers/attestations.py
View File

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

2
tests/core/pyspec/eth2spec/test/phase0/epoch_processing/test_process_registry_updates.py
View File

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

6
tests/core/pyspec/eth2spec/test/phase0/fork_choice/test_get_proposer_head.py
View File

@@ -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,

8
tests/core/pyspec/eth2spec/test/phase0/fork_choice/test_reorg.py
View File

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