Criando Smart Contract com Hardhat

Por

Antes de fazer deploy de um smart contract em qualquer rede, você o escreve em Solidity, compila com o Hardhat e testa localmente. O Hardhat te dá uma blockchain local, um framework de testes e scripts de deploy, tudo em um único pacote.

TL;DR: Escreva, compile e teste um smart contract em Solidity usando o Hardhat com uma rede blockchain local.
Stack: Hardhat, Solidity, Node.js, Ethers.js
Nível: Intermediário
Tempo de leitura: ~10 min

Inicializar o projeto

npx hardhat

Escolha “Create a TypeScript project” e instale as dependências do projeto de exemplo.

Criar o smart contract

Crie um arquivo na pasta contracts/, por exemplo contracts/HelpChains.sol:

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

contract HelpChains {
    address payable public address1 = payable(0xAAAA1111BBBB2222CCCC3333DDDD4444EEEE5555);
    address payable public address2 = payable(0xBBBB2222CCCC3333DDDD4444EEEE5555FFFF6666);

    struct Transaction {
        uint256 amount;
        address from;
        address to;
        uint256 timestamp;
    }

    Transaction[] public donations;
    Transaction[] public withdrawals;

    function donate() external payable {
        require(msg.value > 0, "Valor deve ser maior que 0");
        uint256 half = msg.value / 2;
        address1.transfer(half);
        address2.transfer(msg.value - half);
        donations.push(Transaction({
            amount: msg.value,
            from: msg.sender,
            to: address(0),
            timestamp: block.timestamp
        }));
    }

    function withdraw() external {
        uint256 balance1 = address1.balance;
        uint256 balance2 = address2.balance;
        require(balance1 > 0 || balance2 > 0, "Sem saldo para retirar");
        if (balance1 > 0) {
            address1.transfer(balance1);
            withdrawals.push(Transaction({amount: balance1, from: address1, to: address1, timestamp: block.timestamp}));
        }
        if (balance2 > 0) {
            address2.transfer(balance2);
            withdrawals.push(Transaction({amount: balance2, from: address2, to: address2, timestamp: block.timestamp}));
        }
    }

    function getDonations() external view returns (Transaction[] memory) { return donations; }
    function getWithdrawals() external view returns (Transaction[] memory) { return withdrawals; }
}

Compilar

npx hardhat compile

Configurar o módulo ignition

// ignition/modules/HelpChainsModule.ts
import { buildModule } from "@nomicfoundation/hardhat-ignition/modules";

const HelpChainsModule = buildModule("HelpChainsModule", (m) => {
    const helpChains = m.contract("HelpChains", []);
    return { helpChains };
});

export default HelpChainsModule;

Configurar rede local (hardhat.config.ts)

import { HardhatUserConfig } from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";

const config: HardhatUserConfig = {
    solidity: "0.8.24",
    defaultNetwork: "local",
    networks: {
        local: {
            url: "http://127.0.0.1:8545",
            chainId: 31337,
            accounts: {
                mnemonic: "test test test test test test test test test test test junk"
            }
        }
    }
};

export default config;

Rodar localmente e fazer deploy

# Iniciar o nó local
npx hardhat node

# Deploy (adicione antes ao package.json scripts)
# "deploy:dev": "npx hardhat ignition deploy ignition/modules/HelpChains.ts --network local"
npm run deploy:dev

Interagir pelo console

npx hardhat console --network local

const HelpChains = await ethers.getContractFactory("HelpChains");
const helpChains = await HelpChains.attach("ENDERECO_DO_CONTRATO_DEPLOYADO");
await helpChains.donate({ value: ethers.parseEther("1.0") });
let donations = await helpChains.getDonations();
console.log(donations);

O que você construiu

Um projeto Hardhat com um contrato Solidity compilado, um script de deploy funcionando localmente, e as ferramentas para interagir com ele pelo console.

Próximos passos

  • Escreva testes que cubram casos extremos e condições de falha, não só o caminho feliz. Bugs em smart contracts não podem ser corrigidos após o deploy.
  • Use o console.sol do Hardhat para debugar durante o desenvolvimento: import “hardhat/console.sol” permite imprimir variáveis no terminal a partir do Solidity.
  • Rode npx hardhat coverage para ver quais linhas do seu Solidity estão cobertas por testes antes de fazer deploy em uma testnet.

Dúvidas ou feedback? Me encontre no LinkedIn ou GitHub.

Deixe um comentário