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 complete transaction (state changes in the called function are still rolled back, but the ones in the calling function are not).

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.

Handling external call failures

The try/catch statement allows you to react on failed external calls and contract creation calls, so you cannot use it for internal 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..

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

pragma solidity ^0.6.1;

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

There is a factory contract — CharitySplitterFactory which is used to create and manage instances of CharitySplitter. In the factory we can wrap the new CharitySplitter(charityOwner) in a try/catch as a failsafe for when that constructor might fail because of an empty charityOwner being passed.

pragma solidity ^0.6.1;
import "./CharitySplitter.sol";
contract CharitySplitterFactory {
    mapping (address => CharitySplitter) public charitySplitters;
    uint public errorCount;
    event ErrorHandled(string reason);
    event ErrorNotHandled(bytes reason);
    function createCharitySplitter(address charityOwner) public {
        try new CharitySplitter(charityOwner)
            returns (CharitySplitter newCharitySplitter)
        {
            charitySplitters[msg.sender] = newCharitySplitter;
        } catch {
            errorCount++;
        }
    }
}

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 is itself part of an internal call, any errors it raises will not be caught. Sample demonstrating this behaviour is the modified createCharitySplitter function. Here the CharitySplitter constructor input parameter is retrieved dynamically from another function — getCharityOwner. If that function reverts, in this example with “revert-required-for-testing”, that will not be caught in the try/catch statement.

function createCharitySplitter(address _charityOwner) public {
    try new CharitySplitter(getCharityOwner(_charityOwner, false))
        returns (CharitySplitter newCharitySplitter)
    {
        charitySplitters[msg.sender] = newCharitySplitter;
    } catch (bytes memory reason) {
        ...
    }
}
function getCharityOwner(address _charityOwner, bool _toPass)
        internal returns (address) {
    require(_toPass, "revert-required-for-testing");
    return _charityOwner;
}

Retrieving the error message

We can further extend the try/catch logic in the createCharitySplitter function to retrieve the error message if one was emitted by a failing revert or require and emit it in an event. There are two ways to achieve this:

1. Using catch Error(string memory reason)

function createCharitySplitter(address _charityOwner) public {
    try new CharitySplitter(_charityOwner) returns (CharitySplitter newCharitySplitter)
    {
        charitySplitters[msg.sender] = newCharitySplitter;
    }
    catch Error(string memory reason)
    {
        errorCount++;
        CharitySplitter newCharitySplitter = new
            CharitySplitter(msg.sender);
        charitySplitters[msg.sender] = newCharitySplitter;
        // Emitting the error in event
        emit ErrorHandled(reason);
    }
    catch
    {
        errorCount++;
    }
}

Which emits the following event on a failed constructor require error:

CharitySplitterFactory.ErrorHandled(
    reason: 'no-owner-provided' (type: string)
)

2. Using catch (bytes memory reason)

function createCharitySplitter(address charityOwner) public {
    try new CharitySplitter(charityOwner)
        returns (CharitySplitter newCharitySplitter)
    {
        charitySplitters[msg.sender] = newCharitySplitter;
    }
    catch (bytes memory reason) {
        errorCount++;
        emit ErrorNotHandled(reason);
    }
}

Which emits the following event on a failed constructor require error:

CharitySplitterFactory.ErrorNotHandled(
  reason: hex'08c379a0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000116e6f2d6f776e65722d70726f7669646564000000000000000000000000000000' (type: bytes)

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.

Future plans

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:

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

A debate has erupted among the Bitcoin community over a joint statement released by 31 Bitcoin Core developers on June 6.

In their statement, the developers argued that while the new transaction relay policy might lead to more non-financial use cases, protecting censorship resistance is one of the core tenets of the blockchain.

The developers noted that the Bitcoin network is “defined by its users, who have ultimate freedom” to choose whether they utilize the blockchain for financial or non-financial use cases. As such, the Bitcoin core developers are “not in a position to mandate” what software or policies they choose.

Several Bitcoiners have opposed the developers’ opinion, calling it a drift away from the blockchain’s original intended function. On the other hand, some have defended the developers’ viewpoint, leading to a global debate among Bitcoiners.

The Bitcoin transaction relay policy is at the core of the debate

Transaction relay is a ‘core tenet’ of a Bitcoin node. Nodes relay block transactions and validations to other nodes to ensure that the blockchain remains updated across all nodes.

On May 5, core contributors to the Bitcoin network announced that the next upgrade will remove the 80-byte data cap for transaction relays. This would allow users to embed larger data segments more efficiently, the post noted, adding:

“The long-standing cap, originally a gentle signal that block space should be used sparingly for non-payment proof of publication data, has outlived its utility.”

The developers argued that users have found ways to circumvent the data limit, which can potentially harm the network. Therefore, “retiring a deterrent that no longer deters” large-data inscriptions will enable the fee market to “arbitrate competing demands.”

The announcement sparked a debate with some considering the move to be logical, while others considered it an open invitation to spam transactions.

Bitcoin core developers defend stance to remove data limit for transaction relays

In their Friday statement, the Bitcoin core developers defended their decision to remove the data cap for transaction relays. They noted that it is their responsibility to ensure that their software is efficient and reliable, contributing to Bitcoin’s success as a decentralized digital currency. They stated:

“With regards to transaction relay, this may include adding policies for denial of service (DoS) protection and fee assessment, but not blocking relay of transactions that have sustained economic demand and reliably make it into blocks.”

According to the developers, transaction relay has three major goals. This includes predicting which transactions will be mined, which also serves to prevent denial-of-service (DoS) attacks. In DoS attacks, miscreants flood the network with spam transactions, overwhelming the network and preventing it from processing transaction requests from legitimate users.

Additionally, transaction relay also speeds up transaction propagation, which in turn prevents large miners from gaining an unfair advantage. It also helps miners learn about fee-paying transactions, the developers noted. Therefore, they wrote:

“Knowingly refusing to relay transactions that miners would include in blocks anyway forces users into alternate communication channels, undermining the above goals.”

Besides, the Bitcoin node software should not intervene through a data cap where both transaction creators and miners consent to add a large data inscription to a block, the developers noted. This is because Bitcoin was built on the ethos of censorship resistance, they explained, adding that large data transactions are “largely harmless at a technical level.”

The developers clarified, however:

“This is not endorsing or condoning non-financial data usage, but accepting that as a censorship-resistant system, Bitcoin can and will be used for use cases not everyone agrees on.”

They added that while they are aware of the dissent among Bitcoiners, they sincerely believe the move “is in the best interest of Bitcoin and its users.”

Bitcoiners split over transaction relay policy change

Among those who are opposed to the transaction relay policy change is Bitcoin core developer and OCEAN Bitcoin mining pool creator Luke Dashjr, also known as Luke Kenneth Casson Leighton. In an X post, Dashjr noted:

“The goals of transaction relay listed are basically all wrong. Predicting what will be mined is a centralizing goal. Expecting spam to be mined is defeatism. Helping spam propagate is harmful.”

He added that the statement portrays the abuse of the blockchain through spam transactions as legitimate use cases instead of treating them as DoS attacks. However, he believes such transactions are the same as DoS attacks.

Pseudonymous X user SatsScholar, who runs Bitcoin Knots, a specialized version of Bitcoin Core that is maintained by Dashjr, called the new relay policy an ideological drift, noting:

“Core’s new stance essentially says, “if someone pays enough, any use is valid.” That’s economically naive and ignores Bitcoin’s fundamental purpose as a monetary network.”

Several Bitcoiners echoed SatsScholar’s views, including Dennis Porter, CEO of Bitcoin mining advocacy firm Satoshi Action Fund, who said the policy change is “absolutely condoning bloat.” In a more scathing post, one user wrote:

“It’s Bit”Coin” not Bit”Bucket” or Bit”Store” or whatever general purpose data store you have in mind. It’s a “peer to peer electronic cash system”.”

The user added that keeping the network focused on its original purpose is not censorship.

Dissenters of the proposal also include miners, one of whom claimed that the removal of the data cap “risks diluting Bitcoin’s monetary focus, overburdening future nodes, further centralizing power, possibly threatening scalability, and fracturing the Bitcoin community’s faith.”

Jameson Lopp, co-founder and chief security officer of Bitcoin wallet Casa, was among those who supported the developers’ statement, noting:

“Core Devs are a group saying we can’t force anyone to run code they don’t like, here is our thinking on relay policy & network health.”

Mentioned in this article