Solidity: Is there any catch mechanism for throw? If not switch into return usage might be better?

Question

Based on experienced mentors it seems like throw mechanism is suggested here. I guess catch mechanism does not exist for throw: https://ethereum.stackexchange.com/a/2512/4575.

Based on that I have a problem: First I have to check some condition which might take high gas value. If the condition is failed throw will take place. So if condition fails, I want to pay back the money to the client. Otherwise, money should pay back to the cluster.

[Q] If condition fails, throw will take place. Since throw terminates the code, there is no way for me to catch the reverted version, and apply 1 line of code to payback the money to client. Is there any alternative solution to handle this issue?

Please note that condition will change state. So I have to do throw if there is condition fails.

function payMeBack() {
    if(require(<some condition>)) //if condition is wrong throw take place and never JUMPS to else side.
       if(!client.send(gainedWei)) throw; 
    else
       if(!cluster.send(gainedWei)) throw; 
    gainedWei = 0;
    client.success = 1;
}

Thank you for your valuable time and help.

Answer 1

No catch mechanism for throw. State reverts back to the pre-transaction state. Disregard order of operations and even operations that took place in calling contracts. Throw means the transaction originating at the EOA that signed the transaction did not occur (with the somewhat incidental impact that all gas provided is destroyed).

You're getting into synthesis of best practices so you can work out patterns that work for you. Here are few pointers.

Safe Send:

1. Do optimistic accounting first ... ensure a complete state before send, because we can make no further flow control assumptions after we talk to an untrusted contract.
2. Try the send() and check the result.
3. Revert changes (e.g. with throw) if something went wrong.

Above, you have accounting after the send.

Untrusted contracts

It's not clear to me why funds are supposed to be sent to one of two possible recipients, but there is a problem in any case.

1. Don't talk to more than one external contract at a time. That is, two sends() in one transaction is a red flag. It's too busy for my taste.

Suggestion: break this down into smaller functions and focus on accounting instead of going straight to send(). Keep track of who is owed what as arithmetic/storage operations. You don't need to throw in that case and if() {} else {} logic should work fine.

Use a withdraw pattern to deal with one claim and one user at a time. https://github.com/ConsenSys/smart-contract-best-practices#favor-pull-over-push-for-external-calls

Hope it helps.

Answer 2

In addition to Rob's comments, some comments on the pattern being used. <some condition> doesn't need to throw so doesn't need require. Just use if(<some condition>) and rely on the success/throw of the conditioned .send()'s.

Also, the if(!<condition>)throw can be replaced by require(<condition>) as it throws on false (but note with reversed conditional logic).

function payMeBack() {
    if(<some condition>)
        require(client.send(gainedWei)); 
    else
        require(cluster.send(gainedWei)); 
    gainedWei = 0;
    client.success = 1;
}