Merge branch 'eip-7251-eip-2935-contracts-update' into pectra-devnet-5

Author: marioevz

docs/CHANGELOG.md

@@ -67,6 +67,7 @@ Test fixtures for use by clients are available for each release on the [Github r
 - ✨ Add a default location for evm logs (`--evm-dump-dir`) when filling tests ([#999](https://github.com/ethereum/execution-spec-tests/pull/999)).
 - ✨ Slow tests now have greater timeout when making a request to the T8N server ([#1037](https://github.com/ethereum/execution-spec-tests/pull/1037)).
 - ✨ Disable EIP-7742 framework changes for Prague ([#1023](https://github.com/ethereum/execution-spec-tests/pull/1023)).
+- 🔀 Update EIP-7251, EIP-7002 and EIP-2935 according to spec updates ([#1024](https://github.com/ethereum/execution-spec-tests/pull/1024))
 
 ### 🔧 EVM Tools
 

src/ethereum_test_base_types/base_types.py

@@ -211,6 +211,12 @@ def sha256(self) -> "Hash":
         """
         return Hash(sha256(self).digest())
 
+    def int(self) -> int:
+        """
+        Returns the integer representation of the bytes.
+        """
+        return int.from_bytes(self, "big")
+
 
 S = TypeVar("S", bound="FixedSizeHexNumber")
 

src/ethereum_test_forks/forks/contracts/consolidation_request.bin

@@ -1253,9 +1253,9 @@ def system_contracts(cls, block_number: int = 0, timestamp: int = 0) -> List[Add
         """
         return [
             Address(0x00000000219AB540356CBB839CBE05303D7705FA),
-            Address(0x09FC772D0857550724B07B850A4323F39112AAAA),
-            Address(0x01ABEA29659E5E97C95107F20BB753CD3E09BBBB),
-            Address(0x0AAE40965E6800CD9B1F4B05FF21581047E3F91E),
+            Address(0x0C15F14308530B7CDB8460094BBB9CC28B9AAAAA),
+            Address(0x00431F263CE400F4455C2DCF564E53007CA4BBBB),
+            Address(0x0F792BE4B0C0CB4DAE440EF133E90C0ECD48CCCC),
         ] + super(Prague, cls).system_contracts(block_number, timestamp)
 
     @classmethod
@@ -1397,7 +1397,7 @@ def pre_allocation_blockchain(cls) -> Mapping:
         with open(CURRENT_FOLDER / "contracts" / "withdrawal_request.bin", mode="rb") as f:
             new_allocation.update(
                 {
-                    0x09FC772D0857550724B07B850A4323F39112AAAA: {
+                    0x0C15F14308530B7CDB8460094BBB9CC28B9AAAAA: {
                         "nonce": 1,
                         "code": f.read(),
                     },
@@ -1408,7 +1408,7 @@ def pre_allocation_blockchain(cls) -> Mapping:
         with open(CURRENT_FOLDER / "contracts" / "consolidation_request.bin", mode="rb") as f:
             new_allocation.update(
                 {
-                    0x01ABEA29659E5E97C95107F20BB753CD3E09BBBB: {
+                    0x00431F263CE400F4455C2DCF564E53007CA4BBBB: {
                         "nonce": 1,
                         "code": f.read(),
                     },
@@ -1419,7 +1419,7 @@ def pre_allocation_blockchain(cls) -> Mapping:
         with open(CURRENT_FOLDER / "contracts" / "history_contract.bin", mode="rb") as f:
             new_allocation.update(
                 {
-                    0x0AAE40965E6800CD9B1F4B05FF21581047E3F91E: {
+                    0x0F792BE4B0C0CB4DAE440EF133E90C0ECD48CCCC: {
                         "nonce": 1,
                         "code": f.read(),
                     }

src/ethereum_test_forks/forks/contracts/history_contract.bin

@@ -82,6 +82,7 @@
     Yul,
     YulCompiler,
 )
+from .utility.generators import generate_system_contract_deploy_test
 from .utility.pytest import extend_with_defaults
 
 __all__ = (
@@ -155,6 +156,7 @@
     "compute_create2_address",
     "compute_eofcreate_address",
     "extend_with_defaults",
+    "generate_system_contract_deploy_test",
     "keccak256",
     "vm",
 )

src/ethereum_test_forks/forks/forks.py

@@ -0,0 +1,181 @@
+"""
+Test generator decorators.
+"""
+
+import json
+from enum import Enum
+from pathlib import Path
+from typing import Dict, Generator, List, Protocol, Tuple
+
+import pytest
+
+from ethereum_test_base_types import Account, Address
+from ethereum_test_forks import Fork
+from ethereum_test_specs import BlockchainTestFiller
+from ethereum_test_specs.blockchain import Block, Header
+from ethereum_test_types import Alloc, Transaction
+
+
+class SystemContractDeployTestFunction(Protocol):
+    """
+    Represents a function to be decorated with the `generate_system_contract_deploy_test`
+    decorator.
+    """
+
+    def __call__(
+        self,
+        *,
+        fork: Fork,
+        pre: Alloc,
+    ) -> Generator[Tuple[Transaction | None, Header | None], None, None]:
+        """
+        Args:
+            fork (Fork): The fork to test.
+            pre (Alloc): The pre state of the blockchain.
+
+        Yields:
+            Tuple[Transaction | None, Header | None]: Once per block to add after the contract is
+                deployed, with a single transaction to execute and the header object used to
+                verify the block.
+        """
+        ...
+
+
+def generate_system_contract_deploy_test(
+    fork: Fork,
+    tx_json_path: Path,
+    expected_deploy_address: Address,
+    expected_system_contract_storage: Dict | None,
+):
+    """
+    Decorator to generate a test that verifies the correct deployment of a system contract.
+
+    Generates two tests:
+    - One that deploys the contract before the fork.
+    - One that deploys the contract after the fork.
+
+    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.
+        expected_system_contract_storage (Dict): The expected storage of the system contract.
+    """
+    DeploymentTestType = Enum(
+        "DeploymentTestType",
+        [
+            "DEPLOY_BEFORE_FORK",
+            "DEPLOY_AFTER_FORK",
+        ],
+    )
+
+    with open(tx_json_path, mode="r") as f:
+        tx_json = json.loads(f.read())
+    if "gasLimit" not in tx_json and "gas" in tx_json:
+        tx_json["gasLimit"] = tx_json["gas"]
+        del tx_json["gas"]
+    if "protected" not in tx_json:
+        tx_json["protected"] = False
+    deploy_tx = Transaction.model_validate(tx_json).with_signature_and_sender()  # type: ignore
+    gas_price = deploy_tx.gas_price
+    assert gas_price is not None
+    deployer_required_balance = deploy_tx.gas_limit * gas_price
+    deployer_address = deploy_tx.sender
+
+    def decorator(func: SystemContractDeployTestFunction):
+        @pytest.mark.parametrize(
+            "test_type",
+            [
+                pytest.param(DeploymentTestType.DEPLOY_BEFORE_FORK),
+                pytest.param(DeploymentTestType.DEPLOY_AFTER_FORK),
+            ],
+            ids=lambda x: x.name.lower(),
+        )
+        @pytest.mark.execute(pytest.mark.skip(reason="modifies pre-alloc"))
+        @pytest.mark.valid_at_transition_to(fork.name())
+        def wrapper(
+            blockchain_test: BlockchainTestFiller,
+            pre: Alloc,
+            test_type: DeploymentTestType,
+            fork: Fork,
+        ):
+
+            assert deployer_address is not None
+            assert deploy_tx.created_contract == expected_deploy_address
+            blocks: List[Block] = []
+
+            if test_type == DeploymentTestType.DEPLOY_BEFORE_FORK:
+                blocks = [
+                    Block(  # Deployment block
+                        txs=[deploy_tx],
+                        timestamp=14_999,
+                    ),
+                    Block(  # Empty block on fork
+                        txs=[],
+                        timestamp=15_000,
+                    ),
+                ]
+            elif test_type == DeploymentTestType.DEPLOY_AFTER_FORK:
+                blocks = [
+                    Block(  # Empty block on fork
+                        txs=[],
+                        timestamp=15_000,
+                    ),
+                    Block(  # Deployment block
+                        txs=[deploy_tx],
+                        timestamp=15_001,
+                    ),
+                ]
+
+            for tx_header_verify in func(fork=fork, pre=pre):
+                txs = []
+                if tx_header_verify[0] is not None:
+                    txs.append(tx_header_verify[0])
+                header_verify = tx_header_verify[1]
+                blocks.append(
+                    Block(
+                        txs=txs,
+                        header_verify=header_verify,
+                    )
+                )
+
+            pre[expected_deploy_address] = Account(
+                code=b"",  # Remove the code that is automatically allocated on the fork
+                nonce=0,
+                balance=0,
+            )
+            pre[deployer_address] = Account(
+                balance=deployer_required_balance,
+            )
+
+            post = {}
+            fork_pre_allocation = fork.pre_allocation_blockchain()
+            assert expected_deploy_address.int() in fork_pre_allocation
+            expected_code = fork_pre_allocation[expected_deploy_address.int()]["code"]
+            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,
+                    nonce=1,
+                )
+            post[deployer_address] = Account(
+                nonce=1,
+            )
+            blockchain_test(
+                pre=pre,
+                blocks=blocks,
+                post=post,
+            )
+
+        wrapper.__name__ = func.__name__  # type: ignore
+        wrapper.__doc__ = func.__doc__  # type: ignore
+
+        return wrapper
+
+    return decorator

src/ethereum_test_tools/__init__.py

@@ -0,0 +1,15 @@
+{
+  "type": "0x0",
+  "nonce": "0x0",
+  "to": null,
+  "gas": "0x3d090",
+  "gasPrice": "0xe8d4a51000",
+  "maxPriorityFeePerGas": null,
+  "maxFeePerGas": null,
+  "value": "0x0",
+  "input": "0x60538060095f395ff33373fffffffffffffffffffffffffffffffffffffffe14604657602036036042575f35600143038111604257611fff81430311604257611fff9006545f5260205ff35b5f5ffd5b5f35611fff60014303065500",
+  "v": "0x1b",
+  "r": "0x539",
+  "s": "0xbaefe09f0109759",
+  "hash": "0x8c7bd2d3713a0b2bb693463d2a78c4d612ac47dd38ecb74f8996a4b6fc96f03c"
+}

src/ethereum_test_tools/utility/generators.py

@@ -15,7 +15,7 @@ class ReferenceSpec:
     version: str
 
 
-ref_spec_2935 = ReferenceSpec("EIPS/eip-2935.md", "68d54a80a4f5b9c0cf4ae3a10586d63ef221de36")
+ref_spec_2935 = ReferenceSpec("EIPS/eip-2935.md", "a04da454a5a6ba86a87bb9e15f811feaff3c849a")
 
 
 @dataclass(frozen=True)
@@ -26,6 +26,6 @@ class Spec:
     """
 
     FORK_TIMESTAMP = 15_000
-    HISTORY_STORAGE_ADDRESS = 0x0AAE40965E6800CD9B1F4B05FF21581047E3F91E
-    HISTORY_SERVE_WINDOW = 8192
+    HISTORY_STORAGE_ADDRESS = 0x0F792BE4B0C0CB4DAE440EF133E90C0ECD48CCCC
+    HISTORY_SERVE_WINDOW = 8191
     BLOCKHASH_OLD_WINDOW = 256

tests/prague/eip2935_historical_block_hashes_from_state/contract_deploy_tx.json

@@ -302,9 +302,9 @@ def test_block_hashes_history(
 @pytest.mark.parametrize(
     "block_number,reverts",
     [
-        pytest.param(1, False, id="current_block"),
-        pytest.param(2, False, id="future_block"),
-        pytest.param(2**64 - 1, False, id="2**64-1"),
+        pytest.param(1, True, id="current_block"),
+        pytest.param(2, True, id="future_block"),
+        pytest.param(2**64 - 1, True, id="2**64-1"),
         pytest.param(2**64, True, id="2**64"),
     ],
 )
@@ -328,13 +328,24 @@ def test_invalid_history_contract_calls(
     returned_block_hash_slot = storage.store_next(0)
     block_hash_opcode_slot = storage.store_next(0)
 
+    return_offset = 64
+    return_size = 32
+    args_size = 32
+
     # Check the first block outside of the window if any
     code = (
         Op.MSTORE(0, block_number)
         + Op.SSTORE(
-            return_code_slot, Op.CALL(Op.GAS, Spec.HISTORY_STORAGE_ADDRESS, 0, 0, 32, 32, 64)
+            return_code_slot,
+            Op.CALL(
+                address=Spec.HISTORY_STORAGE_ADDRESS,
+                args_offset=0,
+                args_size=args_size,
+                ret_offset=return_offset,
+                ret_size=return_size,
+            ),
         )
-        + Op.SSTORE(returned_block_hash_slot, Op.MLOAD(32))
+        + Op.SSTORE(returned_block_hash_slot, Op.MLOAD(return_offset))
         + Op.SSTORE(block_hash_opcode_slot, Op.BLOCKHASH(block_number))
     )
     check_contract_address = pre.deploy_contract(code, storage=storage.canary())
@@ -355,3 +366,65 @@ def test_invalid_history_contract_calls(
         post=post,
         reverts=reverts,
     )
+
+
+@pytest.mark.parametrize(
+    "args_size,reverts",
+    [
+        pytest.param(0, True, id="zero_size"),
+        pytest.param(33, True, id="too_large"),
+        pytest.param(31, True, id="too_small"),
+    ],
+)
+@pytest.mark.valid_from("Prague")
+def test_invalid_history_contract_calls_input_size(
+    blockchain_test: BlockchainTestFiller,
+    pre: Alloc,
+    reverts: bool,
+    args_size: int,
+):
+    """
+    Test calling the history contract with invalid input sizes.
+    """
+    storage = Storage()
+
+    return_code_slot = storage.store_next(not reverts)
+    returned_block_hash_slot = storage.store_next(0)
+
+    return_offset = 64
+    return_size = 32
+    block_number = 0
+
+    # Check the first block outside of the window if any
+    code = (
+        Op.MSTORE(0, block_number)
+        + Op.SSTORE(
+            return_code_slot,
+            Op.CALL(
+                address=Spec.HISTORY_STORAGE_ADDRESS,
+                args_offset=0,
+                args_size=args_size,
+                ret_offset=return_offset,
+                ret_size=return_size,
+            ),
+        )
+        + Op.SSTORE(returned_block_hash_slot, Op.MLOAD(return_offset))
+    )
+    check_contract_address = pre.deploy_contract(code, storage=storage.canary())
+
+    txs = [
+        Transaction(
+            to=check_contract_address,
+            gas_limit=10_000_000,
+            sender=pre.fund_eoa(),
+        )
+    ]
+    post = {check_contract_address: Account(storage=storage)}
+
+    blocks = [Block(txs=txs)]
+    blockchain_test(
+        pre=pre,
+        blocks=blocks,
+        post=post,
+        reverts=reverts,
+    )