Introduction

In this smartbook we will discuss about some error hangling functions that solidity has.

Solidity handles issues with state-reverting exceptions. These exceptions revert all modifications done to the state in the current call, including all sub-calls and shows an error to the caller.

Error Handling function

1. assert(bool condition)

Syntax  :  assert(bool condition)

The assert function creates an error of type Panic(uint256) and thus state change reversion if the condition is not met .  Assert should only be used to test for internal errors, and to check invariants. Properly functioning code should never create a Panic, not even on invalid external input. If this happens, then there is a bug in your contract which you should fix. Language analysis tools can evaluate your contract to identify the conditions and function calls which will cause a Panic.

Panic error using assert is created by the compiler in certain situations as listed below as error code and cause :

• 0x00  :  Used for generic compiler inserted panics.
• 0x01  :  If you call assert with an argument that evaluates to false.
• 0x11  :  If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
• 0x12  :  If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
• 0x21  :  If you convert a value that is too big or negative into an enum type.
• 0x22  :  If you access a storage byte array that is incorrectly encoded.
• 0x31  :  If you call .pop() on an empty array.
• 0x32  :  If you access an array, bytesN or an array slice at an out-of-bounds or negative index (i.e. x[i] where i >= x.length or i < 0).
• 0x41  :  If you allocate too much memory or create an array that is too large.
• 0x51  :  If you call a zero-initialized variable of internal function type.

Code Example  : 

// Assert on 100 as a input
function store(uint num) public {
       assert( num == 100);
       number = num;
}

2. require(bool condition)

Syntax  :  require(bool condition, string memory message)

The require function reverts if the condition is not met and creates an error without any data or an error of type Error(string). It should be used to ensure valid conditions that cannot be detected until execution time.  It is to be used for errors in inputs or external components.  This includes conditions on inputs or return values from calls to external contracts.

You can optionally provide a message string for require, but not for assert.

An Error(string) exception (or an exception without data) is generated by the compiler in the following situations:

• Calling require(x) where x evaluates to false.
• If you use revert() or revert("description").
• If you perform an external function call targeting a contract that contains no code.
• If your contract receives Ether via a public function without payable modifier (including the constructor and the fallback function).
• If your contract receives Ether via a public getter function.

For the following cases, the error data from the external call (if provided) is forwarded. This mean that it can either cause an Error or a Panic (or whatever else was given):

• If a .transfer() fails.
• If you call a function via a message call but it does not finish properly (i.e., it runs out of gas, has no matching function, or throws an exception itself), except when a low level operation call, send, delegatecall, callcode or staticcall is used. The low level operations never throw exceptions but indicate failures by returning false.
• If you create a contract using the new keyword but the contract creation does not finish properly.

Code Example  :

// Only numbers below 100 are allowed
function store(uint num) public {
       require( num < 100 , 'Number is above 100');
       number = num;
}

3. revert()

Syntax  :  revert CustomError(arg1, arg2);

A direct revert can be triggered using the revert statement and the revert function. It aborts the execution and revert state changes. The revert statement takes a custom error as an argument

For backards-compatibility reasons, there is also the revert() function, which uses parentheses and accepts a string:

Syntax2  : revert(); revert(“description”);

The error data will be passed back to the caller and can be caught there. Using revert() causes a revert without any error data while revert("description") will create an Error(string) error.

Using a custom error instance will usually be much cheaper than a string description, because you can use the name of the error to describe it, which is encoded in only four bytes. A longer description can be supplied via NatSpec which does not incur any costs.

Code Example  A :

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;

contract VendingMachine {
    address owner;

    function buy(uint amount) public payable {
        if (amount > msg.value / 2 ether)
            revert("Not enough Ether provided.");
        // Alternative way to do it:
        require( amount <= msg.value / 2 ether, "Not enough Ether provided.");
    }
}

Code Example  B :

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.4;

contract VendingMachine {
    address owner;
    error Unauthorized();

function withdraw() public {
        if (msg.sender != owner)
            revert Unauthorized();

        payable(msg.sender).transfer(address(this).balance);
  }
}