Introdução

No mundo das criptomoedas e da blockchain, os contratos inteligentes (smart contracts) são fundamentais para a criação de aplicações descentralizadas. Neste tutorial, vamos aprender a implementar um contrato inteligente utilizando o Solidity, a linguagem de programação mais popular para esse tipo de desenvolvimento. Utilizaremos o Hardhat, um ambiente de desenvolvimento que facilita a construção e testes de contratos inteligentes, e o Ethers.js, uma biblioteca JavaScript que facilita a interação com a blockchain Ethereum. O foco será em prover um guia prático e detalhado, desde o ambiente de desenvolvimento até a realização de testes automatizados, garantindo que você tenha uma compreensão completa do processo de implementação de contratos inteligentes.

Etapas

  1. Configuração do Ambiente de Desenvolvimento

    Primeiro, você precisa ter o Node.js e o npm (Node Package Manager) instalados em sua máquina. Você pode verificar se já os tem instalados rodando os comandos `node -v` e `npm -v`. Caso não os tenha, faça o download do instalador em https:/odejs.org/ e siga as instruções. Em seguida, crie uma nova pasta para o seu projeto e acesse-a através do terminal.

    commands
    # Verificar versão do Node.js
    node -v
    # Verificar versão do npm
    npm -v
    # Criar uma nova pasta para o projeto
    mkdir meu_projeto_solidity
    cd meu_projeto_solidity

  2. Inicializando o projeto e instalando dependências

    Dentro da pasta do projeto, inicie um novo projeto Node.js com `npm init -y`. Após isso, instale o Hardhat e o Ethers.js utilizando o npm. O Hardhat permitirá que você compile, teste e execute seus contratos inteligentes, enquanto o Ethers.js facilitará a interação com a blockchain Ethereum.

    commands
    npm init -y
    npm install --save-dev hardhat
    npm install --save ethers

  3. Criando um novo projeto Hardhat

    Execute o comando `npx hardhat` e siga as instruções para criar um novo projeto. Escolha a opção ‘Create a basic sample project’. Esta ação criará várias pastas e arquivos que serão úteis para o desenvolvimento do contrato inteligente.

    commands
    npx hardhat

  4. Implementando o contrato inteligente

    Navegue até a pasta `contracts` criada pelo Hardhat e crie um novo arquivo chamado `MeuContrato.sol`. Neste arquivo, você implementará um simples contrato inteligente que gerencia um valor. Vamos usar um contrato básico para armazenar e recuperar um número.

    MeuContrato.sol
    pragma solidity ^0.8.0;

contract MeuContrato {
    uint256 private numero;

    function setNumero(uint256 _numero) public {
        numero = _numero;
    }

    function getNumero() public view returns (uint256) {
        return numero;
    }
}

  5. Compilando o contrato inteligente

    Agora você precisa compilar seu contrato inteligente. No terminal, execute o comando `npx hardhat compile`. Isso irá gerar os arquivos necessários na pasta `artifacts`, que serão usados para a implantação e testes do contrato.

    commands
    npx hardhat compile

  6. Desenvolvendo os testes automatizados

    Crie um novo arquivo na pasta `test` chamado `MeuContrato.test.js`. Neste arquivo, você escreverá testes para garantir que a lógica do seu contrato está funcionando como esperado. O Ethers.js será usado em conjunto com o Hardhat para realizar os testes.

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

describe('MeuContrato', function () {
    let MeuContrato;
    let contrato;

    beforeEach(async function () {
        MeuContrato = await ethers.getContractFactory('MeuContrato');
        contrato = await MeuContrato.deploy();
        await contrato.deployed();
    });

    it('deve armazenar um número', async function () {
        await contrato.setNumero(42);
        expect(await contrato.getNumero()).to.equal(42);
    });
});

  7. Executando os testes automatizados

    Com os testes implementados, você agora pode executá-los usando o comando `npx hardhat test`. Isso irá rodar todos os testes definidos na pasta `test` e fornecer um feedback no terminal.

    commands
    npx hardhat test

  8. Implantando o contrato na rede local

    Para implantar seu contrato em uma rede local, você pode usar o comando `npx hardhat run scripts/sample-script.js –network localhost`. Antes disso, você precisará iniciar uma rede local Hardhat com `npx hardhat node`.

    commands
    # Iniciar a rede local
    npx hardhat node
    # Em uma nova aba do terminal, implantar o contrato
    npx hardhat run scripts/sample-script.js --network localhost

  9. Interagindo com o contrato usando Ethers.js

    Crie um novo arquivo JavaScript chamado `interagir.js`. Nesse arquivo, você irá interagir com o seu contrato implantado, definindo e recuperando o valor armazenado. Utilize o Ethers.js para se conectar ao contrato e chamá-lo.

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

async function main() {
    const provider = new ethers.providers.JsonRpcProvider('http://localhost:8545');
    const signer = provider.getSigner();
    const contratoAddress = 'ENDEREÇO_DO_CONTRATO'; // substitua pelo endereço do contrato
    const contratoABI = [
        "function setNumero(uint256 _numero)",
        "function getNumero() view returns (uint256)"
    ];
    const contrato = new ethers.Contract(contratoAddress, contratoABI, signer);

    await contrato.setNumero(123);
    const numero = await contrato.getNumero();
    console.log(`Número armazenado é: ${numero.toString()}`);
}

main();

Conclusão

Neste tutorial, você aprendeu a implementar um contrato inteligente utilizando Solidity, Hardhat e Ethers.js. Passamos por todo o processo, desde a configuração do ambiente até a interação com um contrato implantado. Com o conhecimento adquirido, você agora pode expandir para contratos mais complexos, incluindo funcionalidades adicionais e interações com outras bibliotecas e ferramentas. A prática contínua e a exploração das características avançadas do Solidity serão essenciais para a sua jornada no desenvolvimento de blockchain.

Hashtags

#Solidity #Hardhat #Ethersjs #Blockchain #SmartContracts #DesenvolvimentoDeSoftware