Introdução

Solidity é uma linguagem de programação de alto nível, orientada a objetos, para implementação de contratos inteligentes. Contratos inteligentes são programas que regem o comportamento das contas na rede Ethereum. Solidity é uma linguagem de colchetes projetada para atingir a Máquina Virtual Ethereum (EVM). Entre as ferramentas essenciais no arsenal de um desenvolvedor Solidity estão a instrução require e a capacidade de criar erros personalizados.

No Solidity, a instrução require é usada para validar condições em contratos inteligentes. A sintaxe básica da instrução require envolve a verificação de uma condição e, se a condição for false (falsa), ela reverte a transação.

Os erros personalizados são definidos usando a instrução error no Solidity. Eles podem ser usados ​​dentro e fora de contratos (incluindo interfaces e bibliotecas). Eles ajudam a depurar e compreender o motivo da reversão durante a execução do contrato.

O Que é a Instrução require no Solidity?

A instrução require é usada no Solidity para garantir que certas condições em contratos inteligentes sejam atendidas. Geralmente é usado para validar solicitações de entrada ou execução antes de executar código adicional. Se a condição fornecida para require for avaliada como false, a transação será revertida e quaisquer alterações de estado serão desfeitas.

A sintaxe geral para usar a instrução require no Solidity é:

require(condition, errorMessage);

Abaixo está uma explicação do código acima:

• condition: esta é a condição que precisa ser verdadeira para que a função seja executada com sucesso. Se a condição for falsa, a função será revertida e quaisquer alterações de estado serão desfeitas.
• errorMessage: esta é uma mensagem de erro opcional que será exibida se a condição require for avaliada como false (falsa). Isso ajuda a fornecer contexto sobre o motivo da falha da condição em nosso código.

Aqui está um exemplo que demonstra a sintaxe geral da instrução require:

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

contract RequireStatement {
    function withdraw(uint amount) public {
    require(amount > 0, "Amount should be greater than zero");
    // Código adicional para a retirada/saque
    // ...
    }
}

No exemplo de código acima, a instrução require garante que o amount (valor) fornecido seja maior que zero. Se a condição (amount > 0) não for atendida, a transação será revertida e a mensagem de erro "O valor deve ser maior que zero" será exibida.

Melhores Práticas para Usar a Instrução require no Solidity

Usar a instrução require no Solidity é essencial para garantir a integridade e a segurança dos seus contratos inteligentes. Aqui estão algumas das melhores práticas para usar a instrução require:

• Forneça mensagens de erro informativas: inclua mensagens de erro descritivas para fornecer mais contexto quando uma condição require falhar. Isso ajuda os desenvolvedores e usuários a entender por que a execução da função foi revertida, auxiliando na depuração.
• Mantenha as condições simples e legíveis: escreva condições claras e concisas que sejam fáceis de entender. Condições complexas podem dificultar a leitura e a manutenção do código.
• Use require moderadamente: reverter uma transação pode custar caro, por isso é importante usar a instrução require somente quando necessário.

Benefícios de Usar a Instrução require no Solidity

Usar a instrução require no Solidity oferece vários benefícios que contribuem para a segurança, integridade e clareza do desenvolvimento de contratos inteligentes. Alguns dos principais benefícios incluem:

• Verificações de pré-condição: a instrução require permite a verificação de parâmetros de entrada ou condições de estado antes de executar partes críticas do código. Isso ajuda a garantir que a função ou contrato esteja operando nas circunstâncias esperadas.
• Aprimoramento da segurança: as instruções require são importantes para evitar alterações de estado indesejadas e garantir que o estado do contrato permaneça consistente. Elas ajudam na proteção contra comportamentos inesperados ou maliciosos que possam comprometer a integridade dos contratos inteligentes.
• Legibilidade e manutenção do código: ao usar as instruções require para verificações de pré-condições, o código se torna mais legível e autoexplicativo. Elas melhoram a capacidade de manutenção e tornam o código mais fácil para que desenvolvedores, auditores e qualquer pessoa que revise o código possam compreender.

O Que São Erros Personalizados no Solidity?

O Solidity v0.8.4 trouxe a introdução de erros personalizados. Eles permitem que os desenvolvedores definam seus próprios tipos e mensagens de erros personalizados. São utilizados para fornecer informações mais descritivas e específicas quando algo dá errado durante a execução de uma função em um contrato.

Erros personalizados podem ser definidos usando a instrução error seguida por um nome exclusivo para o erro, juntamente com mensagens de erro específicas ou códigos de erro para fornecer contexto adicional sobre o erro. Os erros personalizados são mais eficientes em termos de gás do que o uso de strings em mensagens de erro, e também podem ser usados ​​para passar parâmetros para mensagens de erro.

No Solidity, você pode definir erros personalizados usando a instrução error dentro do contrato. Aqui está a sintaxe para definir erros personalizados no Solidity:

error MyCustomError(string message);

Abaixo está uma explicação do código acima:

• A instrução error no exemplo de código é uma palavra-chave usada para definir erros personalizados no Solidity.
• MyCustomError é o nome dado ao erro personalizado. Você pode substituir o nome MyCustomError pelo nome desejado.
• string message especifica o tipo de parâmetro a ser incluído no erro. Esse parâmetro pode ser usado para passar informações sobre o erro.

Aqui está um exemplo que demonstra a sintaxe geral da instrução error:

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

contract CustomErrorExample {
    error MyCustomError(uint value, string message);

    function checkValue(uint _value) public {
        if (_value < 10) {
            revert MyCustomError(_value, "Value is too low");
        }
        // Código adicional se o valor for aceitável
     }
}

No exemplo de código acima, a instrução de erro MyCustomError é definida para tratar casos em que um valor é muito baixo. Dentro da função checkValue, se o _value fornecido for menor que 10, ela reverterá e exibirá o erro MyCustomError, passando o _value e a mensagem de erro "O valor é muito baixo”. Isso permite uma mensagem de erro mais descritiva e informativa quando a condição não é atendida.

A definição de erros personalizados permite que os desenvolvedores do Solidity criem tipos de erros específicos com informações adicionais, auxiliando no melhor tratamento de erros e depuração em contratos inteligentes.

Melhores Práticas para Usar Erros Personalizados no Solidity

Ao trabalhar com erros personalizados no Solidity, seguir essas práticas recomendadas é importante para garantir clareza, segurança e tratamento adequado de erros em contratos inteligentes. Aqui estão algumas das melhores práticas para usar erros personalizados:

• Use nomes descritivos: nomeie seus erros personalizados de forma descritiva para indicar facilmente o que aconteceu. Além disso, você deve incluir explicações detalhadas sobre o erro na mensagem de erro.
• Use erros personalizados para representar diferentes tipos de erros. Isso tornará seu código mais fácil de ler e manter. Por exemplo, você pode ter um erro personalizado para fundos insuficientes, um erro personalizado para acesso não autorizado e um erro personalizado para entrada inválida.

Seguindo essas práticas recomendadas, é possível usar erros personalizados para escrever contratos do Solidity mais seguros, confiáveis ​​e eficientes.

Benefícios de Usar Erros Personalizados no Solidity

O uso de erros personalizados no Solidity oferece diversas vantagens e benefícios para o desenvolvimento de contratos inteligentes e tratamento de erros. Alguns dos principais benefícios incluem:

• Custos de gás reduzidos: erros personalizados economizam mais gás do que usar strings em mensagens de erro. Isso ocorre porque a mensagem de erro é codificada no bytecode do contrato, portanto, não precisa ser armazenada na blockchain.
• Maior legibilidade e capacidade de manutenção do código: erros personalizados podem tornar o código mais legível e fácil de manter, declarando explicitamente as suposições que o código está fazendo.

Conclusão

A instrução require é frequentemente usada para verificar parâmetros de entrada, verificar certas condições antes de executar partes críticas do código ou garantir que o estado do contrato seja o esperado antes de prosseguir com outras operações. Isso ajuda a evitar ações erradas ou maliciosas que podem resultar em estados indesejáveis ​​ou inconsistentes da blockchain.

Erros personalizados são úteis para fornecer feedback mais significativo aos usuários que interagem com o contrato, permitindo-lhes entender por que uma transação falhou e proporcionando mais transparência no comportamento do contrato inteligente.

Se você achar este artigo útil, por favor, aplauda, compartilhe e siga-me para aprender mais sobre a rede blockchain, Máquina Virtual Ethereum, Solidity e muito mais. Obrigado por ficar até o fim e até o próximo.

Este artigo foi escrito por Wasiu Akindoyin e traduzido por Isabela Curado Nehme. Seu original pode ser lido aqui.