fix(tools,tests): EIP-2935,7002,7251: Improve generate_system_contract_deploy_test

Author: marioevz

docs/CHANGELOG.md

@@ -20,6 +20,10 @@ Test fixtures for use by clients are available for each release on the [Github r
 
 - 🐞 Fix fixture tarball downloading with regular, non-Github release URLS and with numerical versions in regular release specs, e.g., `[email protected]` ([#1437](https://github.com/ethereum/execution-spec-tests/pull/1437)).
 
+#### Tools
+
+- 🔀 `generate_system_contract_deploy_test` test generator has been updated to handle system contracts that are not allowed to be absent when the fork happens ([#1394](https://github.com/ethereum/execution-spec-tests/pull/1394)).
+
 #### Exceptions
 
 - ✨ New exceptions `BlockException.SYSTEM_CONTRACT_EMPTY` and `BlockException.SYSTEM_CONTRACT_CALL_FAILED` to handle EIP updates [#9508](https://github.com/ethereum/EIPs/pull/9508) and [#9582](https://github.com/ethereum/EIPs/pull/9582) ([#1394](https://github.com/ethereum/execution-spec-tests/pull/1394)).
@@ -33,6 +37,7 @@ Test fixtures for use by clients are available for each release on the [Github r
 - ✨ [EIP-7251](https://eips.ethereum.org/EIPS/eip-7251): Add EIP-7251 test cases for modified consolidations contract that allows more consolidations ([#1465](https://github.com/ethereum/execution-spec-tests/pull/1465)).
 - ✨ [EIP-6110](https://eips.ethereum.org/EIPS/eip-6110): Add extra deposit request edge cases, sending eth to the deposit contract while sending a deposit request ([#1467](https://github.com/ethereum/execution-spec-tests/pull/1467)).
 - ✨ [EIP-7251](https://eips.ethereum.org/EIPS/eip-7251): Remove pytest skips for consolidation request cases ([#1449](https://github.com/ethereum/execution-spec-tests/pull/1449)).
+- ✨ [EIP-7002](https://eips.ethereum.org/EIPS/eip-7002), [EIP-7251](https://eips.ethereum.org/EIPS/eip-7251): Add cases to verify behavior of contracts missing at fork ([#1394](https://github.com/ethereum/execution-spec-tests/pull/1394)).
 
 ### 📋 Misc
 

src/ethereum_test_tools/utility/generators.py

@@ -8,6 +8,7 @@
 import pytest
 
 from ethereum_test_base_types import Account, Address, Hash
+from ethereum_test_exceptions import BlockException
 from ethereum_test_forks import Fork
 from ethereum_test_specs import BlockchainTestFiller
 from ethereum_test_specs.blockchain import Block
@@ -18,6 +19,7 @@ class DeploymentTestType(Enum):
     """Represents the type of deployment test."""
 
     DEPLOY_BEFORE_FORK = "deploy_before_fork"
+    DEPLOY_ON_FORK_BLOCK = "deploy_on_fork_block"
     DEPLOY_AFTER_FORK = "deploy_after_fork"
 
 
@@ -63,29 +65,33 @@ def generate_system_contract_deploy_test(
     fork: Fork,
     tx_json_path: Path,
     expected_deploy_address: Address,
+    fail_on_empty_code: bool,
     expected_system_contract_storage: Dict | None = None,
 ):
     """
     Generate a test that verifies the correct deployment of a system contract.
 
-    Generates four test cases:
+    Generates following test cases:
 
-                                        | before/after fork | has balance |
-    ------------------------------------|-------------------|-------------|
-    `deploy_before_fork-nonzero_balance`| before            | True        |
-    `deploy_before_fork-zero_balance`   | before            | False       |
-    `deploy_after_fork-nonzero_balance` | after             | True        |
-    `deploy_after_fork-zero_balance`    | after             | False       |
+                                          | before/after fork | fail on     | invalid block |
+                                          |                   | empty block |               |
+    --------------------------------------|-------------------|-------------|---------------|
+    `deploy_before_fork-nonzero_balance`  | before            | False       | False         |
+    `deploy_before_fork-zero_balance`     | before            | True        | False         |
+    `deploy_on_fork_block-nonzero_balance`| on fork block     | False       | False         |
+    `deploy_on_fork_block-zero_balance`   | on fork block     | True        | False         |
+    `deploy_after_fork-nonzero_balance`   | after             | False       | False         |
+    `deploy_after_fork-zero_balance`      | after             | True        | True          |
 
-    where `has balance` refers to whether the contract address has a non-zero balance before
-    deployment, or not.
+    The `has balance` parametrization does not have an effect on the expectation of the test.
 
     Args:
         fork (Fork): The fork to test.
         tx_json_path (Path): Path to the JSON file with the transaction to deploy the system
             contract.
             Providing a JSON file is useful to copy-paste the transaction from the EIP.
         expected_deploy_address (Address): The expected address of the deployed contract.
+        fail_on_empty_code (bool): If True, the test is expected to fail on empty code.
         expected_system_contract_storage (Dict | None): The expected storage of the system
             contract.
 
@@ -120,7 +126,11 @@ def decorator(func: SystemContractDeployTestFunction):
             "test_type",
             [
                 pytest.param(DeploymentTestType.DEPLOY_BEFORE_FORK),
-                pytest.param(DeploymentTestType.DEPLOY_AFTER_FORK),
+                pytest.param(DeploymentTestType.DEPLOY_ON_FORK_BLOCK),
+                pytest.param(
+                    DeploymentTestType.DEPLOY_AFTER_FORK,
+                    marks=[pytest.mark.exception_test] if fail_on_empty_code else [],
+                ),
             ],
             ids=lambda x: x.name.lower(),
         )
@@ -148,17 +158,40 @@ def wrapper(
                         timestamp=15_000,
                     ),
                 ]
-            elif test_type == DeploymentTestType.DEPLOY_AFTER_FORK:
+            elif test_type == DeploymentTestType.DEPLOY_ON_FORK_BLOCK:
                 blocks = [
-                    Block(  # Empty block on fork
-                        txs=[],
+                    Block(  # Deployment on fork block
+                        txs=[deploy_tx],
                         timestamp=15_000,
                     ),
-                    Block(  # Deployment block
-                        txs=[deploy_tx],
+                    Block(  # Empty block after fork
+                        txs=[],
                         timestamp=15_001,
                     ),
                 ]
+            elif test_type == DeploymentTestType.DEPLOY_AFTER_FORK:
+                blocks = [
+                    Block(  # Empty block on fork
+                        txs=[],
+                        timestamp=15_000,
+                        exception=BlockException.SYSTEM_CONTRACT_EMPTY
+                        if fail_on_empty_code
+                        else None,
+                    )
+                ]
+                if not fail_on_empty_code:
+                    blocks.append(
+                        Block(  # Deployment after fork block
+                            txs=[deploy_tx],
+                            timestamp=15_001,
+                        )
+                    )
+                    blocks.append(
+                        Block(  # Empty block after deployment
+                            txs=[],
+                            timestamp=15_002,
+                        ),
+                    )
             balance = 1 if has_balance == ContractAddressHasBalance.NONZERO_BALANCE else 0
             pre[expected_deploy_address] = Account(
                 code=b"",  # Remove the code that is automatically allocated on the fork
@@ -176,24 +209,23 @@ def wrapper(
             assert expected_deploy_address_int in fork_pre_allocation
             expected_code = fork_pre_allocation[expected_deploy_address_int]["code"]
             # Note: balance check is omitted; it may be modified by the underlying, decorated test
-            if expected_system_contract_storage is None:
-                post[expected_deploy_address] = Account(
-                    code=expected_code,
-                    nonce=1,
-                )
-            else:
-                post[expected_deploy_address] = Account(
-                    storage=expected_system_contract_storage,
-                    code=expected_code,
+            account_kwargs = {
+                "code": expected_code,
+                "nonce": 1,
+            }
+            if expected_system_contract_storage:
+                account_kwargs["storage"] = expected_system_contract_storage
+            if test_type != DeploymentTestType.DEPLOY_AFTER_FORK or not fail_on_empty_code:
+                post[expected_deploy_address] = Account(**account_kwargs)
+                post[deployer_address] = Account(
                     nonce=1,
                 )
-            post[deployer_address] = Account(
-                nonce=1,
-            )
 
             # Extra blocks (if any) returned by the decorated function to add after the
             # contract is deployed.
-            blocks += list(func(fork=fork, pre=pre, post=post, test_type=test_type))
+            if test_type != DeploymentTestType.DEPLOY_AFTER_FORK or not fail_on_empty_code:
+                # Only fill more blocks if the deploy block does not fail.
+                blocks += list(func(fork=fork, pre=pre, post=post, test_type=test_type))
 
             blockchain_test(
                 pre=pre,

tests/prague/eip2935_historical_block_hashes_from_state/test_contract_deployment.py

@@ -29,6 +29,7 @@
     fork=Prague,
     tx_json_path=Path(realpath(__file__)).parent / "contract_deploy_tx.json",
     expected_deploy_address=Address(Spec.HISTORY_STORAGE_ADDRESS),
+    fail_on_empty_code=False,
 )
 def test_system_contract_deployment(
     *,
@@ -50,11 +51,11 @@ def test_system_contract_deployment(
                     address=Spec.HISTORY_STORAGE_ADDRESS,
                     args_offset=0,
                     args_size=32,
-                    ret_offset=0,
+                    ret_offset=32,
                     ret_size=32,
                 ),
             )
-            + Op.SSTORE(block_number, Op.ISZERO(Op.ISZERO(Op.MLOAD(0))))
+            + Op.SSTORE(block_number, Op.ISZERO(Op.ISZERO(Op.MLOAD(32))))
             for block_number in range(1, 4)
         )
         + Op.STOP
@@ -78,6 +79,13 @@ def test_system_contract_deployment(
             2: 1,  # Fork block, hash should be there.
             3: 1,  # Empty block added at the start of this function, hash should be there.
         }
+    elif test_type == DeploymentTestType.DEPLOY_ON_FORK_BLOCK:
+        # The contract should have the block hashes after contract deployment.
+        storage = {
+            1: 1,  # Fork and deployment block, the first hash that gets added.
+            2: 1,  # Deployment block, hash should be there.
+            3: 1,  # Empty block added at the start of this function, hash should be there.
+        }
     elif test_type == DeploymentTestType.DEPLOY_AFTER_FORK:
         # The contract should have the block hashes after contract deployment.
         storage = {

tests/prague/eip7002_el_triggerable_withdrawals/test_contract_deployment.py

@@ -29,6 +29,7 @@
     fork=Prague,
     tx_json_path=Path(realpath(__file__)).parent / "contract_deploy_tx.json",
     expected_deploy_address=Address(Spec.WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS),
+    fail_on_empty_code=True,
 )
 def test_system_contract_deployment(
     *,

tests/prague/eip7251_consolidations/test_contract_deployment.py

@@ -29,6 +29,7 @@
     fork=Prague,
     tx_json_path=Path(realpath(__file__)).parent / "contract_deploy_tx.json",
     expected_deploy_address=Address(Spec.CONSOLIDATION_REQUEST_PREDEPLOY_ADDRESS),
+    fail_on_empty_code=True,
 )
 def test_system_contract_deployment(
     *,