Benchmark refactoring idea for readability

[LouisTsai-Csie]

Extend benchmark test wrapper logic to support calldata-aware splitting

Originally proposed by @jochem-brouwer in this comment.

The current benchmark test wrapper’s split-tx logic only works when the calldata remains unchanged. However, several benchmark tests rely on calldata as an index (e.g. for selecting storage slots), which prevents us from using the code generator and reduces overall code readability. We should find a way to support dynamic calldata in the split-tx logic.

Use EIP-7702 Delegation for Contract-Size Benchmarks

Originally proposed by @jochem-brouwer in this comment.

Benchmarking different contract sizes (just-created, small, medium, XEN) is cumbersome. We could use EIP-7702 by pre-creating a small set of delegated accounts with fixed storage sizes, then delegate them to different benchmark code as needed. This avoids redeploying contracts while preserving size characteristics.

The main caveat is cleanup: any SSTORE performed during a test must be reverted to the original values so tests can be re-run deterministically, especially in execute remote mode where genesis resets are not possible.

[madisoncarter1234]

Implementation Proposal: Benchmark Refactoring for Readability

1. Calldata-Aware Split-TX Logic

The current BenchmarkCodeGenerator assumes static calldata across split transactions. When calldata is used as an index (e.g., CALLDATALOAD(0) to select storage slots), the split-tx logic breaks because each workload TX needs unique calldata.

Proposed Solution: Calldata Factory Pattern

Extend BenchmarkCodeGenerator with a calldata generation callback:

class BenchmarkCodeGenerator(ABC):
    @abstractmethod
    def generate_workload_txs(
        self,
        pre: Alloc,
        fork: Fork,
    ) -> List[Transaction]:
        ...

    def calldata_for_iteration(self, iteration: int) -> bytes:
        """Override to provide dynamic calldata per split-TX iteration.
        
        Default: static empty calldata (current behavior).
        """
        return b""

Then in the split-tx execution loop:

for i, tx in enumerate(workload_txs):
    if generator.calldata_for_iteration != BenchmarkCodeGenerator.calldata_for_iteration:
        # Dynamic calldata - inject iteration-specific data
        tx = tx.copy(data=generator.calldata_for_iteration(i))
    block.add_tx(tx)

Example Usage - Storage Slot Indexing:

class StorageSlotBenchmark(BenchmarkCodeGenerator):
    def calldata_for_iteration(self, iteration: int) -> bytes:
        # Each TX targets a different storage slot
        return iteration.to_bytes(32, "big")
    
    def generate_workload_txs(self, pre, fork):
        # Contract uses CALLDATALOAD(0) as SLOAD/SSTORE key
        code = Op.SSTORE(Op.CALLDATALOAD(0), Op.ADD(Op.SLOAD(Op.CALLDATALOAD(0)), 1))
        ...

---

2. EIP-7702 Delegation for Contract-Size Benchmarks

Testing different contract sizes (newly created, small, medium, XEN-like) currently requires repetitive deployment. EIP-7702 enables pre-established delegated accounts that can be redirected to different benchmark implementations.

Proposed Solution: Delegated Benchmark Fixture

@pytest.fixture
def delegated_benchmark_accounts(pre: Alloc, fork: Fork) -> Dict[str, Address]:
    """Pre-establish accounts with fixed storage, delegatable to any code."""
    
    accounts = {}
    storage_configs = {
        "empty": {},
        "small": {i: i for i in range(10)},
        "medium": {i: i for i in range(1000)},
        "xen_like": {i: keccak256(i.to_bytes(32, "big")) for i in range(10000)},
    }
    
    for name, storage in storage_configs.items():
        # Create EOA with pre-populated storage via state override
        addr = pre.fund_eoa(amount=10**18, storage=storage)
        accounts[name] = addr
    
    return accounts

Benchmark Code Redirection:

def test_sload_benchmark(
    delegated_benchmark_accounts: Dict[str, Address],
    benchmark_code_templates: Dict[str, bytes],
):
    target = delegated_benchmark_accounts["xen_like"]
    
    # EIP-7702 authorization to delegate to benchmark code
    auth = AuthorizationTuple(
        chain_id=1,
        address=benchmark_code_templates["sload_loop"],
        nonce=0,
        signer=target,
    )
    
    tx = Transaction(
        type=0x04,  # EIP-7702
        authorization_list=[auth],
        to=target,
        # Now target executes sload_loop code against its pre-populated storage
    )

Storage Reset for Deterministic Re-execution:

To satisfy the constraint that storage writes must be reverted for remote execution:

class RevertibleStorageBenchmark(BenchmarkCodeGenerator):
    def generate_workload_txs(self, pre, fork):
        # Wrap benchmark in storage snapshot/restore
        code = (
            # Snapshot original values to memory
            Op.MSTORE(0, Op.SLOAD(Op.CALLDATALOAD(0))) +
            # Benchmark operations
            self.benchmark_ops() +
            # Restore original value
            Op.SSTORE(Op.CALLDATALOAD(0), Op.MLOAD(0))
        )
        ...

Or leverage TSTORE/TLOAD (EIP-1153) for inherently transient storage that auto-reverts:

# Transient storage benchmark - no explicit restore needed
code = While(
    condition=Op.LT(Op.MLOAD(0), iterations),
    body=Op.TSTORE(Op.MLOAD(0), Op.TLOAD(Op.MLOAD(0))) + Op.MSTORE(0, Op.ADD(Op.MLOAD(0), 1))
)

---

Implementation Phases

Phase 1: Add calldata_for_iteration() hook to BenchmarkCodeGenerator
Phase 2: Create delegated_benchmark_accounts fixture with EIP-7702 support
Phase 3: Implement storage-reset patterns (TSTORE or snapshot/restore)
Phase 4: Migrate existing repetitive benchmarks to new patterns

Happy to start working on a PR for Phase 1 if this direction looks good.