O que é Hardhat Ethereum?

Hardhat é um ambiente de desenvolvimento projetado para facilitar a criação e implantação de aplicativos Web3, apoiado pela Ethereum Foundation e amplamente utilizado por grandes empresas dedicadas a construir a próxima geração da World Wide Web.

O Hardhat nos ajuda desde a implantação de um nó Ethereum local que inclui contas pré-carregadas com uma grande quantidade de ethers de teste até a implantação de nosso aplicativo em um nó local ou um Ethereum Testnet usando configurações simples. rede que veremos mais adiante.

Outras ferramentas populares no ecossistema são Ganache e Truffle.

Instalação

Para instalar o Hardhat primeiro precisamos instalar o Node.js, para o qual você pode executar os comandos abaixo de acordo com o SO que estiver utilizando.

Linux (Ubuntu):

sudo apt update
sudo apt install curl git
curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
sudo apt-get install -y nodejs

MacOS:

Podemos usar o Homebrew para instalação e automaticamente a última versão disponível será instalada:

brew install node

Você também pode usar o Node Version Manager (NVM):

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash
nvm install 18
nvm use 18
nvm alias default 18
npm install npm --global # Upgrade npm to the latest version

Windows:

Atualmente, o site oficial do Hardhat recomenda a instalação do node usando o Windows Subsystem for Linux (WSL2), pois, como muitos de nós sabemos, o Windows não é a opção favorita dos desenvolvedores.

Você pode seguir este link para acessar o site oficial da Microsoft e continuar com as etapas de instalação do Node no Windows se preferir usar este sistema operacional ou se estiver se sentindo aventureiro.

Agora que temos o Node em nosso sistema operacional é hora de instalar o Hardhat criando um novo projeto com a ajuda do Node:

mkdir hardhat-example
cd hardhat-example
npm init

Agora podemos instalar o Hardhat:

npm install --save-dev hardhat

No mesmo diretório que instalamos o Hardhat executamos o seguinte comando:

npx hardhat

Selecione "Create an empty hardhat.config.js" com o teclado e pressione a tecla Enter.

Observação: o npm 7 e posteriores facilitam muito a instalação das dependências do Hardhat.

Quando o Hardhat é executado, ele procura o arquivo hardhat.config.js mais próximo a partir do diretório atual. Normalmente esse arquivo fica na raiz do projeto e uma configuração vazia é suficiente para o Hardhat começar a funcionar.

Contratos Inteligentes (Smart Contracts)

Em princípio, o conceito de contratos inteligentes pode ser um pouco difícil de digerir, supondo que você entenda o básico do Blockchain, podemos dizer que um contrato inteligente é um protocolo de transação cujo objetivo é controlar os eventos e ações dentro do acordo com o que foi alcançado entre as partes é automaticamente executado.

Por exemplo, um caso prático de celebração de um contrato inteligente dentro do Blockchain ocorre na locação ou compra de um apartamento, que pode ser executado quando o locador deposita uma determinada quantia de Ethers em uma conta gerenciada pelo contrato e, após Por sua vez, o locador pode entrar com uma ação para confirmar a entrega do imóvel.

Quando ambos aprovam seu acordo, o contrato inteligente transfere automaticamente os recursos para o locador, evitando um banco como intermediário (por exemplo). Caso não seja verificada a comprovação de ambas as partes, o contrato poderá efetivar a devolução dos recursos depositados pelo locatário ou a transferência parcial ao locador se a lógica do contrato assim o estipular.

Agora vamos ver como é um contrato inteligente na prática. A Ethereum usa a linguagem Solidity para a criação de contratos inteligentes.

Para começar vamos criar um novo diretório chamado contracts e dentro dele um arquivo que chamaremos de Token.sol (espanhol).

// SPDX-License-Identifier: UNLICENSED
// Los archivos de Solidity deben iniciar con pragma.
// Sera usado por el compilador para validar su version.

pragma solidity ^0.8.9;

// Este es el building block principal del contrato.
contract Token {
    
    // Variables de tipo String para identificar el token.
    
    string public name = "My Hardhat Token";
    string public symbol = "MHT";
    
    // El monto fijo de tokens.
    
    uint256 public totalSupply = 1000000;
    
    // Variable de tipo address usada para guardar cuentas.
    
    address public owner;
    
    // El tipo mapping es un mapa de tipo key/value map. 
    // Aquí guardaremos los balances de las cuentas.
    
    mapping(address => uint256) balances;
    
    // El evento Transfer ayuda a las aplicaciones fuera del Blockchain
    // a entender lo que pasa con el contrato.
    
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    
    /**
     * Contract initialization.
     */
    
    constructor() {
        
        // EL total del suministro es asignado al sender de la transacción,
        // que es la cuenta encargada de hacer deploy del contrato.
        
        balances[msg.sender] = totalSupply;
        owner = msg.sender;
    }
    /**
     * Función para transferir tokens.
     *
     */
    function transfer(address to, uint256 amount) external {
        
        // Verifica si el que envió la transacción tiene suficientes tokens.
        // Si la función “require” evalúa falso entonces la
        // transacción es revertida.
        
        require(balances[msg.sender] >= amount, "Not enough tokens");

        // Transfiere el monto.
        
        balances[msg.sender] -= amount;
        balances[to] += amount;

        // Notifica a la ampliación fuera del blockchain 
	    // sobre la transferencia.
        
        emit Transfer(msg.sender, to, amount);
    }
    /**
     * Función de solo lectura para obtener el balance del token 
	 * de una cuenta dada.
     *
     * El modificador `view` indica que no se hará ninguna modificación 
     * al estado del contrato y una transacción no es necesaria.
     */
     
    function balanceOf(address account) external view returns (uint256) {
        return balances[account];
    }
}

Compilar os contratos

Para compilar o contrato você precisa rodar no seu terminal:

npx hardhat compile 

Se tudo correr bem, você verá a seguinte mensagem:

$ npx hardhat compile
Compiling 1 file with 0.8.9
Compilation finished successfully

Nosso contrato foi compilado satisfatoriamente. Parabéns! Você acabou de criar seu primeiro contrato inteligente.

Deploy do Contrato Inteligente

Instalamos o Ethers, uma implementação de uma carteira Ethereum com utilitários que nos ajudarão no processo. No mesmo terminal executamos:

npm i ethers @nomiclabs/hardhat-waffle

Em seguida criamos uma pasta chamada scripts e dentro dela criamos o arquivo deploy.js e colamos o código abaixo.

const { ethers } = require("hardhat");
async function main() {
  const Token = await ethers.getContractFactory("Token");
  // Comienza el deploy, retornando una promesa que se resuelve 
  // en un objeto tipo contract
  const token = await Token.deploy();
  await token.deployed();
  console.log("Token Contract deployed to: ", token.address);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error)
    process.exit(1)
});

Agora copiamos e colamos o código abaixo no arquivo hardhat.config.js

/* hardhat.config.js */
require("@nomiclabs/hardhat-waffle")

module.exports = {
  defaultNetwork: "hardhat",
  networks: {
    hardhat: {
      chainId: 1337
    },
  },
  solidity: {
    version: "0.8.4",
    settings: {
      optimizer: {
        enabled: true,
        runs: 200
      }
    }
  }
}

Configuramos um nó de teste executando o seguinte comando no terminal:

npx hardhat node

E veremos uma lista com 19 contas que podem ser usadas para testar nosso contrato. Por padrão, a primeira conta será usada para o deploy do nosso contrato inteligente.

Agora podemos fazer o deploy do nosso contrato no nó local, executando o seguinte comando em nosso terminal:

npx hardhat --network localhost run scripts/deploy.js

E você verá o endereço do contrato:

Token Contract deployed to: 0x5fbdb2315678afec....xxxx

Hora de testar seu contrato inteligente

Chegou a hora de interagir com o contrato inteligente, para o qual a Hardhat também nos fornece um console JavaScript interativo com o qual é possível acessar as funções definidas em nosso contrato.

Em um novo console, execute o seguinte comando:

npx hardhat console

Welcome to Node.js v12.10.0.
Type ".help" for more information.
>

A interação com a rede Ethereum e os contratos inteligentes são operações assíncronas. Portanto, precisamos fazer uso de promessas para retornar os valores.
Para facilitar as coisas, o console Hardhat suporta o operador await.

Para usar esse recurso, você precisa usar o Node 10 ou superior.

Para se conectar a uma rede diferente da que temos por padrão usando o nó Hardhat local, podemos usar o seguinte comando:

npx hardhat console --network network_name

Que procurará o nome da rede específica no arquivo de configuração hardhat.config.js, por exemplo:

networks: {
  hardhat: {
    chainId: 1337
  },
  network_name: {
    url: API_URL,
    accounts: [`0x${PRIVATE_KEY}`]
  }
},

Por enquanto, usaremos apenas o nó Hardhat local e instanciaremos o contrato usando Ethers Contract Factory.

const Contract = await ethers.getContractFactory("Token")

Depois de obter a instância, precisamos anexar o endereço do contrato que acabamos de implantar para interagir com o contrato (mesmo endereço que obtivemos acima).

const contract = await Contract.attach("0x5fbdb2315678afec....xxxx")

Por exemplo, podemos transferir 100 tokens MHT para uma nova conta (você pode usar uma das contas disponíveis ao construir o nó com Hardhat, exceto a primeira, a mesma usada por padrão para implantar o contrato):

await contract.transfer('0x3C44CdDdB6a900...xxxxx', 100)

E você verá os detalhes da transação:

{
  hash: '0x6ca133f7770fe478b62ab0608cd1c6f51c097c4426a5296dc4ae15bbd4a2c6cd',
  type: 2,
  accessList: [],
  blockHash: '0x49bc61eb9b90f6b60b75482dc7d58bc6da4f396dba31f7be4b9840365178045e',
  blockNumber: 1,
  transactionIndex: 0,
  confirmations: 1,
  from: '0xf39Fd6e51aad88....xxxxx',
  gasPrice: BigNumber { value: "1875000000" },
  maxPriorityFeePerGas: BigNumber { value: "1000000000" },
  maxFeePerGas: BigNumber { value: "2750000000" },
  gasLimit: BigNumber { value: "29022808" },
  to: '0x3C44CdDdB6a900...xxxxx',
  value: BigNumber { value: "0" },
  nonce: 0,
  data: '0xa9059cbb0000000000000000000000003c44cdddb6a900fa2b585dd299e03d12fa4293bc0000000000000000000000000000000000000000000000000000000000000064',
  r: '0xa91d4832956a8ac159c809387394a58a687948362d564d1dbcd68e76b09325b0',
  s: '0x0c061826e4dab67ae065e016837cd8457ca34a7c9eac09048258b0e5e5b8b958',
  v: 1,
  creates: null,
  chainId: 1337,
  wait: [Function (anonymous)]
}

Este console é muito útil para inspecionar o que realmente está acontecendo com nosso contrato e se é realmente o que esperamos de seu comportamento.

Conclusões

Hardhat nos fornece um ecossistema completo para poder gerar um nó, compilar contratos inteligentes e fazer o deploy sem a necessidade de usar ou criar uma rede Ethereum privada ou depender da disponibilidade de uma rede externa, também nos fornece os mecanismos para realizar a mesma implantação com as redes disponíveis para teste fornecidas pela Ethereum.

Usando o Hardhat, temos tudo o que precisamos para começar a escrever nosso aplicativo Web3.0.

Sucesso!