Introdução

O desenvolvimento de aplicativos descentralizados (DApps) está em alta, especialmente com a crescente popularidade de blockchains como Fantom. Considerada uma plataforma rápida e escalável, Fantom oferece ferramentas e infraestrutura robusta para criação de DApps. Neste guia prático, vamos explorar como utilizar o framework Moralis para acelerar o desenvolvimento de DApps, além de ferramentas essenciais como Truffle e Hardhat para garantir um ciclo de desenvolvimento eficiente. Com uma abordagem passo a passo, iremos cobrir a configuração do ambiente de desenvolvimento, a criação de contratos inteligentes e a implementação de testes, trazendo tudo o que você precisa saber para iniciar sua jornada no desenvolvimento de DApps na rede Fantom.

Etapas

  1. Configuração do Ambiente de Desenvolvimento

    Certifique-se de ter o Node.js e o npm instalados em sua máquina. Esses são pré-requisitos para instalar o Moralis, o Truffle e o Hardhat, ferramentas que serão indispensáveis no desenvolvimento de DApps.

    commands
    # Verificar versões do Node.js e npm
    node -v
    npm -v
    # Se não estiverem instalados, faça o download do Node.js em https://nodejs.org/

  2. Instalação do Moralis

    Instale o Moralis SDK em seu projeto. Esse SDK facilitará a conexão com a rede Fantom e fornecerá serviços essenciais como autenticação e armazenamento. Utilize o npm para instalar o Moralis.

    commands
    # Crie um novo diretório para o seu projeto
    mkdir meu-dapp-fantom && cd meu-dapp-fantom
    # Inicialize o projeto Node.js
    npm init -y
    # Instale o Moralis
    npm install moralis

  3. Configuração do Hardhat

    Instale o Hardhat, uma ferramenta essencial para a criação e teste de contratos inteligentes. Com o Hardhat, você poderá emular a rede e realizar testes locais antes de implantar os contratos na rede Fantom.

    commands
    # Instale o Hardhat
    npm install --save-dev hardhat
    # Inicie o Hardhat
    npx hardhat

    example
    Durante a inicialização, escolha a opção de criar um projeto básico.

  4. Criação de um Contrato Inteligente

    Crie um contrato simples em Solidity, a linguagem de programação para contratos inteligentes. Neste exemplo, criaremos um contrato de armazenamento que permitirá adicionar e recuperar valores.

    Storage.sol
    pragma solidity ^0.8.0;

contract Storage {
    uint256 number;

    function store(uint256 num) public {
        number = num;
    }

    function retrieve() public view returns (uint256){
        return number;
    }
}

  5. Compilação do Contrato

    Compile o contrato inteligente que você acabou de criar para verificar se não existem erros de sintaxe. O Hardhat fornece um comando fácil para isso.

    commands
    # Compile o contrato
    npx hardhat compile

  6. Desdobrando o Contrato na Rede Fantom

    Configure a conexão com a rede Fantom e o endereço do contrato. Você precisará de um serviço como Infura ou uma chave de API do Moralis para isso. Em seguida, efetue a implantação do contrato.

    deploy.js
    const hre = require("hardhat");

async function main() {
    const Storage = await hre.ethers.getContractFactory("Storage");
    const storage = await Storage.deploy();
    await storage.deployed();
    console.log(`Contrato desdobrado para: ${storage.address}`);
}

main().catch((error) => {
    console.error(error);
    process.exitCode = 1;
});

  7. Executando os Testes

    Para garantir que o contrato funcione como esperado, você deve escrever e executar testes. O Hardhat pode executar testes de contratos inteligentes utilizando a biblioteca Mocha.

    Storage.test.js
    const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("Storage", function () {
    it("Deve armazenar e recuperar um número", async function () {
        const Storage = await ethers.getContractFactory("Storage");
        const storage = await Storage.deploy();
        await storage.store(42);
        expect(await storage.retrieve()).to.equal(42);
    });
});

    commands
    # Execute os testes
    npx hardhat test

  8. Integrando com o Frontend usando Moralis

    Utilize o SDK do Moralis para configurar sua aplicação frontend e conectar-se com a blockchain Fantom. É possível realizar operações como login de usuários e chamadas de funções do contrato diretamente através do Moralis.

    index.js
    Moralis.start({
    serverUrl: "YOUR_SERVER_URL",
    appId: "YOUR_APP_ID"
});

async function login() {
    const user = await Moralis.authenticate();
    console.log(`Usuário logado: ${user.get('username')}`);
}

// Função para armazenar número
async function storeNumber(num) {
    const options = {
        contractAddress: "YOUR_CONTRACT_ADDRESS",
        functionName: "store",
        abi: [{
            "inputs": [{"internalType": "uint256","name": "num","type": "uint256"}],
            "name": "store",
            "outputs": [],
            "stateMutability": "nonpayable",
            "type": "function"
        }],
        params: { num },
    };
    await Moralis.executeFunction(options);
}

  9. Executando o Projeto

    Inicie seu frontend e realize testes de integração com o Moralis. Assegure-se de que todas as funções estão conectadas corretamente e funcionando como esperado.

    commands
    # Inicie seu projeto frontend (por exemplo, se você estiver usando um servidor de desenvolvimento como o http-server)
    npx http-server

Conclusão

Neste tutorial, você explorou o desenvolvimento de aplicativos descentralizados na rede Fantom usando Moralis, Truffle e Hardhat. Vimos desde a configuração do ambiente de desenvolvimento até a criação e teste de contratos inteligentes. Com esses passos, você está capacitado para desenvolver DApps complexos e aproveitar todas as vantagens que a blockchain oferece. Agora é hora de experimentar e criar suas próprias aplicações inovadoras na blockchain.

Hashtags

#Fantom #DApps #Moralis #Truffle #Hardhat #Blockchain