EIP-7732 current fork spectests

.circleci/config.yml

@@ -194,6 +194,19 @@ jobs:
           command: make citest fork=eip7594
       - store_test_results:
           path: tests/core/pyspec/test-reports
+  test-eip7732:
+    docker:
+      - image: cimg/python:3.12.4
+    working_directory: ~/specs-repo
+    steps:
+      - restore_cache:
+          key: v3-specs-repo-{{ .Branch }}-{{ .Revision }}
+      - restore_pyspec_cached_venv
+      - run:
+          name: Run py-tests
+          command: make citest fork=eip7732
+      - store_test_results:
+          path: tests/core/pyspec/test-reports
   table_of_contents:
     docker:
       - image: circleci/node:10.16.3
@@ -323,6 +336,9 @@ workflows:
       - test-eip7594:
           requires:
             - install_pyspec_test
+      - test-eip7732:
+          requires:
+            - install_pyspec_test
       - table_of_contents
       - codespell
       - lint:

.github/workflows/run-tests.yml

@@ -74,7 +74,7 @@ jobs:
     needs: [lint,codespell,table_of_contents]
     strategy:
       matrix:
-        version: ["phase0", "altair", "bellatrix", "capella", "deneb", "electra", "whisk", "eip7594"]
+        version: ["phase0", "altair", "bellatrix", "capella", "deneb", "electra", "whisk", "eip7594", "eip7732"]
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4

specs/_features/eip7732/beacon-chain.md

@@ -54,6 +54,9 @@
       - [New `verify_execution_payload_envelope_signature`](#new-verify_execution_payload_envelope_signature)
     - [Modified `is_merge_transition_complete`](#modified-is_merge_transition_complete)
     - [Modified `validate_merge_block`](#modified-validate_merge_block)
+- [Testing](#testing)
+  - [Modified `initialize_beacon_state_from_eth1`](#modified-initialize_beacon_state_from_eth1)
+  - [Modified `is_merge_transition_complete`](#modified-is_merge_transition_complete-1)
 
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->
 <!-- /TOC -->
@@ -714,3 +717,80 @@ def validate_merge_block(block: BeaconBlock) -> None:
     # Check if `pow_block` is a valid terminal PoW block
     assert is_valid_terminal_pow_block(pow_block, pow_parent)
 ```
+
+## Testing
+
+### Modified `initialize_beacon_state_from_eth1`
+
+*Note*: The function `initialize_beacon_state_from_eth1` is modified for pure EIP-7732 testing only.
+Modifications include:
+1. Use `EIP7732_FORK_VERSION` as the previous and current fork version.
+
+```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=EIP7732_FORK_VERSION,  # [Modified in EIP-7732]
+        current_version=EIP7732_FORK_VERSION,  # [Modified in EIP-7732]
+        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
+        deposit_requests_start_index=UNSET_DEPOSIT_REQUESTS_START_INDEX,  # [New in Electra:EIP6110]
+    )
+
+    # 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]
+        # [Modified in Electra:EIP7251]
+        validator.effective_balance = min(
+            balance - balance % EFFECTIVE_BALANCE_INCREMENT, get_validator_max_effective_balance(validator))
+        if validator.effective_balance >= MIN_ACTIVATION_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
+    state.latest_execution_payload_header = execution_payload_header
+
+    return state
+```
+
+### Modified `is_merge_transition_complete` 
+
+The function `is_merge_transition_complete` is modified for test purposes only to include the hash tree root of the empty KZG commitment list
+
+```python
+def is_merge_transition_complete(state: BeaconState) -> bool:
+    header = ExecutionPayloadHeader()
+    kzgs = List[KZGCommitment, MAX_BLOB_COMMITMENTS_PER_BLOCK]()
+    header.blob_kzg_commitments_root = kzgs.hash_tree_root()
+
+    return state.latest_execution_payload_header != header
+```

specs/_features/eip7732/fork-choice.md

@@ -32,6 +32,7 @@
   - [`seconds_into_slot`](#seconds_into_slot)
   - [Modified `on_tick_per_slot`](#modified-on_tick_per_slot)
   - [`on_payload_attestation_message`](#on_payload_attestation_message)
+  - [Modified `validate_merge_block`](#modified-validate_merge_block)
 
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->
 <!-- /TOC -->
@@ -561,3 +562,34 @@ def on_payload_attestation_message(
         store.payload_withhold_boost_root = block.parent_root
         store.payload_withhold_boost_full = is_parent_node_full(store, block)
 ```
+
+### Modified `validate_merge_block` 
+
+The function `validate_merge_block` is modified for test purposes
+
+```python
+def validate_merge_block(block: BeaconBlock) -> None:
+    """
+    Check the parent PoW block of execution payload is a valid terminal PoW block.
+
+    Note: Unavailable PoW block(s) may later become available,
+    and a client software MAY delay a call to ``validate_merge_block``
+    until the PoW block(s) become available.
+    """
+    if TERMINAL_BLOCK_HASH != Hash32():
+        # If `TERMINAL_BLOCK_HASH` is used as an override, the activation epoch must be reached.
+        assert compute_epoch_at_slot(block.slot) >= TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH
+        assert block.body.signed_execution_payload_header.message.parent_block_hash == TERMINAL_BLOCK_HASH
+        return
+
+    pow_block = get_pow_block(block.body.signed_execution_payload_header.message.parent_block_hash)
+    # Check if `pow_block` is available
+    assert pow_block is not None
+    pow_parent = get_pow_block(pow_block.parent_hash)
+    # Check if `pow_parent` is available
+    assert pow_parent is not None
+    # Check if `pow_block` is a valid terminal PoW block
+    assert is_valid_terminal_pow_block(pow_block, pow_parent)
+
+
+

tests/core/pyspec/eth2spec/test/bellatrix/block_processing/test_process_execution_payload.py

@@ -13,9 +13,12 @@
     expect_assertion_error,
     spec_state_test,
     with_bellatrix_and_later,
+    with_bellatrix_until_eip7732,
     with_phases,
 )
+from eth2spec.test.helpers.keys import privkeys
 from eth2spec.test.helpers.state import next_slot
+from eth2spec.test.helpers.forks import is_post_eip7732
 
 
 def run_execution_payload_processing(spec, state, execution_payload, valid=True, execution_valid=True):
@@ -28,34 +31,68 @@ def run_execution_payload_processing(spec, state, execution_payload, valid=True,
     If ``valid == False``, run expecting ``AssertionError``
     """
     # Before Deneb, only `body.execution_payload` matters. `BeaconBlockBody` is just a wrapper.
-    body = spec.BeaconBlockBody(execution_payload=execution_payload)
+    # after EIP-7732 the execution payload is no longer in the body
+    if is_post_eip7732(spec):
+        envelope = spec.ExecutionPayloadEnvelope(
+            payload=execution_payload,
+            beacon_block_root=state.latest_block_header.hash_tree_root(),
+            payload_withheld=False,
+        )
+        post_state = state.copy()
+        post_state.latest_block_hash = execution_payload.block_hash
+        post_state.latest_full_slot = state.slot
+        envelope.state_root = post_state.hash_tree_root()
+        privkey = privkeys[0]
+        signature = spec.get_execution_payload_envelope_signature(
+            state,
+            envelope,
+            privkey,
+        )
+        signed_envelope = spec.SignedExecutionPayloadEnvelope(
+            message=envelope,
+            signature=signature,
+        )
+    else:
+        body = spec.BeaconBlockBody(execution_payload=execution_payload)
 
     yield 'pre', state
     yield 'execution', {'execution_valid': execution_valid}
-    yield 'body', body
+    if not is_post_eip7732(spec):
+        yield 'body', body
 
     called_new_block = False
 
     class TestEngine(spec.NoopExecutionEngine):
         def verify_and_notify_new_payload(self, new_payload_request) -> bool:
             nonlocal called_new_block, execution_valid
             called_new_block = True
-            assert new_payload_request.execution_payload == body.execution_payload
+            assert new_payload_request.execution_payload == execution_payload
             return execution_valid
 
     if not valid:
-        expect_assertion_error(lambda: spec.process_execution_payload(state, body, TestEngine()))
+        if is_post_eip7732(spec):
+            expect_assertion_error(lambda: spec.process_execution_payload(state, signed_envelope, TestEngine()))
+        else:
+            expect_assertion_error(lambda: spec.process_execution_payload(state, body, TestEngine()))
         yield 'post', None
         return
 
-    spec.process_execution_payload(state, body, TestEngine())
+    if is_post_eip7732(spec):
+        spec.process_execution_payload(state, signed_envelope, TestEngine())
+    else:
+        spec.process_execution_payload(state, body, TestEngine())
 
     # Make sure we called the engine
     assert called_new_block
 
     yield 'post', state
 
-    assert state.latest_execution_payload_header == get_execution_payload_header(spec, body.execution_payload)
+    if is_post_eip7732(spec):
+        assert state.latest_full_slot == state.slot
+        assert state.latest_block_hash == execution_payload.block_hash
+    else:
+        assert state.latest_execution_payload_header == get_execution_payload_header(
+            spec, state, body.execution_payload)
 
 
 def run_success_test(spec, state):
@@ -65,15 +102,15 @@ def run_success_test(spec, state):
     yield from run_execution_payload_processing(spec, state, execution_payload)
 
 
-@with_bellatrix_and_later
+@with_bellatrix_until_eip7732
 @spec_state_test
 def test_success_first_payload(spec, state):
     state = build_state_with_incomplete_transition(spec, state)
 
     yield from run_success_test(spec, state)
 
 
-@with_bellatrix_and_later
+@with_bellatrix_until_eip7732
 @spec_state_test
 def test_success_regular_payload(spec, state):
     state = build_state_with_complete_transition(spec, state)
@@ -89,14 +126,14 @@ def run_gap_slot_test(spec, state):
     yield from run_execution_payload_processing(spec, state, execution_payload)
 
 
-@with_bellatrix_and_later
+@with_bellatrix_until_eip7732
 @spec_state_test
 def test_success_first_payload_with_gap_slot(spec, state):
     state = build_state_with_incomplete_transition(spec, state)
     yield from run_gap_slot_test(spec, state)
 
 
-@with_bellatrix_and_later
+@with_bellatrix_until_eip7732
 @spec_state_test
 def test_success_regular_payload_with_gap_slot(spec, state):
     state = build_state_with_complete_transition(spec, state)
@@ -111,14 +148,14 @@ def run_bad_execution_test(spec, state):
     yield from run_execution_payload_processing(spec, state, execution_payload, valid=False, execution_valid=False)
 
 
-@with_bellatrix_and_later
+@with_bellatrix_until_eip7732
 @spec_state_test
 def test_invalid_bad_execution_first_payload(spec, state):
     state = build_state_with_incomplete_transition(spec, state)
     yield from run_bad_execution_test(spec, state)
 
 
-@with_bellatrix_and_later
+@with_bellatrix_until_eip7732
 @spec_state_test
 def test_invalid_bad_execution_regular_payload(spec, state):
     state = build_state_with_complete_transition(spec, state)
@@ -255,14 +292,14 @@ def run_non_empty_extra_data_test(spec, state):
     assert state.latest_execution_payload_header.extra_data == execution_payload.extra_data
 
 
-@with_bellatrix_and_later
+@with_bellatrix_until_eip7732
 @spec_state_test
 def test_non_empty_extra_data_first_payload(spec, state):
     state = build_state_with_incomplete_transition(spec, state)
     yield from run_non_empty_extra_data_test(spec, state)
 
 
-@with_bellatrix_and_later
+@with_bellatrix_until_eip7732
 @spec_state_test
 def test_non_empty_extra_data_regular_payload(spec, state):
     state = build_state_with_complete_transition(spec, state)
@@ -284,14 +321,14 @@ def run_non_empty_transactions_test(spec, state):
     assert state.latest_execution_payload_header.transactions_root == execution_payload.transactions.hash_tree_root()
 
 
-@with_bellatrix_and_later
+@with_bellatrix_until_eip7732
 @spec_state_test
 def test_non_empty_transactions_first_payload(spec, state):
     state = build_state_with_incomplete_transition(spec, state)
     yield from run_non_empty_extra_data_test(spec, state)
 
 
-@with_bellatrix_and_later
+@with_bellatrix_until_eip7732
 @spec_state_test
 def test_non_empty_transactions_regular_payload(spec, state):
     state = build_state_with_complete_transition(spec, state)
@@ -310,14 +347,14 @@ def run_zero_length_transaction_test(spec, state):
     assert state.latest_execution_payload_header.transactions_root == execution_payload.transactions.hash_tree_root()
 
 
-@with_bellatrix_and_later
+@with_bellatrix_until_eip7732
 @spec_state_test
 def test_zero_length_transaction_first_payload(spec, state):
     state = build_state_with_incomplete_transition(spec, state)
     yield from run_zero_length_transaction_test(spec, state)
 
 
-@with_bellatrix_and_later
+@with_bellatrix_until_eip7732
 @spec_state_test
 def test_zero_length_transaction_regular_payload(spec, state):
     state = build_state_with_complete_transition(spec, state)
@@ -328,6 +365,11 @@ def run_randomized_non_validated_execution_fields_test(spec, state, rng, executi
     next_slot(spec, state)
     execution_payload = build_randomized_execution_payload(spec, state, rng)
 
+    if is_post_eip7732(spec):
+        state.latest_execution_payload_header.block_hash = execution_payload.block_hash
+        state.latest_execution_payload_header.gas_limit = execution_payload.gas_limit
+        state.latest_block_hash = execution_payload.parent_hash
+
     yield from run_execution_payload_processing(
         spec, state,
         execution_payload,