Ir para o conteúdo
Buscar

WEB3DEV

Cover image for Construindo seu primeiro Dapp com Solidity na blockchain da Polygon
Rodrigo Faria
Rodrigo Faria

Posted on

Construindo seu primeiro Dapp com Solidity na blockchain da Polygon

#javascript #polygon #desenvolvimento #solidity

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

Hardhatt

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
Enter fullscreen mode Exit fullscreen mode

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.

Alchemy

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"
Enter fullscreen mode Exit fullscreen mode

Alchemy

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/
Enter fullscreen mode Exit fullscreen mode

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"
Enter fullscreen mode Exit fullscreen mode

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

Obtendo tokens de teste

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
Enter fullscreen mode Exit fullscreen mode

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");
        }
    }
}
Enter fullscreen mode Exit fullscreen mode

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}`]
    }
  },
}
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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);
    });
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

Você deverá ver algo como:

Contrato deployado no endereço: 0x56D94982E71867c007c57659d5a2b199E581b502
Enter fullscreen mode Exit fullscreen mode

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.

Polyscan

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”.

Alchemy

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.

Top comments (0)


Leia o próximo

panegali profile image

Contrato inteligente. Solidity + Ganache

Panegali -

isabelacnehme profile image

Lista de Permissões Usando a Árvore de Merkle no Solidity

Isabela Curado Nehme -

devaraujo profile image

Entendendo Assinaturas Digitais: O Papel de v, r, s na Segurança Criptográfica e Verificação de Assinaturas.

Adriano P. Araujo -

paulogio profile image

Solidity vs Rust: As Principais Diferenças entre as Linguagens de Programação Web3

Paulo Gio -