Como verificar um contrato inteligente no Etherscan usando o Hardhat

23 de Outubro de 2022

Devido, em grande parte, à natureza imutável dos contratos inteligentes implantados em blockchains de uso geral, a segurança é sempre a primeira prioridade tanto dos usuários quanto das empresas. Por essa razão, uma das etapas-chave em desenvolvimento de contratos inteligentes na Ethereum é a verificação do Etherscan após a implantação inicial. O Etherscan permite que qualquer um, de usuários a desenvolvedores experientes e caçadores de bugs, verifique a validade, correção e segurança de seu código.

Em artigos anteriores, aprendemos como ler o contrato inteligente no Etherscan e como verificar o contrato inteligente no Etherscan usando o Remix IDE. Neste tutorial, nosso objetivo é entender como a verificação pode ser feita usando um dos frameworks de desenvolvimento de contrato inteligente mais usados - o Hardhat.

Vamos começar.

Criar um projeto no Hardhat

Vamos criar um novo projeto no Hardhat. Primeiro, verificaremos a versão npm (node package manager) que temos instalada em nossa máquina. Abra seu terminal e digite:

npm -v

Se você não tiver o npm instalado, siga este guia. Em seguida, insira o seguinte comando para instalar o Hardhat:

npm install --save-dev hardhat

Se você estiver usando o yarn ao invés do npm, insira:

yarn add --dev hardhat

Se você estiver usando o Windows, é altamente recomendável usar o WSL 2.

Para criar um projeto de amostra, execute o seguinte comando na pasta do seu projeto e selecione “Create a TypScript project” (Criar um projeto TypeScript):

npx hardhat

Desenvolvendo um contrato inteligente

Se as etapas anteriores funcionaram corretamente, você deve agora ser capaz de ver três pastas principais do Hardhat: “contracts” (contratos), “test” (teste) e “scripts”. Vá até a pasta “contracts”, crie um novo arquivo Solidity e nomeie-o “PriceFeedConsumer.sol”. Em seguida, copie o código-fonte a seguir, retirado da Chainlink Official Documentation (Documentação Oficial da Chainlink).

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

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

contract PriceConsumerV3 {

    AggregatorV3Interface internal priceFeed;

    /**
     * Network: Goerli
     * Aggregator: ETH/USD
     * Address: 0xD4a33860578De61DBAbDc8BFdb98FD742fA7028e
     */
    constructor(address priceFeedAddress) {
        priceFeed = AggregatorV3Interface(priceFeedAddress);
    }

    /**
     * Returns the latest price
     */
    function getLatestPrice() public view returns (int) {
        (
            /*uint80 roundID*/,
            int price,
            /*uint startedAt*/,
            /*uint timeStamp*/,
            /*uint80 answeredInRound*/
        ) = priceFeed.latestRoundData();
        return price;
    }
}

Agora, instale o pacote @chainlink/contracts executando o comando a seguir:

npm install --save-dev @chainlink/contracts

Depois disso, compile nosso contrato inteligente executando

npx hardhat compile

Opção 1 : Verifique seu contrato inteligente usando o plugin hardhat-etherscan dentro do script de implantação

Com o Hardhat, você pode verificar seus contratos inteligentes no Etherscan usando o plugin hardhat-etherscan.

Para começar, você precisará de uma chave API do Etherscan. Para obter uma, acesse o site do Etherscan, crie uma nova conta gratuitamente e faça login. Depois disso, clique na aba “API Keys” (Chaves API). Por fim, clique no botão “Add” (adicionar) para gerar a nova chave API.

Vamos implantar nosso contrato inteligente na rede de teste Goerli. Se você nunca fez isso antes, talvez queira saber que, para implantar um contrato inteligente do Hardhat, você deve fornecer a chave privada da sua carteira e o JSON RPC URL. Você pode assinar uma chave gratuita do Alchemy.

Você também precisará de alguns ETH de teste, que podem ser obtidos facilmente na Chainlink Faucet (Torneira da Chainlink).

Navegue de volta ao seu projeto Hardhat. Modifique o arquivo “hardhat.config.ts”:

export default {
  // rest of the config
  networks: {
    hardhat: {},
    goerli: {
      url: `https://eth-goerli.alchemyapi.io/v2/${ALCHEMY_API_KEY}`,
      accounts: [GOERLI_PRIVATE_KEY],
    },
  },
  etherscan: {
    apiKey: "ABCDE12345ABCDE12345ABCDE123456789", // Your Etherscan API key
  },
};

Crie um novo arquivo dentro da pasta “scripts” e nomeie-o “deployPriceFeedConsumer.ts”. O script implantará o contrato inteligente PriceFeedConsumer.sol, aguardará a inclusão de alguns blocos na cadeira por motivos de segurança e tentará verificá-lo no Etherscan.

import { ethers, network, run } from "hardhat";

async function main() {
  const priceFeedAddress = “0xD4a33860578De61DBAbDc8BFdb98FD742fA7028e”;

  const priceFeedConsumerFactory = await ethers.getContractFactory(“PriceConsumerV3”);
  const priceFeedConsumer = await priceFeedConsumerFactory.deploy(priceFeedAddress);

  const WAIT_BLOCK_CONFIRMATIONS = 6;
  await priceFeedConsumer.deployTransaction.wait(WAIT_BLOCK_CONFIRMATIONS);

  console.log(`Contract deployed to ${priceFeedConsumer.address} on ${network.name}`);

  console.log(`Verifying contract on Etherscan...`);

  await run(`verify:verify`, {
    address: priceFeedConsumer.address,
    constructorArguments: [priceFeedAddress],
  });
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

Salve o arquivo e execute o próximo comando do seu terminal:

npx hardhat run scripts/deployPriceFeedConsumer.ts --network goerli

Seu contrato deve agora ser implantado na rede de teste Goerli e verificado no explorador Etherscan.

Opção 2: Verifique seu contrato usando o plugin hardhat-etherscan da sua CLI (Command Line Interface - Interface de linha de comando)

Mais uma vez, usaremos o plugin hardhat-etherscan para verificar nosso contrato inteligente.

Para começar, vá ao Etherscan e faça login em uma conta. Nas configurações da sua conta, encontre a seção “API Keys” (Chaves API). Gere uma chave API usando o plano gratuito.

Mais uma vez, implantaremos nosso contrato inteligente na rede de teste Goerli. Se você precisar de tokens de teste, visite a Chainlink Faucet (Torneira da Chainlink).

Modifique o arquivo “hardhat.config.ts”:

export default {
  // rest of the config
  networks: {
    hardhat: {},
    goerli: {
      url: `https://eth-goerli.alchemyapi.io/v2/${ALCHEMY_API_KEY}`,
      accounts: [GOERLI_PRIVATE_KEY],
    },
  },
  etherscan: {
    apiKey: "ABCDE12345ABCDE12345ABCDE123456789", // Your Etherscan API key
  },
};

Crie um novo arquivo dentro da pasta “scripts” e nomeie-o “deployPriceFeedConsumer.ts”. Isso implantará o contrato inteligente PriceFeedConsumer.sol e aguardará alguns blocos serem incluídos na cadeia por questões de segurança.

import { ethers, network } from "hardhat";

async function main() {
  const priceFeedAddress = “0xD4a33860578De61DBAbDc8BFdb98FD742fA7028e”;

  const priceFeedConsumerFactory = await ethers.getContractFactory(“PriceConsumerV3”);
  const priceFeedConsumer = await priceFeedConsumerFactory.deploy(priceFeedAddress);

  const WAIT_BLOCK_CONFIRMATIONS = 6;
  await priceFeedConsumer.deployTransaction.wait(WAIT_BLOCK_CONFIRMATIONS);

  console.log(`Contract deployed to ${priceFeedConsumer.address} on ${network.name}`);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

Implante seu contrato inteligente usando o seguinte comando:

npx hardhat run scripts/deployPriceFeedConsumer.ts --network goerli

Vamos agora verificar este contrato inteligente no Etherscan a partir da CLI usando a tarefa “verify” (verificar) do Hardhat. A sintaxe geral deste comando se parece algo isto:

npx hardhat verify --network <network> <contract address> <constructor parameters>

Vamos ajustar da seguinte forma:

npx hardhat verify --network goerli <contract address>
0xD4a33860578De61DBAbDc8BFdb98FD742fA7028e

Você deve ser capaz de ver um link para o código-fonte verificado publicamente do nosso contrato no Etherscan. Se você receber um erro dizendo que o endereço não possui bytecode (código de byte), provavelmente significa que o Etherscan ainda não indexou seu contrato. Nesse caso, aguarde um minuto e então tente novamente.

Opção 3: Verifique seu contrato usando a tarefa de nivelamento do hardhat

A terceira opção para verificação do Etherscan usando Hardhat é semelhante ao processo de verificação através do Remix IDE, que está descrito em um dos nossos posts anteriores no blog.
Mais uma vez, estamos implantando na rede de teste Goerli e, se você precisar de tokens de teste, navegue até a Chainlink Faucet (Torneira da Chainlink). Você não precisa de uma chave API do Etherscan para isso.

Seu arquivo “hardhat.config.ts” deve ficar assim:

export default {
  // rest of the config
  solidity: "0.8.9",
  networks: {
    hardhat: {},
    goerli: {
      url: `https://eth-goerli.alchemyapi.io/v2/${ALCHEMY_API_KEY}`,
      accounts: [GOERLI_PRIVATE_KEY],
    },
  }
};

Vamos reutilizar o script de implantação do capítulo anterior:

import { ethers, network } from "hardhat";

async function main() {
  const priceFeedAddress = “0xD4a33860578De61DBAbDc8BFdb98FD742fA7028e”;

  const priceFeedConsumerFactory = await ethers.getContractFactory(“PriceConsumerV3”);
  const priceFeedConsumer = await priceFeedConsumerFactory.deploy(priceFeedAddress);

  const WAIT_BLOCK_CONFIRMATIONS = 6;
  await priceFeedConsumer.deployTransaction.wait(WAIT_BLOCK_CONFIRMATIONS);

  console.log(`Contract deployed to ${priceFeedConsumer.address} on ${network.name}`);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

Execute o script de implantação:

npx hardhat run scripts/deployPriceFeedConsumer.ts --network goerli

Se você pesquisar o endereço do seu contrato no Etherscan, verá apenas o bytecode do contrato ao clicar na aba “Contract” (contrato).

Para iniciar o processo de verificação, clique no link “Verify and Publish” (verificar e publicar). A seguinte página irá aparecer.

Insira o endereço do seu contrato no primeiro campo de entrada, caso ainda não esteja preenchido por padrão.

Em seguida, no menu suspenso “Compiler Type” (Tipo de compilador), selecione “Solidity (Single File)” - Solidity (Arquivo único).

Depois disso, o menu suspenso “Compiler Version” (Versão do compilador) aparecerá. Aqui, você precisa selecionar a mesma versão do compilador Solidity que você usou para compilar este contrato inteligente antes da implantação. Se você voltar ao arquivo “hardhat.config.ts”, verá que, em nosso caso, essa foi a versão 0.8.9.

Por fim, no menu suspenso “Open Source License Type” (Tipo de licença de código aberto), selecione a licença especificada no início do arquivo Solidity “SPDX-License-Identifier”, MIT em nosso caso. Clique em “Continue” (Continuar) para ir para a próxima página.

Na página seguinte, você deve colar o código-fonte do contrato inteligente. Infelizmente, se você importou outros contratos ou interfaces, como nós fizemos, você não pode apenas copiar e colá-los aqui. O Etherscan também precisa saber o código-fonte desses contratos importados. Para fazê-lo, você precisa “nivelar” seu contrato inteligente digitando o comando a seguir:

npx hardhat flatten

A versão “nivelada” do seu contrato inteligente será impressa no terminal. De forma alternativa, você pode querer salvá-lo em um arquivo separado, o que pode ser feito digitando:

npx hardhat flatten contracts/PriceFeedConsumer.sol > cotracts/PriceFeedConsumer_flat.sol

Agora você pode colar o código-fonte do contrato na caixa de entrada “Enter the Solidity Contract Code below” (Insira o código Solidity do contrato abaixo). Em seguida, resolva o Captcha e clique no botão azul “Verify and Publish” (Verificar e publicar). Você deve ser capaz de ver uma marca de seleção verde na aba Contract (Contrato). Isso significa que você verificou seu contrato com sucesso.

Conclusão

Neste artigo, abordamos como verificar contratos inteligentes no Etherscan do Hardhat utilizando três métodos diferentes. A verificação de contrato inteligente é uma das etapas cruciais no processo de implantação porque permite à comunidade conferir o código-fonte antes de usá-lo.

Saiba mais sobre a Chainlink visitando chain.link ou lendo a documentação em docs.chain.link. Para discutir uma integração, entre em contato com um especialista.

Esse artigo foi escrito por Andrej Rakic e traduzido por Isabela Curado Nehme. Seu original pode ser lido aqui.