0Pricing
Blockchain Smart Contracts with Solidity · Lesson

Error Handling with Revert/Require

Implement effective error handling strategies using `require()`, `revert()`, and `assert()` for robust contract execution.

Error Handling with Revert/Require is a free Blockchain Smart Contracts with Solidity lesson on CoddyKit — lesson 3 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Blockchain Smart Contracts with Solidity learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Robust Contracts: Error Handling

Welcome to error handling in Solidity! Writing smart contracts requires extreme care, as they often manage valuable assets and are immutable once deployed.

Effective error handling is crucial for creating robust and secure decentralized applications (dApps). It helps prevent unexpected behavior and protects users.

`require()`: Validating Inputs

The require() function is your primary tool for validating conditions that must be true before a function executes.

  • It checks pre-conditions and user inputs.
  • If the condition is false, it reverts all state changes made in the current transaction.
  • It refunds any remaining gas to the caller, effectively canceling the transaction.

Use require() for external conditions and user-provided data checks.

`require()` in Action

Let's see require() in a simple contract. This function only allows users older than 18 to register.

pragma solidity ^0.8.0;

contract UserRegistration {
    uint public minAge = 18;
    address[] public registeredUsers;

    function registerUser(uint _age) public {
        // Validate user input: age must be at least minAge
        require(_age >= minAge, "Must be 18 or older to register.");
        registeredUsers.push(msg.sender);
    }
}

`revert()`: Flexible Error Handling

The revert() statement offers more flexibility than require(), especially when you need to handle complex error logic or integrate with custom error types.

  • Like require(), it reverts all state changes and refunds gas.
  • It's often used inside if statements for more intricate conditional checks.
  • It can be called directly or with a string message, similar to require().

Custom Errors with `revert()`

Solidity 0.8.4+ introduced Custom Errors. These are more gas-efficient than string messages and provide better clarity for off-chain applications.

You define custom errors at the contract or file level, then use them with revert(). They help reduce transaction costs and improve contract readability.

Custom Error Demo

Here's how to define and use a custom error with revert(). Notice the error keyword.

pragma solidity ^0.8.4;

contract Wallet {
    address public owner;
    uint public balance;

    // Define a custom error
    error InsufficientFunds(uint requested, uint available);

    constructor() {
        owner = msg.sender;
    }

    function deposit() public payable {
        balance += msg.value;
    }

    function withdraw(uint _amount) public {
        require(msg.sender == owner, "Only owner can withdraw.");

        // Use revert() with the custom error
        if (_amount > balance) {
            revert InsufficientFunds(_amount, balance);
        }
        balance -= _amount;
        payable(owner).transfer(_amount);
    }
}

`assert()`: Internal Invariants

The assert() function is used for a very specific purpose: checking internal invariants.

  • It verifies conditions that should never be false if your code is working correctly.
  • If an assert() fails, it indicates a bug in your contract logic.
  • Crucially, a failed assert() consumes all remaining gas, unlike require() and revert() which refund gas.

Use assert() for post-conditions or internal consistency checks, not for user input validation.

When to Use Which?

Choosing the right error handler is key:

  • require(): For validating user inputs, external conditions, or state changes before execution. Refunds gas.
  • revert(): For more complex error logic, often with custom errors. Also refunds gas.
  • assert(): For internal consistency checks and invariants. Indicates a bug if it fails and consumes all gas.

Prioritize require() and revert() for expected errors, and reserve assert() for unexpected, internal errors.

Error Handling Check

You're building a function that transfers tokens. Before sending, you need to ensure the sender has enough balance. If not, the transaction should fail and refund any unused gas.

Recap: Error Handling

You've learned how to make your Solidity contracts robust with proper error handling:

  • require() is for validating external conditions and user inputs.
  • revert() offers flexibility, often used with gas-efficient custom errors.
  • assert() is for internal invariants, signaling a bug if it fails.

Mastering these ensures your smart contracts are secure and predictable. Great job!

Frequently asked questions

Is the “Error Handling with Revert/Require” lesson free?

Yes — the full text of “Error Handling with Revert/Require” is free to read here on the web, and the Blockchain Smart Contracts with Solidity course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Blockchain Smart Contracts with Solidity course, upgrade to CoddyKit PRO.

What will I learn in “Error Handling with Revert/Require”?

Implement effective error handling strategies using `require()`, `revert()`, and `assert()` for robust contract execution. You practise Blockchain Smart Contracts with Solidity with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Blockchain Smart Contracts with Solidity?

No prior experience is required. Blockchain Smart Contracts with Solidity on CoddyKit is structured for beginners through advanced learners; this is — lesson 3 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Error Handling with Revert/Require” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Blockchain Smart Contracts with Solidity lesson?

Yes. Every Blockchain Smart Contracts with Solidity lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. Inheritance and Interfaces
  2. Libraries and Abstract Contracts
  3. Error Handling with Revert/Require
  4. Modifiers and the Checks-Effects-Interactions Pattern
← Back to Blockchain Smart Contracts with Solidity