Merge branch 'dev' into init-electra

hwwhww · hwwhww · commit ab8815ba101d · 2024-04-09T12:26:07.000+09:00
diff --git a/specs/_features/eip7251/beacon-chain.md b/specs/_features/eip7251/beacon-chain.md
diff --git 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
@@ -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,
+    )
+```
diff --git 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
@@ -7,7 +7,7 @@
     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
@@ -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,27 +94,21 @@ 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:
         index = 0
 
     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,15 +203,17 @@ 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):
             if participation_fn is None:
                 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 participants_filter(comm):
         )
 
 
+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
@@ -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
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
