test_calling_from_new_contract_to_pre_existing_contract()

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

Generate fixtures for these test cases for Amsterdam with:

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

Test that if an account created in the current transaction delegate-call a previously created account that executes self-destruct, the calling account is deleted.

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

@pytest.mark.parametrize("call_times", [1])
@pytest.mark.parametrize("selfdestruct_contract_initial_balance", [0, 1])
@pytest.mark.parametrize("call_opcode", [Op.DELEGATECALL, Op.CALLCODE])
@pytest.mark.parametrize("create_opcode", [Op.CREATE])
@pytest.mark.valid_from("Shanghai")
def test_calling_from_new_contract_to_pre_existing_contract(
    state_test: StateTestFiller,
    pre: Alloc,
    sender: EOA,
    fork: Fork,
    sendall_recipient_addresses: List[Address],
    create_opcode: Op,
    call_opcode: Op,
    call_times: int,
    selfdestruct_contract_initial_balance: int,
) -> None:
    """
    Test that if an account created in the current transaction delegate-call a
    previously created account that executes self-destruct, the calling account
    is deleted.
    """
    pre_existing_selfdestruct_address = pre.deploy_contract(
        selfdestruct_code_preset(
            sendall_recipient_addresses=sendall_recipient_addresses,
        ),
    )
    # Our entry point is an initcode that in turn creates a self-destructing
    # contract
    entry_code_storage = Storage()
    sendall_amount = 0

    entry_code_address = compute_create_address(address=sender, nonce=0)
    selfdestruct_contract_address = compute_create_address(
        address=entry_code_address, nonce=1
    )

    if selfdestruct_contract_initial_balance > 0:
        pre.fund_address(
            selfdestruct_contract_address,
            selfdestruct_contract_initial_balance,
        )

    # self-destructing call
    selfdestruct_code = call_opcode(address=pre_existing_selfdestruct_address)
    selfdestruct_contract_initcode = Initcode(deploy_code=selfdestruct_code)
    initcode_copy_from_address = pre.deploy_contract(
        selfdestruct_contract_initcode
    )

    # Bytecode used to create the contract, can be CREATE or CREATE2
    create_bytecode = create_opcode(size=len(selfdestruct_contract_initcode))

    # Entry code that will be executed, creates the contract and then calls it
    # in the same tx
    entry_code = (
        # Initcode is already deployed at `initcode_copy_from_address`, so just
        # copy it
        Op.EXTCODECOPY(
            initcode_copy_from_address,
            0,
            0,
            len(selfdestruct_contract_initcode),
        )
        # And we store the created address for verification purposes
        + Op.SSTORE(
            entry_code_storage.store_next(selfdestruct_contract_address),
            create_bytecode,
        )
    )

    # Store the EXTCODE* properties of the created address
    entry_code += Op.SSTORE(
        entry_code_storage.store_next(len(selfdestruct_code)),
        Op.EXTCODESIZE(selfdestruct_contract_address),
    )

    entry_code += Op.SSTORE(
        entry_code_storage.store_next(selfdestruct_code.keccak256()),
        Op.EXTCODEHASH(selfdestruct_contract_address),
    )

    # Call the self-destructing contract multiple times as required, increasing
    # the wei sent each time
    entry_code_balance = 0
    for i in range(call_times):
        entry_code += Op.SSTORE(
            entry_code_storage.store_next(1),
            Op.CALL(
                Op.GASLIMIT,  # Gas
                selfdestruct_contract_address,  # Address
                i,  # Value
                0,
                0,
                0,
                0,
            ),
        )
        entry_code_balance += i
        sendall_amount += i

        entry_code += Op.SSTORE(
            entry_code_storage.store_next(0),
            Op.BALANCE(selfdestruct_contract_address),
        )

    # Check the EXTCODE* properties of the self-destructing contract again
    entry_code += Op.SSTORE(
        entry_code_storage.store_next(len(selfdestruct_code)),
        Op.EXTCODESIZE(selfdestruct_contract_address),
    )

    entry_code += Op.SSTORE(
        entry_code_storage.store_next(selfdestruct_code.keccak256()),
        Op.EXTCODEHASH(selfdestruct_contract_address),
    )

    # Lastly return zero so the entry point contract is created and we can
    # retain the stored values for verification.
    entry_code += Op.RETURN(max(len(selfdestruct_contract_initcode), 32), 1)

    if selfdestruct_contract_initial_balance > 0:
        # Address where the contract is created already had some balance,
        # which must be included in the send-all operation
        sendall_amount += selfdestruct_contract_initial_balance

    post: Dict[Address, Account] = {
        entry_code_address: Account(
            storage=entry_code_storage,
        ),
        selfdestruct_contract_address: Account.NONEXISTENT,  # type: ignore
        sendall_recipient_addresses[0]: Account(
            balance=sendall_amount, storage={0: 1}
        ),
    }

    tx = Transaction(
        value=entry_code_balance,
        data=entry_code,
        sender=sender,
        to=None,
        gas_limit=500_000,
    )

    if fork.is_eip_enabled(7708):
        # The new contract's body is a DELEGATECALL/CALLCODE to the pre-
        # existing selfdestruct code, so SELFDESTRUCT runs in the NEW
        # contract's context and transfers its balance to the recipient.
        expected_logs = []
        if entry_code_balance > 0:
            expected_logs.append(
                transfer_log(sender, entry_code_address, entry_code_balance)
            )
        running_balance = selfdestruct_contract_initial_balance
        for i in range(call_times):
            if i > 0:
                expected_logs.append(
                    transfer_log(
                        entry_code_address, selfdestruct_contract_address, i
                    )
                )
            running_balance += i
            if running_balance > 0:
                expected_logs.append(
                    transfer_log(
                        selfdestruct_contract_address,
                        sendall_recipient_addresses[0],
                        running_balance,
                    )
                )
            running_balance = 0
        tx.expected_receipt = TransactionReceipt(logs=expected_logs)

    state_test(pre=pre, post=post, tx=tx)

Parametrized Test Cases

This test generates 4 parametrized test cases across 5 forks.