feat(benchmark): add code generator to generate transaction

Author: LouisTsai-Csie

src/ethereum_test_specs/benchmark.py

@@ -128,7 +128,9 @@ def generate_blockchain_test(self, fork: Fork) -> BlockchainTest:
                 genesis_environment=self.env,
             )
         else:
-            raise ValueError("Cannot create BlockchainTest without transactions or blocks")
+            raise ValueError(
+                "Cannot create BlockchainTest without transactions, blocks, or code_generator"
+            )
 
     def generate(
         self,

src/ethereum_test_specs/benchmark_state.py

@@ -29,7 +29,6 @@
 )
 from ethereum_test_forks import Fork
 from ethereum_test_types import Alloc, Environment, Transaction
-from ethereum_test_vm import Bytecode
 
 from .base import BaseTest, OpMode
 from .blockchain import Block, BlockchainTest
@@ -44,8 +43,6 @@ class BenchmarkStateTest(BaseTest):
     post: Alloc
     tx: Transaction
     gas_benchmark_value: int
-    setup_bytecode: Bytecode | None = None
-    attack_bytecode: Bytecode | None = None
     env: Environment
     chain_id: int = 1
 

src/ethereum_test_tools/__init__.py

@@ -78,6 +78,11 @@
     call_return_code,
 )
 
+from .benchmark_code_generator import (
+    BenchmarkCodeGenerator,
+    ExtCallGenerator,
+    JumpLoopGenerator,
+)
 from .code import (
     CalldataCase,
     Case,
@@ -102,6 +107,7 @@
     "AuthorizationTuple",
     "BaseFixture",
     "BaseTest",
+    "BenchmarkCodeGenerator",
     "BenchmarkTest",
     "BenchmarkTestFiller",
     "BenchmarkStateTest",
@@ -120,6 +126,7 @@
     "CodeGasMeasure",
     "Conditional",
     "ConsolidationRequest",
+    "ExtCallGenerator",
     "DeploymentTestType",
     "DepositRequest",
     "EngineAPIError",
@@ -135,6 +142,7 @@
     "Hash",
     "Header",
     "Initcode",
+    "JumpLoopGenerator",
     "Macro",
     "Macros",
     "NetworkWrappedTransaction",

src/ethereum_test_tools/benchmark_code_generator.py

@@ -0,0 +1,96 @@
+"""Benchmark code generator classes for creating optimized bytecode patterns."""
+
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from ethereum_test_forks import Fork
+from ethereum_test_tools import Alloc, Bytecode, Transaction
+from ethereum_test_tools.vm.opcode import Opcodes as Op
+
+
+class BenchmarkCodeGenerator(ABC):
+    """Abstract base class for generating benchmark bytecode."""
+
+    def __init__(
+        self,
+        fork: Fork,
+        attack_block: Bytecode,
+        setup: Optional[Bytecode] = None,
+    ):
+        """Initialize with fork, attack block, and optional setup bytecode."""
+        self.fork = fork
+        self.setup = setup or Bytecode()
+        self.attack_block = attack_block
+
+    @abstractmethod
+    def generate_transaction(self, pre: Alloc, gas_limit: int) -> Transaction:
+        """Generate a transaction with the specified gas limit."""
+        pass
+
+    def generate_repeated_code(self, repeated_code: Bytecode, setup: Bytecode) -> Bytecode:
+        """Calculate the maximum number of iterations that can fit in the code size limit."""
+        max_code_size = self.fork.max_code_size()
+
+        overhead = len(Op.JUMPDEST) + len(Op.JUMP(len(setup)))
+        available_space = max_code_size - overhead
+        max_iterations = available_space // len(repeated_code) if len(repeated_code) > 0 else 0
+
+        code = setup + Op.JUMPDEST + repeated_code * max_iterations + Op.JUMP(len(setup))
+
+        self._validate_code_size(code)
+
+        return code
+
+    def _validate_code_size(self, code: Bytecode) -> None:
+        """Validate that the generated code fits within size limits."""
+        if len(code) > self.fork.max_code_size():
+            raise ValueError(
+                f"Generated code size {len(code)} exceeds maximum allowed size "
+                f"{self.fork.max_code_size()}"
+            )
+
+
+class JumpLoopGenerator(BenchmarkCodeGenerator):
+    """Generates bytecode that loops execution using JUMP operations."""
+
+    def generate_transaction(self, pre: Alloc, gas_limit: int) -> Transaction:
+        """Generate transaction with looping bytecode pattern."""
+        # Benchmark Test Structure:
+        # setup + JUMPDEST + attack + attack + ... + attack + JUMP(setup_length)
+
+        code = self.generate_repeated_code(self.attack_block, self.setup)
+
+        return Transaction(
+            to=pre.deploy_contract(code=code),
+            gas_limit=self.fork.transaction_gas_limit_cap() or 30_000_000,
+            sender=pre.fund_eoa(),
+        )
+
+
+class ExtCallGenerator(BenchmarkCodeGenerator):
+    """Generates bytecode that fills the contract to maximum allowed code size."""
+
+    def generate_transaction(self, pre: Alloc, gas_limit: int) -> Transaction:
+        """Generate transaction with maximal code size coverage."""
+        # Benchmark Test Structure:
+        # There are two contracts:
+        # 1. The target contract that executes certain operation but not loop (e.g. PUSH)
+        # 2. The loop contract that calls the target contract in a loop
+        #
+        # attack = POP(STATICCALL(GAS, target_contract_address, 0, 0, 0, 0))
+        # setup + JUMPDEST + attack + attack + ... + attack + JUMP(setup_lengt)
+        # This could optimize the gas consumption and increase the cycle count.
+
+        max_stack_height = self.fork.max_stack_height()
+
+        target_contract_address = pre.deploy_contract(code=self.attack_block * max_stack_height)
+
+        code_sequence = Op.POP(Op.STATICCALL(Op.GAS, target_contract_address, 0, 0, 0, 0))
+
+        code = self.generate_repeated_code(code_sequence, Bytecode())
+
+        return Transaction(
+            to=pre.deploy_contract(code=code),
+            gas_limit=self.fork.transaction_gas_limit_cap() or 30_000_000,
+            sender=pre.fund_eoa(),
+        )

tests/benchmark/test_worst_compute.py

@@ -28,6 +28,7 @@
     Transaction,
     add_kzg_version,
 )
+from ethereum_test_tools.benchmark_code_generator import JumpLoopGenerator
 from ethereum_test_tools.vm.opcode import Opcodes as Op
 from ethereum_test_types import TransactionType
 from ethereum_test_vm.opcode import Opcode
@@ -1829,27 +1830,19 @@ def test_worst_jumpis(
 @pytest.mark.valid_from("Cancun")
 @pytest.mark.slow
 def test_worst_jumpdests(
-    state_test: StateTestFiller,
+    benchmark_state_test: BenchmarkStateTestFiller,
     pre: Alloc,
+    env: Environment,
     fork: Fork,
     gas_benchmark_value: int,
 ):
     """Test running a JUMPDEST-intensive contract."""
-    max_code_size = fork.max_code_size()
+    generator = JumpLoopGenerator(fork, Op.JUMPDEST)
+    tx = generator.generate_transaction(pre, gas_benchmark_value)
 
-    # Create and deploy a contract with many JUMPDESTs
-    code_suffix = Op.JUMP(Op.PUSH0)
-    code_body = Op.JUMPDEST * (max_code_size - len(code_suffix))
-    code = code_body + code_suffix
-    jumpdests_address = pre.deploy_contract(code=code)
-
-    tx = Transaction(
-        to=jumpdests_address,
-        gas_limit=gas_benchmark_value,
-        sender=pre.fund_eoa(),
-    )
-
-    state_test(
+    benchmark_state_test(
+        env=env,
+        gas_benchmark_value=gas_benchmark_value,
         pre=pre,
         post={},
         tx=tx,
@@ -2780,7 +2773,6 @@ def test_worst_swap(
 
     tx = Transaction(
         to=pre.deploy_contract(code=code),
-        gas_limit=gas_benchmark_value,
         sender=pre.fund_eoa(),
     )