How to handle errors in Solidity? (require, revert, assert)

Solidity provides `require`, `revert`, and `assert` for error handling, ensuring secure and predictable smart contract execution.

Jul 20, 2025 at 05:00 am

Understanding Error Handling in Solidity

Solidity, the primary programming language for Ethereum smart contracts, provides several mechanisms for error handling. These mechanisms are crucial for ensuring that contracts behave predictably and securely when unexpected or invalid conditions occur. The main tools available for error handling in Solidity are require, revert, and assert. Each of these functions serves a different purpose and should be used appropriately based on the situation.

Using require for Input Validation

The require function is primarily used to validate inputs and conditions before executing a function's core logic. If the condition provided to require evaluates to false, the transaction is reverted, and any changes made to the state are rolled back. Additionally, require allows developers to provide a custom error message.

Example:

function transfer(address to, uint amount) public {
require(amount > 0, "Amount must be greater than zero");
require(balance[msg.sender] >= amount, "Insufficient balance");
balance[msg.sender] -= amount;
balance[to] += amount;
}

In this example, require ensures that the sender has sufficient balance and that the amount being transferred is valid. If either condition fails, the transaction reverts with a clear error message.

Employing revert for Custom Error Conditions

The revert function offers more flexibility than require by allowing developers to revert execution at any point within a function. It is especially useful when dealing with complex logic or multiple conditions that may not be easily handled by a single require statement.

Example:

function withdraw(uint amount) public {
if (amount > balance[msg.sender]) {
    revert("Insufficient funds for withdrawal");
}
if (block.timestamp < lockTime[msg.sender]) {
    revert("Funds are locked until a later time");
}
balance[msg.sender] -= amount;
payable(msg.sender).transfer(amount);
}

In this scenario, revert is used to handle two distinct conditions that could prevent a withdrawal. Each condition is evaluated separately, and a specific message is returned when the condition fails.

Utilizing assert for Internal Error Detection

The assert function is intended for checking invariants and catching internal errors that should never occur under normal circumstances. Unlike require and revert, using assert consumes all the gas provided in the transaction when triggered. Therefore, it should be reserved for situations where a critical bug is suspected.

Example:

function calculateSum(uint a, uint b) internal pure returns (uint) {
uint sum = a + b;
assert(sum >= a);
return sum;
}

In this function, assert ensures that the addition operation does not result in an underflow or overflow. If such an anomaly occurs, the transaction reverts, indicating a potential bug in the code.

Differences Between require, revert, and assert

Understanding the distinctions between require, revert, and assert is essential for effective error handling in Solidity:

• Gas Consumption: require and revert only consume gas up to the point of the error, while assert consumes all provided gas.
• Use Cases: require is best for input validation, revert for custom conditions, and assert for internal logic checks.
• Error Messages: Both require and revert allow for custom error messages; assert does not provide a way to return custom messages in older versions of Solidity (prior to 0.8.0).

Choosing the appropriate error handling method ensures that your smart contracts are both secure and efficient.

Custom Errors in Solidity

Starting from Solidity 0.8.0, developers can define custom error types, which are more gas-efficient and readable than string-based error messages. Custom errors are defined using the error keyword and can be used in conjunction with revert.

Example:

error InsufficientBalance(uint requested, uint available);
error FundsLocked(uint releaseTime, uint currentTime);
function withdraw(uint amount) public {
if (amount > balance[msg.sender]) {
    revert InsufficientBalance(amount, balance[msg.sender]);
}
if (block.timestamp < lockTime[msg.sender]) {
    revert FundsLocked(lockTime[msg.sender], block.timestamp);
}
balance[msg.sender] -= amount;
payable(msg.sender).transfer(amount);
}

By using custom errors, developers can provide structured error information that is both easy to understand and efficient in terms of gas usage.

Frequently Asked Questions

Q: Can I use assert for input validation?

A: No, assert should not be used for input validation. It is designed for internal checks and should only be used to detect unreachable code or critical bugs.

Q: How do custom errors save gas compared to string messages?

A: Custom errors are encoded as four-byte selectors, similar to function signatures, which are much shorter and cheaper than full string messages. This results in lower gas costs when an error is triggered.

Q: What happens if I don’t handle errors in my contract?

A: If errors are not properly handled, invalid or unexpected conditions may lead to incorrect state changes, loss of funds, or vulnerabilities that can be exploited by attackers.

Q: Can I combine require and revert in the same function?

A: Yes, require and revert can be used together in the same function. require is typically used for simple condition checks, while revert is used for more complex or conditional reverts later in the function.