Skip to content

Ethereum Execution Spec Tests

Test Blob Txs

execution-spec-tests

Test Blob Txs¶

Documentation for tests/cancun/eip4844_blobs/test_blob_txs.py.

Generate fixtures for these test cases with:

fill -v tests/cancun/eip4844_blobs/test_blob_txs.py

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 or state_test
pre
env
block or txs

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

`test_valid_blob_tx_combinations(blockchain_test, pre, env, 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.

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,
    block: 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=[block],
        genesis_environment=env,
    )

`test_invalid_tx_max_fee_per_blob_gas(blockchain_test, pre, env, block, non_zero_blob_gas_used_genesis_block)` ¶

Reject blocks with invalid blob txs due to:

tx max_fee_per_blob_gas is barely not enough
tx max_fee_per_blob_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_blob_gas,tx_error",
    [
        # tx max_blob_gas_cost of the transaction is not enough
        pytest.param(
            SpecHelpers.get_min_excess_blobs_for_blob_gas_price(2) - 1,  # blob gas price is 1
            SpecHelpers.target_blobs_per_block() + 1,  # blob gas cost increases to 2
            1,  # tx max_blob_gas_cost is 1
            TransactionException.INSUFFICIENT_MAX_FEE_PER_BLOB_GAS,
            id="insufficient_max_fee_per_blob_gas",
        ),
        # tx max_blob_gas_cost of the transaction is zero, which is invalid
        pytest.param(
            0,  # blob gas price is 1
            0,  # blob gas cost stays put at 1
            0,  # tx max_blob_gas_cost is 0
            TransactionException.INSUFFICIENT_MAX_FEE_PER_BLOB_GAS,
            id="invalid_max_fee_per_blob_gas",
        ),
    ],
)
@pytest.mark.parametrize(
    "account_balance_modifier",
    [1_000_000_000],
)  # Extra balance to cover block blob gas cost
@pytest.mark.valid_from("Cancun")
def test_invalid_tx_max_fee_per_blob_gas(
    blockchain_test: BlockchainTestFiller,
    pre: Dict,
    env: Environment,
    block: Block,
    non_zero_blob_gas_used_genesis_block: Optional[Block],
):
    """
    Reject blocks with invalid blob txs due to:

    - tx max_fee_per_blob_gas is barely not enough
    - tx max_fee_per_blob_gas is zero
    """
    blocks = [block]
    if non_zero_blob_gas_used_genesis_block is not None:
        pre[TestAddress2] = Account(balance=10**9)
        blocks = [non_zero_blob_gas_used_genesis_block, block]
    blockchain_test(
        pre=pre,
        post={},
        blocks=blocks,
        genesis_environment=env,
    )

`test_invalid_tx_max_fee_per_blob_gas_state(state_test_only, state_env, pre, txs)` ¶

Reject an invalid blob transaction due to:

tx max_fee_per_blob_gas is barely not enough
tx max_fee_per_blob_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_blob_gas,tx_error",
    [
        # tx max_blob_gas_cost of the transaction is not enough
        pytest.param(
            SpecHelpers.get_min_excess_blobs_for_blob_gas_price(2) - 1,  # blob gas price is 1
            SpecHelpers.target_blobs_per_block() + 1,  # blob gas cost increases to 2
            1,  # tx max_blob_gas_cost is 1
            TransactionException.INSUFFICIENT_MAX_FEE_PER_BLOB_GAS,
            id="insufficient_max_fee_per_blob_gas",
        ),
        # tx max_blob_gas_cost of the transaction is zero, which is invalid
        pytest.param(
            0,  # blob gas price is 1
            0,  # blob gas cost stays put at 1
            0,  # tx max_blob_gas_cost is 0
            TransactionException.INSUFFICIENT_MAX_FEE_PER_BLOB_GAS,
            id="invalid_max_fee_per_blob_gas",
        ),
    ],
)
@pytest.mark.valid_from("Cancun")
def test_invalid_tx_max_fee_per_blob_gas_state(
    state_test_only: StateTestFiller,
    state_env: Environment,
    pre: Dict,
    txs: List[Transaction],
):
    """
    Reject an invalid blob transaction due to:

    - tx max_fee_per_blob_gas is barely not enough
    - tx max_fee_per_blob_gas is zero
    """
    assert len(txs) == 1
    state_test_only(
        pre=pre,
        post={},
        tx=txs[0],
        env=state_env,
    )

`test_invalid_normal_gas(state_test, state_env, pre, txs, header_verify, rlp_modifier)` ¶

Reject an invalid blob transaction due to:

Sufficient max fee per blob 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 blob gas is ok, but max fee per gas is less than base fee per gas
        (
            6,
            TransactionException.INSUFFICIENT_MAX_FEE_PER_GAS,
        ),
    ],
    ids=["insufficient_max_fee_per_gas"],
)
@pytest.mark.valid_from("Cancun")
def test_invalid_normal_gas(
    state_test: StateTestFiller,
    state_env: Environment,
    pre: Dict,
    txs: List[Transaction],
    header_verify: Optional[Header],
    rlp_modifier: Optional[Header],
):
    """
    Reject an invalid blob transaction due to:

    - Sufficient max fee per blob gas, but insufficient max fee per gas
    """
    assert len(txs) == 1
    state_test(
        pre=pre,
        post={},
        tx=txs[0],
        env=state_env,
        blockchain_test_header_verify=header_verify,
        blockchain_test_rlp_modifier=rlp_modifier,
    )

`test_invalid_block_blob_count(blockchain_test, pre, env, 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.

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", [TransactionException.TYPE_3_TX_MAX_BLOB_GAS_ALLOWANCE_EXCEEDED], ids=[""]
)
@pytest.mark.valid_from("Cancun")
def test_invalid_block_blob_count(
    blockchain_test: BlockchainTestFiller,
    pre: Dict,
    env: Environment,
    block: 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=[block],
        genesis_environment=env,
    )

`test_insufficient_balance_blob_tx(state_test, state_env, pre, txs)` ¶

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

Transactions with max fee equal or higher than current block base fee
Transactions with and without priority fee
Transactions with and without value
Transactions with and without calldata
Transactions with max fee per blob gas lower or higher than the priority fee

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

@pytest.mark.parametrize(
    "tx_access_list",
    [[], [AccessList(address=100, storage_keys=[100, 200])]],
    ids=["no_access_list", "access_list"],
)
@pytest.mark.parametrize("tx_max_fee_per_gas", [7, 14])
@pytest.mark.parametrize("tx_max_priority_fee_per_gas", [0, 7])
@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_blob_gas", [1, 100, 10000])
@pytest.mark.parametrize("account_balance_modifier", [-1], ids=["exact_balance_minus_1"])
@pytest.mark.parametrize("tx_error", [TransactionException.INSUFFICIENT_ACCOUNT_FUNDS], ids=[""])
@pytest.mark.valid_from("Cancun")
def test_insufficient_balance_blob_tx(
    state_test: StateTestFiller,
    state_env: Environment,
    pre: Dict,
    txs: List[Transaction],
):
    """
    Reject blocks where user cannot afford the blob gas specified (but
    max_fee_per_gas would be enough for current block), including:

    - Transactions with max fee equal or higher than current block base fee
    - Transactions with and without priority fee
    - Transactions with and without value
    - Transactions with and without calldata
    - Transactions with max fee per blob gas lower or higher than the priority fee
    """
    assert len(txs) == 1
    state_test(
        pre=pre,
        post={},
        tx=txs[0],
        env=state_env,
    )

`test_sufficient_balance_blob_tx(state_test, state_env, pre, txs)` ¶

Check that transaction is accepted when user can exactly afford the blob gas specified (and max_fee_per_gas would be enough for current block), including:

Transactions with max fee equal or higher than current block base fee
Transactions with and without priority fee
Transactions with and without value
Transactions with and without calldata
Transactions with max fee per blob gas lower or higher than the priority fee

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

@pytest.mark.parametrize(
    "tx_access_list",
    [[], [AccessList(address=100, storage_keys=[100, 200])]],
    ids=["no_access_list", "access_list"],
)
@pytest.mark.parametrize("tx_max_fee_per_gas", [7, 14])
@pytest.mark.parametrize("tx_max_priority_fee_per_gas", [0, 7])
@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_blob_gas", [1, 100, 10000])
@pytest.mark.valid_from("Cancun")
def test_sufficient_balance_blob_tx(
    state_test: StateTestFiller,
    state_env: Environment,
    pre: Dict,
    txs: List[Transaction],
):
    """
    Check that transaction is accepted when user can exactly afford the blob gas specified (and
    max_fee_per_gas would be enough for current block), including:

    - Transactions with max fee equal or higher than current block base fee
    - Transactions with and without priority fee
    - Transactions with and without value
    - Transactions with and without calldata
    - Transactions with max fee per blob gas lower or higher than the priority fee
    """
    assert len(txs) == 1
    state_test(
        pre=pre,
        post={},
        tx=txs[0],
        env=state_env,
    )

`test_sufficient_balance_blob_tx_pre_fund_tx(blockchain_test, total_account_minimum_balance, env, pre, txs, header_verify)` ¶

Check that transaction is accepted when user can exactly afford the blob gas specified (and max_fee_per_gas would be enough for current block) because a funding transaction is prepended in the same block, including:

Transactions with max fee equal or higher than current block base fee
Transactions with and without priority fee
Transactions with and without value
Transactions with and without calldata
Transactions with max fee per blob gas lower or higher than the priority fee

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

@pytest.mark.parametrize(
    "tx_access_list",
    [[], [AccessList(address=100, storage_keys=[100, 200])]],
    ids=["no_access_list", "access_list"],
)
@pytest.mark.parametrize("tx_max_fee_per_gas", [7, 14])
@pytest.mark.parametrize("tx_max_priority_fee_per_gas", [0, 7])
@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_blob_gas", [1, 100, 10000])
@pytest.mark.valid_from("Cancun")
def test_sufficient_balance_blob_tx_pre_fund_tx(
    blockchain_test: BlockchainTestFiller,
    total_account_minimum_balance: int,
    env: Environment,
    pre: Dict,
    txs: List[Transaction],
    header_verify: Optional[Header],
):
    """
    Check that transaction is accepted when user can exactly afford the blob gas specified (and
    max_fee_per_gas would be enough for current block) because a funding transaction is
    prepended in the same block, including:

    - Transactions with max fee equal or higher than current block base fee
    - Transactions with and without priority fee
    - Transactions with and without value
    - Transactions with and without calldata
    - Transactions with max fee per blob gas lower or higher than the priority fee
    """
    pre = {
        TestPreFundingAddress: Account(balance=(21_000 * 100) + total_account_minimum_balance),
    }
    txs = [
        Transaction(
            ty=2,
            nonce=0,
            to=TestAddress,
            value=total_account_minimum_balance,
            gas_limit=21_000,
            max_fee_per_gas=100,
            max_priority_fee_per_gas=0,
            access_list=[],
            secret_key=TestPreFundingKey,
        )
    ] + txs
    blockchain_test(
        pre=pre,
        post={},
        blocks=[
            Block(
                txs=txs,
                header_verify=header_verify,
            )
        ],
        genesis_environment=env,
    )

`test_blob_gas_subtraction_tx(state_test, state_env, pre, txs, destination_account, mid_tx_send_amount, total_account_transactions_fee)` ¶

Check that the blob gas fee for a transaction is subtracted from the sender balance before the transaction is executed, including:

Transactions with max fee equal or higher than current block base fee
Transactions with and without value
Transactions with and without calldata
Transactions with max fee per blob gas lower or higher than the priority fee
Transactions where an externally owned account sends funds to the sender mid execution

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

@pytest.mark.parametrize(
    "tx_access_list",
    [[], [AccessList(address=100, storage_keys=[100, 200])]],
    ids=["no_access_list", "access_list"],
)
@pytest.mark.parametrize("tx_max_fee_per_gas", [7, 14])
@pytest.mark.parametrize("tx_max_priority_fee_per_gas", [0, 7])
@pytest.mark.parametrize("tx_value", [0, 1])
@pytest.mark.parametrize(
    "tx_calldata",
    [b"", b"\x01"],
    ids=["no_calldata", "single_non_zero_byte_calldata"],
)
@pytest.mark.parametrize("tx_max_fee_per_blob_gas", [1, 100])
@pytest.mark.parametrize(
    "tx_gas", [500_000], ids=[""]
)  # Increase gas to account for contract code
@pytest.mark.parametrize(
    "mid_tx_send_amount", [100]
)  # Amount sent by the contract to the sender mid execution
@pytest.mark.valid_from("Cancun")
def test_blob_gas_subtraction_tx(
    state_test: StateTestFiller,
    state_env: Environment,
    pre: Dict,
    txs: List[Transaction],
    destination_account: Address,
    mid_tx_send_amount: int,
    total_account_transactions_fee: int,
):
    """
    Check that the blob gas fee for a transaction is subtracted from the sender balance before the
    transaction is executed, including:

    - Transactions with max fee equal or higher than current block base fee
    - Transactions with and without value
    - Transactions with and without calldata
    - Transactions with max fee per blob gas lower or higher than the priority fee
    - Transactions where an externally owned account sends funds to the sender mid execution
    """
    assert len(txs) == 1
    pre[destination_account] = Account(
        balance=mid_tx_send_amount,
        code=Op.SSTORE(0, Op.BALANCE(Op.ORIGIN))
        + Op.CALL(Op.GAS, Op.ORIGIN, mid_tx_send_amount, 0, 0, 0, 0)
        + Op.SSTORE(1, Op.BALANCE(Op.ORIGIN)),
    )
    post = {
        destination_account: Account(
            storage={
                0: pre[TestAddress].balance - total_account_transactions_fee,
                1: pre[TestAddress].balance - total_account_transactions_fee + mid_tx_send_amount,
            }
        )
    }
    state_test(
        pre=pre,
        post=post,
        tx=txs[0],
        env=state_env,
    )

`test_insufficient_balance_blob_tx_combinations(blockchain_test, pre, env, 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

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", [TransactionException.INSUFFICIENT_ACCOUNT_FUNDS], ids=[""])
@pytest.mark.valid_from("Cancun")
def test_insufficient_balance_blob_tx_combinations(
    blockchain_test: BlockchainTestFiller,
    pre: Dict,
    env: Environment,
    block: 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=[block],
        genesis_environment=env,
    )

`test_invalid_tx_blob_count(state_test, state_env, pre, txs, header_verify, rlp_modifier)` ¶

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], TransactionException.TYPE_3_TX_ZERO_BLOBS),
        (
            [SpecHelpers.max_blobs_per_block() + 1],
            TransactionException.TYPE_3_TX_BLOB_COUNT_EXCEEDED,
        ),
    ],
    ids=["too_few_blobs", "too_many_blobs"],
)
@pytest.mark.valid_from("Cancun")
def test_invalid_tx_blob_count(
    state_test: StateTestFiller,
    state_env: Environment,
    pre: Dict,
    txs: List[Transaction],
    header_verify: Optional[Header],
    rlp_modifier: Optional[Header],
):
    """
    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
    """
    assert len(txs) == 1
    state_test(
        pre=pre,
        post={},
        tx=txs[0],
        env=state_env,
        blockchain_test_header_verify=header_verify,
        blockchain_test_rlp_modifier=rlp_modifier,
    )

`test_invalid_blob_hash_versioning_single_tx(state_test, state_env, pre, txs, header_verify, rlp_modifier)` ¶

Reject blob transactions with invalid blob hash version, including:

Transaction with single blob with invalid version
Transaction with multiple blobs all with invalid version
Transaction with multiple blobs either with invalid version

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

@pytest.mark.parametrize(
    "blob_hashes_per_tx",
    [
        [[Hash(1)]],
        [[Hash(x) for x in range(2)]],
        [add_kzg_version([Hash(1)], Spec.BLOB_COMMITMENT_VERSION_KZG) + [Hash(2)]],
        [[Hash(1)] + add_kzg_version([Hash(2)], Spec.BLOB_COMMITMENT_VERSION_KZG)],
    ],
    ids=[
        "single_blob",
        "multiple_blobs",
        "multiple_blobs_single_bad_hash_1",
        "multiple_blobs_single_bad_hash_2",
    ],
)
@pytest.mark.parametrize(
    "tx_error", [TransactionException.TYPE_3_TX_INVALID_BLOB_VERSIONED_HASH], ids=[""]
)
@pytest.mark.valid_from("Cancun")
def test_invalid_blob_hash_versioning_single_tx(
    state_test: StateTestFiller,
    state_env: Environment,
    pre: Dict,
    txs: List[Transaction],
    header_verify: Optional[Header],
    rlp_modifier: Optional[Header],
):
    """
    Reject blob transactions with invalid blob hash version, including:

    - Transaction with single blob with invalid version
    - Transaction with multiple blobs all with invalid version
    - Transaction with multiple blobs either with invalid version
    """
    assert len(txs) == 1
    state_test(
        pre=pre,
        post={},
        tx=txs[0],
        env=state_env,
        blockchain_test_header_verify=header_verify,
        blockchain_test_rlp_modifier=rlp_modifier,
    )

`test_invalid_blob_hash_versioning_multiple_txs(blockchain_test, pre, env, block)` ¶

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

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",
    [
        [
            add_kzg_version([Hash(1)], Spec.BLOB_COMMITMENT_VERSION_KZG),
            [Hash(2)],
        ],
        [
            add_kzg_version([Hash(1)], Spec.BLOB_COMMITMENT_VERSION_KZG),
            [Hash(x) for x in range(1, 3)],
        ],
        [
            add_kzg_version([Hash(1)], Spec.BLOB_COMMITMENT_VERSION_KZG),
            [Hash(2)] + add_kzg_version([Hash(3)], Spec.BLOB_COMMITMENT_VERSION_KZG),
        ],
        [
            add_kzg_version([Hash(1)], Spec.BLOB_COMMITMENT_VERSION_KZG),
            add_kzg_version([Hash(2)], Spec.BLOB_COMMITMENT_VERSION_KZG),
            [Hash(3)],
        ],
    ],
    ids=[
        "single_blob",
        "multiple_blobs",
        "multiple_blobs_single_bad_hash_1",
        "multiple_blobs_single_bad_hash_2",
    ],
)
@pytest.mark.parametrize(
    "tx_error", [TransactionException.TYPE_3_TX_INVALID_BLOB_VERSIONED_HASH], ids=[""]
)
@pytest.mark.valid_from("Cancun")
def test_invalid_blob_hash_versioning_multiple_txs(
    blockchain_test: BlockchainTestFiller,
    pre: Dict,
    env: Environment,
    block: Block,
):
    """
    Reject blocks that include blob transactions with invalid blob hash
    version, including:

    - 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=[block],
        genesis_environment=env,
    )

`test_invalid_blob_tx_contract_creation(blockchain_test, pre, env, txs, header_verify)` ¶

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(
    "tx_gas", [500_000], ids=[""]
)  # Increase gas to account for contract creation
@pytest.mark.valid_from("Cancun")
def test_invalid_blob_tx_contract_creation(
    blockchain_test: BlockchainTestFiller,
    pre: Dict,
    env: Environment,
    txs: List[Transaction],
    header_verify: Optional[Header],
):
    """
    Reject blocks that include blob transactions that have nil to value (contract creating).
    """
    assert len(txs) == 1
    assert txs[0].blob_versioned_hashes is not None and len(txs[0].blob_versioned_hashes) == 1
    # Replace the transaction with a contract creating one, only in the RLP version
    contract_creating_tx = txs[0].copy(to=None).with_signature_and_sender()
    txs[0].rlp_override = contract_creating_tx.rlp
    blockchain_test(
        pre=pre,
        post={},
        blocks=[
            Block(
                txs=txs,
                exception=[
                    BlockException.RLP_STRUCTURES_ENCODING,
                    TransactionException.TYPE_3_TX_CONTRACT_CREATION,
                ],
                header_verify=header_verify,
            )
        ],
        genesis_environment=env,
    )

`test_blob_tx_attribute_opcodes(state_test, pre, opcode, state_env, txs, 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(
    state_test: StateTestFiller,
    pre: Dict,
    opcode: Tuple[Bytecode, Storage.StorageDictType],
    state_env: Environment,
    txs: List[Transaction],
    destination_account: Address,
):
    """
    Test opcodes that read transaction attributes work properly for blob type transactions:

    - ORIGIN
    - CALLER
    """
    assert len(txs) == 1
    code, storage = opcode
    pre[destination_account] = Account(code=code)
    post = {
        destination_account: Account(
            storage=storage,
        )
    }
    state_test(
        pre=pre,
        post=post,
        tx=txs[0],
        env=state_env,
    )

`test_blob_tx_attribute_value_opcode(state_test, pre, opcode, state_env, txs, 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(
    state_test: StateTestFiller,
    pre: Dict,
    opcode: Tuple[Bytecode, Storage.StorageDictType],
    state_env: Environment,
    txs: List[Transaction],
    tx_value: int,
    destination_account: Address,
):
    """
    Test the VALUE opcode with different blob type transaction value amounts.
    """
    assert len(txs) == 1
    code, storage = opcode
    pre[destination_account] = Account(code=code)
    post = {
        destination_account: Account(
            storage=storage,
            balance=tx_value,
        )
    }
    state_test(
        pre=pre,
        post=post,
        tx=txs[0],
        env=state_env,
    )

`test_blob_tx_attribute_calldata_opcodes(state_test, pre, opcode, state_env, txs, 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(
    state_test: StateTestFiller,
    pre: Dict,
    opcode: Tuple[Bytecode, Storage.StorageDictType],
    state_env: Environment,
    txs: List[Transaction],
    destination_account: Address,
):
    """
    Test calldata related opcodes to verify their behavior is not affected by blobs:

    - CALLDATALOAD
    - CALLDATASIZE
    - CALLDATACOPY
    """
    assert len(txs) == 1
    code, storage = opcode
    pre[destination_account] = Account(code=code)
    post = {
        destination_account: Account(
            storage=storage,
        )
    }
    state_test(
        pre=pre,
        post=post,
        tx=txs[0],
        env=state_env,
    )

`test_blob_tx_attribute_gasprice_opcode(state_test, pre, opcode, state_env, txs, destination_account)` ¶

Test GASPRICE opcode to sanity check that the blob gas fee 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_blob_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(
    state_test: StateTestFiller,
    pre: Dict,
    opcode: Tuple[Bytecode, Storage.StorageDictType],
    state_env: Environment,
    txs: List[Transaction],
    destination_account: Address,
):
    """
    Test GASPRICE opcode to sanity check that the blob gas fee does not affect
    its calculation:

    - No priority fee
    - Priority fee below data fee
    - Priority fee above data fee
    """
    assert len(txs) == 1
    code, storage = opcode
    pre[destination_account] = Account(code=code)
    post = {
        destination_account: Account(
            storage=storage,
        )
    }
    state_test(
        pre=pre,
        post=post,
        tx=txs[0],
        env=state_env,
    )

`test_blob_type_tx_pre_fork(state_test, pre, txs)` ¶

Reject blocks with blob type transactions before Cancun fork.

Blocks sent by NewPayloadV2 (Shanghai) that contain blob type transactions, furthermore blobs field within NewPayloadV2 method must be computed as INVALID, due to an invalid block hash.

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

@pytest.mark.parametrize(
    [
        "blobs_per_tx",
        "parent_excess_blobs",
        "tx_max_fee_per_blob_gas",
        "tx_error",
    ],
    [
        (
            [0],
            None,
            1,
            [TransactionException.TYPE_3_TX_PRE_FORK, TransactionException.TYPE_3_TX_ZERO_BLOBS],
        ),
        ([1], None, 1, TransactionException.TYPE_3_TX_PRE_FORK),
    ],
    ids=["no_blob_tx", "one_blob_tx"],
)
@pytest.mark.valid_at_transition_to("Cancun")
def test_blob_type_tx_pre_fork(
    state_test: StateTestFiller,
    pre: Dict,
    txs: List[Transaction],
):
    """
    Reject blocks with blob type transactions before Cancun fork.

    Blocks sent by NewPayloadV2 (Shanghai) that contain blob type transactions, furthermore blobs
    field within NewPayloadV2 method must be computed as INVALID, due to an invalid block hash.
    """
    assert len(txs) == 1
    state_test(
        pre=pre,
        post={},
        tx=txs[0],
        env=Environment(),  # `env` fixture has blob fields
    )