test_ether_transfers()

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

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
    sends_value = transfer_amount > 0
    distinct_receivers = case_id in ("a_to_diff_acc", "diff_acc_to_diff_acc")

    if case_id == "a_to_a":
        recipient_type = RecipientType.SELF
    elif receiver_account_type.delegated:
        recipient_type = RecipientType.DELEGATION_7702
    else:
        recipient_type = RecipientType.CONTRACT

    warm_list = (
        [AccessList(address=Address(0x100), storage_keys=[])]
        if warm_access
        else None
    )

    transfer_cost = fork.transaction_intrinsic_cost_calculator()(
        access_list=warm_list,
        sends_value=sends_value,
        recipient_type=recipient_type,
    ) + fork.transaction_top_frame_execution_gas(
        sends_value=sends_value,
        recipient_type=recipient_type,
    )

    creates_account = (
        sends_value
        and balance == 0
        and not receiver_account_type.delegated
        and recipient_type != RecipientType.SELF
    )

    new_account_cost = (
        fork.transaction_top_frame_state_gas(
            sends_value=True,
            recipient_type=RecipientType.EMPTY_ACCOUNT,
        )
        if creates_account
        else 0
    )

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

    gas_used = 0
    tx_index = 0
    while True:
        creating = creates_account and (distinct_receivers or tx_index == 0)
        tx_cost = transfer_cost + (new_account_cost if creating else 0)
        if gas_used + tx_cost > gas_benchmark_value:
            break

        gas_used += tx_cost

        receiver = next(receivers)
        token_transfers[receiver] = (
            token_transfers.get(receiver, 0) + transfer_amount
        )

        txs.append(
            Transaction(
                to=receiver,
                value=transfer_amount,
                gas_limit=tx_cost,
                sender=next(senders),
                access_list=(
                    [AccessList(address=receiver, storage_keys=[])]
                    if warm_access
                    else None
                ),
            )
        )
        tx_index += 1

    post_state = (
        {}
        if recipient_type == RecipientType.SELF
        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=gas_used,
    )

Parametrized Test Cases

This test generates 60 parametrized test cases across 3 forks.