test_auth_transaction()

Documentation for tests/benchmark/compute/scenario/test_transaction_types.py::test_auth_transaction@892e6d1e.

Generate fixtures for these test cases for Amsterdam with:

fill -v tests/benchmark/compute/scenario/test_transaction_types.py::test_auth_transaction --gas-benchmark-values 1

Test an auth block.

Source code in tests/benchmark/compute/scenario/test_transaction_types.py

@pytest.mark.parametrize("empty_authority", [True, False])
@pytest.mark.parametrize("zero_delegation", [True, False])
@pytest.mark.parametrize("empty_account", [True, False])
@pytest.mark.parametrize("transfer_amount", [True, False])
def test_auth_transaction(
    benchmark_test: BenchmarkTestFiller,
    pre: Alloc,
    gas_benchmark_value: int,
    fork: Fork,
    empty_authority: bool,
    empty_account: bool,
    transfer_amount: int,
    zero_delegation: bool,
    tx_gas_limit: int,
) -> None:
    """Test an auth block."""
    gas_costs = fork.gas_costs()
    intrinsic_cost_calc = fork.transaction_intrinsic_cost_calculator()

    code = Op.INVALID * fork.max_code_size()
    auth_target = (
        Address(0) if zero_delegation else pre.deploy_contract(code=code)
    )

    remaining_gas = gas_benchmark_value
    authorizations_per_tx: List[int] = []

    min_authorization_intrinsic_gas = intrinsic_cost_calc(
        authorization_list_or_count=1
    )

    while remaining_gas >= min_authorization_intrinsic_gas:
        tx_max_gas = min(remaining_gas, tx_gas_limit)

        low = 1
        high = 2

        # Exponential search to find upper bound
        while (
            intrinsic_cost_calc(authorization_list_or_count=high) < tx_max_gas
        ):
            low = high
            high *= 2

        # Binary search for exact fit
        while low < high:
            mid = (low + high) // 2

            if (
                intrinsic_cost_calc(authorization_list_or_count=mid)
                > tx_max_gas
            ):
                high = mid
            else:
                low = mid + 1

        best_iterations = low - 1
        authorizations_per_tx.append(best_iterations)
        remaining_gas -= intrinsic_cost_calc(
            authorization_list_or_count=best_iterations
        )

    total_gas_used = 0
    total_refund = 0
    txs = []

    for auths_in_this_tx in authorizations_per_tx:
        auth_tuples = []
        for _ in range(auths_in_this_tx):
            signer = (
                pre.fund_eoa(amount=0, delegation=None)
                if empty_authority
                else pre.fund_eoa(amount=0, delegation=auth_target)
            )
            auth_tuple = AuthorizationTuple(
                address=auth_target, nonce=signer.nonce, signer=signer
            )
            auth_tuples.append(auth_tuple)

        tx_gas_used = intrinsic_cost_calc(
            authorization_list_or_count=auth_tuples
        )
        total_gas_used += tx_gas_used

        if not empty_authority:
            total_refund += min(
                tx_gas_used // 5,
                (
                    gas_costs.AUTH_PER_EMPTY_ACCOUNT
                    - gas_costs.REFUND_AUTH_PER_EXISTING_ACCOUNT
                )
                * auths_in_this_tx,
            )

        receiver = pre.fund_eoa(0 if empty_account else 1)

        txs.append(
            Transaction(
                to=receiver,
                value=transfer_amount,
                gas_limit=tx_gas_used,
                sender=pre.fund_eoa(),
                authorization_list=auth_tuples,
            )
        )

    # EIP-7778: refunds no longer reduce block-level gas accounting
    expected_gas_usage = (
        total_gas_used
        if fork.is_eip_enabled(7778)
        else total_gas_used - total_refund
    )

    benchmark_test(
        pre=pre,
        post={},
        blocks=[Block(txs=txs)],
        expected_benchmark_gas_used=expected_gas_usage,
    )

Parametrized Test Cases

This test generates 16 parametrized test cases across 3 forks.