test_ether_transfers()

Documentation for tests/benchmark/compute/scenario/test_transaction_types.py::test_ether_transfers@21507778.

Generate fixtures for these test cases for Amsterdam with:

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

Single test for ether transfer scenarios.

Scenarios: - a_to_a: one sender → one sender - a_to_b: one sender → one receiver - diff_acc_to_b: multiple senders → one receiver - a_to_diff_acc: one sender → multiple receivers - diff_acc_to_diff_acc: multiple senders → multiple receivers

When warm_access is True, each transaction includes an access list entry for the receiver to warm the account before the transfer.

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

@pytest.mark.parametrize(
    "case_id",
    [
        "a_to_a",
        "a_to_b",
        "diff_acc_to_b",
        "a_to_diff_acc",
        "diff_acc_to_diff_acc",
    ],
)
@pytest.mark.parametrize("transfer_amount", [0, 1])
@pytest.mark.parametrize(
    "receiver_account_type",
    [
        pytest.param(
            ReceiverAccountType(balance=0, delegated=False),
            id="empty_account",
        ),
        pytest.param(
            ReceiverAccountType(balance=1, delegated=False),
            id="non_empty_account",
        ),
        pytest.param(
            ReceiverAccountType(balance=0, delegated=True),
            id="delegated_account",
        ),
    ],
)
@pytest.mark.parametrize("warm_access", [False, True])
def test_ether_transfers(
    benchmark_test: BenchmarkTestFiller,
    pre: Alloc,
    case_id: str,
    receiver_account_type: ReceiverAccountType,
    transfer_amount: int,
    fork: Fork,
    gas_benchmark_value: int,
    warm_access: bool,
    ether_transfer_case: Tuple[
        Generator[Address, None, None], Generator[Address, None, None]
    ],
) -> None:
    """
    Single test for ether transfer scenarios.

    Scenarios:
    - a_to_a: one sender → one sender
    - a_to_b: one sender → one receiver
    - diff_acc_to_b: multiple senders → one receiver
    - a_to_diff_acc: one sender → multiple receivers
    - diff_acc_to_diff_acc: multiple senders → multiple receivers

    When warm_access is True, each transaction includes an access list
    entry for the receiver to warm the account before the transfer.
    """
    senders, receivers = ether_transfer_case

    balance = receiver_account_type.balance

    txs = []
    token_transfers: dict[Address, int] = {}

    iteration_cost = fork.transaction_intrinsic_cost_calculator()(
        access_list=(
            [AccessList(address=Address(0x100), storage_keys=[])]
            if warm_access
            else None
        ),
    )
    iteration_count = gas_benchmark_value // iteration_cost

    for _ in range(iteration_count):
        receiver = next(receivers)
        token_transfers[receiver] = (
            token_transfers.get(receiver, 0) + transfer_amount
        )
        access_list = (
            [AccessList(address=receiver, storage_keys=[])]
            if warm_access
            else None
        )
        txs.append(
            Transaction(
                to=receiver,
                value=transfer_amount,
                gas_limit=iteration_cost,
                sender=next(senders),
                access_list=access_list,
            )
        )

    post_state = (
        {}
        if case_id == "a_to_a"
        else {
            receiver: Account(balance=balance + transferred_amount)
            for receiver, transferred_amount in token_transfers.items()
            if balance + transferred_amount > 0
        }
    )

    benchmark_test(
        pre=pre,
        post=post_state,
        blocks=[Block(txs=txs)],
        expected_benchmark_gas_used=iteration_count * iteration_cost,
    )

Parametrized Test Cases

This test generates 60 parametrized test cases across 3 forks.