O desenvolvimento de contratos inteligentes é vital para construir aplicações descentralizadas na blockchain. No entanto, como em qualquer desenvolvimento de software, depurar contratos inteligentes pode ser desafiador, mas é possível determinar rapidamente a causa de uma falha em uma única transação ou na execução do contrato com uma ferramenta avançada para depuração de contratos inteligentes em Solidity.
Podemos implementar uma solução adequada uma vez que identificamos o erro que levou a um problema específico e aprendemos detalhes profundos sobre a natureza do erro.
Este guia fornecerá dicas e ferramentas para depurar contratos inteligentes, para ajudar os desenvolvedores Web3 a garantir que seus contratos funcionem conforme o esperado.
Depurando Contratos Inteligentes
Depurar contratos inteligentes é identificar e corrigir erros nestes contratos. É essencial no desenvolvimento de qualquer aplicação descentralizada, pois garante que os contratos funcionem conforme o planejado.
O desenvolvimento de contratos pode encontrar vários problemas, incluindo comportamento imprevisível, erros de codificação e falhas de segurança. A depuração pode ajudar a resolver esses problemas e prevenir que problemas mais graves surjam posteriormente.
Implementação, teste e implantação são apenas alguns processos no desenvolvimento de um contrato inteligente. Uma fase crucial em cada um desses passos é a depuração. Após implantar o contrato, a depuração ajuda a encontrar e corrigir falhas no código introduzidas durante a fase de escrita.
Durante a fase de testes, a depuração ajuda a encontrar e corrigir problemas que podem ter passado despercebidos durante a escrita. A depuração também garante que o contrato seja implantado corretamente e interaja com a blockchain conforme o previsto durante a implantação.
Dicas de Depuração
Escrever contratos inteligentes que sejam fáceis de depurar é um passo crucial no desenvolvimento. Abaixo estão algumas dicas para escrever contratos inteligentes que são fáceis de depurar:
- Use nomes simples e sugestivos para suas variáveis e funções para que qualquer um possa entender rapidamente o que cada uma faz e identificar erros.
- Utilize a função embutida em Solidity chamada
requirepara garantir que uma determinada condição seja satisfeita antes que o contrato continue a execução. É uma ferramenta valiosa para depuração, pois interrompe a execução do contrato quando a condição não é atendida, permitindo que os programadores localizem o problema rapidamente. - O Truffle Debugger é uma ferramenta poderosa que você pode usar para depurar contratos durante a fase de testes. Ele permite que os desenvolvedores revisem o código, inspecionem valores de variáveis e revertam para estados anteriores.
- O Remix IDE é um popular editor de código online para Solidity. Ele possui uma função de depuração integrada que permite aos programadores navegar pelo código e verificar os valores das variáveis.
Categorias de Erros
Erros de sintaxe, de execução e lógicos são os problemas mais frequentes que os engenheiros enfrentam ao escrever ou executar código para contratos em Solidity.
Erro de Sintaxe
Um erro de sintaxe em um contrato inteligente é um erro no código que impede o computador de entendê-lo. Erros simples, como omitir um ponto e vírgula ou usar indevidamente um termo, podem ser considerados erros de sintaxe.
Erro Lógico
Um erro lógico em um contrato inteligente refere-se a um erro no código que não o impede de ser executado, mas faz com que ele produza resultados inesperados ou incorretos.
Por exemplo, um contrato transfere dinheiro para o endereço errado ao enviar dinheiro de uma conta para outra.
Uma auditoria de um contrato inteligente pode encontrar problemas lógicos, pois, às vezes, na perspectiva do desenvolvedor, tudo está indo conforme o planejado. Mesmo que não haja um erro no código, um auditor ainda pode executar um contrato inteligente para procurar vulnerabilidades de segurança, examinar a lógica de negócios e encontrar brechas.
Erro de Execução
Qualquer erro durante a execução de um contrato é chamado de erro de execução. Isso pode ocorrer se um contrato não lidar corretamente com entradas ou condições inesperadas ou tentar realizar uma operação proibida pela blockchain subjacente.
Por exemplo, um contrato que tenta transferir mais dinheiro do que o permitido em uma conta resultaria em um erro de execução.
Os problemas de execução são mais desafiadores de diagnosticar do que os erros de sintaxe, pois não são conhecidos antes de serem implantados em uma blockchain e só podem ocorrer quando o estado de um contrato inteligente muda.
Erros de Execução Comuns
Vamos analisar os erros de execução mais comuns ao desenvolver contratos inteligentes para a rede Ethereum.
Transbordamento de Pilha (Stack Overflow)
Em Solidity, uma pilha pode conter apenas 1024 quadros, o que significa que uma função só pode se chamar 1024 vezes antes que ocorra um transbordamento de pilha. Se houver uma tentativa de executar uma função recursivamente e não houver condição para interrompê-la, ocorrerá um transbordamento de pilha.
pragma solidity ^0.8.0;
contract Overflow {
function count(uint256 num) public returns (uint256) {
return count(num + 1);
}
}
Overflow o = new Overflow();
o.count(1); // Isso causará um erro de Transbordamento de Pilha, pois a função continua chamando a si mesma infinitamente.
Subtransbordamento de Pilha (Stack Underflow)
Quando há uma tentativa de remover uma variável inexistente na linguagem assembly, ocorre um subtransbordamento de pilha.
O Solidity não possui um modelo de execução baseado em pilha como algumas outras linguagens de programação, como C, por isso é impossível causar um erro de Subtransbordamento de Pilha em Solidity da mesma maneira que nessas linguagens.
No entanto, o Solidity possui algumas exceções que podem ser lançadas se um contrato ficar sem gás, o que pode ser pensado como um conceito semelhante ao Subtransbordamento de Pilha. Aqui está um exemplo de código Solidity que pode potencialmente causar um erro “Out of Gas” (Sem Gás):
pragma solidity ^0.8.0;
contract Underflow {
function loop(uint256 num) public returns (uint256) {
for (uint256 i = 0; i < num; i--) {
// Faça alguma operação
}
return num;
}
}
Underflow u = new Underflow();
u.loop(1); // Este código pode ficar sem gás, pois a condição do loop for sempre será verdadeira e o loop continuará indefinidamente, podendo causar um erro "Out of Gas".
Execução Revertida
Quando um contrato interrompe a execução de uma transação que se desvia de sua lógica de negócios, ocorrem erros de reversão. Os contratos geralmente incluem verificações para vários critérios necessários. Se uma transação não atender a todos os requisitos, o contrato considera essa transação inválida e interrompe a execução.
É vital lembrar que uma transação só será revertida se houver uma tentativa de conclusão, mas não puder ser executada com base na lógica do contrato inteligente; neste caso, a EVM retornará um erro, e a transação será revertida.
pragma solidity ^0.8.0;
contract Revert {
function transfer(address payable recipient, uint256 amount) public {
require(amount > 0, "Amount must be greater than zero");
recipient.transfer(amount);
}
}
Revert r = new Revert();
r.transfer(address(0), 0); // Este código causará um erro de Execução Revertida, pois a instrução `require` falhará já que o valor é zero, fazendo com que a função reverta sua execução.
Out of Gas
O erro "Out of Gas" ocorre quando você não fornece gás suficiente para executar uma transação ou o gás é insuficiente para concluir uma transação.
pragma solidity ^0.8.0;
contract OutOfGas {
function consumeGas() public {
while (true) {
// Faça algum cálculo que consuma gás
}
}
}
OutOfGas o = new OutOfGas();
o.consumeGas(); // Este código pode ficar sem gás, pois o loop while é executado indefinidamente, consumindo todo o gás disponível.
Código de Operação Inválido
Os erros de código de operação inválido ocorrem quando a EVM encontra uma incompatibilidade com um contrato. Por exemplo, quando o contrato foi compilado com um compilador não suportado.
Erros de Salto (JUMP Errors)
O salto inválido (jump) acontece quando você tenta chamar uma função que não existe, como quando chama uma função de um contrato através de outro contrato que não existe. Um problema semelhante pode ocorrer quando você usa a linguagem assembly e aponta para uma memória falsa.
pragma solidity ^0.8.0;
contract JumpError {
function jump() public returns (uint256) {
uint256 x = 1;
if (x == 1) {
return 1;
} else {
return 2;
}
return 3; // Este código é inacessível e pode causar um erro JUMP.
}
}
JumpError j = new JumpError();
j.jump(); // Este código pode causar um erro JUMP, já que a declaração de retorno final é inacessível.
Ferramentas de Depuração
A seção anterior nos ensinou sobre erros comuns ao construir e implantar contratos inteligentes. Agora, vamos conferir as ferramentas para depurar contratos inteligentes.
Hardhat & Truffle
Hardhat é um ambiente de desenvolvimento de código aberto para Ethereum. Inclui ferramentas para desenvolver, testar e implantar contratos inteligentes. O Hardhat também tem um depurador integrado que permite aos desenvolvedores revisar o código e inspecionar os valores das variáveis.
Truffle é um framework de desenvolvimento popular para Ethereum. Ele inclui um conjunto de ferramentas para desenvolver, testar e implantar contratos inteligentes. O Truffle também possui o Truffle Debugger, uma ferramenta poderosa para depurar contratos durante a fase de teste.
Remix
Remix é um popular editor de código online para Solidity. Ele possui uma função de depuração integrada que permite aos desenvolvedores navegar pelo código e verificar os valores das variáveis.
EtherScan
Etherscan é um explorador de blockchain para Ethereum. Ele permite que os desenvolvedores inspecionem e depurem contratos implantados na blockchain Ethereum.
O estágio de desenvolvimento e os requisitos específicos do projeto determinarão a melhor ferramenta a ser usada para depurar contratos.
Remix e EtherScan são mais adequados para a fase de implantação, enquanto Truffle e Hardhat são mais adequados para testes. O Truffle e o Hardhat oferecem ferramentas de depuração mais sofisticadas, como avanço de código e retorno a estados anteriores. O Remix e o Etherscan, por outro lado, proporcionam visibilidade adicional e transparência ao contrato implantado.
Testar diversas ferramentas para determinar qual melhor atende às demandas do projeto é crucial.
Conclusão
Depurar contratos inteligentes é uma etapa crítica na criação de aplicativos descentralizados para o blockchain. Os desenvolvedores Web3 podem garantir que seus contratos funcionem conforme o esperado seguindo os conselhos e usando os recursos descritos neste guia.
À medida que a tecnologia e as melhores práticas avançam, é fundamental continuar aprendendo e experimentando novas ferramentas e estratégias para depurar contratos.
Recursos
- Ethereum Developers Tools list
- Smart Contract tools you need to know
- Guide to Ethereum Developer Tools
- How to Debug Smart Contract Transactions
Adoraria me conectar com você no Twitter | LinkedIn | GitHub | Portfólio
Vejo você no meu próximo artigo de blog. Cuide-se!!!
Artigo original publicado por Idris Olubisi. Traduzido por Paulinho Giovannini.
Oldest comments (0)