Solidity 0.6.x Options: strive/catch assertion

The strive/catch syntax launched in 0.6.0 is arguably the most important leap ahead in Solidity’s error-handling capabilities, since arrays for return and require they have been launched in v0.4.22. Each check out and catch are reserved key phrases from v0.5.9 and now we are able to use them to troubleshoot exterior perform calls with out rolling again the complete transaction (state adjustments within the referred to as perform are nonetheless rolled again, however these within the calling perform usually are not).

We’re taking a step away from a purist all-or-nothing method to the transaction lifecycle, which falls in need of the sensible conduct we regularly need.

Dealing with failed exterior calls

The strive/catch assertion permits you to react to a failed one exterior calls and contract creation calls, so you may’t use it for inner perform calls. Observe that to wrap a public perform name throughout the identical strive/catch contract, it may be made exterior by calling the perform with this one..

The instance beneath exhibits how strive/catch is utilized in a kind manufacturing facility the place the contract creation may fail. Subsequent CharitySplitter the contract requires a compulsory actual property tackle _owner in its constructor.

pragma solidity ^0.6.1;

contract CharitySplitter {
    tackle public proprietor;
    constructor (tackle _owner) public {
        require(_owner != tackle(0), "no-owner-provided");
        proprietor = _owner;
    }
}

There’s a manufacturing facility contract — CharitySplitterFactory which is used to create and handle situations CharitySplitter. We are able to wrap within the manufacturing facility new CharitySplitter(charityOwner) in strive/catch as a failsafe in case that constructor fails attributable to empty mercyOwner it’s handed.

pragma solidity ^0.6.1;
import "./CharitySplitter.sol";
contract CharitySplitterFactory {
    mapping (tackle => CharitySplitter) public charitySplitters;
    uint public errorCount;
    occasion ErrorHandled(string cause);
    occasion ErrorNotHandled(bytes cause);
    perform createCharitySplitter(tackle charityOwner) public {
        strive new CharitySplitter(charityOwner)
            returns (CharitySplitter newCharitySplitter)
        {
            charitySplitters[msg.sender] = newCharitySplitter;
        } catch {
            errorCount++;
        }
    }
}

Observe that solely exceptions that happen throughout the outer name itself are caught with strive/catch. Errors inside an expression usually are not caught, for instance if the enter parameter is for the brand new CharitySplitter is itself a part of an inner name, any errors it raises won’t be caught. A pattern that displays this conduct has been modified createCharitySplitter perform. It is right here CharitySplitter the constructor enter parameter is dynamically retrieved from one other perform — getCharityOwner. If that perform returns, on this instance s “return-required-for-testing”which won’t be caught within the strive/catch assertion.

perform createCharitySplitter(tackle _charityOwner) public {
    strive new CharitySplitter(getCharityOwner(_charityOwner, false))
        returns (CharitySplitter newCharitySplitter)
    {
        charitySplitters[msg.sender] = newCharitySplitter;
    } catch (bytes reminiscence cause) {
        ...
    }
}
perform getCharityOwner(tackle _charityOwner, bool _toPass)
        inner returns (tackle) {
    require(_toPass, "revert-required-for-testing");
    return _charityOwner;
}

Retrieving the error message

We are able to additional prolong the strive/catch logic in createCharitySplitter perform to retrieve an error message if it was emitted by a fault return or require and emit it in an occasion. There are two methods to attain this:

1. Use catch Error (string reminiscence cause)

perform createCharitySplitter(tackle _charityOwner) public {
    strive new CharitySplitter(_charityOwner) returns (CharitySplitter newCharitySplitter)
    {
        charitySplitters[msg.sender] = newCharitySplitter;
    }
    catch Error(string reminiscence cause)
    {
        errorCount++;
        CharitySplitter newCharitySplitter = new
            CharitySplitter(msg.sender);
        charitySplitters[msg.sender] = newCharitySplitter;
        // Emitting the error in occasion
        emit ErrorHandled(cause);
    }
    catch
    {
        errorCount++;
    }
}

Which emits the next occasion on a failed constructor requires an error:

CharitySplitterFactory.ErrorHandled(
    cause: 'no-owner-provided' (sort: string)
)

2. Use catch (reminiscence bytes cause)

perform createCharitySplitter(tackle charityOwner) public {
    strive new CharitySplitter(charityOwner)
        returns (CharitySplitter newCharitySplitter)
    {
        charitySplitters[msg.sender] = newCharitySplitter;
    }
    catch (bytes reminiscence cause) {
        errorCount++;
        emit ErrorNotHandled(cause);
    }
}

Which emits the next occasion on a failed constructor requires an error:

CharitySplitterFactory.ErrorNotHandled(
  cause: hex'08c379a0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000116e6f2d6f776e65722d70726f7669646564000000000000000000000000000000' (sort: bytes)

The above two strategies for retrieving the error string give the same consequence. The distinction is that the second technique doesn’t decode the ABI error string. The benefit of the second technique is that it’s also executed if the ABI decoding of the error string fails or if no cause is given.

Plans for the longer term

There are plans to launch help for error sorts which implies we will declare errors in the same option to occasions permitting us to catch various kinds of errors, for instance:

catch CustomErrorA(uint data1) { … }
catch CustomErrorB(uint[] reminiscence data2) { … }
catch {}