temp

LouisTsai-Csie · LouisTsai-Csie · commit 641036c2c1c3 · 2025-08-05T23:24:32.000+08:00
diff --git a/src/ethereum_test_specs/__init__.py b/src/ethereum_test_specs/__init__.py
@@ -3,6 +3,7 @@
 from .base import BaseTest, TestSpec
 from .base_static import BaseStaticTest
 from .benchmark import BenchmarkTest, BenchmarkTestFiller, BenchmarkTestSpec
+from .benchmark_state import BenchmarkStateTest, BenchmarkStateTestFiller, BenchmarkStateTestSpec
 from .blobs import BlobsTest, BlobsTestFiller, BlobsTestSpec
 from .blockchain import (
     BlockchainTest,
@@ -27,6 +28,9 @@
     "BenchmarkTest",
     "BenchmarkTestFiller",
     "BenchmarkTestSpec",
+    "BenchmarkStateTest",
+    "BenchmarkStateTestFiller",
+    "BenchmarkStateTestSpec",
     "BlobsTest",
     "BlobsTestFiller",
     "BlobsTestSpec",
diff --git a/src/ethereum_test_specs/benchmark_state.py b/src/ethereum_test_specs/benchmark_state.py
@@ -0,0 +1,160 @@
+"""Ethereum benchmark state test spec definition and filler."""
+
+import math
+from typing import Callable, ClassVar, Generator, List, Sequence, Type
+
+from ethereum_clis import TransitionTool
+from ethereum_test_base_types import HexNumber
+from ethereum_test_execution import (
+    BaseExecute,
+    ExecuteFormat,
+    LabeledExecuteFormat,
+    TransactionPost,
+)
+from ethereum_test_fixtures import (
+    BaseFixture,
+    BlockchainFixture,
+    FixtureFormat,
+    LabeledFixtureFormat,
+    StateFixture,
+)
+from ethereum_test_forks import Fork
+from ethereum_test_tools import Bytecode
+from ethereum_test_types import Alloc, Environment, Transaction
+
+from .base import BaseTest
+from .blockchain import Block, BlockchainTest
+
+
+class BenchmarkStateTest(BaseTest):
+    """
+    Test type designed specifically for benchmark state test cases.
+
+    This test type is designed specifically for benchmark state test cases and supports:
+    - High compatibility with state_test format
+    - Support for EIP-7825 transaction gas limit cap (2^24)
+    - Automatic splitting of tests when gas limit exceeds the cap
+    - Converts state_test format to blockchain_test format internally
+    """
+
+    pre: Alloc
+    post: Alloc
+    tx: Transaction
+    gas_benchmark_value: int
+    setup_bytecode: Bytecode
+    attack_bytecode: Bytecode
+    env: Environment
+
+    # Support both state test and blockchain test formats
+    supported_fixture_formats: ClassVar[Sequence[FixtureFormat | LabeledFixtureFormat]] = [
+        StateFixture,
+    ] + [
+        LabeledFixtureFormat(
+            fixture_format,
+            f"{fixture_format.format_name}_from_benchmark_state_test",
+            f"A {fixture_format.format_name} generated from a benchmark_state_test",
+        )
+        for fixture_format in BlockchainTest.supported_fixture_formats
+    ]
+
+    supported_execute_formats: ClassVar[Sequence[LabeledExecuteFormat]] = [
+        LabeledExecuteFormat(
+            TransactionPost,
+            "benchmark_state_test",
+            "An execute test derived from a benchmark state test",
+        ),
+    ]
+
+    def split_transaction(self, tx: Transaction, gas_limit_cap: int | None) -> List[Transaction]:
+        """Split a transaction that exceeds the gas limit cap into multiple transactions."""
+        if (gas_limit_cap is None) or (tx.gas_limit <= gas_limit_cap):
+            return [tx]
+
+        # Calculate how many transactions we need
+        total_gas = int(tx.gas_limit)
+        num_splits = math.ceil(total_gas / gas_limit_cap)
+
+        split_transactions = []
+        remaining_gas = total_gas
+        for i in range(num_splits):
+            split_tx = tx.model_copy()
+            # Use the cap for all transactions except the last one, which gets the remainder
+            split_tx.gas_limit = HexNumber(min(gas_limit_cap, remaining_gas))
+            split_tx.nonce = HexNumber(tx.nonce + i)
+            split_transactions.append(split_tx)
+            remaining_gas -= gas_limit_cap
+
+        return split_transactions
+
+    def _generate_state_test_fixture(self, t8n: TransitionTool, fork: Fork) -> StateFixture:
+        """Generate a state test fixture from this benchmark state test."""
+        # Create a temporary StateTest to generate the fixture
+        from .state import StateTest
+
+        state_test = StateTest(
+            env=self.env,
+            pre=self.pre,
+            post=self.post,
+            tx=self.tx,
+        )
+
+        return state_test.make_state_test_fixture(t8n, fork)
+
+    def generate_blockchain_test(self, fork: Fork) -> BlockchainTest:
+        """Create a BlockchainTest from this BenchmarkStateTest."""
+        # Convert single transaction to a block
+        gas_limit_cap = fork.transaction_gas_limit_cap()
+
+        transactions = self.split_transaction(self.tx, gas_limit_cap)
+
+        blocks = [Block(txs=transactions)]
+
+        return BlockchainTest.from_test(
+            base_test=self,
+            pre=self.pre,
+            post=self.post,
+            blocks=blocks,
+            genesis_environment=self.env,
+        )
+
+    def generate(
+        self,
+        t8n: TransitionTool,
+        fork: Fork,
+        fixture_format: FixtureFormat,
+    ) -> BaseFixture:
+        """Generate the test fixture."""
+        self.check_exception_test(exception=self.tx.error is not None)
+        if fixture_format in BlockchainTest.supported_fixture_formats:
+            return self.generate_blockchain_test(fork=fork).generate(
+                t8n=t8n, fork=fork, fixture_format=fixture_format
+            )
+        elif fixture_format == StateFixture:
+            gas_limit_cap = fork.transaction_gas_limit_cap()
+            transactions = self.split_transaction(self.tx, gas_limit_cap)
+
+            if len(transactions) == 1:
+                return self._generate_state_test_fixture(t8n, fork)
+            else:
+                return self.generate_blockchain_test(fork=fork).generate(
+                    t8n=t8n, fork=fork, fixture_format=BlockchainFixture
+                )
+
+        raise Exception(f"Unknown fixture format: {fixture_format}")
+
+    def execute(
+        self,
+        *,
+        fork: Fork,
+        execute_format: ExecuteFormat,
+    ) -> BaseExecute:
+        """Execute the benchmark state test by sending it to the live network."""
+        if execute_format == TransactionPost:
+            # Convert to blockchain test and use its execute method
+            blockchain_test = self.generate_blockchain_test(fork=fork)
+            return blockchain_test.execute(fork=fork, execute_format=execute_format)
+        raise Exception(f"Unsupported execute format: {execute_format}")
+
+
+BenchmarkStateTestSpec = Callable[[str], Generator[BenchmarkStateTest, None, None]]
+BenchmarkStateTestFiller = Type[BenchmarkStateTest]
diff --git a/src/ethereum_test_tools/__init__.py b/src/ethereum_test_tools/__init__.py
@@ -25,6 +25,8 @@
 from ethereum_test_fixtures import BaseFixture, FixtureCollector
 from ethereum_test_specs import (
     BaseTest,
+    BenchmarkStateTest,
+    BenchmarkStateTestFiller,
     BenchmarkTest,
     BenchmarkTestFiller,
     BlobsTest,
@@ -102,6 +104,8 @@
     "BaseTest",
     "BenchmarkTest",
     "BenchmarkTestFiller",
+    "BenchmarkStateTest",
+    "BenchmarkStateTestFiller",
     "Blob",
     "BlobsTest",
     "BlobsTestFiller",
diff --git a/tests/benchmark/test_benchmark_state_scenarios.py b/tests/benchmark/test_benchmark_state_scenarios.py
@@ -0,0 +1,79 @@
+"""
+Test file demonstrating the benchmark_state_test usage scenarios.
+
+This file shows how BenchmarkStateTest can be used to convert state_test format
+to blockchain_test format with EIP-7825 support.
+"""
+
+import pytest
+
+from ethereum_test_tools import (
+    Alloc,
+    BenchmarkStateTestFiller,
+    Bytecode,
+    Environment,
+    Transaction,
+)
+
+
+@pytest.mark.valid_from("Osaka")
+def test_benchmark_state_basic_scenario(
+    benchmark_state_test: BenchmarkStateTestFiller,
+    pre: Alloc,
+    env: Environment,
+):
+    """
+    Basic scenario: Convert state_test format to blockchain_test format.
+
+    This demonstrates how BenchmarkStateTest converts a single transaction
+    into a blockchain_test format internally.
+    """
+    tx = Transaction(
+        to=pre.fund_eoa(),
+        value=1,
+        gas_limit=21000,  # Standard transfer gas
+        sender=pre.fund_eoa(),
+    )
+
+    # Use state_test format - this will be converted to blockchain_test format
+    benchmark_state_test(
+        env=env,
+        pre=pre,
+        post={},
+        tx=tx,
+        gas_benchmark_value=30_000_000,
+        setup_bytecode=Bytecode(b""),
+        attack_bytecode=Bytecode(b""),
+    )
+
+
+@pytest.mark.valid_from("Osaka")
+def test_benchmark_state_eip7825_gas_limit_cap(
+    benchmark_state_test: BenchmarkStateTestFiller,
+    pre: Alloc,
+    env: Environment,
+):
+    """
+    Test EIP-7825 transaction gas limit cap functionality.
+
+    This test demonstrates how BenchmarkStateTest automatically handles transaction splitting
+    when the gas limit exceeds the 2^24 cap introduced in Osaka.
+    """
+    # Create a transaction with gas limit that exceeds the cap (2^24 = 16,777,216)
+    tx = Transaction(
+        to=pre.fund_eoa(),
+        value=1,
+        gas_limit=20_000_000,  # Exceeds the 2^24 cap
+        sender=pre.fund_eoa(),
+    )
+
+    # This should automatically split the transaction due to EIP-7825
+    benchmark_state_test(
+        env=env,
+        pre=pre,
+        post={},
+        tx=tx,
+        gas_benchmark_value=30_000_000,
+        setup_bytecode=Bytecode(b""),
+        attack_bytecode=Bytecode(b""),
+    )
diff --git a/tests/benchmark/test_worst_blocks.py b/tests/benchmark/test_worst_blocks.py
@@ -14,7 +14,7 @@
     Alloc,
     BenchmarkTestFiller,
     Block,
-    BlockchainTestFiller,
+    Environment,
     StateTestFiller,
     Transaction,
 )
@@ -151,7 +151,6 @@ def test_block_full_of_ether_transfers(
         else {receiver: Account(balance=balance) for receiver, balance in balances.items()}
     )
 
-    blockchain_test(
     benchmark_test(
         genesis_environment=env,
         pre=pre,
