Move old Deneb sanity tests to block_processing (operations) tests

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

@@ -0,0 +1,175 @@
+from random import Random
+
+from eth2spec.test.helpers.execution_payload import (
+    build_empty_execution_payload,
+    compute_el_block_hash,
+    get_execution_payload_header,
+)
+from eth2spec.test.context import (
+    spec_state_test,
+    expect_assertion_error,
+    with_deneb_and_later
+)
+from eth2spec.test.helpers.sharding import (
+    get_sample_opaque_tx,
+)
+
+
+def run_execution_payload_processing(spec, state, execution_payload, blob_kzg_commitments,
+                                     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``
+    """
+    # Before Deneb, only `body.execution_payload` matters. `BeaconBlockBody` is just a wrapper.
+    body = spec.BeaconBlockBody(
+        blob_kzg_commitments=blob_kzg_commitments,
+        execution_payload=execution_payload
+    )
+
+    yield 'pre', state
+    yield 'execution', {'execution_valid': execution_valid}
+    yield 'body', body
+
+    called_new_block = False
+
+    class TestEngine(spec.NoopExecutionEngine):
+        def 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
+            return execution_valid
+
+    if not valid:
+        expect_assertion_error(lambda: spec.process_execution_payload(state, body, TestEngine()))
+        yield 'post', None
+        return
+
+    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)
+
+
+@with_deneb_and_later
+@spec_state_test
+def test_incorrect_blob_tx_type(spec, state):
+    """
+    The versioned hashes are wrong, but the testing ExecutionEngine returns VALID by default.
+    """
+    execution_payload = build_empty_execution_payload(spec, state)
+
+    opaque_tx, _, blob_kzg_commitments, _ = get_sample_opaque_tx(spec)
+    opaque_tx = b'\x04' + opaque_tx[1:]  # incorrect tx type
+
+    execution_payload.transactions = [opaque_tx]
+    execution_payload.block_hash = compute_el_block_hash(spec, execution_payload)
+
+    yield from run_execution_payload_processing(spec, state, execution_payload, blob_kzg_commitments)
+
+
+@with_deneb_and_later
+@spec_state_test
+def test_incorrect_transaction_length_1_byte(spec, state):
+    """
+    The versioned hashes are wrong, but the testing ExecutionEngine returns VALID by default.
+    """
+    execution_payload = build_empty_execution_payload(spec, state)
+
+    opaque_tx, _, blob_kzg_commitments, _ = get_sample_opaque_tx(spec)
+    opaque_tx = opaque_tx + b'\x12'  # incorrect tx length
+
+    execution_payload.transactions = [opaque_tx]
+    execution_payload.block_hash = compute_el_block_hash(spec, execution_payload)
+
+    yield from run_execution_payload_processing(spec, state, execution_payload, blob_kzg_commitments)
+
+
+@with_deneb_and_later
+@spec_state_test
+def test_incorrect_transaction_length_32_bytes(spec, state):
+    """
+    The versioned hashes are wrong, but the testing ExecutionEngine returns VALID by default.
+    """
+    execution_payload = build_empty_execution_payload(spec, state)
+
+    opaque_tx, _, blob_kzg_commitments, _ = get_sample_opaque_tx(spec)
+    opaque_tx = opaque_tx + b'\x12' * 32  # incorrect tx length
+
+    execution_payload.transactions = [opaque_tx]
+    execution_payload.block_hash = compute_el_block_hash(spec, execution_payload)
+
+    yield from run_execution_payload_processing(spec, state, execution_payload, blob_kzg_commitments)
+
+
+@with_deneb_and_later
+@spec_state_test
+def test_incorrect_commitment(spec, state):
+    """
+    The versioned hashes are wrong, but the testing ExecutionEngine returns VALID by default.
+    """
+    execution_payload = build_empty_execution_payload(spec, state)
+
+    opaque_tx, _, blob_kzg_commitments, _ = get_sample_opaque_tx(spec)
+    blob_kzg_commitments[0] = b'\x12' * 48  # incorrect commitment
+
+    execution_payload.transactions = [opaque_tx]
+    execution_payload.block_hash = compute_el_block_hash(spec, execution_payload)
+
+    yield from run_execution_payload_processing(spec, state, execution_payload, blob_kzg_commitments)
+
+
+@with_deneb_and_later
+@spec_state_test
+def test_incorrect_commitments_order(spec, state):
+    """
+    The versioned hashes are wrong, but the testing ExecutionEngine returns VALID by default.
+    """
+    execution_payload = build_empty_execution_payload(spec, state)
+
+    opaque_tx, _, blob_kzg_commitments, _ = get_sample_opaque_tx(spec, blob_count=2, rng=Random(1111))
+    blob_kzg_commitments = [blob_kzg_commitments[1], blob_kzg_commitments[0]]  # incorrect order
+
+    execution_payload.transactions = [opaque_tx]
+    execution_payload.block_hash = compute_el_block_hash(spec, execution_payload)
+
+    yield from run_execution_payload_processing(spec, state, execution_payload, blob_kzg_commitments)
+
+
+@with_deneb_and_later
+@spec_state_test
+def test_incorrect_block_hash(spec, state):
+    execution_payload = build_empty_execution_payload(spec, state)
+
+    opaque_tx, _, blob_kzg_commitments, _ = get_sample_opaque_tx(spec)
+
+    execution_payload.transactions = [opaque_tx]
+    execution_payload.block_hash = b'\x12' * 32  # incorrect block hash
+
+    # CL itself doesn't verify EL block hash
+    yield from run_execution_payload_processing(spec, state, execution_payload, blob_kzg_commitments)
+
+
+@with_deneb_and_later
+@spec_state_test
+def test_zeroed_commitment(spec, state):
+    """
+    The blob is invalid, but the commitment is in correct form.
+    """
+    execution_payload = build_empty_execution_payload(spec, state)
+
+    opaque_tx, _, blob_kzg_commitments, _ = get_sample_opaque_tx(spec, blob_count=1, is_valid_blob=False)
+    assert all(commitment == b'\x00' * 48 for commitment in blob_kzg_commitments)
+
+    execution_payload.transactions = [opaque_tx]
+    execution_payload.block_hash = compute_el_block_hash(spec, execution_payload)
+
+    yield from run_execution_payload_processing(spec, state, execution_payload, blob_kzg_commitments)

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

@@ -1,5 +1,3 @@
-import random
-
 from eth2spec.test.helpers.state import (
     state_transition_and_sign_block
 )
@@ -49,139 +47,3 @@ def test_one_blob(spec, state):
 @spec_state_test
 def test_max_blobs(spec, state):
     yield from run_block_with_blobs(spec, state, blob_count=spec.MAX_BLOBS_PER_BLOCK)
-
-
-@with_deneb_and_later
-@spec_state_test
-def test_incorrect_blob_tx_type(spec, state):
-    """
-    The versioned hashes are wrong, but the testing ExecutionEngine returns VALID by default.
-    """
-    yield 'pre', state
-
-    block = build_empty_block_for_next_slot(spec, state)
-    opaque_tx, _, blob_kzg_commitments, _ = get_sample_opaque_tx(spec)
-    block.body.blob_kzg_commitments = blob_kzg_commitments
-    opaque_tx = b'\x04' + opaque_tx[1:]  # incorrect tx type
-    block.body.execution_payload.transactions = [opaque_tx]
-    block.body.execution_payload.block_hash = compute_el_block_hash(spec, block.body.execution_payload)
-    signed_block = state_transition_and_sign_block(spec, state, block)
-
-    yield 'blocks', [signed_block]
-    yield 'post', state
-
-
-@with_deneb_and_later
-@spec_state_test
-def test_incorrect_transaction_length_1_byte(spec, state):
-    """
-    The versioned hashes are wrong, but the testing ExecutionEngine returns VALID by default.
-    """
-    yield 'pre', state
-
-    block = build_empty_block_for_next_slot(spec, state)
-    opaque_tx, _, blob_kzg_commitments, _ = get_sample_opaque_tx(spec)
-    block.body.blob_kzg_commitments = blob_kzg_commitments
-    opaque_tx = opaque_tx + b'\x12'  # incorrect tx length
-    block.body.execution_payload.transactions = [opaque_tx]
-    block.body.execution_payload.block_hash = compute_el_block_hash(spec, block.body.execution_payload)
-    signed_block = state_transition_and_sign_block(spec, state, block)
-
-    yield 'blocks', [signed_block]
-    yield 'post', state
-
-
-@with_deneb_and_later
-@spec_state_test
-def test_incorrect_transaction_length_32_bytes(spec, state):
-    """
-    The versioned hashes are wrong, but the testing ExecutionEngine returns VALID by default.
-    """
-    yield 'pre', state
-
-    block = build_empty_block_for_next_slot(spec, state)
-    opaque_tx, _, blob_kzg_commitments, _ = get_sample_opaque_tx(spec)
-    block.body.blob_kzg_commitments = blob_kzg_commitments
-    opaque_tx = opaque_tx + b'\x12' * 32  # incorrect tx length
-    block.body.execution_payload.transactions = [opaque_tx]
-    block.body.execution_payload.block_hash = compute_el_block_hash(spec, block.body.execution_payload)
-    signed_block = state_transition_and_sign_block(spec, state, block)
-
-    yield 'blocks', [signed_block]
-    yield 'post', state
-
-
-@with_deneb_and_later
-@spec_state_test
-def test_incorrect_commitment(spec, state):
-    """
-    The versioned hashes are wrong, but the testing ExecutionEngine returns VALID by default.
-    """
-    yield 'pre', state
-
-    block = build_empty_block_for_next_slot(spec, state)
-    opaque_tx, _, blob_kzg_commitments, _ = get_sample_opaque_tx(spec)
-    blob_kzg_commitments[0] = b'\x12' * 48  # incorrect commitment
-    block.body.blob_kzg_commitments = blob_kzg_commitments
-    block.body.execution_payload.transactions = [opaque_tx]
-    block.body.execution_payload.block_hash = compute_el_block_hash(spec, block.body.execution_payload)
-    signed_block = state_transition_and_sign_block(spec, state, block)
-
-    yield 'blocks', [signed_block]
-    yield 'post', state
-
-
-@with_deneb_and_later
-@spec_state_test
-def test_incorrect_commitments_order(spec, state):
-    """
-    The versioned hashes are wrong, but the testing ExecutionEngine returns VALID by default.
-    """
-    yield 'pre', state
-
-    block = build_empty_block_for_next_slot(spec, state)
-    opaque_tx, _, blob_kzg_commitments, _ = get_sample_opaque_tx(spec, blob_count=2, rng=random.Random(1111))
-    block.body.blob_kzg_commitments = [blob_kzg_commitments[1], blob_kzg_commitments[0]]  # incorrect order
-    block.body.execution_payload.transactions = [opaque_tx]
-    block.body.execution_payload.block_hash = compute_el_block_hash(spec, block.body.execution_payload)
-    signed_block = state_transition_and_sign_block(spec, state, block)
-
-    yield 'blocks', [signed_block]
-    yield 'post', state
-
-
-@with_deneb_and_later
-@spec_state_test
-def test_incorrect_block_hash(spec, state):
-    yield 'pre', state
-
-    block = build_empty_block_for_next_slot(spec, state)
-    opaque_tx, _, blob_kzg_commitments, _ = get_sample_opaque_tx(spec)
-    block.body.blob_kzg_commitments = blob_kzg_commitments
-    block.body.execution_payload.transactions = [opaque_tx]
-    block.body.execution_payload.block_hash = b'\x12' * 32  # incorrect block hash
-    # CL itself doesn't verify EL block hash
-    signed_block = state_transition_and_sign_block(spec, state, block)
-
-    yield 'blocks', [signed_block]
-    yield 'post', state
-
-
-@with_deneb_and_later
-@spec_state_test
-def test_zeroed_commitment(spec, state):
-    """
-    The blob is invalid, but the commitment is in correct form.
-    """
-    yield 'pre', state
-
-    block = build_empty_block_for_next_slot(spec, state)
-    opaque_tx, _, blob_kzg_commitments, _ = get_sample_opaque_tx(spec, blob_count=1, is_valid_blob=False)
-    assert all(commitment == b'\x00' * 48 for commitment in blob_kzg_commitments)
-    block.body.blob_kzg_commitments = blob_kzg_commitments
-    block.body.execution_payload.transactions = [opaque_tx]
-    block.body.execution_payload.block_hash = compute_el_block_hash(spec, block.body.execution_payload)
-    signed_block = state_transition_and_sign_block(spec, state, block)
-
-    yield 'blocks', [signed_block]
-    yield 'post', state

tests/generators/operations/main.py

@@ -36,7 +36,10 @@ if __name__ == "__main__":
     ]}
     capella_mods = combine_mods(_new_capella_mods, bellatrix_mods)
 
-    deneb_mods = capella_mods
+    _new_deneb_mods = {key: 'eth2spec.test.deneb.block_processing.test_process_' + key for key in [
+        'execution_payload',
+    ]}
+    deneb_mods = combine_mods(_new_deneb_mods, capella_mods)
 
     _new_eip6110_mods = {key: 'eth2spec.test.eip6110.block_processing.test_process_' + key for key in [
         'deposit_receipt',