Introdução

O desenvolvimento de aplicações em blockchain exige uma compreensão profunda não apenas da tecnologia subjacente, mas também das práticas e ferramentas que facilitam o processo. Neste tutorial, vamos explorar o ecossistema de desenvolvimento de blockchain, focando em dois frameworks populares: Truffle e Hardhat. Truffle é amplamente utilizado para desenvolvimento e testes de contratos inteligentes no Ethereum, enquanto o Hardhat oferece uma abordagem moderna e flexível com suporte a funcionalidades avançadas. Abordaremos como configurar um ambiente de desenvolvimento pronto para construir, testar e implantar contratos inteligentes, além de discutir práticas comuns de testes e integração contínua que ajudam a garantir a robustez e eficiência das aplicações. Esteja preparado para mergulhar no mundo da blockchain com exemplos práticos e uma abordagem passo a passo.

Etapas

  1. Configuração do Ambiente de Desenvolvimento

    Antes de começarmos, você precisa ter o Node.js instalado em sua máquina, já que Truffle e Hardhat são ferramentas baseadas em JavaScript. Verifique se o Node.js está instalado usando o comando `node -v` em seu terminal. Se não estiver, você pode instalá-lo a partir do site oficial do Node.js.

    commands
    # Verificar se o Node.js está instalado
    node -v

  2. Instalação do Truffle

    Instale o Truffle globalmente usando npm (Node Package Manager). Abra o terminal e execute o comando para instalar o Truffle.

    commands
    # Instalar o Truffle
    npm install -g truffle

  3. Criando um Novo Projeto Truffle

    Agora, crie um novo diretório para o seu projeto de blockchain e inicialize um novo projeto Truffle nele. Use os comandos abaixo.

    commands
    # Criar um diretório para o projeto e navegar até ele
    mkdir my-blockchain-project
    cd my-blockchain-project
    # Inicializar um novo projeto Truffle
    truffle init

  4. Escrevendo um Contrato Inteligente

    No diretório `contracts`, crie um novo arquivo chamado `HelloWorld.sol` e implemente um simples contrato que armazena e retorna uma mensagem de saudação.

    HelloWorld.sol
    pragma solidity ^0.8.0;

contract HelloWorld {
    string public message;

    constructor() {
        message = 'Hello, Blockchain!';
    }

    function getMessage() public view returns (string memory) {
        return message;
    }
}

  5. Compilando o Contrato

    Compile o contrato recém-criado usando o comando Truffle abaixo. Isso gerará os arquivos de artefato necessários no diretório `build`.

    commands
    # Compilar o contrato
    truffle compile

  6. Realizando Testes com Truffle

    No diretório `test`, crie um arquivo chamado `HelloWorld.test.js` para testar o contrato. Este teste valida se a mensagem inicial é a esperada.

    HelloWorld.test.js
    const HelloWorld = artifacts.require('HelloWorld');

describe('HelloWorld Contract', () => {
    let helloWorld;

    beforeEach(async () => {
        helloWorld = await HelloWorld.new();
    });

    it('should return the initial message', async () => {
        const message = await helloWorld.getMessage();
        assert.equal(message, 'Hello, Blockchain!');
    });
});

  7. Executando os Testes

    Execute os testes do contrato para garantir que tudo esteja funcionando corretamente. Use o comando abaixo.

    commands
    # Executar os testes
    truffle test

  8. Instalação do Hardhat

    Para utilizar o Hardhat, instale-o como uma dependência de desenvolvimento no seu projeto. Execute o seguinte comando no terminal.

    commands
    # Instalação do Hardhat
    npm install --save-dev hardhat

  9. Configurando Hardhat

    Depois de instalar o Hardhat, inicialize-o no seu projeto para criar uma configuração básica. Siga as instruções no terminal.

    commands
    # Inicializar o Hardhat
    npx hardhat

  10. Criando um Contrato com Hardhat

    No diretório `contracts` criado pelo Hardhat, crie um arquivo `Greeter.sol` semelhante ao feito anteriormente com Truffle.

    Greeter.sol
    pragma solidity ^0.8.0;

contract Greeter {
    string public greeting;

    constructor(string memory _greeting) {
        greeting = _greeting;
    }

    function greet() public view returns (string memory) {
        return greeting;
    }
}

  11. Testando o Contrato com Hardhat

    No diretório `test`, crie um novo arquivo chamado `Greeter.test.js` e escreva testes para o seu contrato Greeter.

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

describe('Greeter', function () {
    let Greeter;
    let greeter;

    beforeEach(async function () {
        Greeter = await ethers.getContractFactory('Greeter');
        greeter = await Greeter.deploy('Hello, Hardhat!');
    });

    it('should return the greeting', async function () {
        expect(await greeter.greet()).to.equal('Hello, Hardhat!');
    });
});

  12. Executando Testes com Hardhat

    Para rodar os testes no Hardhat, use o comando abaixo.

    commands
    # Executar os testes no Hardhat
    npx hardhat test

  13. Implementando Integração Contínua

    Considere implementar ferramentas como GitHub Actions ou Travis CI para garantir que seus testes sejam executados automaticamente a cada commit. Um exemplo de configuração do GitHub Actions pode incluir a execução dos testes do Truffle ou Hardhat em cada push.

    .github/workflows/test.yml
    name: Run Tests

on:
  push:
    branches:
      - main

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Setup Node.js
        uses: actions/setup-node@v2
        with:
          node-version: '14'
      - name: Install dependencies
        run: npm install
      - name: Run Truffle tests
        run: npx truffle test
      - name: Run Hardhat tests
        run: npx hardhat test

Conclusão

Neste tutorial, examinamos duas ferramentas populares no desenvolvimento de blockchain: Truffle e Hardhat. Aprendemos a criar contratos inteligentes em Solidity, compilá-los, testá-los e configurar práticas de integração contínua para manter a qualidade do seu código. Essa jornada não apenas nos apresentou as funcionalidades dessas ferramentas, mas também estabeleceu uma base sólida para futuros desenvolvimentos em blockchain, onde a eficiência e a confiabilidade são cruciais. Agora, você pode explorar mais sobre como integrar essas tecnologias em aplicações descentralizadas, otimizando seu fluxo de trabalho de desenvolvimento.

Hashtags

#Blockchain #Truffle #Hardhat #DesenvolvimentoDeSoftware #TestesUnitários #IntegraçãoContínua