Is there a case in which selfdestruct is more "powerful" than throw or revert?

Question

Example in this scenario I guess selfdestruct will never get called (also: contract A isn't so important by the way just focus on B onward):

in Contract A:

address contractb = 0x....;

function sending() {
    contractb.call.value(1 ether)();
}

in Contract B:

address contractc = 0x...;

function () public payable {
    if (!contractc.send(msg.value)) {
        throw;
    }
    if (!contractc.send(0)) {
        throw;
    }
}

in Contract C:

address someone = 0x...;

function () public payable {
    selfdestruct(someone);
}

In short:

1. Contract A sends ether to B using call to have lots of gas...
2. B forwards the money further to C, the first time it tries it succeeds but C selfdestructs; The 2nd time it fails since C is selfdestructed...
3. throw should revert to a state without changes, but how can it revert a selfdesctructed contract?

I guess (and I am 99% sure what will happen...about to test now on Ropsten...): nothing will ever reach C since before any execution revert will check if anything can fail and if it can it reverts - speaking of which how can revert be so sure? What if transaction simply lacks gas to be mined say like 3 gas in call.gas(3).value(1)() - surely this will not get mined and maybe revert will prevent anything until mining happens? Thanx!

Answer 1

You can simplify your setup to only 2 contracts. I've taken the liberty of editing the contracts a bit to make the testing a lot easier and more specific.

You can copy paste them in Remix and test yourself.

contract A {
    B b;

    constructor(B _b) public {
        b = _b;
    }  

    function() external payable {
        (bool success, bytes memory result) = address(b).call.value(msg.value)("");

        revert();
    }
}

contract B {
    function() external payable {
        selfdestruct(msg.sender);
    }

    function alive() public pure returns (bool) {
        return true;
    }
}

The selfdestruct is never finalized because it needs a successful transaction to be completed. The throw / revert() rollsback the selfdestruct, so it never happens.

To test you need to:

• deploy contract B and copy its address
• deploy contract A with B's address
• call the fallback function of A
• the transaction fails because the execution always fails
• you can check if B is still alive by calling alive() with returns true

If you want to understand what happens when you send ether to a selfdestructed contract, it's just like sending to a random address. No code is attached to it, the former contract acts like a simple account. It accepts ether and no code is run when it receives it.