The try/catch syntax introduced in 0.6.0 is arguably the largest leap in error dealing with capabilities in Solidity, since cause strings for revert and require have been launched in v0.4.22. Each strive and catch have been reserved key phrases since v0.5.9 and now we will use them to deal with failures in exterior operate calls with out rolling again the whole transaction (state modifications within the referred to as operate are nonetheless rolled again, however the ones within the calling operate aren’t).
We’re transferring one step away from the purist “all-or-nothing” strategy in a transaction lifecycle, which falls in need of sensible behaviour we frequently need.
Dealing with exterior name failures
The strive/catch assertion lets you react on failed exterior calls and contract creation calls, so you can’t use it for inner operate calls. Be aware that to wrap a public operate name throughout the identical contract with strive/catch, it may be made exterior by calling the operate with this..
The instance under demonstrates how strive/catch is utilized in a manufacturing facility sample the place contract creation may fail. The next CharitySplitter contract requires a compulsory tackle property _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 cases of CharitySplitter. Within the manufacturing facility we will wrap the new CharitySplitter(charityOwner) in a strive/catch as a failsafe for when that constructor may fail due to an empty charityOwner being 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); operate createCharitySplitter(tackle charityOwner) public { strive new CharitySplitter(charityOwner) returns (CharitySplitter newCharitySplitter) { charitySplitters[msg.sender] = newCharitySplitter; } catch { errorCount++; } } }
Be aware that with strive/catch, solely exceptions taking place contained in the exterior name itself are caught. Errors contained in the expression aren’t caught, for instance if the enter parameter for the new CharitySplitter is itself a part of an inner name, any errors it raises won’t be caught. Pattern demonstrating this behaviour is the modified createCharitySplitter operate. Right here the CharitySplitter constructor enter parameter is retrieved dynamically from one other operate — getCharityOwner. If that operate reverts, on this instance with “revert-required-for-testing”, that won’t be caught within the strive/catch assertion.
operate createCharitySplitter(tackle _charityOwner) public { strive new CharitySplitter(getCharityOwner(_charityOwner, false)) returns (CharitySplitter newCharitySplitter) { charitySplitters[msg.sender] = newCharitySplitter; } catch (bytes reminiscence cause) { ... } } operate getCharityOwner(tackle _charityOwner, bool _toPass) inner returns (tackle) { require(_toPass, "revert-required-for-testing"); return _charityOwner; }
Retrieving the error message
We will additional lengthen the strive/catch logic within the createCharitySplitter operate to retrieve the error message if one was emitted by a failing revert or require and emit it in an occasion. There are two methods to attain this:
1. Utilizing catch Error(string reminiscence cause)
operate 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 require error:
CharitySplitterFactory.ErrorHandled( cause: 'no-owner-provided' (sort: string) )
2. Utilizing catch (bytes reminiscence cause)
operate 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 require error:
CharitySplitterFactory.ErrorNotHandled( cause: hex'08c379a0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000116e6f2d6f776e65722d70726f7669646564000000000000000000000000000000' (sort: bytes)
The above two strategies for retrieving the error string produce the same outcome. The distinction is that the second technique doesn’t ABI-decode the error string. The benefit of the second technique is that additionally it is executed if ABI decoding the error string fails or if no cause was supplied.
Future plans
There are plans to launch assist for error sorts which means we can declare errors in the same strategy to occasions permitting us to catch totally different sort of errors, for instance:
catch CustomErrorA(uint data1) { … } catch CustomErrorB(uint[] reminiscence data2) { … } catch {}