Test Excess Data Gas

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

Generate fixtures for these test cases for Cancun with:

Cancun only:

fill -v tests/cancun/eip4844_blobs/test_excess_data_gas.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_excess_data_gas.py --until=Cancun --evm-bin=/path/to/evm-tool-dev-version

Tests excessDataGas and dataGasUsed block fields for EIP-4844: Shard Blob Transactions

Test excessDataGas and dataGasUsed block fields 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
• env
• pre
• blocks
• post
• correct_excess_data_gas

The following arguments need to be parametrized or the test will not be generated:

• new_blobs

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

Spec dataclass

Parameters from the EIP-4844 specifications as defined at https://eips.ethereum.org/EIPS/eip-4844#parameters

If the parameter is not currently used within the tests, it is commented out.

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

@dataclass(frozen=True)
class Spec:
    """
    Parameters from the EIP-4844 specifications as defined at
    https://eips.ethereum.org/EIPS/eip-4844#parameters

    If the parameter is not currently used within the tests, it is commented
    out.
    """

    BLOB_TX_TYPE = 0x03
    FIELD_ELEMENTS_PER_BLOB = 4096
    BLS_MODULUS = 0x73EDA753299D7D483339D80809A1D80553BDA402FFFE5BFEFFFFFFFF00000001
    BLOB_COMMITMENT_VERSION_KZG = 1
    POINT_EVALUATION_PRECOMPILE_ADDRESS = 20
    POINT_EVALUATION_PRECOMPILE_GAS = 50_000
    MAX_DATA_GAS_PER_BLOCK = 786432
    TARGET_DATA_GAS_PER_BLOCK = 393216
    MIN_DATA_GASPRICE = 1
    DATA_GASPRICE_UPDATE_FRACTION = 3338477
    # MAX_VERSIONED_HASHES_LIST_SIZE = 2**24
    # MAX_CALLDATA_SIZE = 2**24
    # MAX_ACCESS_LIST_SIZE = 2**24
    # MAX_ACCESS_LIST_STORAGE_KEYS = 2**24
    # MAX_TX_WRAP_COMMITMENTS = 2**12
    # LIMIT_BLOBS_PER_TX = 2**12
    DATA_GAS_PER_BLOB = 2**17
    HASH_OPCODE_BYTE = 0x49
    HASH_GAS_COST = 3

    @classmethod
    def kzg_to_versioned_hash(
        cls,
        kzg_commitment: bytes | int,  # 48 bytes
        blob_commitment_version_kzg: Optional[bytes | int] = None,
    ) -> bytes:
        """
        Calculates the versioned hash for a given KZG commitment.
        """
        if blob_commitment_version_kzg is None:
            blob_commitment_version_kzg = cls.BLOB_COMMITMENT_VERSION_KZG
        if isinstance(kzg_commitment, int):
            kzg_commitment = kzg_commitment.to_bytes(48, "big")
        if isinstance(blob_commitment_version_kzg, int):
            blob_commitment_version_kzg = blob_commitment_version_kzg.to_bytes(1, "big")
        return blob_commitment_version_kzg + sha256(kzg_commitment).digest()[1:]

    @classmethod
    def fake_exponential(cls, factor: int, numerator: int, denominator: int) -> int:
        """
        Used to calculate the data gas cost.
        """
        i = 1
        output = 0
        numerator_accumulator = factor * denominator
        while numerator_accumulator > 0:
            output += numerator_accumulator
            numerator_accumulator = (numerator_accumulator * numerator) // (denominator * i)
            i += 1
        return output // denominator

    @classmethod
    def calc_excess_data_gas(cls, parent: BlockHeaderDataGasFields) -> int:
        """
        Calculate the excess data gas for a block given the excess data gas
        and data gas used from the parent block header.
        """
        if parent.excess_data_gas + parent.data_gas_used < cls.TARGET_DATA_GAS_PER_BLOCK:
            return 0
        else:
            return parent.excess_data_gas + parent.data_gas_used - cls.TARGET_DATA_GAS_PER_BLOCK

    # Note: Currently unused.
    # @classmethod
    # def get_total_data_gas(cls, tx: Transaction) -> int:
    #     """
    #     Calculate the total data gas for a transaction.
    #     """
    #     if tx.blob_versioned_hashes is None:
    #         return 0
    #     return cls.DATA_GAS_PER_BLOB * len(tx.blob_versioned_hashes)

    @classmethod
    def get_data_gasprice(cls, *, excess_data_gas: int) -> int:
        """
        Calculate the data gas price from the excess.
        """
        return cls.fake_exponential(
            cls.MIN_DATA_GASPRICE,
            excess_data_gas,
            cls.DATA_GASPRICE_UPDATE_FRACTION,
        )

SpecHelpers dataclass

Define parameters and helper functions that are tightly coupled to the 4844 spec but not strictly part of it.

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

@dataclass(frozen=True)
class SpecHelpers:
    """
    Define parameters and helper functions that are tightly coupled to the 4844
    spec but not strictly part of it.
    """

    BYTES_PER_FIELD_ELEMENT = 32

    @classmethod
    def max_blobs_per_block(cls) -> int:  # MAX_BLOBS_PER_BLOCK =
        """
        Returns the maximum number of blobs per block.
        """
        return Spec.MAX_DATA_GAS_PER_BLOCK // Spec.DATA_GAS_PER_BLOB

    @classmethod
    def target_blobs_per_block(cls) -> int:
        """
        Returns the target number of blobs per block.
        """
        return Spec.TARGET_DATA_GAS_PER_BLOCK // Spec.DATA_GAS_PER_BLOB

    @classmethod
    def calc_excess_data_gas_from_blob_count(
        cls, parent_excess_data_gas: int, parent_blob_count: int
    ) -> int:
        """
        Calculate the excess data gas for a block given the parent excess data gas
        and the number of blobs in the block.
        """
        parent_consumed_data_gas = parent_blob_count * Spec.DATA_GAS_PER_BLOB
        return Spec.calc_excess_data_gas(
            BlockHeaderDataGasFields(parent_excess_data_gas, parent_consumed_data_gas)
        )

    @classmethod
    def get_min_excess_data_gas_for_data_gas_price(cls, data_gas_price: int) -> int:
        """
        Gets the minimum required excess data gas value to get a given data gas cost in a block
        """
        current_excess_data_gas = 0
        current_data_gas_price = 1
        while current_data_gas_price < data_gas_price:
            current_excess_data_gas += Spec.DATA_GAS_PER_BLOB
            current_data_gas_price = Spec.get_data_gasprice(
                excess_data_gas=current_excess_data_gas
            )
        return current_excess_data_gas

    @classmethod
    def get_min_excess_data_blobs_for_data_gas_price(cls, data_gas_price: int) -> int:
        """
        Gets the minimum required excess data blobs to get a given data gas cost in a block
        """
        return (
            cls.get_min_excess_data_gas_for_data_gas_price(data_gas_price)
            // Spec.DATA_GAS_PER_BLOB
        )

test_correct_excess_data_gas_calculation(blockchain_test, env, pre, blocks, post, correct_excess_data_gas)

Test calculation of the excessDataGas increase/decrease across multiple blocks with and without blobs:

• With parent block containing [0, MAX_BLOBS_PER_BLOCK] blobs
• With parent block containing [0, TARGET_BLOBS_PER_BLOCK] equivalent value of excess data gas

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

@pytest.mark.parametrize("parent_blobs", range(0, SpecHelpers.max_blobs_per_block() + 1))
@pytest.mark.parametrize("parent_excess_blobs", range(0, SpecHelpers.target_blobs_per_block() + 1))
@pytest.mark.parametrize("new_blobs", [1])
def test_correct_excess_data_gas_calculation(
    blockchain_test: BlockchainTestFiller,
    env: Environment,
    pre: Mapping[str, Account],
    blocks: List[Block],
    post: Mapping[str, Account],
    correct_excess_data_gas: int,
):
    """
    Test calculation of the `excessDataGas` increase/decrease across
    multiple blocks with and without blobs:

    - With parent block containing `[0, MAX_BLOBS_PER_BLOCK]` blobs
    - With parent block containing `[0, TARGET_BLOBS_PER_BLOCK]` equivalent value of excess data gas
    """  # noqa: E501
    blockchain_test(
        pre=pre,
        post=post,
        blocks=blocks,
        genesis_environment=env,
        tag=f"expected_excess_data_gas:{hex(correct_excess_data_gas)}",
    )

test_correct_increasing_data_gas_costs(blockchain_test, env, pre, blocks, post, correct_excess_data_gas)

Test calculation of the excessDataGas and data gas tx costs at value points where the cost increases to interesting amounts:

• At the first data gas cost increase (1 to 2)
• At total transaction data cost increase to > 2^32
• At data gas wei cost increase to > 2^32
• At total transaction data cost increase to > 2^64
• At data gas wei cost increase to > 2^64
• At data gas wei cost increase of around current total Ether supply

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

@pytest.mark.parametrize(
    "parent_excess_blobs",
    [g - 1 for g in DATA_GAS_COST_INCREASES],
)
@pytest.mark.parametrize("parent_blobs", [SpecHelpers.target_blobs_per_block() + 1])
@pytest.mark.parametrize("new_blobs", [1])
def test_correct_increasing_data_gas_costs(
    blockchain_test: BlockchainTestFiller,
    env: Environment,
    pre: Mapping[str, Account],
    blocks: List[Block],
    post: Mapping[str, Account],
    correct_excess_data_gas: int,
):
    """
    Test calculation of the `excessDataGas` and data gas tx costs at
    value points where the cost increases to interesting amounts:

    - At the first data gas cost increase (1 to 2)
    - At total transaction data cost increase to `> 2^32`
    - At data gas wei cost increase to `> 2^32`
    - At total transaction data cost increase to `> 2^64`
    - At data gas wei cost increase to `> 2^64`
    - At data gas wei cost increase of around current total Ether supply
    """
    blockchain_test(
        pre=pre,
        post=post,
        blocks=blocks,
        genesis_environment=env,
        tag=f"expected_excess_data_gas:{hex(correct_excess_data_gas)}",
    )

test_correct_decreasing_data_gas_costs(blockchain_test, env, pre, blocks, post, correct_excess_data_gas)

Test calculation of the excessDataGas and data gas tx costs at value points where the cost decreases to interesting amounts.

See test_correct_increasing_data_gas_costs.

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

@pytest.mark.parametrize(
    "parent_excess_blobs",
    [g for g in DATA_GAS_COST_INCREASES],
)
@pytest.mark.parametrize("parent_blobs", [SpecHelpers.target_blobs_per_block() - 1])
@pytest.mark.parametrize("new_blobs", [1])
def test_correct_decreasing_data_gas_costs(
    blockchain_test: BlockchainTestFiller,
    env: Environment,
    pre: Mapping[str, Account],
    blocks: List[Block],
    post: Mapping[str, Account],
    correct_excess_data_gas: int,
):
    """
    Test calculation of the `excessDataGas` and data gas tx costs at
    value points where the cost decreases to interesting amounts.

    See test_correct_increasing_data_gas_costs.
    """
    blockchain_test(
        pre=pre,
        post=post,
        blocks=blocks,
        genesis_environment=env,
        tag=f"expected_excess_data_gas:{hex(correct_excess_data_gas)}",
    )

test_invalid_zero_excess_data_gas_in_header(blockchain_test, env, pre, blocks, correct_excess_data_gas, header_excess_data_gas)

Test rejection of blocks where the excessDataGas in the header drops to zero in a block with or without data blobs, but the excess blobs in the parent are greater than target.

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

@pytest.mark.parametrize("header_excess_data_gas", [0])
@pytest.mark.parametrize("new_blobs", [0, 1])
@pytest.mark.parametrize("parent_blobs", range(0, SpecHelpers.max_blobs_per_block() + 1))
def test_invalid_zero_excess_data_gas_in_header(
    blockchain_test: BlockchainTestFiller,
    env: Environment,
    pre: Mapping[str, Account],
    blocks: List[Block],
    correct_excess_data_gas: int,
    header_excess_data_gas: Optional[int],
):
    """
    Test rejection of blocks where the `excessDataGas` in the header drops to
    zero in a block with or without data blobs, but the excess blobs in the parent are
    greater than target.
    """
    if header_excess_data_gas is None:
        raise Exception("test case is badly formatted")

    if header_excess_data_gas == correct_excess_data_gas:
        raise Exception("invalid test case")

    blockchain_test(
        pre=pre,
        post={},
        blocks=blocks,
        genesis_environment=env,
        tag="-".join(
            [
                f"correct:{hex(correct_excess_data_gas)}",
                f"header:{hex(header_excess_data_gas)}",
            ]
        ),
    )

test_invalid_data_gas_used_in_header(blockchain_test, env, pre, blocks, new_blobs, header_data_gas_used)

Test rejection of blocks where the dataGasUsed in the header is invalid:

• dataGasUsed is not equal to the number of data blobs in the block
• dataGasUsed is the max uint64 value

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

@pytest.mark.parametrize(
    "new_blobs,header_data_gas_used",
    all_invalid_data_gas_used_combinations(),
)
@pytest.mark.parametrize("parent_blobs", [0])
def test_invalid_data_gas_used_in_header(
    blockchain_test: BlockchainTestFiller,
    env: Environment,
    pre: Mapping[str, Account],
    blocks: List[Block],
    new_blobs: int,
    header_data_gas_used: Optional[int],
):
    """
    Test rejection of blocks where the `dataGasUsed` in the header is invalid:

    - `dataGasUsed` is not equal to the number of data blobs in the block
    - `dataGasUsed` is the max uint64 value
    """
    if header_data_gas_used is None:
        raise Exception("test case is badly formatted")
    blockchain_test(
        pre=pre,
        post={},
        blocks=blocks,
        genesis_environment=env,
        tag="-".join(
            [
                f"correct:{hex(new_blobs *Spec.DATA_GAS_PER_BLOB)}",
                f"header:{hex(header_data_gas_used)}",
            ]
        ),
    )

test_invalid_excess_data_gas_above_target_change(blockchain_test, env, pre, blocks, correct_excess_data_gas, header_excess_data_gas)

Test rejection of blocks where the excessDataGas

• decreases more than TARGET_DATA_GAS_PER_BLOCK in a single block with zero blobs
• increases more than TARGET_DATA_GAS_PER_BLOCK in a single block with max blobs

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

@pytest.mark.parametrize(
    "header_excess_blobs_delta,parent_blobs",
    [
        (-1, 0),
        (+1, SpecHelpers.max_blobs_per_block()),
    ],
    ids=["zero_blobs_decrease_more_than_expected", "max_blobs_increase_more_than_expected"],
)
@pytest.mark.parametrize("new_blobs", [1])
def test_invalid_excess_data_gas_above_target_change(
    blockchain_test: BlockchainTestFiller,
    env: Environment,
    pre: Mapping[str, Account],
    blocks: List[Block],
    correct_excess_data_gas: int,
    header_excess_data_gas: Optional[int],
):
    """
    Test rejection of blocks where the `excessDataGas`

    - decreases more than `TARGET_DATA_GAS_PER_BLOCK` in a single block with zero blobs
    - increases more than `TARGET_DATA_GAS_PER_BLOCK` in a single block with max blobs
    """
    if header_excess_data_gas is None:
        raise Exception("test case is badly formatted")

    if header_excess_data_gas == correct_excess_data_gas:
        raise Exception("invalid test case")

    blockchain_test(
        pre=pre,
        post={},
        blocks=blocks,
        genesis_environment=env,
        tag="-".join(
            [
                f"correct:{hex(correct_excess_data_gas)}",
                f"header:{hex(header_excess_data_gas)}",
            ]
        ),
    )

test_invalid_static_excess_data_gas(blockchain_test, env, pre, blocks, correct_excess_data_gas, parent_excess_data_gas)

Test rejection of blocks where the excessDataGas remains unchanged but the parent blobs included are not TARGET_BLOBS_PER_BLOCK.

Test is parametrized to MAX_BLOBS_PER_BLOCK and TARGET_BLOBS_PER_BLOCK.

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

@pytest.mark.parametrize(
    "parent_blobs",
    [
        b
        for b in range(0, SpecHelpers.max_blobs_per_block() + 1)
        if b != SpecHelpers.target_blobs_per_block()
    ],
)
@pytest.mark.parametrize("parent_excess_blobs", [1, SpecHelpers.target_blobs_per_block()])
@pytest.mark.parametrize("new_blobs", [1])
def test_invalid_static_excess_data_gas(
    blockchain_test: BlockchainTestFiller,
    env: Environment,
    pre: Mapping[str, Account],
    blocks: List[Block],
    correct_excess_data_gas: int,
    parent_excess_data_gas: int,
):
    """
    Test rejection of blocks where the `excessDataGas` remains unchanged
    but the parent blobs included are not `TARGET_BLOBS_PER_BLOCK`.

    Test is parametrized to `MAX_BLOBS_PER_BLOCK` and `TARGET_BLOBS_PER_BLOCK`.
    """
    blocks[-1].rlp_modifier = Header(excess_data_gas=parent_excess_data_gas)
    blocks[-1].exception = "invalid excessDataGas"
    blockchain_test(
        pre=pre,
        post={},
        blocks=blocks,
        genesis_environment=env,
        tag="-".join(
            [
                f"correct:{hex(correct_excess_data_gas)}",
                f"header:{hex(parent_excess_data_gas)}",
            ]
        ),
    )

test_invalid_excess_data_gas_target_blobs_increase_from_zero(blockchain_test, env, pre, blocks, correct_excess_data_gas, header_excess_data_gas)

Test rejection of blocks where the excessDataGas increases from zero, even when the included blobs are on or below target.

Test is parametrized according to [0, TARGET_BLOBS_PER_BLOCK new blobs.

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

@pytest.mark.parametrize("header_excess_blobs_delta", range(1, SpecHelpers.max_blobs_per_block()))
@pytest.mark.parametrize("parent_blobs", range(0, SpecHelpers.target_blobs_per_block() + 1))
@pytest.mark.parametrize("parent_excess_blobs", [0])  # Start at 0
@pytest.mark.parametrize("new_blobs", [1])
def test_invalid_excess_data_gas_target_blobs_increase_from_zero(
    blockchain_test: BlockchainTestFiller,
    env: Environment,
    pre: Mapping[str, Account],
    blocks: List[Block],
    correct_excess_data_gas: int,
    header_excess_data_gas: Optional[int],
):
    """
    Test rejection of blocks where the `excessDataGas` increases from zero,
    even when the included blobs are on or below target.

    Test is parametrized according to `[0, TARGET_BLOBS_PER_BLOCK` new blobs.
    """
    if header_excess_data_gas is None:
        raise Exception("test case is badly formatted")

    if header_excess_data_gas == correct_excess_data_gas:
        raise Exception("invalid test case")

    blockchain_test(
        pre=pre,
        post={},
        blocks=blocks,
        genesis_environment=env,
        tag="-".join(
            [
                f"correct:{hex(correct_excess_data_gas)}",
                f"header:{hex(header_excess_data_gas)}",
            ]
        ),
    )

test_invalid_static_excess_data_gas_from_zero_on_blobs_above_target(blockchain_test, env, pre, blocks, correct_excess_data_gas, header_excess_data_gas)

Test rejection of blocks where the excessDataGas does not increase from zero, even when the included blobs is above target.

Test is parametrized to [TARGET_BLOBS_PER_BLOCK+1, MAX_BLOBS_PER_BLOCK] new blobs.

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

@pytest.mark.parametrize("header_excess_data_gas", [0])
@pytest.mark.parametrize(
    "parent_blobs",
    range(SpecHelpers.target_blobs_per_block() + 1, SpecHelpers.max_blobs_per_block() + 1),
)
@pytest.mark.parametrize("parent_excess_blobs", [0])  # Start at 0
@pytest.mark.parametrize("new_blobs", [1])
def test_invalid_static_excess_data_gas_from_zero_on_blobs_above_target(
    blockchain_test: BlockchainTestFiller,
    env: Environment,
    pre: Mapping[str, Account],
    blocks: List[Block],
    correct_excess_data_gas: int,
    header_excess_data_gas: Optional[int],
):
    """
    Test rejection of blocks where the `excessDataGas` does not increase from
    zero, even when the included blobs is above target.

    Test is parametrized to `[TARGET_BLOBS_PER_BLOCK+1, MAX_BLOBS_PER_BLOCK]` new blobs.
    """
    if header_excess_data_gas is None:
        raise Exception("test case is badly formatted")

    if header_excess_data_gas == correct_excess_data_gas:
        raise Exception("invalid test case")

    blockchain_test(
        pre=pre,
        post={},
        blocks=blocks,
        genesis_environment=env,
        tag="-".join(
            [
                f"correct:{hex(correct_excess_data_gas)}",
                f"header:{hex(header_excess_data_gas)}",
            ]
        ),
    )

test_invalid_excess_data_gas_change(blockchain_test, env, pre, blocks, correct_excess_data_gas, header_excess_data_gas)

Test rejection of blocks where the excessDataGas changes to an invalid value.

Given a parent block containing [0, MAX_BLOBS_PER_BLOCK] blobs, test an invalid excessDataGas value by changing it by [-TARGET_BLOBS_PER_BLOCK, TARGET_BLOBS_PER_BLOCK] from the correct value.

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

@pytest.mark.parametrize(
    "parent_blobs,header_excess_blobs_delta",
    itertools.product(
        # parent_blobs
        range(0, SpecHelpers.max_blobs_per_block() + 1),
        # header_excess_blobs_delta (from correct value)
        [
            x
            for x in range(
                -SpecHelpers.target_blobs_per_block(), SpecHelpers.target_blobs_per_block() + 1
            )
            if x != 0
        ],
    ),
)
@pytest.mark.parametrize("new_blobs", [1])
def test_invalid_excess_data_gas_change(
    blockchain_test: BlockchainTestFiller,
    env: Environment,
    pre: Mapping[str, Account],
    blocks: List[Block],
    correct_excess_data_gas: int,
    header_excess_data_gas: Optional[int],
):
    """
    Test rejection of blocks where the `excessDataGas` changes to an invalid
    value.

    Given a parent block containing `[0, MAX_BLOBS_PER_BLOCK]` blobs, test an invalid
    `excessDataGas` value by changing it by `[-TARGET_BLOBS_PER_BLOCK, TARGET_BLOBS_PER_BLOCK]`
    from the correct value.
    """
    if header_excess_data_gas is None:
        raise Exception("test case is badly formatted")

    if header_excess_data_gas == correct_excess_data_gas:
        raise Exception("invalid test case")

    blockchain_test(
        pre=pre,
        post={},
        blocks=blocks,
        genesis_environment=env,
        tag="-".join(
            [
                f"correct:{hex(correct_excess_data_gas)}",
                f"header:{hex(header_excess_data_gas)}",
            ]
        ),
    )

test_invalid_negative_excess_data_gas(blockchain_test, env, pre, blocks, correct_excess_data_gas, header_excess_data_gas)

Test rejection of blocks where the excessDataGas changes to the two's complement equivalent of the negative value after subtracting target blobs.

Reasoning is that the excessDataGas is a uint64, so it cannot be negative, and we test for a potential underflow here.

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

@pytest.mark.parametrize(
    "header_excess_data_gas",
    [
        (2**64 + (x * Spec.DATA_GAS_PER_BLOB))
        for x in range(-SpecHelpers.target_blobs_per_block(), 0)
    ],
)
@pytest.mark.parametrize("parent_blobs", range(SpecHelpers.target_blobs_per_block()))
@pytest.mark.parametrize("new_blobs", [1])
@pytest.mark.parametrize("parent_excess_blobs", range(SpecHelpers.target_blobs_per_block()))
def test_invalid_negative_excess_data_gas(
    blockchain_test: BlockchainTestFiller,
    env: Environment,
    pre: Mapping[str, Account],
    blocks: List[Block],
    correct_excess_data_gas: int,
    header_excess_data_gas: Optional[int],
):
    """
    Test rejection of blocks where the `excessDataGas` changes to the two's
    complement equivalent of the negative value after subtracting target blobs.

    Reasoning is that the `excessDataGas` is a `uint64`, so it cannot be negative, and
    we test for a potential underflow here.
    """
    if header_excess_data_gas is None:
        raise Exception("test case is badly formatted")

    if header_excess_data_gas == correct_excess_data_gas:
        raise Exception("invalid test case")

    blockchain_test(
        pre=pre,
        post={},
        blocks=blocks,
        genesis_environment=env,
        tag="-".join(
            [
                f"correct:{hex(correct_excess_data_gas)}",
                f"header:{hex(header_excess_data_gas)}",
            ]
        ),
    )

test_invalid_non_multiple_excess_data_gas(blockchain_test, env, pre, blocks, correct_excess_data_gas, header_excess_data_gas)

Test rejection of blocks where the excessDataGas changes to a value that is not a multiple of Spec.DATA_GAS_PER_BLOB`:

• Parent block contains TARGET_BLOBS_PER_BLOCK + 1 blobs, but excessDataGas is off by ±1
• Parent block contains TARGET_BLOBS_PER_BLOCK - 1 blobs, but excessDataGas is off by ±1

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

@pytest.mark.parametrize(
    "parent_blobs,header_excess_data_gas_delta",
    [
        (SpecHelpers.target_blobs_per_block() + 1, 1),
        (SpecHelpers.target_blobs_per_block() + 1, Spec.DATA_GAS_PER_BLOB - 1),
        (SpecHelpers.target_blobs_per_block() - 1, -1),
        (SpecHelpers.target_blobs_per_block() - 1, -(Spec.DATA_GAS_PER_BLOB - 1)),
    ],
)
@pytest.mark.parametrize("new_blobs", [1])
@pytest.mark.parametrize("parent_excess_blobs", [SpecHelpers.target_blobs_per_block() + 1])
def test_invalid_non_multiple_excess_data_gas(
    blockchain_test: BlockchainTestFiller,
    env: Environment,
    pre: Mapping[str, Account],
    blocks: List[Block],
    correct_excess_data_gas: int,
    header_excess_data_gas: Optional[int],
):
    """
    Test rejection of blocks where the `excessDataGas` changes to a value that
    is not a multiple of Spec.DATA_GAS_PER_BLOB`:

    - Parent block contains `TARGET_BLOBS_PER_BLOCK + 1` blobs, but `excessDataGas` is off by +/-1
    - Parent block contains `TARGET_BLOBS_PER_BLOCK - 1` blobs, but `excessDataGas` is off by +/-1
    """
    if header_excess_data_gas is None:
        raise Exception("test case is badly formatted")

    if header_excess_data_gas == correct_excess_data_gas:
        raise Exception("invalid test case")

    blockchain_test(
        pre=pre,
        post={},
        blocks=blocks,
        genesis_environment=env,
        tag="-".join(
            [
                f"correct:{hex(correct_excess_data_gas)}",
                f"header:{hex(header_excess_data_gas)}",
            ]
        ),
    )