Test Selfdestruct Revert

Documentation for tests/cancun/eip6780_selfdestruct/test_selfdestruct_revert.py.

Generate fixtures for these test cases for Cancun with:

Cancun only:

fill -v tests/cancun/eip6780_selfdestruct/test_selfdestruct_revert.py --fork=Cancun --evm-bin=/path/to/evm-tool-dev-version

For all forks up to and including Cancun:

fill -v tests/cancun/eip6780_selfdestruct/test_selfdestruct_revert.py --until=Cancun --evm-bin=/path/to/evm-tool-dev-version

tests for selfdestruct interaction with revert

test_selfdestruct_created_in_same_tx_with_revert(state_test, env, pre, entry_code_address, selfdestruct_on_outer_call, selfdestruct_with_transfer_contract_code, selfdestruct_with_transfer_contract_initcode, selfdestruct_with_transfer_contract_address, selfdestruct_recipient_address, selfdestruct_with_transfer_initcode_copy_from_address, recursive_revert_contract_address, recursive_revert_contract_code)

Given

Contract A which has methods to receive balance and selfdestruct, and was created in current tx

Test the following call sequence: Transfer value to A and call A.selfdestruct. Recurse into a new call from transfers value to A, calls A.selfdestruct, and reverts.

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

@pytest.mark.parametrize(
    "selfdestruct_on_outer_call",
    [0, 1, 2],
    ids=[
        "no_outer_selfdestruct",
        "outer_selfdestruct_before_inner_call",
        "outer_selfdestruct_after_inner_call",
    ],
)
@pytest.mark.valid_from("Cancun")
def test_selfdestruct_created_in_same_tx_with_revert(  # noqa SC200
    state_test: StateTestFiller,
    env: Environment,
    pre: Dict[str, Account],
    entry_code_address: str,
    selfdestruct_on_outer_call: int,
    selfdestruct_with_transfer_contract_code: SupportsBytes,
    selfdestruct_with_transfer_contract_initcode: SupportsBytes,
    selfdestruct_with_transfer_contract_address: str,
    selfdestruct_recipient_address: str,
    selfdestruct_with_transfer_initcode_copy_from_address: str,
    recursive_revert_contract_address: str,
    recursive_revert_contract_code: SupportsBytes,
):
    """
    Given:
        Contract A which has methods to receive balance and selfdestruct, and was created in current tx
    Test the following call sequence:
         Transfer value to A and call A.selfdestruct.
         Recurse into a new call from transfers value to A, calls A.selfdestruct, and reverts.
    """  # noqa: E501
    entry_code = Op.EXTCODECOPY(
        Op.PUSH20(selfdestruct_with_transfer_initcode_copy_from_address),
        0,
        0,
        len(bytes(selfdestruct_with_transfer_contract_initcode)),
    )

    entry_code += Op.SSTORE(
        0,
        Op.CREATE(
            0, 0, len(bytes(selfdestruct_with_transfer_contract_initcode))  # Value  # Offset
        ),
    )

    entry_code += Op.CALL(
        Op.GASLIMIT(),
        Op.PUSH20(recursive_revert_contract_address),
        0,  # value
        0,  # arg offset
        0,  # arg length
        0,  # ret offset
        0,  # ret length
    )

    post: Dict[str, Account] = {
        entry_code_address: Account(
            code="0x", storage=Storage({0: selfdestruct_with_transfer_contract_address})
        ),
        selfdestruct_with_transfer_initcode_copy_from_address: Account(
            code=selfdestruct_with_transfer_contract_initcode,
        ),
        recursive_revert_contract_address: Account(
            code=recursive_revert_contract_code,
            storage=Storage({1: 1}),
        ),
    }

    if selfdestruct_on_outer_call > 0:
        post[selfdestruct_with_transfer_contract_address] = Account.NONEXISTENT  # type: ignore
        post[selfdestruct_recipient_address] = Account(
            balance=1 if selfdestruct_on_outer_call == 1 else 2,
        )
    else:
        post[selfdestruct_with_transfer_contract_address] = Account(
            balance=1,
            code=selfdestruct_with_transfer_contract_code,
            storage=Storage(
                {
                    # 2 value transfers (1 in outer call, 1 in reverted inner call)
                    0: 1,
                    # 1 selfdestruct in reverted inner call
                    1: 0,
                }
            ),
        )
        post[selfdestruct_recipient_address] = Account.NONEXISTENT  # type: ignore

    nonce = count()
    tx = Transaction(
        ty=0x0,
        value=0,
        data=entry_code,
        chain_id=0x0,
        nonce=next(nonce),
        to=None,
        gas_limit=100_000_000,
        gas_price=10,
        protected=False,
    )

    state_test(env=env, pre=pre, post=post, txs=[tx])

test_selfdestruct_not_created_in_same_tx_with_revert(state_test, env, entry_code_address, selfdestruct_on_outer_call, selfdestruct_with_transfer_contract_code, selfdestruct_with_transfer_contract_address, selfdestruct_recipient_address, recursive_revert_contract_address, recursive_revert_contract_code)

Same test as selfdestruct_created_in_same_tx_with_revert except selfdestructable contract is pre-existing

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

@pytest.mark.parametrize(
    "selfdestruct_on_outer_call",
    [0, 1, 2],
    ids=[
        "no_outer_selfdestruct",
        "outer_selfdestruct_before_inner_call",
        "outer_selfdestruct_after_inner_call",
    ],
)
@pytest.mark.valid_from("Cancun")
def test_selfdestruct_not_created_in_same_tx_with_revert(
    state_test: StateTestFiller,
    env: Environment,
    entry_code_address: str,
    selfdestruct_on_outer_call: int,
    selfdestruct_with_transfer_contract_code: SupportsBytes,
    selfdestruct_with_transfer_contract_address: str,
    selfdestruct_recipient_address: str,
    recursive_revert_contract_address: str,
    recursive_revert_contract_code: SupportsBytes,
):
    """
    Same test as selfdestruct_created_in_same_tx_with_revert except selfdestructable contract
    is pre-existing
    """
    entry_code = Op.CALL(
        Op.GASLIMIT(),
        Op.PUSH20(recursive_revert_contract_address),
        0,  # value
        0,  # arg offset
        0,  # arg length
        0,  # ret offset
        0,  # ret length
    )

    pre: Dict[str, Account] = {
        TestAddress: Account(balance=100_000_000_000_000_000_000),
        selfdestruct_with_transfer_contract_address: Account(
            code=selfdestruct_with_transfer_contract_code
        ),
        recursive_revert_contract_address: Account(
            code=bytes(recursive_revert_contract_code), balance=2
        ),
    }

    post: Dict[str, Account] = {
        entry_code_address: Account(code="0x"),
    }

    if selfdestruct_on_outer_call > 0:
        post[selfdestruct_with_transfer_contract_address] = Account(
            balance=1 if selfdestruct_on_outer_call == 1 else 0,
            code=selfdestruct_with_transfer_contract_code,
            storage=Storage(
                {
                    # 2 value transfers: 1 in outer call, 1 in reverted inner call
                    0: 1,
                    # 1 selfdestruct in reverted inner call
                    1: 1,
                }
            ),
        )
        post[selfdestruct_recipient_address] = Account(
            balance=1 if selfdestruct_on_outer_call == 1 else 2
        )
    else:
        post[selfdestruct_with_transfer_contract_address] = Account(
            balance=1,
            code=selfdestruct_with_transfer_contract_code,
            storage=Storage(
                {
                    # 2 value transfers: 1 in outer call, 1 in reverted inner call
                    0: 1,
                    # 2 selfdestructs: 1 in outer call, 1 in reverted inner call # noqa SC100
                    1: 0,
                }
            ),
        )
        post[selfdestruct_recipient_address] = Account.NONEXISTENT  # type: ignore

    nonce = count()
    tx = Transaction(
        ty=0x0,
        value=0,
        data=entry_code,
        chain_id=0x0,
        nonce=next(nonce),
        to=None,
        gas_limit=100_000_000,
        gas_price=10,
        protected=False,
    )

    state_test(env=env, pre=pre, post=post, txs=[tx])