Erro

Um erro desfaz todas as alterações feitas no estado durante uma transação.

Você pode lançar um erro chamando require, revert ou assert.

• require é usado para validar entradas e condições antes da execução.
• revert é semelhante a require. Veja o código abaixo para detalhes.
• assert é usado para checar se existe código que nunca deve ser falso. Afirmação falha provavelmente significa que existe um bug.

Use erro personalizado para economizar gás.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract Erro {
    function testRequire(uint _i) public pure {
        // Require deve ser usado para validar condições como:
        // - entradas
        // - condições anteriores à execução
        // - retornar valores de chamadas para outras funções
        require(_i > 10, "A entrada deve ser maior que 10");
    }

    function testRevert(uint _i) public pure {
        // Revert é útil quando a condição a ser verificada é complexa.
        // Esse código faz exatamente a mesma coisa que o exemplo acima
        if (_i <= 10) {
            revert("A entrada deve ser maior que 10");
        }
    }

    uint public num;

    function testAssert() public view {
        // Assert somente deve ser usada para testar erros internos,
        // e para checar invariantes.

        // Aqui nós afirmamos que num é sempre igual a 0
        // já que é impossível atualizar o valor de num
        assert(num == 0);
    }

    // erro personalizado
    error InsufficientBalance(uint saldo, uint retirarQuantidade);

    function testCustomError(uint _retirarQuantidade) public view {
        uint bal = address(this).balance;
        if (bal < _retirarQuantidade) {
            revert InsufficientBalance({saldo: bal, retirarQuantidade: _retirarQuantidade});
        }
    }
}

Aqui está outro exemplo

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract Conta {
    uint public saldo;
    uint public constant MAX_UINT = 2**256 - 1;

    function deposit(uint _quantidade) public {
        uint saldoAntigo = saldo;
        uint saldoNovo = saldo + _quantidade;

        // saldo + _quantidade não entra em condição de overflow se saldo + _quantidade >= saldo
        require(saldoNovo >= saldoAntigo, "Overflow");

        saldo = saldoNovo;

        assert(saldo >= saldoAntigo);
    }

    function withdraw(uint _quantidade) public {
        uint saldoAntigo = saldo;

        // saldo - _quantidade não entra em condição de underflow se saldo >= _quantidade
        require(saldo >= _quantidade, "Underflow");

        if (saldo < _quantidade) {
            revert("Underflow");
        }

        saldo -= _quantidade;

        assert(saldo <= saldoAntigo);
    }
}

Teste no Remix

Erro.sol (opens new window)

Conta.sol (opens new window)