Tratamento de erros em Solidity

‍Como funciona o tratamento de erros em Solidity?

Solidity usa exceções que revertem o estado para lidar com erros, e essa exceção desfaz todas as alterações feitas no estado durante a chamada atual e, ao mesmo tempo, sinaliza um erro ao chamador. ‍

Solidity, uma linguagem de programação orientada a objetos para implementar smart contracts em blockchains como Ethereum, possui diversas funções para tratar problemas subjacentes que podem ocorrer em tempo de compilação ou em tempo de execução. Embora as verificações de erro de sintaxe ocorram em tempo de compilação, os erros de tempo de execução são difíceis de detectar e geralmente ocorrem durante o processo de execução do contrato. Alguns exemplos de erros de tempo de execução incluem erro de divisão por zero, erro de índice de array fora dos limites, entre outros.

Na prática, o tratamento de erros em Solidity garante a atomicidade como propriedade. Quando a chamada de um smart contract termina com erro, todas as alterações de estado (ou seja, alterações feitas em variáveis, saldos, etc.) são revertidas, ao longo de toda a cadeia de chamadas de contratos.

É importante notar que desenvolvedores podem interagir diretamente com outros contratos declarando uma interface. Na blockchain Ethereum, as transações são atômicas, o que significa que elas são totalmente concluídas ou não têm efeito algum sobre o estado e são revertidas por completo.

Quais são as três principais funções de tratamento de erros do Solidity?

O tratamento de erros em Solidity é gerenciado, em princípio, por três funções especiais: assert, require e revert. Até a versão 0.4.10, havia apenas a instrução throw disponível em Solidity.

Solidity foi projetada para ter como alvo a Ethereum Virtual Machine (EVM) e é influenciada por C++, Javascript e Python. Usando Solidity, desenvolvedores podem criar contratos para usos como votação, crowdfunding, carteiras multi-assinatura e até leilões cegos.

Na prática, isso significava que um desenvolvedor precisava escrever várias funções de teste para verificar valores subjacentes e disparar erros, o que não era otimizado para gas. No lançamento da versão 0.4.10 do Solidity, novas construções de tratamento de erros — assert, require e revert — foram introduzidas, e o throw tornou-se obsoleto.

O que é a função require?

A função require é usada para verificar entradas e condições antes da execução. Por exemplo, se a condição for falsa, a função require interrompe imediatamente a execução. Em outras palavras, require atua como um modificador de verificação de portão, impedindo que a lógica avance para a execução da função e produzindo assim um erro. Require é ideal para controlar o fluxo lógico e validar entradas do usuário em funções.

Instruções require declaram pré-requisitos para a execução da função, que devem ser satisfeitos antes da execução do código. A função require aceita um único argumento e, após a avaliação, retorna um valor booleano true ou false. Caso a execução seja encerrada devido a uma condição falsa, o gas não utilizado é devolvido ao chamador e o estado é revertido ao estado original. Também é possível adicionar mensagens de string personalizadas.

Aqui está um exemplo de uma instrução require em Solidity:

Casos de uso da instrução require

Por razões práticas, desenvolvedores podem usar require nos seguintes cenários:

1. Validar respostas de um contrato externo
2. Verificar condições de estado antes da execução final
3. Autenticar entradas do usuário

O que é a instrução revert?

‍Revert não avalia nenhuma condição e não depende de nenhum estado ou instrução. A instrução revert é semelhante à instrução require, pois a função revert pode lidar com os mesmos tipos de erro que a função require, mas é mais apropriada para portões lógicos complexos.

Se uma instrução revert for chamada, o gas não utilizado é devolvido e o estado é revertido ao estado original. A capacidade de adicionar uma mensagem personalizada é a mesma da função require.

Aqui está um exemplo de uma instrução revert em Solidity:

O que é a função assert?

Assert é uma função usada para verificar código que nunca deveria ser falso, e desempenha um papel importante na prevenção de cenários impossíveis. Se a função assert retornar um valor booleano true, um bug terminal será exibido e os programas não serão executados.

Em contraste com as funções require e revert, assert não devolve nenhum gas não utilizado; em vez disso, a função assert consumirá todo o suprimento de gas antes de proceder à reversão do programa ao seu estado original. Curiosamente, antes do fork Byzantium, tanto as funções require quanto assert se comportavam de maneira idêntica, porém eram compiladas em opcodes distintos.

Tipos de exceções do assert

1. Um valor é submetido a módulo ou dividido por zero
2. Uma variável não inicializada de uma função é chamada
3. Um valor negativo ou grande é convertido para um enum
4. Acesso a um array em um índice negativo ou maior que o esperado

Exemplo de instrução assert:

Casos de uso da instrução assert

Em teoria, assert deve ser usado com menos frequência em comparação com a função require. Desenvolvedores devem considerar usar a função assert nos seguintes casos de uso:

• Validar o estado do contrato após fazer alterações
• Evitar condições que nunca deveriam ser possíveis
• Verificar parâmetros de overflow e underflow
• Examinar invariantes

Require vs. revert vs. assert

Aqui está um resumo que fornece uma descrição sucinta das três funções de tratamento de erros do Solidity: require, revert e assert.

Require

• Usado no início de uma função
• Valida contra entradas ilegais
• Verifica condições de estado antes da execução
• Reembolsa o gas restante

Revert

• Idêntico ao require
• Útil para portões de fluxo lógico mais complexos (ou seja, blocos if-then complicados)
• Reembolsa o gas restante

Assert

• Usado no final de uma função
• Valida algo que é impossível
• Fundamental para ferramentas de análise estática de código
• Não reembolsa o gas restante

Como aprender mais sobre require e o tratamento de erros em Solidity

Desenvolvedores interessados em aprender mais sobre o tratamento de erros em Solidity devem se inscrever no curso intensivo gratuito de Solidity da Alchemy University. Esse bootcamp GRATUITO, de 7 semanas, ajuda desenvolvedores web2 e programadores completamente novos a aprender a escrever smart contracts em Solidity. Se os desenvolvedores forem novos no desenvolvimento em geral, o curso intensivo de JavaScript de 3 semanas da Alchemy University é um ótimo pré-requisito antes de iniciar um bootcamp de Ethereum.