Construindo seu primeiro Dapp com Solidity na blockchain da Polygon

Artigo traduzido do original Building your first Dapp with Solidity on the Polygon Blockchain https://dev.to/salviencode/building-your-first-dapp-with-solidity-on-the-polygon-blockchain-46n

Hoje vou mostrar como é fácil criar um aplicativo descentralizado. É apenas para fins educacionais, mas com este artigo você verá como um dapp funciona e por que é incrível e inovador.

O que estamos construindo?

Construiremos um simples jogo de adivinhação usando Solidity, mas na blockchain. Parece legal, certo? Vamos lá.

O que precisaremos?

1. Uma conta na Alchemy, inscreva-se gratuitamente aqui.
2. Uma carteira Metamask, (baixe no link).
3. Solidity e Hardhat (falaremos sobre isso mais tarde).

Inicializando nosso projeto

Supõe-se que você esteja um pouco familiarizado com o node.js e já o tenha instalado em seu terminal, execute:

npm init

Instalando e inicializando o Hardhat

O último comando deve ter gerado um arquivo package.json para que você possa controlar as dependências. Em seguida, vamos instalar o Hardhat.

npm install --save-dev hardhat

Hardhat é um ambiente de desenvolvimento para compilar, fazer deploy, testar e debugar seu software Ethereum (a Polygon acaba sendo uma solução de Layer-2 para Ethereum). Ele ajuda os desenvolvedores a criarem smart contracts e dApps localmente antes de fazerem o deploy _na _chain produtiva.

Depois que a instalação estiver concluída, execute o comando abaixo para criar um novo projeto

npx hardhat

Você deve ver a tela acima no seu terminal. Apenas pressione Enter, pois as configurações padrão estão corretas para este tutorial.

Armazenando e protegendo nossas chaves

Estamos quase terminando de configurar, precisamos de uma maneira de armazenar nossas chaves com segurança, então execute:

npm install dotenv

Quando terminar a instalação, crie um arquivo chamado .env, onde armazenaremos nossas chaves em seguida.

AVISO: Se você estiver usando um sistema de controle de versão tal qual o GIT para gerenciar seu projeto, NÃO rastreie o arquivo .env. Adicione a extensão .env no seu arquivo .gitignore para que você não publique acidentalmente suas chaves e credenciais para o mundo.

Configurando o Alchemy

Alchemy é uma plataforma de desenvolvimento de blockchain que nos permite comunicar com a blockchain da Polygon sem ter que configurar nossos próprios nós, então certifique-se de estar inscrito no site com o link.

Depois de registrar uma conta, você poderá gerar chaves das APIs criando um aplicativo.

Com isto, copie suas CHAVES de API e armazene no arquivo .env adicionando algo como:

API_URL = "https://polygon-mumbai.g.alchemy.com/v2/your-api-key"

Configuração da Metamask

Uma vez que você tiver criado uma conta, siga estas etapas para configurar a rede Polygon em sua carteira.

Selecione “Configurações” no menu do canto superior direito da sua carteira Metamask.

Selecione “Redes” no menu à esquerda.

Conecte sua carteira ao Mumbai Testnet usando os seguintes parâmetros.

Network Name: Polygon Mumbai Testnet
New RPC URL: https://polygon-mumbai.g.alchemy.com/v2/your-api-key
ChainID: 80001
Symbol: MATIC
Block Explorer URL: https://mumbai.polygonscan.com/

Obtendo tokens de teste

Em seguida, você precisará de algum MATIC falso para teste, você pode obter alguns no site Polygon Mumbai Testnet. Selecione "Mumbai", escolha "MATIC Token", insira o endereço da sua carteira Polygon e clique em "Enviar". Pode levar algum tempo para receber ETH falso devido ao tráfego de rede.

Exporte e copie sua chave privada da carteira Metamask e inclua-a em seu arquivo .env.

PRIVATE_KEY = "your-metamask-private-key"

Seu arquivo .env deve ficar assim, leia mais sobre arquivos de variáveis ​​de ambiente aqui.

O jogo de adivinhação

Navegue até o diretório de contratos, crie um novo arquivo Solidity e execute:

cd contracts && touch Guess_Game.sol

Abra o arquivo Guess_Game.sol e cole o código abaixo, certifique-se de ler os comentários para entender como ele funciona.

//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;

import "../node_modules/hardhat/console.sol";

// Verifique a documentação oficial e aprenda mais sobre os conceitos aqui: https://docs.soliditylang.org/en/v0.8.13/index.html

contract Guess_Game {

    //  Variáveis de estado cujos valores são armazenados permanentemente no storage do contrato.
    uint random_number;
    bool game_completion;
    address winner;

    // Este é um Struct que define valor para o usuário que está interagindo com o smart contract
    struct player {
        uint guess;
        uint trials;
        bool registered;
    }

    // Criado um mapping de endereços para o jogador Struct
    mapping (address => player) player_structs;

    // Criado um array dinâmico dos endereços dos jogador
    address[] internal players_addresses;

    // Definindo o Contructor que é o bloco de código que executa no momento que o contrato é deployado
    constructor() {

        // Dependendo do timestamp do bloco atual, a função keccak  gerará um número randômico e o manteremos entre 1 e 100
        random_number = uint(keccak256(abi.encodePacked(block.timestamp))) % 100;

        // Quando o contrato é deployado, inicializamos esta variável como "false", dado que ninguém ganhou ainda
        game_completion = false;
    }

    // Gera um novo  struct com msg.sender que é o endereço da carteira do jogador e adiciona ao array
    function set_Player() internal {
        player_structs[msg.sender].guess = 0;
        player_structs[msg.sender].trials = 5;
        player_structs[msg.sender].registered = true;

        players_addresses.push(msg.sender);
    }

    // Uma função para verificar se o usuário tem tentado adivinhar antes de estar registrado
    function get_Player(address _player) internal view returns(bool) {
        return player_structs[_player].registered;
    }

    // Esta função é visível para o usuário, ela lê a entrada do usuário e executa a função game
    function Guess(uint _Guess) public {
        if (game_completion) {
            console.log("O jogo terminou e o endereço vencedor é ", winner);
        }

        // Checa se o jogador foi assignado ao struct
        if (get_Player(msg.sender) != false) {
            set_Player();
        }

        // Passa a entrada e a armazena para o jogador em particular
        player_structs[msg.sender].guess = _Guess;

        Game();
    }

    // A lógica do jogo, esta função interna é chamada sempre que uma tentativa é feita
    function Game() internal {
        uint guess = player_structs[msg.sender].guess;
        uint attempts = player_structs[msg.sender].trials;

        if (attempts > 0) {
            if (guess > random_number) {
                console.log("O seu chute foi muito alto, Tente novamente");
            }

            else if (guess < random_number) {
                console.log("O seu chute foi muito baixo, Tente novamente");
            }

            else if (guess == random_number && game_completion) {
                console.log("Você adivinhou o número, mas o jogo já foi vencido");
            }

            else if (guess == random_number && !game_completion) {
                console.log("Parabéns! Você venceu o jogo de adivinhação");
                winner = msg.sender;
                game_completion = true;
            }
        }

        else {
            console.log("Você não tem mais tentativas");
        }
    }
}

Conecte a Metamask e o Alchemy ao seu projeto

Criamos uma carteira Metamask e uma conta Alchemy, e escrevemos nosso smart contract, agora é hora de conectar os três.

Nossas chaves para a carteira e a conta Alchemy já estão armazenadas, então é hora de atualizar nosso arquivo hardhat.config.js para poder iniciar a conexão.

Vá para seu diretório raiz e atualize seu arquivo hardhat.config.js:

/**
* @type import('hardhat/config').HardhatUserConfig
*/

require('dotenv').config();
require("@nomiclabs/hardhat-ethers");

const { API_URL, PRIVATE_KEY } = process.env;

module.exports = {
  solidity: "0.8.9",
  defaultNetwork: "polygon_mumbai",
  networks: {
    hardhat: {},
    polygon_mumbai: {
      url: API_URL,
      accounts: [`0x${PRIVATE_KEY}`]
    }
  },
}

Compile nosso smart contract

Para ter certeza de que tudo está funcionando até agora, vamos compilar nosso smart contract. A tarefa de compilação é uma das tarefas built-in do Hardhat.

Na linha de comando, execute:

npx hardhat compile

Faça o deploy do nosso contrato

Nosso contrato está escrito e nosso arquivo de configuração também está pronto, é hora de escrever nosso script de deploy de contratos para que possamos fazer o deploy do contrato.

Navegue até a pasta scripts/ e crie um novo arquivo chamado deploy.js e adicione o seguinte:

async function main() {
    const Guess_Game = await ethers.getContractFactory("Guess_Game");

    // Iniciar deploy, retornando uma promise que resulta no objeto do contrato
    const guess_game = await Guess_Game.deploy(); 
    console.log("Contrato deployado no endereço:", guess_game.address);
   }

   main()
    .then(() => process.exit(0))
    .catch(error => {
    console.error(error);
    process.exit(1);
    });

Confirma os documentos para entender o que cada linha faz.

Tempo de deploy

Agora é, finalmente, hora do deploy, navegue até a linha de comando e execute:

npx hardhat run scripts/deploy.js --network polygon_mumbai

Você deverá ver algo como:

Contrato deployado no endereço: 0x56D94982E71867c007c57659d5a2b199E581b502

Copie este endereço; vamos dar uma olhada, vá para o explorador da Polygon Mumbai e procure pelo nosso endereço de contrato, devemos ser capazes de ver que ele foi implantado com sucesso.

Parabéns! Você acabou de implantar um smart contract na blockchain da Polygon. 🎉

Para entender o que está acontecendo nos bastidores, navegue até a guia Explorer em nosso painel Alchemy “The Guessing Game”.

Nos artigos subsequentes, criaremos uma interface de usuário para este dapp, aqui está o Github para o código acima.

Obrigado por ficar até o final, o feedback é sempre bem-vindo.