Test Blob Txs

Documentation for 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

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

Test blob type transactions for [EIP-4844: Shard Blob Transactions](https://eips.ethereum.org/EIPS/eip-4844).

note: 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_blob_gas(blockchain_test, pre, env, blocks, parent_blobs, 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
        (
            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
            "insufficient max fee per blob gas",
        ),
        # tx max_blob_gas_cost of the transaction is zero, which is invalid
        (
            0,  # blob gas price is 1
            0,  # blob gas cost stays put at 1
            0,  # tx max_blob_gas_cost is 0
            "invalid max fee per blob gas",
        ),
    ],
    ids=["insufficient_max_fee_per_blob_gas", "invalid_max_fee_per_blob_gas"],
)
@pytest.mark.valid_from("Cancun")
def test_invalid_tx_max_fee_per_blob_gas(
    blockchain_test: BlockchainTestFiller,
    pre: Dict,
    env: Environment,
    blocks: List[Block],
    parent_blobs: int,
    non_zero_blob_gas_used_genesis_block: 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
    """
    if parent_blobs:
        pre[TestAddress2] = Account(balance=10**9)
        blocks.insert(0, non_zero_blob_gas_used_genesis_block)
        if env.excess_blob_gas is not None:
            assert isinstance(env.excess_blob_gas, int)
            env.excess_blob_gas += Spec.TARGET_BLOB_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 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,
            "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 blob 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("block_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 blob 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 blob 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_blob_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 blob 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 blob 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,block_error",
    [
        ([0], "zero blob tx", "zero blob tx"),
        ([SpecHelpers.max_blobs_per_block() + 1], None, "too many blobs"),
    ],
    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)], Spec.BLOB_COMMITMENT_VERSION_KZG)
            + [to_hash_bytes(2)]
        ],
        [
            [to_hash_bytes(1)]
            + add_kzg_version([to_hash_bytes(2)], Spec.BLOB_COMMITMENT_VERSION_KZG)
        ],
        [
            add_kzg_version([to_hash_bytes(1)], Spec.BLOB_COMMITMENT_VERSION_KZG),
            [to_hash_bytes(2)],
        ],
        [
            add_kzg_version([to_hash_bytes(1)], Spec.BLOB_COMMITMENT_VERSION_KZG),
            [to_hash_bytes(x) for x in range(1, 3)],
        ],
        [
            add_kzg_version([to_hash_bytes(1)], Spec.BLOB_COMMITMENT_VERSION_KZG),
            [to_hash_bytes(2)]
            + add_kzg_version([to_hash_bytes(3)], Spec.BLOB_COMMITMENT_VERSION_KZG),
        ],
        [
            add_kzg_version([to_hash_bytes(1)], Spec.BLOB_COMMITMENT_VERSION_KZG),
            add_kzg_version([to_hash_bytes(2)], Spec.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 blob 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=[""]
)
# TODO: Uncomment after #242 -> https://github.com/ethereum/execution-spec-tests/issues/242
@pytest.mark.skip(reason="Unable to fill due to invalid field in transaction")
@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 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(
    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 blob gas fee 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.

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, "tx type 3 not allowed pre-Cancun"),
        ([1], None, 1, "tx type 3 not allowed pre-Cancun"),
    ],
    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.

    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.
    """
    blockchain_test(
        pre=pre,
        post={},
        blocks=blocks,
        genesis_environment=Environment(),  # `env` fixture has blob fields
    )