Supply gas from contract to execution of function

Question

let's say I have something like this

function usuallyCheapFunction() external {
    ... do something cheap...
    if(rareCondition == true) {
        expensiveCleanupFunction();
    }
}

function expensiveCleanupFunction() internal {
   ... shuffle around some storage ...
}

Users would call usuallyCheapFunction() to do something, expecting cheap transaction price. Sometimes the contract needs to do some expensive cleanup - is it possible in this case to supply gas from the contract to call expensiveCleanupFunction() so that the call does not cause out-of-gas? If so, how would this look like?

Answer 1

For now it is not possible to pay for gas from contract's balance, though this may change in future, but smart contract may refund gas transaction publisher spent on housekeeping function:

modifier refundable () {
    uint256 gasBefore = gasleft ();
    _;
    tx.origin.send (tx.gasprice * (gasleft () - gasBefore));
}

function expensiveCleanupFunction() refundable internal {
    ... shuffle around some storage ...
}

This will not refund gas in case smart contract does not have enough ether, though. If you need to refund even in case of insufficient balance, do something like this:

mapping (address => uint256) private refundBalance;

modifier refundable () {
    uint256 gasBefore = gasleft ();
    _;
    uint256 toRefund = tx.gasprice * (gasleft () - gasBefore);
    if (!tx.origin.send (toRefund))
        refundBalance [tx.origin] += toRefund;
}

function withdraw () public {
    uint256 toTransfer = refundBalance [msg.sender];
    refundBalance [msg.sender] = 0;
    msg.sender.transfer (toTransfer);
}

function expensiveCleanupFunction () refundable internal {
    ... shuffle around some storage ...
}

So in case instant refund failed, smart contracts increments refund balance of the users, and once smart contract balance will be resupplied, user will be able to withdraw his refund.

Answer 2

It is not possible to do this in a single transaction, as each operation in Solidity compiles down to an opcode, and each opcode has an associated cost. All of these costs are greater than 0, so there is no way to 'cleanup' a transaction and allow it to use more gas (i.e., generate more opcodes).

Generally, if you are running into scenarios where this is the case, it is best to refactor the contract to behave in such a way that does not use as much gas in a single transaction. If possible, you can split a single function into multiple functions, called at different points (different transactions), that save the state of the contract.

See this repo for a list of opcode costs.