{"id":18371,"date":"2026-03-17T04:28:27","date_gmt":"2026-03-17T04:28:27","guid":{"rendered":"https:\/\/cryptoted.net\/index.php\/2026\/03\/17\/solidity-0-6-x-features-try-catch-statement\/"},"modified":"2026-03-17T04:28:27","modified_gmt":"2026-03-17T04:28:27","slug":"solidity-0-6-x-features-try-catch-statement","status":"publish","type":"post","link":"https:\/\/cryptoted.net\/index.php\/2026\/03\/17\/solidity-0-6-x-features-try-catch-statement\/","title":{"rendered":"Solidity 0.6.x features: try\/catch statement"},"content":{"rendered":"


\n
<\/p>\n

\n

The try\/catch syntax introduced in 0.6.0<\/a> is arguably the biggest leap in error handling capabilities in Solidity, since reason strings for revert<\/span> and require<\/span> were released in v0.4.22. Both try<\/span> and catch<\/span> have been reserved keywords since v0.5.9<\/a> and now we can use them to handle failures in external<\/span> function calls without rolling back the complete transaction (state changes in the called function are still rolled back, but the ones in the calling function are not).<\/p>\n

We are moving one step away from the purist “all-or-nothing” approach in a transaction lifecycle, which falls short of practical behaviour we often want.<\/p>\n

<\/g><\/svg><\/a>Handling external call failures<\/h2>\n

The try\/catch statement allows you to react on failed external<\/em> calls and contract creation<\/em> calls, so you cannot use it for internal<\/em> function calls. Note that to wrap a public function call within the same contract with try\/catch, it can be made external by calling the function with this.<\/span>.<\/p>\n

The example below demonstrates how try\/catch is used in a factory pattern where contract creation might fail. The following CharitySplitter<\/span> contract requires a mandatory address property _owner<\/span> in its constructor.<\/p>\n

\n
pragma solidity ^0.6.1<\/span>;<\/span>\n<\/span>\ncontract CharitySplitter <\/span>{<\/span>\n<\/span>    address public owner<\/span>;<\/span>\n<\/span>    constructor <\/span>(<\/span>address _owner<\/span>)<\/span> public <\/span>{<\/span>\n<\/span>        require<\/span>(<\/span>_owner <\/span>!=<\/span> address<\/span>(<\/span>0<\/span>)<\/span>, <\/span>\"no-owner-provided\"<\/span>)<\/span>;<\/span>\n<\/span>        owner <\/span>=<\/span> _owner<\/span>;<\/span>\n<\/span>    <\/span>}<\/span>\n<\/span>}<\/span>\n<\/span><\/code><\/pre>\n<\/div>\n
There is a factory contract \u2014 CharitySplitterFactory<\/span> which is used to create and manage instances of CharitySplitter<\/span>. In the factory we can wrap the new CharitySplitter(charityOwner)<\/span> in a try\/catch as a failsafe for when that constructor might fail because of an empty charityOwner<\/span> being passed.<\/p>\n
\n
pragma solidity ^0.6.1<\/span>;<\/span>\n<\/span>import<\/span> <\/span>\".\/CharitySplitter.sol\"<\/span>;<\/span>\n<\/span>contract CharitySplitterFactory <\/span>{<\/span>\n<\/span>    mapping <\/span>(<\/span>address <\/span>=<\/span>><\/span> CharitySplitter<\/span>)<\/span> public charitySplitters<\/span>;<\/span>\n<\/span>    uint public errorCount<\/span>;<\/span>\n<\/span>    event ErrorHandled<\/span>(<\/span>string reason<\/span>)<\/span>;<\/span>\n<\/span>    event ErrorNotHandled<\/span>(<\/span>bytes reason<\/span>)<\/span>;<\/span>\n<\/span>    <\/span>function<\/span> createCharitySplitter<\/span>(<\/span>address charityOwner<\/span>)<\/span> public <\/span>{<\/span>\n<\/span>        try new CharitySplitter<\/span>(<\/span>charityOwner<\/span>)<\/span>\n<\/span>            returns <\/span>(<\/span>CharitySplitter newCharitySplitter<\/span>)<\/span>\n<\/span>        <\/span>{<\/span>\n<\/span>            charitySplitters<\/span>[<\/span>msg.sender<\/span>]<\/span> <\/span>=<\/span> newCharitySplitter<\/span>;<\/span>\n<\/span>        <\/span>}<\/span> catch <\/span>{<\/span>\n<\/span>            errorCount++<\/span>;<\/span>\n<\/span>        <\/span>}<\/span>\n<\/span>    <\/span>}<\/span>\n<\/span>}<\/span>\n<\/span><\/code><\/pre>\n<\/div>\n
Note that with try\/catch, only exceptions happening inside the external call itself are caught. Errors inside the expression are not caught, for example if the input parameter for the new CharitySplitter<\/span> is itself part of an internal call, any errors it raises will not be caught. Sample demonstrating this behaviour is the modified createCharitySplitter<\/span> function. Here the CharitySplitter<\/span> constructor input parameter is retrieved dynamically from another function \u2014 getCharityOwner<\/span>. If that function reverts, in this example with “revert-required-for-testing”<\/span>, that will not be caught in the try\/catch statement.<\/p>\n
\n
function<\/span> createCharitySplitter<\/span>(<\/span>address _charityOwner<\/span>)<\/span> public <\/span>{<\/span>\n<\/span>    try new CharitySplitter<\/span>(<\/span>getCharityOwner<\/span>(<\/span>_charityOwner, <\/span>false<\/span>))<\/span>\n<\/span>        returns <\/span>(<\/span>CharitySplitter newCharitySplitter<\/span>)<\/span>\n<\/span>    <\/span>{<\/span>\n<\/span>        charitySplitters<\/span>[<\/span>msg.sender<\/span>]<\/span> <\/span>=<\/span> newCharitySplitter<\/span>;<\/span>\n<\/span>    <\/span>}<\/span> catch <\/span>(<\/span>bytes memory reason<\/span>)<\/span> <\/span>{<\/span>\n<\/span>        <\/span>..<\/span>.\n<\/span>    <\/span>}<\/span>\n<\/span>}<\/span>\n<\/span>function<\/span> getCharityOwner<\/span>(<\/span>address _charityOwner, bool _toPass<\/span>)<\/span>\n<\/span>        internal returns <\/span>(<\/span>address<\/span>)<\/span> <\/span>{<\/span>\n<\/span>    require<\/span>(<\/span>_toPass, <\/span>\"revert-required-for-testing\"<\/span>)<\/span>;<\/span>\n<\/span>    <\/span>return<\/span> _charityOwner<\/span>;<\/span>\n<\/span>}<\/span>\n<\/span><\/code><\/pre>\n<\/div>\n
<\/g><\/svg><\/a>Retrieving the error message<\/h2>\n
We can further extend the try\/catch logic in the createCharitySplitter<\/span> function to retrieve the error message if one was emitted by a failing revert<\/span> or require<\/span> and emit it in an event. There are two ways to achieve this:<\/p>\n
<\/g><\/svg><\/a>1. Using catch Error(string memory reason)<\/span><\/h3>\n
\n
function<\/span> createCharitySplitter<\/span>(<\/span>address _charityOwner<\/span>)<\/span> public <\/span>{<\/span>\n<\/span>    try new CharitySplitter<\/span>(<\/span>_charityOwner<\/span>)<\/span> returns <\/span>(<\/span>CharitySplitter newCharitySplitter<\/span>)<\/span>\n<\/span>    <\/span>{<\/span>\n<\/span>        charitySplitters<\/span>[<\/span>msg.sender<\/span>]<\/span> <\/span>=<\/span> newCharitySplitter<\/span>;<\/span>\n<\/span>    <\/span>}<\/span>\n<\/span>    catch Error<\/span>(<\/span>string memory reason<\/span>)<\/span>\n<\/span>    <\/span>{<\/span>\n<\/span>        errorCount++<\/span>;<\/span>\n<\/span>        CharitySplitter newCharitySplitter <\/span>=<\/span> new\n<\/span>            CharitySplitter<\/span>(<\/span>msg.sender<\/span>)<\/span>;<\/span>\n<\/span>        charitySplitters<\/span>[<\/span>msg.sender<\/span>]<\/span> <\/span>=<\/span> newCharitySplitter<\/span>;<\/span>\n<\/span>        \/\/ Emitting the error <\/span>in<\/span> event\n<\/span>        emit ErrorHandled<\/span>(<\/span>reason<\/span>)<\/span>;<\/span>\n<\/span>    <\/span>}<\/span>\n<\/span>    catch\n    <\/span>{<\/span>\n<\/span>        errorCount++<\/span>;<\/span>\n<\/span>    <\/span>}<\/span>\n<\/span>}<\/span>\n<\/span><\/code><\/pre>\n<\/div>\n
Which emits the following event on a failed constructor require error:<\/p>\n
\n
CharitySplitterFactory.ErrorHandled<\/span>(<\/span>\n<\/span>    reason: <\/span>'no-owner-provided'<\/span> <\/span>(<\/span>type: string<\/span>)<\/span>\n<\/span>)<\/span>\n<\/span><\/code><\/pre>\n<\/div>\n
<\/g><\/svg><\/a>2. Using catch (bytes memory reason)<\/span><\/h3>\n
\n
function<\/span> createCharitySplitter<\/span>(<\/span>address charityOwner<\/span>)<\/span> public <\/span>{<\/span>\n<\/span>    try new CharitySplitter<\/span>(<\/span>charityOwner<\/span>)<\/span>\n<\/span>        returns <\/span>(<\/span>CharitySplitter newCharitySplitter<\/span>)<\/span>\n<\/span>    <\/span>{<\/span>\n<\/span>        charitySplitters<\/span>[<\/span>msg.sender<\/span>]<\/span> <\/span>=<\/span> newCharitySplitter<\/span>;<\/span>\n<\/span>    <\/span>}<\/span>\n<\/span>    catch <\/span>(<\/span>bytes memory reason<\/span>)<\/span> <\/span>{<\/span>\n<\/span>        errorCount++<\/span>;<\/span>\n<\/span>        emit ErrorNotHandled<\/span>(<\/span>reason<\/span>)<\/span>;<\/span>\n<\/span>    <\/span>}<\/span>\n<\/span>}<\/span>\n<\/span><\/code><\/pre>\n<\/div>\n
Which emits the following event on a failed constructor require error:<\/p>\n
\n
CharitySplitterFactory.ErrorNotHandled<\/span>(<\/span>\n<\/span>  reason: hex<\/span>'08c379a0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000116e6f2d6f776e65722d70726f7669646564000000000000000000000000000000'<\/span> <\/span>(<\/span>type: bytes<\/span>)<\/span>\n<\/span><\/code><\/pre>\n<\/div>\n
The above two methods for retrieving the error string produce a similar result. The difference is that the second method does not ABI-decode the error string. The advantage of the second method is that it is also executed if ABI decoding the error string fails or if no reason was provided.<\/p>\n
<\/g><\/svg><\/a>Future plans<\/h2>\n
There are plans to release support for error types meaning we will be able to declare errors in a similar way to events allowing us to catch different type of errors, for example:<\/p>\n
\n
catch CustomErrorA<\/span>(<\/span>uint data1<\/span>)<\/span> <\/span>{<\/span> \u2026 <\/span>}<\/span>\n<\/span>catch CustomErrorB<\/span>(<\/span>uint<\/span>[<\/span>]<\/span> memory data2<\/span>)<\/span> <\/span>{<\/span> \u2026 <\/span>}<\/span>\n<\/span>catch <\/span>{<\/span>}<\/span>\n<\/span><\/code><\/pre>\n<\/div>\n<\/div>\n
The try\/catch syntax introduced in 0.6.0 is arguably the biggest leap in error handling capabilities in Solidity, since reason strings for revert and require were released in v0.4.22. Both try and catch have been reserved keywords since v0.5.9 and now we can use them to handle failures in external function calls without rolling back the […]<\/p>\n","protected":false},"author":6,"featured_media":18372,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"tdm_status":"","tdm_grid_status":"","footnotes":""},"categories":[24],"tags":[],"kronos_expire_date":[],"class_list":["post-18371","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-ethereum"],"_links":{"self":[{"href":"https:\/\/cryptoted.net\/index.php\/wp-json\/wp\/v2\/posts\/18371","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/cryptoted.net\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/cryptoted.net\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/cryptoted.net\/index.php\/wp-json\/wp\/v2\/users\/6"}],"replies":[{"embeddable":true,"href":"https:\/\/cryptoted.net\/index.php\/wp-json\/wp\/v2\/comments?post=18371"}],"version-history":[{"count":0,"href":"https:\/\/cryptoted.net\/index.php\/wp-json\/wp\/v2\/posts\/18371\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/cryptoted.net\/index.php\/wp-json\/wp\/v2\/media\/18372"}],"wp:attachment":[{"href":"https:\/\/cryptoted.net\/index.php\/wp-json\/wp\/v2\/media?parent=18371"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/cryptoted.net\/index.php\/wp-json\/wp\/v2\/categories?post=18371"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/cryptoted.net\/index.php\/wp-json\/wp\/v2\/tags?post=18371"},{"taxonomy":"kronos_expire_date","embeddable":true,"href":"https:\/\/cryptoted.net\/index.php\/wp-json\/wp\/v2\/kronos_expire_date?post=18371"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}

\n
Source link <\/a><\/p>\n","protected":false},"excerpt":{"rendered":"