Introdução

Neste tutorial, iremos explorar a construção de uma aplicação descentralizada (dApp) na rede Fantom, uma blockchain conhecida por sua rapidez e baixos custos de transação. Utilizaremos o Hardhat, um poderoso ambiente de desenvolvimento para Ethereum e blockchains compatíveis, combinado com a biblioteca Ethers.js, que facilita interações com contratos inteligentes. Ao longo do artigo, desenvolveremos um dApp simples, abordando desde a configuração do ambiente de desenvolvimento até a implementação de testes unitários. Este guia é ideal para desenvolvedores que desejam entrar no mundo das aplicações descentralizadas com uma abordagem prática e eficaz.

Etapas

  1. Configuração do Ambiente de Desenvolvimento

    Certifique-se de ter o Node.js e npm instalados em sua máquina. Você pode baixar a versão mais recente em https:/odejs.org. Após a instalação, verifique as versões instaladas usando os comandos `node -v` e `npm -v`. Em seguida, crie um novo diretório para o seu projeto e acesse-o pelo terminal.

    commands
    # Verificar versões instaladas
    node -v
    npm -v
    # Criar diretório do projeto e acessar
    mkdir meu-dapp-fantom
    cd meu-dapp-fantom

  2. Inicialização do Projeto com Hardhat

    Dentro do diretório do projeto, inicialize um novo projeto Hardhat utilizando os comandos abaixo. Escolha ‘create a basic sample project’ quando solicitado. Após concluir, instale a biblioteca Ethers.js para facilitar a interação com contratos inteligentes.

    commands
    # Inicializar projeto Hardhat
    npx hardhat
    # Instalar Ethers.js
    npm install ethers

  3. Estrutura do Contrato Inteligente

    Crie um novo contrato inteligente `MyToken.sol` no diretório `contracts`. Este contrato será um token simples seguindo o padrão ERC20. Defina as funções básicas e as variáveis necessárias.

    MyToken.sol
    pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract MyToken is ERC20 {
    constructor(uint256 initialSupply) ERC20("MyToken", "MTK") {
        _mint(msg.sender, initialSupply);
    }
}

  4. Configuração do Hardhat para a Rede Fantom

    No arquivo `hardhat.config.js`, adicione as configurações necessárias para conectar-se à rede Fantom. É importante adicionar um provedor de rede e definir a conta de implantação.

    hardhat.config.js
    require('@nomiclabs/hardhat-waffle');

module.exports = {
    solidity: "0.8.0",
    networks: {
        fantom: {
            url: "https://rpcapi.fantom.network",
            accounts: ["<sua chave privada>"]
        }
    }
};

  5. Migrações do Contrato Inteligente

    Crie um arquivo de migração em um novo diretório `scripts` que implementará o contrato na rede Fantom. O arquivo deve conter a lógica para implantar o contrato e registrar o endereço.

    deploy.js
    async function main() {
    const MyToken = await ethers.getContractFactory("MyToken");
    const myToken = await MyToken.deploy(1000000);
    await myToken.deployed();

    console.log("Token implantado para: " + myToken.address);
}

main();

  6. Execução da Migração

    Execute o script de migração para implantar o contrato na rede Fantom através do Hardhat. O comando mostrará o endereço do contrato implantado.

    commands
    # Executar a migração
    npx hardhat run scripts/deploy.js --network fantom

  7. Interagindo com o Contrato Inteligente

    Crie um arquivo `interact.js` em `scripts` para interagir com o contrato. Este arquivo deve conter funcionalidades para consultar o saldo de um endereço e realizar transferências.

    interact.js
    const { ethers } = require('hardhat');

async function main() {
    const address = "<endereço do contrato>";
    const MyToken = await ethers.getContractAt("MyToken", address);

    const balance = await MyToken.balanceOf(<seu endereço>);
    console.log(`Seu saldo: ${ethers.utils.formatUnits(balance, 18)}`);

    // Para transferir tokens
    // await MyToken.transfer(<endereço de destino>, ethers.utils.parseUnits('10', 18));
}

main();

  8. Testes em um Ambiente Local

    Instale o framework de testes Mocha e Chai para realizar testes unitários. Crie um arquivo de teste para validar as funcionalidades do contrato e execute os testes.

    commands
    # Instalando Mocha e Chai
    npm install --save-dev mocha chai
    # Criar o arquivo de teste
    mkdir test && touch test/MyToken.test.js

  9. Implementação das Testes Unitários

    No arquivo `MyToken.test.js`, implemente testes para verificar as funcionalidades básicas do contrato, como o saldo e transferências. Use Mocha e Chai para as asserções.

    MyToken.test.js
    const { expect } = require('chai');
const { ethers } = require('hardhat');

describe("MyToken", function () {
    let myToken;
    beforeEach(async function () {
        const MyToken = await ethers.getContractFactory("MyToken");
        myToken = await MyToken.deploy(1000000);
        await myToken.deployed();
    });

    it("Deve retornar o saldo correto após a implantação", async function () {
        const balance = await myToken.balanceOf(<seu endereço>);
        expect(balance).to.equal(1000000);
    });
});

  10. Executando os Testes

    Utilize o comando abaixo para executar os testes e garantir que todas as funcionalidades do contrato funcionam conforme esperado.

    commands
    # Executar os testes
    npx hardhat test

Conclusão

Neste tutorial, você aprendeu como construir um dApp simples na rede Fantom usando Hardhat e Ethers.js. Através da criação de um contrato inteligente básico ERC20, você executou a implantação e interações básicas, além de implementar testes para garantir a funcionalidade do seu código. Com essa base, você pode começar a explorar recursos mais avançados e desenvolver dApps mais complexos. Sinta-se livre para personalizar o contrato com funcionalidades adicionais e experimentar as capacidades que a rede Fantom tem a oferecer.

Hashtags

#Fantom #dApp #Hardhat #EthersJS #Blockchain #Solidity