test_bloatnet_balance_extcodehash()

Documentation for tests/benchmark/stateful/bloatnet/test_multi_opcode.py::test_bloatnet_balance_extcodehash@88e9fb8f.

Generate fixtures for these test cases for Osaka with:

fill -v tests/benchmark/stateful/bloatnet/test_multi_opcode.py::test_bloatnet_balance_extcodehash -m stateful

BloatNet test using BALANCE + EXTCODEHASH with on-the-fly CREATE2 address generation.

This test: 1. Assumes contracts are already deployed via the factory 2. Generates CREATE2 addresses dynamically during execution 3. Calls BALANCE and EXTCODEHASH (order controlled by balance_first param) 4. Forces client to compute code hash for 24KB bytecode

Source code in tests/benchmark/stateful/bloatnet/test_multi_opcode.py

@pytest.mark.parametrize(
    "balance_first",
    [True, False],
    ids=["balance_extcodehash", "extcodehash_balance"],
)
@pytest.mark.valid_from("Prague")
def test_bloatnet_balance_extcodehash(
    blockchain_test: BlockchainTestFiller,
    pre: Alloc,
    fork: Fork,
    gas_benchmark_value: int,
    balance_first: bool,
) -> None:
    """
    BloatNet test using BALANCE + EXTCODEHASH with on-the-fly CREATE2
    address generation.

    This test:
    1. Assumes contracts are already deployed via the factory
    2. Generates CREATE2 addresses dynamically during execution
    3. Calls BALANCE and EXTCODEHASH (order controlled by balance_first param)
    4. Forces client to compute code hash for 24KB bytecode
    """
    gas_costs = fork.gas_costs()

    # Calculate gas costs
    intrinsic_gas = fork.transaction_intrinsic_cost_calculator()(calldata=b"")

    # Cost per contract access with CREATE2 address generation
    cost_per_contract = (
        gas_costs.G_KECCAK_256  # SHA3 static cost for address generation (30)
        + gas_costs.G_KECCAK_256_WORD * 3  # SHA3 dynamic cost (85 bytes = 3 words * 6)
        + gas_costs.G_COLD_ACCOUNT_ACCESS  # Cold access (2600)
        + gas_costs.G_BASE  # POP first result (2)
        + gas_costs.G_WARM_ACCOUNT_ACCESS  # Warm access (100)
        + gas_costs.G_BASE  # POP second result (2)
        + gas_costs.G_BASE  # DUP1 before first op (3)
        + gas_costs.G_VERY_LOW * 4  # PUSH1 operations (4 * 3)
        + gas_costs.G_LOW  # MLOAD for salt (3)
        + gas_costs.G_VERY_LOW  # ADD for increment (3)
        + gas_costs.G_LOW  # MSTORE salt back (3)
        + 10  # While loop overhead
    )

    # Calculate how many contracts to access based on available gas
    available_gas = gas_benchmark_value - intrinsic_gas - 1000  # Reserve for cleanup
    contracts_needed = int(available_gas // cost_per_contract)

    # Deploy factory using stub contract
    factory_address = pre.deploy_contract(
        code=Bytecode(),
        stub="bloatnet_factory",
    )

    # Log test requirements
    print(
        f"Test needs {contracts_needed} contracts for "
        f"{gas_benchmark_value / 1_000_000:.1f}M gas. "
        f"Factory storage will be checked during execution."
    )

    # Define operations that differ based on parameter
    balance_op = Op.POP(Op.BALANCE)
    extcodehash_op = Op.POP(Op.EXTCODEHASH)
    benchmark_ops = (
        (balance_op + extcodehash_op) if balance_first else (extcodehash_op + balance_op)
    )

    # Build attack contract that reads config from factory and performs attack
    attack_code = (
        # Call getConfig() on factory to get num_deployed and init_code_hash
        Op.STATICCALL(
            gas=Op.GAS,
            address=factory_address,
            args_offset=0,
            args_size=0,
            ret_offset=96,
            ret_size=64,
        )
        # Check if call succeeded
        + Op.ISZERO
        + Op.PUSH2(0x1000)  # Jump to error handler if failed
        + Op.JUMPI
        # Load results from memory
        + Op.MLOAD(96)  # Load num_deployed_contracts
        + Op.MLOAD(128)  # Load init_code_hash
        # Setup memory for CREATE2 address generation
        + Op.MSTORE(0, factory_address)
        + Op.MSTORE8(11, 0xFF)
        + Op.MSTORE(32, 0)  # Initial salt
        + Op.PUSH1(64)
        + Op.MSTORE  # Store init_code_hash
        # Main attack loop
        + While(
            body=(
                # Generate CREATE2 address
                Op.SHA3(11, 85)
                + Op.DUP1  # Duplicate for second operation
                + benchmark_ops  # Execute operations in specified order
                # Increment salt
                + Op.MSTORE(32, Op.ADD(Op.MLOAD(32), 1))
            ),
            condition=Op.DUP1 + Op.PUSH1(1) + Op.SWAP1 + Op.SUB + Op.DUP1 + Op.ISZERO + Op.ISZERO,
        )
        + Op.POP  # Clean up counter
    )

    # Deploy attack contract
    attack_address = pre.deploy_contract(code=attack_code)

    # Run the attack
    attack_tx = Transaction(
        to=attack_address,
        gas_limit=gas_benchmark_value,
        sender=pre.fund_eoa(),
    )

    # Post-state
    post = {
        attack_address: Account(storage={}),
    }

    blockchain_test(
        pre=pre,
        blocks=[Block(txs=[attack_tx])],
        post=post,
    )

Parametrized Test Cases

The interactive table below is also available as a standalone page.

Fork All Forks Prague Osaka

Fixture Type All Fixture Types blockchain_test

Test ID (Abbreviated)	balance_first
...fork_Prague-blockchain_test-balance_extcodehash	True
...fork_Prague-blockchain_test-extcodehash_balance	False
...fork_Osaka-blockchain_test-balance_extcodehash	True
...fork_Osaka-blockchain_test-extcodehash_balance	False