Test Blob Txs

Documentation for test cases from tests/cancun/eip4844_blobs/test_blob_txs.py.

Generate fixtures for these test cases for Cancun with:

Cancun only:

fill -v tests/cancun/eip4844_blobs/test_blob_txs.py --fork=Cancun --evm-bin=/path/to/evm-tool-dev-version

For all forks up to and including Cancun:

fill -v tests/cancun/eip4844_blobs/test_blob_txs.py --until=Cancun --evm-bin=/path/to/evm-tool-dev-version

Tests blob type transactions for EIP-4844: Shard Blob Transactions

Test blob type transactions for EIP-4844: Shard Blob Transactions.

Adding a new test

Add a function that is named test_<test_name> and takes at least the following arguments:

• blockchain_test
• pre
• env
• blocks

All other pytest.fixture fixtures can be parametrized to generate new combinations and test cases.

test_valid_blob_tx_combinations(blockchain_test, pre, env, blocks)

Test all valid blob combinations in a single block, assuming a given value of MAX_BLOBS_PER_BLOCK.

This assumes a block can include from 1 and up to MAX_BLOBS_PER_BLOCK transactions where all transactions contain at least 1 blob, and the sum of all blobs in a block is at most MAX_BLOBS_PER_BLOCK.

This test is parametrized with all valid blob transaction combinations for a given block, and therefore if value of MAX_BLOBS_PER_BLOCK changes, this test is automatically updated.

Source code in tests/cancun/eip4844_blobs/test_blob_txs.py

@pytest.mark.parametrize(
    "blobs_per_tx",
    all_valid_blob_combinations(),
)
@pytest.mark.valid_from("Cancun")
def test_valid_blob_tx_combinations(
    blockchain_test: BlockchainTestFiller,
    pre: Dict,
    env: Environment,
    blocks: List[Block],
):
    """
    Test all valid blob combinations in a single block, assuming a given value of
    `MAX_BLOBS_PER_BLOCK`.

    This assumes a block can include from 1 and up to `MAX_BLOBS_PER_BLOCK` transactions where all
    transactions contain at least 1 blob, and the sum of all blobs in a block is at
    most `MAX_BLOBS_PER_BLOCK`.

    This test is parametrized with all valid blob transaction combinations for a given block, and
    therefore if value of `MAX_BLOBS_PER_BLOCK` changes, this test is automatically updated.
    """
    blockchain_test(
        pre=pre,
        post={},
        blocks=blocks,
        genesis_environment=env,
    )

test_invalid_tx_max_fee_per_data_gas(blockchain_test, pre, env, blocks, parent_blobs, block_intermediate)

Reject blocks with invalid blob txs due to:

• tx max_fee_per_data_gas is barely not enough
• tx max_fee_per_data_gas is zero

Source code in tests/cancun/eip4844_blobs/test_blob_txs.py

@pytest.mark.parametrize(
    "parent_excess_blobs,parent_blobs,tx_max_fee_per_data_gas,tx_error",
    [
        # tx max_data_gas_cost of the transaction is not enough
        (
            get_min_excess_data_blobs_for_data_gas_price(2) - 1,  # data gas price is 1
            TARGET_BLOBS_PER_BLOCK + 1,  # data gas cost increases to 2
            1,  # tx max_data_gas_cost is 1
            "insufficient max fee per data gas",
        ),
        # tx max_data_gas_cost of the transaction is zero, which is invalid
        (
            0,  # data gas price is 1
            0,  # data gas cost stays put at 1
            0,  # tx max_data_gas_cost is 0
            "invalid max fee per data gas",
        ),
    ],
    ids=["insufficient_max_fee_per_data_gas", "invalid_max_fee_per_data_gas"],
)
@pytest.mark.valid_from("Cancun")
def test_invalid_tx_max_fee_per_data_gas(
    blockchain_test: BlockchainTestFiller,
    pre: Dict,
    env: Environment,
    blocks: List[Block],
    parent_blobs: int,
    block_intermediate: Block,
):
    """
    Reject blocks with invalid blob txs due to:

    - tx max_fee_per_data_gas is barely not enough
    - tx max_fee_per_data_gas is zero
    """
    if parent_blobs:
        pre[TestAddress2] = Account(balance=10**9)
        blocks.insert(0, block_intermediate)
        if env.excess_data_gas is not None:
            env.excess_data_gas += TARGET_DATA_GAS_PER_BLOCK
    blockchain_test(
        pre=pre,
        post={},
        blocks=blocks,
        genesis_environment=env,
    )

test_invalid_normal_gas(blockchain_test, pre, env, blocks)

Reject blocks with invalid blob txs due to:

• Sufficient max fee per data gas, but insufficient max fee per gas

Source code in tests/cancun/eip4844_blobs/test_blob_txs.py

@pytest.mark.parametrize(
    "tx_max_fee_per_gas,tx_error",
    [
        # max data gas is ok, but max fee per gas is less than base fee per gas
        (
            6,
            "insufficient max fee per gas",
        ),
    ],
    ids=["insufficient_max_fee_per_gas"],
)
@pytest.mark.valid_from("Cancun")
def test_invalid_normal_gas(
    blockchain_test: BlockchainTestFiller,
    pre: Dict,
    env: Environment,
    blocks: List[Block],
):
    """
    Reject blocks with invalid blob txs due to:

    - Sufficient max fee per data gas, but insufficient max fee per gas
    """
    blockchain_test(
        pre=pre,
        post={},
        blocks=blocks,
        genesis_environment=env,
    )

test_invalid_block_blob_count(blockchain_test, pre, env, blocks)

Test all invalid blob combinations in a single block, where the sum of all blobs in a block is at MAX_BLOBS_PER_BLOCK + 1.

This test is parametrized with all blob transaction combinations exceeding MAX_BLOBS_PER_BLOCK by one for a given block, and therefore if value of MAX_BLOBS_PER_BLOCK changes, this test is automatically updated.

Source code in tests/cancun/eip4844_blobs/test_blob_txs.py

@pytest.mark.parametrize(
    "blobs_per_tx",
    invalid_blob_combinations(),
)
@pytest.mark.parametrize("tx_error", ["invalid_blob_count"])
@pytest.mark.valid_from("Cancun")
def test_invalid_block_blob_count(
    blockchain_test: BlockchainTestFiller,
    pre: Dict,
    env: Environment,
    blocks: List[Block],
):
    """
    Test all invalid blob combinations in a single block, where the sum of all blobs in a block is
    at `MAX_BLOBS_PER_BLOCK + 1`.

    This test is parametrized with all blob transaction combinations exceeding
    `MAX_BLOBS_PER_BLOCK` by one for a given block, and
    therefore if value of `MAX_BLOBS_PER_BLOCK` changes, this test is automatically updated.
    """
    blockchain_test(
        pre=pre,
        post={},
        blocks=blocks,
        genesis_environment=env,
    )

test_insufficient_balance_blob_tx(blockchain_test, pre, env, blocks)

Reject blocks where user cannot afford the data gas specified (but max_fee_per_gas would be enough for current block), including:

• Transactions with and without priority fee
• Transactions with and without value
• Transactions with and without calldata
• Transactions with max fee per data gas lower or higher than the priority fee

Source code in tests/cancun/eip4844_blobs/test_blob_txs.py

@pytest.mark.parametrize("tx_max_priority_fee_per_gas", [0, 8])
@pytest.mark.parametrize("tx_value", [0, 1])
@pytest.mark.parametrize(
    "tx_calldata",
    [b"", b"\x00", b"\x01"],
    ids=["no_calldata", "single_zero_calldata", "single_one_calldata"],
)
@pytest.mark.parametrize("tx_max_fee_per_data_gas", [1, 100, 10000])
@pytest.mark.parametrize("account_balance_modifier", [-1], ids=["exact_balance_minus_1"])
@pytest.mark.parametrize("tx_error", ["insufficient_account_balance"], ids=[""])
@pytest.mark.valid_from("Cancun")
def test_insufficient_balance_blob_tx(
    blockchain_test: BlockchainTestFiller,
    pre: Dict,
    env: Environment,
    blocks: List[Block],
):
    """
    Reject blocks where user cannot afford the data gas specified (but
    max_fee_per_gas would be enough for current block), including:

    - Transactions with and without priority fee
    - Transactions with and without value
    - Transactions with and without calldata
    - Transactions with max fee per data gas lower or higher than the priority fee
    """
    blockchain_test(
        pre=pre,
        post={},
        blocks=blocks,
        genesis_environment=env,
    )

test_insufficient_balance_blob_tx_combinations(blockchain_test, pre, env, blocks)

Reject all valid blob transaction combinations in a block, but block is invalid due to:

• The amount of blobs is correct but the user cannot afford the transaction total cost

Source code in tests/cancun/eip4844_blobs/test_blob_txs.py

@pytest.mark.parametrize(
    "blobs_per_tx",
    all_valid_blob_combinations(),
)
@pytest.mark.parametrize("account_balance_modifier", [-1], ids=["exact_balance_minus_1"])
@pytest.mark.parametrize("tx_error", ["insufficient_account_balance"], ids=[""])
@pytest.mark.valid_from("Cancun")
def test_insufficient_balance_blob_tx_combinations(
    blockchain_test: BlockchainTestFiller,
    pre: Dict,
    env: Environment,
    blocks: List[Block],
):
    """
    Reject all valid blob transaction combinations in a block, but block is invalid due to:

    - The amount of blobs is correct but the user cannot afford the
            transaction total cost
    """
    blockchain_test(
        pre=pre,
        post={},
        blocks=blocks,
        genesis_environment=env,
    )

test_invalid_tx_blob_count(blockchain_test, pre, env, blocks)

Reject blocks that include blob transactions with invalid blob counts:

• blob count == 0 in type 3 transaction
• blob count > MAX_BLOBS_PER_BLOCK in type 3 transaction

Source code in tests/cancun/eip4844_blobs/test_blob_txs.py

@pytest.mark.parametrize(
    "blobs_per_tx,tx_error",
    [
        ([0], "zero_blob_tx"),
        ([MAX_BLOBS_PER_BLOCK + 1], "too_many_blobs_tx"),
    ],
    ids=["too_few_blobs", "too_many_blobs"],
)
@pytest.mark.valid_from("Cancun")
def test_invalid_tx_blob_count(
    blockchain_test: BlockchainTestFiller,
    pre: Dict,
    env: Environment,
    blocks: List[Block],
):
    """
    Reject blocks that include blob transactions with invalid blob counts:

    - `blob count == 0` in type 3 transaction
    - `blob count > MAX_BLOBS_PER_BLOCK` in type 3 transaction
    """
    blockchain_test(
        pre=pre,
        post={},
        blocks=blocks,
        genesis_environment=env,
    )

test_invalid_blob_hash_versioning(blockchain_test, pre, env, blocks)

Reject blocks that include blob transactions with invalid blob hash version, including:

• Single blob transaction with single blob with invalid version
• Single blob transaction with multiple blobs all with invalid version
• Single blob transaction with multiple blobs either with invalid version
• Multiple blob transactions with single blob all with invalid version
• Multiple blob transactions with multiple blobs all with invalid version
• Multiple blob transactions with multiple blobs only one with invalid version

Source code in tests/cancun/eip4844_blobs/test_blob_txs.py

@pytest.mark.parametrize(
    "blob_hashes_per_tx",
    [
        [[to_hash_bytes(1)]],
        [[to_hash_bytes(x) for x in range(2)]],
        [add_kzg_version([to_hash_bytes(1)], BLOB_COMMITMENT_VERSION_KZG) + [to_hash_bytes(2)]],
        [[to_hash_bytes(1)] + add_kzg_version([to_hash_bytes(2)], BLOB_COMMITMENT_VERSION_KZG)],
        [
            add_kzg_version([to_hash_bytes(1)], BLOB_COMMITMENT_VERSION_KZG),
            [to_hash_bytes(2)],
        ],
        [
            add_kzg_version([to_hash_bytes(1)], BLOB_COMMITMENT_VERSION_KZG),
            [to_hash_bytes(x) for x in range(1, 3)],
        ],
        [
            add_kzg_version([to_hash_bytes(1)], BLOB_COMMITMENT_VERSION_KZG),
            [to_hash_bytes(2)] + add_kzg_version([to_hash_bytes(3)], BLOB_COMMITMENT_VERSION_KZG),
        ],
        [
            add_kzg_version([to_hash_bytes(1)], BLOB_COMMITMENT_VERSION_KZG),
            add_kzg_version([to_hash_bytes(2)], BLOB_COMMITMENT_VERSION_KZG),
            [to_hash_bytes(3)],
        ],
    ],
    ids=[
        "single_tx_single_blob",
        "single_tx_multiple_blobs",
        "single_tx_multiple_blobs_single_bad_hash_1",
        "single_tx_multiple_blobs_single_bad_hash_2",
        "multiple_txs_single_blob",
        "multiple_txs_multiple_blobs",
        "multiple_txs_multiple_blobs_single_bad_hash_1",
        "multiple_txs_multiple_blobs_single_bad_hash_2",
    ],
)
@pytest.mark.parametrize("tx_error", ["invalid_versioned_hash"], ids=[""])
@pytest.mark.valid_from("Cancun")
def test_invalid_blob_hash_versioning(
    blockchain_test: BlockchainTestFiller,
    pre: Dict,
    env: Environment,
    blocks: List[Block],
):
    """
    Reject blocks that include blob transactions with invalid blob hash
    version, including:

    - Single blob transaction with single blob with invalid version
    - Single blob transaction with multiple blobs all with invalid version
    - Single blob transaction with multiple blobs either with invalid version
    - Multiple blob transactions with single blob all with invalid version
    - Multiple blob transactions with multiple blobs all with invalid version
    - Multiple blob transactions with multiple blobs only one with invalid version
    """
    blockchain_test(
        pre=pre,
        post={},
        blocks=blocks,
        genesis_environment=env,
    )

test_invalid_blob_tx_contract_creation(blockchain_test, pre, env, blocks)

Reject blocks that include blob transactions that have nil to value (contract creating).

Source code in tests/cancun/eip4844_blobs/test_blob_txs.py

@pytest.mark.parametrize(
    "destination_account,tx_error", [(None, "no_contract_creating_blob_txs")], ids=[""]
)
@pytest.mark.valid_from("Cancun")
def test_invalid_blob_tx_contract_creation(
    blockchain_test: BlockchainTestFiller,
    pre: Dict,
    env: Environment,
    blocks: List[Block],
):
    """
    Reject blocks that include blob transactions that have nil to value (contract creating).
    """
    blockchain_test(
        pre=pre,
        post={},
        blocks=blocks,
        genesis_environment=env,
    )

test_blob_tx_attribute_opcodes(blockchain_test, pre, opcode, env, blocks, destination_account)

Test opcodes that read transaction attributes work properly for blob type transactions:

• ORIGIN
• CALLER

Source code in tests/cancun/eip4844_blobs/test_blob_txs.py

@pytest.mark.parametrize(
    "opcode",
    [Op.ORIGIN, Op.CALLER],
    indirect=["opcode"],
)
@pytest.mark.parametrize("tx_gas", [500_000])
@pytest.mark.valid_from("Cancun")
def test_blob_tx_attribute_opcodes(
    blockchain_test: BlockchainTestFiller,
    pre: Dict,
    opcode: Tuple[bytes, Storage.StorageDictType],
    env: Environment,
    blocks: List[Block],
    destination_account: str,
):
    """
    Test opcodes that read transaction attributes work properly for blob type transactions:

    - ORIGIN
    - CALLER
    """
    code, storage = opcode
    pre[destination_account] = Account(code=code)
    post = {
        destination_account: Account(
            storage=storage,
        )
    }
    blockchain_test(
        pre=pre,
        post=post,
        blocks=blocks,
        genesis_environment=env,
    )

test_blob_tx_attribute_value_opcode(blockchain_test, pre, opcode, env, blocks, tx_value, destination_account)

Test the VALUE opcode with different blob type transaction value amounts.

Source code in tests/cancun/eip4844_blobs/test_blob_txs.py

@pytest.mark.parametrize("opcode", [Op.CALLVALUE], indirect=["opcode"])
@pytest.mark.parametrize("tx_value", [0, 1, int(1e18)])
@pytest.mark.parametrize("tx_gas", [500_000])
@pytest.mark.valid_from("Cancun")
def test_blob_tx_attribute_value_opcode(
    blockchain_test: BlockchainTestFiller,
    pre: Dict,
    opcode: Tuple[bytes, Storage.StorageDictType],
    env: Environment,
    blocks: List[Block],
    tx_value: int,
    destination_account: str,
):
    """
    Test the VALUE opcode with different blob type transaction value amounts.
    """
    code, storage = opcode
    pre[destination_account] = Account(code=code)
    post = {
        destination_account: Account(
            storage=storage,
            balance=tx_value,
        )
    }
    blockchain_test(
        pre=pre,
        post=post,
        blocks=blocks,
        genesis_environment=env,
    )

test_blob_tx_attribute_calldata_opcodes(blockchain_test, pre, opcode, env, blocks, destination_account)

Test calldata related opcodes to verify their behavior is not affected by blobs:

• CALLDATALOAD
• CALLDATASIZE
• CALLDATACOPY

Source code in tests/cancun/eip4844_blobs/test_blob_txs.py

@pytest.mark.parametrize(
    "opcode",
    [
        Op.CALLDATALOAD,
        Op.CALLDATASIZE,
        Op.CALLDATACOPY,
    ],
    indirect=True,
)
@pytest.mark.parametrize(
    "tx_calldata",
    [
        b"",
        b"\x01",
        b"\x00\x01" * 16,
    ],
    ids=["empty", "single_byte", "word"],
)
@pytest.mark.parametrize("tx_gas", [500_000])
@pytest.mark.valid_from("Cancun")
def test_blob_tx_attribute_calldata_opcodes(
    blockchain_test: BlockchainTestFiller,
    pre: Dict,
    opcode: Tuple[bytes, Storage.StorageDictType],
    env: Environment,
    blocks: List[Block],
    destination_account: str,
):
    """
    Test calldata related opcodes to verify their behavior is not affected by blobs:

    - CALLDATALOAD
    - CALLDATASIZE
    - CALLDATACOPY
    """
    code, storage = opcode
    pre[destination_account] = Account(code=code)
    post = {
        destination_account: Account(
            storage=storage,
        )
    }
    blockchain_test(
        pre=pre,
        post=post,
        blocks=blocks,
        genesis_environment=env,
    )

test_blob_tx_attribute_gasprice_opcode(blockchain_test, pre, opcode, env, blocks, destination_account)

Test GASPRICE opcode to sanity check that the data fee per gas does not affect its calculation:

• No priority fee
• Priority fee below data fee
• Priority fee above data fee

Source code in tests/cancun/eip4844_blobs/test_blob_txs.py

@pytest.mark.parametrize("tx_max_priority_fee_per_gas", [0, 2])  # always below data fee
@pytest.mark.parametrize("tx_max_fee_per_data_gas", [1, 3])  # normal and above priority fee
@pytest.mark.parametrize("tx_max_fee_per_gas", [100])  # always above priority fee
@pytest.mark.parametrize("opcode", [Op.GASPRICE], indirect=True)
@pytest.mark.parametrize("tx_gas", [500_000])
@pytest.mark.valid_from("Cancun")
def test_blob_tx_attribute_gasprice_opcode(
    blockchain_test: BlockchainTestFiller,
    pre: Dict,
    opcode: Tuple[bytes, Storage.StorageDictType],
    env: Environment,
    blocks: List[Block],
    destination_account: str,
):
    """
    Test GASPRICE opcode to sanity check that the data fee per gas does not affect
    its calculation:

    - No priority fee
    - Priority fee below data fee
    - Priority fee above data fee
    """
    code, storage = opcode
    pre[destination_account] = Account(code=code)
    post = {
        destination_account: Account(
            storage=storage,
        )
    }
    blockchain_test(
        pre=pre,
        post=post,
        blocks=blocks,
        genesis_environment=env,
    )

test_blob_type_tx_pre_fork(blockchain_test, pre, blocks)

Reject blocks with blob type transactions before Cancun fork

Source code in tests/cancun/eip4844_blobs/test_blob_txs.py

@pytest.mark.parametrize(
    [
        "blobs_per_tx",
        "parent_excess_blobs",
        "tx_max_fee_per_data_gas",
        "tx_error",
    ],
    [
        ([0], None, 1, "tx_type_3_not_allowed_yet"),
        ([1], None, 1, "tx_type_3_not_allowed_yet"),
    ],
    ids=["no_blob_tx", "one_blob_tx"],
)
@pytest.mark.valid_at_transition_to("Cancun")
def test_blob_type_tx_pre_fork(
    blockchain_test: BlockchainTestFiller,
    pre: Dict,
    blocks: List[Block],
):
    """
    Reject blocks with blob type transactions before Cancun fork
    """
    blockchain_test(
        pre=pre,
        post={},
        blocks=blocks,
        genesis_environment=Environment(),  # `env` fixture has blob fields
    )