test_bal_invalid_duplicate_entries()

Documentation for tests/amsterdam/eip7928_block_level_access_lists/test_block_access_lists_invalid.py::test_bal_invalid_duplicate_entries@2119b382.

Generate fixtures for these test cases for Amsterdam with:

fill -v tests/amsterdam/eip7928_block_level_access_lists/test_block_access_lists_invalid.py::test_bal_invalid_duplicate_entries --fork Amsterdam

Test that clients reject blocks where BAL contains duplicate entries.

Oracle writes storage, reads storage, and CREATEs a small contract. Verify the EIP-7928 uniqueness constraints: each block_access_index must appear at most once per change list (nonce, balance, code, slot), each storage key at most once in storage_changes and storage_reads, and no key in both.

Source code in tests/amsterdam/eip7928_block_level_access_lists/test_block_access_lists_invalid.py

@pytest.mark.valid_from("Amsterdam")
@pytest.mark.exception_test
@pytest.mark.parametrize(
    "modifier",
    [
        pytest.param(
            lambda alice, **_: duplicate_nonce_change(alice, 1),
            id="duplicate_nonce_change",
        ),
        pytest.param(
            lambda oracle, **_: duplicate_balance_change(oracle, 1),
            id="duplicate_balance_change",
        ),
        pytest.param(
            lambda created, **_: duplicate_code_change(created, 1),
            id="duplicate_code_change",
        ),
        pytest.param(
            lambda oracle, **_: duplicate_storage_slot(oracle, 1),
            id="duplicate_storage_slot",
        ),
        pytest.param(
            lambda oracle, **_: duplicate_storage_read(oracle, 2),
            id="duplicate_storage_read",
        ),
        pytest.param(
            lambda oracle, **_: duplicate_slot_change(oracle, 1, 1),
            id="duplicate_slot_change",
        ),
        pytest.param(
            lambda oracle, **_: insert_storage_read(oracle, 1),
            id="storage_key_in_both_changes_and_reads",
        ),
    ],
)
def test_bal_invalid_duplicate_entries(
    blockchain_test: BlockchainTestFiller,
    pre: Alloc,
    modifier: Callable,
) -> None:
    """
    Test that clients reject blocks where BAL contains duplicate entries.

    Oracle writes storage, reads storage, and CREATEs a small contract.
    Verify the EIP-7928 uniqueness constraints: each block_access_index
    must appear at most once per change list (nonce, balance, code,
    slot), each storage key at most once in storage_changes and
    storage_reads, and no key in both.
    """
    alice = pre.fund_eoa()
    deploy_code = b"\x13\x37"
    initcode = Initcode(deploy_code=deploy_code)
    initcode_word = int.from_bytes(bytes(initcode).ljust(32, b"\x00"), "big")
    oracle = pre.deploy_contract(
        code=(
            Op.SSTORE(1, 0x42)
            + Op.SLOAD(2)
            + Op.MSTORE(0, initcode_word)
            + Op.CREATE(0, 0, len(initcode))
        ),
        storage={2: 0x84},
    )
    created = compute_create_address(address=oracle, nonce=1)

    tx = Transaction(
        sender=alice,
        to=oracle,
        value=100,
    )

    blockchain_test(
        pre=pre,
        post=pre,
        blocks=[
            Block(
                txs=[tx],
                exception=BlockException.INVALID_BLOCK_ACCESS_LIST,
                expected_block_access_list=BlockAccessListExpectation(
                    account_expectations={
                        alice: BalAccountExpectation(
                            nonce_changes=[
                                BalNonceChange(
                                    block_access_index=1,
                                    post_nonce=1,
                                ),
                            ],
                        ),
                        oracle: BalAccountExpectation(
                            balance_changes=[
                                BalBalanceChange(
                                    block_access_index=1,
                                    post_balance=100,
                                ),
                            ],
                            storage_changes=[
                                BalStorageSlot(
                                    slot=1,
                                    slot_changes=[
                                        BalStorageChange(
                                            block_access_index=1,
                                            post_value=0x42,
                                        ),
                                    ],
                                ),
                            ],
                            storage_reads=[2],
                        ),
                        created: BalAccountExpectation(
                            code_changes=[
                                BalCodeChange(
                                    block_access_index=1,
                                    new_code=deploy_code,
                                ),
                            ],
                        ),
                    }
                ).modify(
                    modifier(
                        alice=alice,
                        oracle=oracle,
                        created=created,
                    )
                ),
            )
        ],
    )

Parametrized Test Cases

This test generates 7 parametrized test cases across 1 fork.