test_create_multiple_contracts_destroy_one_then_destroy_other_next_tx()

Documentation for tests/cancun/eip6780_selfdestruct/test_selfdestruct.py::test_create_multiple_contracts_destroy_one_then_destroy_other_next_tx@b47f0253.

Generate fixtures for these test cases for Amsterdam with:

fill -v tests/cancun/eip6780_selfdestruct/test_selfdestruct.py::test_create_multiple_contracts_destroy_one_then_destroy_other_next_tx --fork Amsterdam

Test creating multiple contracts in one transaction, destroying only one of them, then attempting to destroy the other in a subsequent transaction.

Contract A: Self-destructs in the same transaction as creation (deleted) Contract B: Does NOT self-destruct in creation tx, attempted destruction in subsequent tx (persists after EIP-6780)

Source code in tests/cancun/eip6780_selfdestruct/test_selfdestruct.py

@pytest.mark.parametrize("selfdestruct_contract_initial_balance", [0, 100_000])
@pytest.mark.valid_from("Shanghai")
def test_create_multiple_contracts_destroy_one_then_destroy_other_next_tx(
    blockchain_test: BlockchainTestFiller,
    eip_enabled: bool,
    pre: Alloc,
    sender: EOA,
    fork: Fork,
    selfdestruct_contract_initial_balance: int,
) -> None:
    """
    Test creating multiple contracts in one transaction, destroying only one
    of them, then attempting to destroy the other in a subsequent transaction.

    Contract A: Self-destructs in the same transaction as creation (deleted)
    Contract B: Does NOT self-destruct in creation tx, attempted destruction
                in subsequent tx (persists after EIP-6780)
    """
    # Pre-deploy a recipient contract
    sendall_recipient = pre.deploy_contract(
        code=Op.SSTORE(0, 0),
        storage={0: 1},
    )

    # Self-destructing contract code: selfdestruct based on calldata
    # If calldata[0] == 1, self-destruct; otherwise just increment storage
    selfdestruct_code = Op.SSTORE(0, Op.ADD(Op.SLOAD(0), 1)) + Conditional(
        condition=Op.EQ(Op.CALLDATALOAD(0), 1),
        if_true=Op.SELFDESTRUCT(sendall_recipient),
        if_false=Op.STOP,
    )
    selfdestruct_initcode = Initcode(deploy_code=selfdestruct_code)
    initcode_copy_from_address = pre.deploy_contract(selfdestruct_initcode)

    # Deploy entry contract
    entry_code_storage = Storage()

    # Entry code: create both contracts, call A with selfdestruct flag,
    # call B without
    entry_code = Op.EXTCODECOPY(
        initcode_copy_from_address,
        0,
        0,
        len(selfdestruct_initcode),
    )

    # Create contract A with salt=0
    entry_code += Op.SSTORE(
        entry_code_storage.store_next(0),  # Replaced with actual address
        Op.CREATE2(value=0, offset=0, size=len(selfdestruct_initcode), salt=0),
    )

    # Create contract B with salt=1
    entry_code += Op.SSTORE(
        entry_code_storage.store_next(0),  # Replaced with actual address
        Op.CREATE2(value=0, offset=0, size=len(selfdestruct_initcode), salt=1),
    )

    # Call contract A (slot 0) with flag=1 to self-destruct
    entry_code += Op.MSTORE(0, 1)
    entry_code += Op.SSTORE(
        entry_code_storage.store_next(1),
        Op.CALL(Op.GASLIMIT, Op.SLOAD(0), 0, 0, 32, 0, 0),
    )

    # Call contract B (slot 1) with flag=0 to NOT self-destruct
    entry_code += Op.MSTORE(0, 0)
    entry_code += Op.SSTORE(
        entry_code_storage.store_next(1),
        Op.CALL(Op.GASLIMIT, Op.SLOAD(1), 0, 0, 32, 0, 0),
    )

    entry_code += Op.STOP

    entry_code_address = pre.deploy_contract(entry_code)

    # Calculate contract addresses
    contract_a_address = compute_create_address(
        address=entry_code_address,
        salt=0,
        initcode=selfdestruct_initcode,
        opcode=Op.CREATE2,
    )
    contract_b_address = compute_create_address(
        address=entry_code_address,
        salt=1,
        initcode=selfdestruct_initcode,
        opcode=Op.CREATE2,
    )

    # Update expected storage
    entry_code_storage[0] = contract_a_address
    entry_code_storage[1] = contract_b_address

    if selfdestruct_contract_initial_balance > 0:
        pre.fund_address(
            contract_a_address, selfdestruct_contract_initial_balance
        )
        pre.fund_address(
            contract_b_address, selfdestruct_contract_initial_balance
        )

    # Second transaction: try to self-destruct contract B
    tx2_caller = pre.deploy_contract(
        Op.MSTORE(0, 1)
        + Op.CALL(Op.GASLIMIT, contract_b_address, 0, 0, 32, 0, 0)
        + Op.STOP
    )

    tx1_receipt = None
    tx2_receipt = None
    if fork.is_eip_enabled(7708):
        # Tx1: only A SELFDESTRUCTs (flag=1), transferring its pre-funded
        # balance to the shared recipient. B gets called with flag=0 and
        # returns without emitting any log.
        tx1_logs = []
        if selfdestruct_contract_initial_balance > 0:
            tx1_logs.append(
                transfer_log(
                    contract_a_address,
                    sendall_recipient,
                    selfdestruct_contract_initial_balance,
                )
            )
        tx1_receipt = TransactionReceipt(logs=tx1_logs)

        # Tx2: B (now pre-existing) SELFDESTRUCTs transferring its
        # pre-funded balance to the recipient.
        tx2_logs = []
        if selfdestruct_contract_initial_balance > 0:
            tx2_logs.append(
                transfer_log(
                    contract_b_address,
                    sendall_recipient,
                    selfdestruct_contract_initial_balance,
                )
            )
        tx2_receipt = TransactionReceipt(logs=tx2_logs)

    txs = [
        Transaction(
            sender=sender,
            to=entry_code_address,
            gas_limit=1_000_000,
            expected_receipt=tx1_receipt,
        ),
        Transaction(
            sender=sender,
            to=tx2_caller,
            gas_limit=500_000,
            expected_receipt=tx2_receipt,
        ),
    ]

    post: Dict[Address, Account] = {
        entry_code_address: Account(storage=entry_code_storage),
        # Contract A is always destroyed (created and destroyed same tx)
        contract_a_address: Account.NONEXISTENT,  # type: ignore
    }

    if eip_enabled:
        # After EIP-6780: Contract B persists (not destroyed in same tx)
        # Storage shows 2 calls (one in tx1, one in tx2)
        post[contract_b_address] = Account(
            storage={0: 2},
            balance=0,  # Balance sent but contract persists
        )
        post[sendall_recipient] = Account(
            balance=selfdestruct_contract_initial_balance * 2,
            storage={0: 1},
        )
    else:
        # Before EIP-6780: Contract B is destroyed in tx2
        post[contract_b_address] = Account.NONEXISTENT  # type: ignore
        post[sendall_recipient] = Account(
            balance=selfdestruct_contract_initial_balance * 2,
            storage={0: 1},
        )

    blockchain_test(pre=pre, post=post, blocks=[Block(txs=txs)])

Parametrized Test Cases

This test generates 2 parametrized test cases across 5 forks.