Merge test vectors: enable phase0 tests for Merge + start on new testing

specs/merge/beacon-chain.md

@@ -146,8 +146,8 @@ def is_transition_completed(state: BeaconState) -> bool:
 #### `is_transition_block`
 
 ```python
-def is_transition_block(state: BeaconState, block_body: BeaconBlockBody) -> bool:
-    return not is_transition_completed(state) and block_body.execution_payload != ExecutionPayload()
+def is_transition_block(state: BeaconState, block: BeaconBlock) -> bool:
+    return not is_transition_completed(state) and block.body.execution_payload != ExecutionPayload()
 ```
 
 #### `compute_time_at_slot`
@@ -168,7 +168,9 @@ def process_block(state: BeaconState, block: BeaconBlock) -> None:
     process_randao(state, block.body)
     process_eth1_data(state, block.body)
     process_operations(state, block.body)
-    process_execution_payload(state, block.body)  # [New in Merge]
+    # Pre-merge, skip execution payload processing
+    if is_transition_completed(state) or is_transition_block(state, block):
+        process_execution_payload(state, block.body.execution_payload)  # [New in Merge]
 ```
 
 #### Execution payload processing
@@ -181,16 +183,10 @@ The body of the function is implementation dependent.
 ##### `process_execution_payload`
 
 ```python
-def process_execution_payload(state: BeaconState, body: BeaconBlockBody) -> None:
+def process_execution_payload(state: BeaconState, execution_payload: ExecutionPayload) -> None:
     """
     Note: This function is designed to be able to be run in parallel with the other `process_block` sub-functions
     """
-    # Pre-merge, skip processing
-    if not is_transition_completed(state) and not is_transition_block(state, body):
-        return
-
-    execution_payload = body.execution_payload
-
     if is_transition_completed(state):
         assert execution_payload.parent_hash == state.latest_execution_payload_header.block_hash
         assert execution_payload.number == state.latest_execution_payload_header.number + 1

specs/merge/fork-choice.md

@@ -75,7 +75,7 @@ def on_block(store: Store, signed_block: SignedBeaconBlock) -> None:
     assert get_ancestor(store, block.parent_root, finalized_slot) == store.finalized_checkpoint.root
 
     # [New in Merge]
-    if is_transition_block(pre_state, block.body):
+    if is_transition_block(pre_state, block):
         # Delay consideration of block until PoW block is processed by the PoW node
         pow_block = get_pow_block(block.body.execution_payload.parent_hash)
         assert pow_block.is_processed

tests/core/pyspec/eth2spec/test/context.py

@@ -8,7 +8,7 @@
 from .exceptions import SkippedTest
 from .helpers.constants import (
     PHASE0, ALTAIR,
-    ALL_PHASES, FORKS_BEFORE_ALTAIR,
+    ALL_PHASES, FORKS_BEFORE_ALTAIR, FORKS_BEFORE_MERGE,
 )
 from .helpers.genesis import create_genesis_state
 from .utils import vector_test, with_meta_tags
@@ -365,3 +365,9 @@ def is_post_altair(spec):
     if spec.fork in FORKS_BEFORE_ALTAIR:
         return False
     return True
+
+
+def is_post_merge(spec):
+    if spec.fork in FORKS_BEFORE_MERGE:
+        return False
+    return True

tests/core/pyspec/eth2spec/test/helpers/block.py

@@ -1,4 +1,5 @@
-from eth2spec.test.context import is_post_altair
+from eth2spec.test.context import is_post_altair, is_post_merge
+from eth2spec.test.helpers.execution_payload import build_empty_execution_payload
 from eth2spec.test.helpers.keys import privkeys
 from eth2spec.utils import bls
 from eth2spec.utils.bls import only_with_bls
@@ -94,6 +95,9 @@ def build_empty_block(spec, state, slot=None):
     if is_post_altair(spec):
         empty_block.body.sync_aggregate.sync_committee_signature = spec.G2_POINT_AT_INFINITY
 
+    if is_post_merge(spec):
+        empty_block.body.execution_payload = build_empty_execution_payload(spec, state)
+
     apply_randao_reveal(spec, state, empty_block)
     return empty_block
 

tests/core/pyspec/eth2spec/test/helpers/constants.py

@@ -7,21 +7,24 @@
 # Some of the Spec module functionality is exposed here to deal with phase-specific changes.
 PHASE0 = SpecForkName('phase0')
 ALTAIR = SpecForkName('altair')
+MERGE = SpecForkName('merge')
 
 # Experimental phases (not included in default "ALL_PHASES"):
-MERGE = SpecForkName('merge')
 SHARDING = SpecForkName('sharding')
 CUSTODY_GAME = SpecForkName('custody_game')
 DAS = SpecForkName('das')
 
 # The forks that pytest runs with.
-ALL_PHASES = (PHASE0, ALTAIR)
+ALL_PHASES = (PHASE0, ALTAIR, MERGE)
 # The forks that output to the test vectors.
-TESTGEN_FORKS = (PHASE0, ALTAIR)
+TESTGEN_FORKS = (PHASE0, ALTAIR, MERGE)
 # TODO: everything runs in parallel to Altair.
 # After features are rebased on the Altair fork, this can be reduced to just PHASE0.
 FORKS_BEFORE_ALTAIR = (PHASE0, MERGE, SHARDING, CUSTODY_GAME, DAS)
 
+# TODO: when rebasing Merge onto Altair, add ALTAIR to this tuple.
+FORKS_BEFORE_MERGE = (PHASE0,)
+
 #
 # Config
 #

tests/core/pyspec/eth2spec/test/helpers/execution_payload.py

@@ -0,0 +1,26 @@
+
+def build_empty_execution_payload(spec, state):
+    """
+    Assuming a pre-state of the same slot, build a valid ExecutionPayload without any transactions.
+    """
+    latest = state.latest_execution_payload_header
+    timestamp = spec.compute_time_at_slot(state, state.slot)
+    empty_txs = spec.List[spec.OpaqueTransaction, spec.MAX_EXECUTION_TRANSACTIONS]()
+
+    payload = spec.ExecutionPayload(
+        block_hash=spec.Hash32(),
+        parent_hash=latest.block_hash,
+        coinbase=spec.Bytes20(),
+        state_root=latest.state_root,  # no changes to the state
+        number=latest.number + 1,
+        gas_limit=latest.gas_limit,  # retain same limit
+        gas_used=0,  # empty block, 0 gas
+        timestamp=timestamp,
+        receipt_root=b"no receipts here" + b"\x00"*16,  # TODO: root of empty MPT may be better.
+        logs_bloom=spec.ByteVector[spec.BYTES_PER_LOGS_BLOOM](),  # TODO: zeroed logs bloom for empty logs ok?
+        transactions_root=empty_txs,
+    )
+    # TODO: real RLP + block hash logic would be nice, requires RLP and keccak256 dependency however.
+    payload.block_hash = spec.Hash32(spec.hash(payload.hash_tree_root() + b"FAKE RLP HASH"))
+
+    return payload

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

@@ -0,0 +1,147 @@
+from eth2spec.test.helpers.constants import PHASE0, ALTAIR
+from eth2spec.test.context import spec_state_test, expect_assertion_error, always_bls, with_all_phases_except
+
+with_merge_and_later = with_all_phases_except([PHASE0, ALTAIR])
+
+
+def run_execution_payload_processing(spec, state, execution_payload, valid=True, execution_valid=True):
+    """
+    Run ``process_execution_payload``, yielding:
+      - pre-state ('pre')
+      - execution payload ('execution_payload')
+      - execution details, to mock EVM execution ('execution.yml', a dict with 'execution_valid' key and boolean value)
+      - post-state ('post').
+    If ``valid == False``, run expecting ``AssertionError``
+    """
+
+    yield 'pre', state
+    yield 'execution', {'execution_valid': execution_valid}
+    yield 'execution_payload', execution_payload
+
+    if not valid:
+        expect_assertion_error(lambda: spec.process_execution_payload(state, execution_payload))
+        yield 'post', None
+        return
+
+    spec.process_execution_payload(state, execution_payload)
+
+    yield 'post', state
+
+    # TODO: any assertions to make?
+
+
+@with_merge_and_later
+@spec_state_test
+def test_success_first_payload(spec, state):
+    assert not spec.is_transition_completed(state)
+
+    # TODO: execution payload
+    execution_payload = spec.ExecutionPayload()
+
+    yield from run_execution_payload_processing(spec, state, execution_payload)
+
+
+@with_merge_and_later
+@spec_state_test
+def test_success_regular_payload(spec, state):
+    # TODO: setup state
+    assert spec.is_transition_completed(state)
+
+    # TODO: execution payload
+    execution_payload = spec.ExecutionPayload()
+
+    yield from run_execution_payload_processing(spec, state, execution_payload)
+
+
+@with_merge_and_later
+@spec_state_test
+def test_success_first_payload_with_gap_slot(spec, state):
+    # TODO: transition gap slot
+
+    assert not spec.is_transition_completed(state)
+
+    # TODO: execution payload
+    execution_payload = spec.ExecutionPayload()
+
+    yield from run_execution_payload_processing(spec, state, execution_payload)
+
+
+@with_merge_and_later
+@spec_state_test
+def test_success_regular_payload_with_gap_slot(spec, state):
+    # TODO: setup state
+    assert spec.is_transition_completed(state)
+    # TODO: transition gap slot
+
+    # TODO: execution payload
+    execution_payload = spec.ExecutionPayload()
+
+    yield from run_execution_payload_processing(spec, state, execution_payload)
+
+
+@with_merge_and_later
+@spec_state_test
+def test_bad_execution_first_payload(spec, state):
+    # completely valid payload, but execution itself fails (e.g. block exceeds gas limit)
+
+    # TODO: execution payload.
+    execution_payload = spec.ExecutionPayload()
+
+    yield from run_execution_payload_processing(spec, state, execution_payload, valid=False, execution_valid=False)
+
+
+@with_merge_and_later
+@spec_state_test
+def test_bad_execution_regular_payload(spec, state):
+    # completely valid payload, but execution itself fails (e.g. block exceeds gas limit)
+
+    # TODO: execution payload
+    execution_payload = spec.ExecutionPayload()
+
+    yield from run_execution_payload_processing(spec, state, execution_payload, valid=False, execution_valid=False)
+
+
+@with_merge_and_later
+@spec_state_test
+def test_bad_parent_hash_first_payload(spec, state):
+    # TODO: execution payload
+    execution_payload = spec.ExecutionPayload()
+
+    yield from run_execution_payload_processing(spec, state, execution_payload, valid=False)
+
+
+@with_merge_and_later
+@spec_state_test
+def test_bad_number_first_payload(spec, state):
+    # TODO: execution payload
+    execution_payload = spec.ExecutionPayload()
+
+    yield from run_execution_payload_processing(spec, state, execution_payload, valid=False)
+
+
+@with_merge_and_later
+@spec_state_test
+def test_bad_everything_first_payload(spec, state):
+    # TODO: execution payload
+    execution_payload = spec.ExecutionPayload()
+
+    yield from run_execution_payload_processing(spec, state, execution_payload, valid=False)
+
+
+@with_merge_and_later
+@spec_state_test
+def test_bad_timestamp_first_payload(spec, state):
+    # TODO: execution payload
+    execution_payload = spec.ExecutionPayload()
+
+    yield from run_execution_payload_processing(spec, state, execution_payload, valid=False)
+
+
+@with_merge_and_later
+@spec_state_test
+def test_bad_timestamp_regular_payload(spec, state):
+    # TODO: execution payload
+    execution_payload = spec.ExecutionPayload()
+
+    yield from run_execution_payload_processing(spec, state, execution_payload, valid=False)
+

tests/core/pyspec/eth2spec/test/merge/sanity/test_blocks.py

@@ -0,0 +1,25 @@
+from eth2spec.test.helpers.state import (
+    state_transition_and_sign_block
+)
+from eth2spec.test.helpers.block import (
+    build_empty_block_for_next_slot
+)
+from eth2spec.test.context import (
+    with_all_phases, spec_state_test
+)
+
+
+@with_all_phases
+@spec_state_test
+def test_empty_block_transition(spec, state):
+    yield 'pre', state
+
+    block = build_empty_block_for_next_slot(spec, state)
+    assert len(block.body.execution_payload.transactions) == 0
+
+    signed_block = state_transition_and_sign_block(spec, state, block)
+
+    yield 'blocks', [signed_block]
+    yield 'post', state
+
+# TODO: tests with EVM, mock or replacement?

tests/formats/operations/README.md

@@ -33,17 +33,23 @@ This excludes the other parts of the block-transition.
 
 Operations:
 
-| *`operation-name`*      | *`operation-object`*  | *`input name`*       | *`processing call`*                                             |
-|-------------------------|-----------------------|----------------------|-----------------------------------------------------------------|
-| `attestation`           | `Attestation`         | `attestation`        | `process_attestation(state, attestation)`                       |
-| `attester_slashing`     | `AttesterSlashing`    | `attester_slashing`  | `process_attester_slashing(state, attester_slashing)`           |
-| `block_header`          | `BeaconBlock`         | **`block`**          | `process_block_header(state, block)`                            |
-| `deposit`               | `Deposit`             | `deposit`            | `process_deposit(state, deposit)`                               |
-| `proposer_slashing`     | `ProposerSlashing`    | `proposer_slashing`  | `process_proposer_slashing(state, proposer_slashing)`           |
-| `voluntary_exit`        | `SignedVoluntaryExit` | `voluntary_exit`     | `process_voluntary_exit(state, voluntary_exit)`                 |
-| `sync_aggregate`        | `SyncAggregate`       | `sync_aggregate`     | `process_sync_committee(state, sync_aggregate)` (new in Altair) |
+| *`operation-name`*      | *`operation-object`*  | *`input name`*       | *`processing call`*                                                  |
+|-------------------------|-----------------------|----------------------|----------------------------------------------------------------------|
+| `attestation`           | `Attestation`         | `attestation`        | `process_attestation(state, attestation)`                            |
+| `attester_slashing`     | `AttesterSlashing`    | `attester_slashing`  | `process_attester_slashing(state, attester_slashing)`                |
+| `block_header`          | `BeaconBlock`         | **`block`**          | `process_block_header(state, block)`                                 |
+| `deposit`               | `Deposit`             | `deposit`            | `process_deposit(state, deposit)`                                    |
+| `proposer_slashing`     | `ProposerSlashing`    | `proposer_slashing`  | `process_proposer_slashing(state, proposer_slashing)`                |
+| `voluntary_exit`        | `SignedVoluntaryExit` | `voluntary_exit`     | `process_voluntary_exit(state, voluntary_exit)`                      |
+| `sync_aggregate`        | `SyncAggregate`       | `sync_aggregate`     | `process_sync_committee(state, sync_aggregate)` (new in Altair)      |
+| `execution_payload`     | `ExecutionPayload`    | `execution_payload`  | `process_execution_payload(state, execution_payload)` (new in Merge) |
 
 Note that `block_header` is not strictly an operation (and is a full `Block`), but processed in the same manner, and hence included here.
 
+The `execution_payload` processing normally requires a `verify_execution_state_transition(execution_payload)`,
+a responsibility of an (external) execution engine.
+During testing this execution is mocked, an `execution.yml` is provided instead:
+a dict containing an `execution_valid` boolean field with the verification result.
+
 The resulting state should match the expected `post` state, or if the `post` state is left blank,
  the handler should reject the input operation as invalid.

tests/generators/epoch_processing/main.py

@@ -1,10 +1,11 @@
 from eth2spec.gen_helpers.gen_from_tests.gen import run_state_test_generators
 from eth2spec.phase0 import spec as spec_phase0
 from eth2spec.altair import spec as spec_altair
-from eth2spec.test.helpers.constants import PHASE0, ALTAIR
+from eth2spec.merge import spec as spec_merge
+from eth2spec.test.helpers.constants import PHASE0, ALTAIR, MERGE
 
 
-specs = (spec_phase0, spec_altair)
+specs = (spec_phase0, spec_altair, spec_merge)
 
 
 if __name__ == "__main__":
@@ -27,6 +28,10 @@
         **phase_0_mods,
     }  # also run the previous phase 0 tests
 
+    # No epoch-processing changes in Merge and previous testing repeats with new types, so no additional tests required.
+    # TODO: rebase onto Altair testing later.
+    merge_mods = phase_0_mods
+
     # TODO Custody Game testgen is disabled for now
     # custody_game_mods = {**{key: 'eth2spec.test.custody_game.epoch_processing.test_process_' + key for key in [
     #     'reveal_deadlines',
@@ -37,6 +42,7 @@
     all_mods = {
         PHASE0: phase_0_mods,
         ALTAIR: altair_mods,
+        MERGE: merge_mods,
     }
 
     run_state_test_generators(runner_name="epoch_processing", specs=specs, all_mods=all_mods)