O que é o Solidity console log?

O debugging é uma etapa vital e recorrente em aprender a escrever smart contracts em Solidity, corrigir vulnerabilidades e resolver bugs problemáticos. Os dois tipos típicos de erros de desenvolvimento em smart contracts são erros de runtime e erros de lógica.

Utilizar ferramentas que ampliam a compreensão dos desenvolvedores facilita a experiência de desenvolvimento, especialmente quando se trata de corrigir erros em programas. De forma semelhante ao desenvolvimento em JavaScript, a função console.log() é usada para retornar uma mensagem de saída para o console web, o que ajuda no processo de debugging.

O console.log() aceita um parâmetro (ex.: array, objeto ou mensagem) e imprime o valor no console web para que os desenvolvedores possam avaliá-lo. Esse método permite que os desenvolvedores identifiquem o problema ao delinear a saída do código passo a passo.

Neste artigo, mostraremos a principal forma de fazer debugging em Solidity, revisaremos ferramentas de debugging no Hardhat, Foundry, Truffle e Brownie, e em seguida traremos dicas de debugging.

O que é o console log do Solidity?

Registrar logs no console é uma ferramenta comum usada para debugging de código, e console.log() é uma função de uma biblioteca de contratos fornecida pelo Hardhat. Enviar informações para o console ajuda os desenvolvedores a entender e solucionar problemas em seu programa. Em Solidity, isso seria chamado de evento.

O Ethereum oferece uma funcionalidade de logging que armazena dados na estrutura de dados de log da transação na blockchain. Os eventos do Solidity fornecem uma abstração para essa funcionalidade, pois permitem que os desenvolvedores exponham dados na blockchain.

Como os logs permanecem intactos junto com o endereço do contrato na blockchain e continuam acessíveis com o bloco, os desenvolvedores Solidity podem consultar e referenciar a blockchain para obter os dados específicos da transação.

Casos de uso para eventos em Solidity

Eventos em Solidity podem ser usados de várias formas, incluindo testar smart contracts, indexar dados de transação, servir de referência para desenvolvimento frontend, entre outras. Mais comumente, os desenvolvedores usam eventos em três casos de uso:

1. Em smart contracts, para retornar valores que podem ser usados no frontend
2. Como gatilho assíncrono para que o smart contract emita um evento que aciona uma ação no frontend
3. Como forma mais barata de armazenamento, já que os dados ficam registrados no log da transação.

Dentro dos eventos, os parâmetros podem ser especificados como indexados ou não indexados. Os dados da transação em um log serão exibidos como codificados se o contrato estiver verificado; caso contrário, aparecerão como não indexados ou em formato hash.

Em outros casos, se o processo de desenvolvimento ocorrer em ambientes de suporte como o Hardhat, a função console.log() pode ser usada em conjunto com eventos, funcionando de forma semelhante ao desenvolvimento em JavaScript.

Por que os console logs são importantes?

Os console logs são uma ferramenta necessária para os desenvolvedores no processo de debugging de smart contracts. O console log é uma combinação do ambiente de teste do programa (console) e uma função usada para exibir dados (log()).

Em essência, o console log fornece uma saída do programa em um ambiente de teste que pode ser aproveitada no processo de desenvolvimento e debugging. Se um erro ou problema surgir no programa, o console log seria usado como uma etapa inicial para inspecionar o código e identificar a causa raiz de um bug.

Ao escrever smart contracts em Solidity, os console logs também servem como uma etapa eficaz no processo de debugging para extrair o código e entender a lógica.

Como funciona o logging em Solidity?

O logging, também conhecido como protocolo de observação de eventos ou evento, resulta em sinais gerados por transações e blocos, usados para fornecer informações que não podem ser obtidas pelo smart contract.

O Solidity tem o conceito de 'evento'. Eventos podem ser emitidos em funções de smart contracts e podem ter de 0 a 4 topics, que são indexados para busca rápida. Em Solidity, a palavra-chave 'emit' é usada para emitir eventos. Isso é traduzido em um dos opcodes da EVM: LOG0, LOG1, ..., LOG4.

Como os dados do contrato ficam na State trie e os dados de eventos são armazenados na Transaction Receipts trie, os smart contracts não conseguem ler dados de eventos.

Os dados da transação ou entradas de log consistem em:

• Address - o endereço do contrato
• Topic - os valores indexados do evento
• Data - os valores codificados em ABI ou não indexados do evento

Ferramentas de debugging para Solidity no Hardhat

O Hardhat é um ambiente de desenvolvimento Ethereum focado em permitir que os desenvolvedores criem smart contracts em Solidity localmente e os capacita com ferramentas essenciais de debugging para Solidity.

O Hardhat oferece um conjunto de ferramentas para testar, compilar, implantar e fazer debugging de aplicações. Ao utilizar a Hardhat Network, os desenvolvedores conseguem criar, compilar e implantar smart contracts a partir da própria máquina local por meio da interface Solidity.

1. Console.log

Dentro da Hardhat Network, a função console.log() pode ser usada como uma ferramenta confiável para exibir mensagens de log e extrair detalhes diretamente do código Solidity. A Hardhat Network foi projetada para fornecer uma inspeção de execução flexível e abrangente, independentemente de falhas na transação.

Como imprimir logs no console do Solidity

Os console logs do Solidity podem ser impressos em uma estrutura semelhante à do JavaScript. Depois de concluída a importação, a função console.log() pode ser usada dentro da função para imprimir uma saída específica dependendo do contexto do smart contract. O código a seguir descreve o processo.

Primeiro, importe hardhat/console.sol para o smart contract

Em seguida, adicione a função console.log() dentro de uma função específica no smart contract:

Observação: a ferramenta de console log do Hardhat só pode ser usada depois que hardhat/console.sol for importado no smart contract.

2. Stack traces em Solidity

A ferramenta de stack trace do Hardhat combina JavaScript e Solidity para fornecer um relatório quando uma transação ocorre ou uma chamada falha. Esse relatório automático de erros oferece aos desenvolvedores informações valiosas para avaliar e fazer debugging de seu smart contract.

3. Erros explícitos

O Hardhat oferece uma variedade de possíveis erros que podem ajudar os desenvolvedores a simplificar o processo de debugging, incluindo:

• gerais
• de rede
• de definição de tarefas
• de argumentos
• de resolução de dependências
• de tarefas integradas (built-in)
• de artifacts
• de plugins
• internos
• de nomes de fontes
• de nomes de contratos

Dica de console log em Solidity: use eventos e funções para melhorar o debugging

Eventos podem ser usados para exibir dados dos logs de transação no console, tanto nos estágios de debugging quanto de produção. Um evento serve como um marcador para indicar se um processo ocorreu. Além disso, os eventos indicam se ocorreu algum problema em etapas específicas. Esse processo é semelhante à palavra-chave "require" em Solidity, que verifica se uma condição é verdadeira e permite que o código siga em frente somente se e quando a condição exigida for verdadeira.

Para começar a usar eventos e funções para melhorar o debugging, crie um evento devidamente definido e emita o evento na função. Essas duas etapas garantem que o evento ocorra sempre que a função for chamada.

Ferramentas adicionais de console log para Solidity

Embora o Hardhat seja o padrão da indústria em ferramentas de desenvolvimento Solidity para construir, testar e fazer debugging de smart contracts, existem algumas ferramentas alternativas para solucionar problemas em código Solidity, incluindo Foundry, Truffle e Brownie.

1. Foundry

O Foundry oferece um conjunto de ferramentas de desenvolvimento de smart contracts para Ethereum que permite gerenciar dependências, compilar, implantar, testar e interagir on-chain com smart contracts.

O toolkit do Foundry pode ser integrado ao Hardhat para aproveitar sua função console.log() no processo de debugging. Os desenvolvedores podem chamar a função com até 4 parâmetros, incluindo uint, string, bool e address.

Forge

O Forge é uma ferramenta de linha de comando (CLI) integrada ao Foundry para testar, construir e implantar smart contracts. Esse framework de testes permite que os desenvolvedores criem testes em Solidity usando JavaScript ou TypeScript, além de disponibilizar diversos recursos para o processo de debugging.

O comando test do forge automatiza os testes em Solidity e ainda fornece um resumo dos resultados, incluindo logs e stack traces. O comando debug do forge também é um debugger interativo que analisa um único smart contract como um script para identificar quaisquer erros no programa.

Cast

O Cast é uma ferramenta de interface de linha de comando (CLI) que interage com chamadas RPC do Ethereum. Isso inclui chamadas a smart contracts, transações ou recuperação de dados da chain via linha de comando.

Anvil

O Anvil é um nó de testnet local integrado ao Foundry para permitir a implantação e o teste de smart contracts a partir do frontend ou por meio de interações via RPC (Remote Procedure Calls) com redes compatíveis com EVM (Ethereum Virtual Machine).

2. Truffle

O Truffle oferece três ferramentas de desenvolvimento de smart contracts para Ethereum: um ambiente de desenvolvimento, um framework de testes e um asset pipeline para blockchains. O ecossistema abrangente do Truffle fornece aos desenvolvedores diversas ferramentas para criar, testar e fazer debugging de aplicações descentralizadas de ponta a ponta.

Esses conjuntos de ferramentas oferecidos pelo Truffle são:

• Toolkit para smart contracts - compilação, linking, implantação, etc.
• Debugging - breakpoints, análise de variáveis, execução passo a passo, testes automatizados de contratos
• Gerenciamento - frameworks de rede, pacotes e migrations

Saiba mais: https://trufflesuite.com/docs/truffle/

3. Brownie

O Brownie é um framework de desenvolvimento e testes baseado em Python para smart contracts no Ethereum, com suporte a Solidity e Vyper, dividido em 4 categorias: testes, debugging, interação e implantação. Cada etapa apoia os desenvolvedores na criação de programas flexíveis.

Os desenvolvedores podem acessar diversas ferramentas de debugging para reunir informações detalhadas sobre falhas de transação e para localizar, reproduzir e solucionar erros em Solidity.

• TransactionReceipt.revert_ms - obtém uma mensagem de explicação direta sobre a falha da transação
• TransactionReceipt.error() - localiza a causa raiz e a seção do smart contract que causou a falha na transação
• TransactionReceipt.events - visualiza eventos disparados em transações revertidas
• TransactionReceipt.trace - visualiza uma lista de dicionários contendo as informações da transação
• TransactionReceipt.call_trace() - visualiza um mapa completo (trace) das etapas da transação

Os desenvolvedores também podem utilizar o pytest para testes unitários de smart contracts e, em seguida, analisar o relatório de stack trace fornecido.

Saiba mais: https://eth-brownie.readthedocs.io/en/v1.2.1/index.html

Aprenda sobre o console log do Solidity com a Alchemy University

Este artigo apresentou as ferramentas de logging e debugging mais populares para desenvolver smart contracts em Solidity. Se você está aprendendo Solidity, escolher as melhores ferramentas para debugging de smart contracts é essencial para resolver os problemas que você encontra no desenvolvimento em Solidity.

Para começar ou acelerar seu treinamento em desenvolvimento Solidity, conheça o bootcamp gratuito de 7 semanas para desenvolvedores Solidity da Alchemy University, originalmente um curso de certificação de $3.000 ministrado pela ChainShot, e agora totalmente integrado à Alchemy! Se você é novo no desenvolvimento em geral, o curso intensivo de JavaScript de 3 semanas da Alchemy é um ótimo pré-requisito antes de começar um bootcamp de Ethereum.