Ir para o conteúdo
Buscar

WEB3DEV

Cover image for Tutorial de Yield Farming - Parte 3
Diogo Jorge
Diogo Jorge

Posted on

Tutorial de Yield Farming - Parte 3

#defi #metamask #hardhat #tutorial

Implantando Contratos Inteligentes com Hardhat

Image description

Caso você tenha perdido:

Introdução

A implantação de contratos inteligentes com o Hardhat é bem diferente que a implantação com o Truffle. O Truffle usou sua própria pasta Migrations com um arquivo “1_initial_migrations.js”. A abordagem geral para implantar contratos incluía definir um novo arquivo “2_deploy_contracts.js” e escrever scripts de implantação nele. O Hardhat, por padrão, optou por não aplicar a mesma abordagem. Em vez disso, eles oferecem seu próprio recurso de tarefas em conjunto com os próprios scripts do usuário. Para os desenvolvedores mais novos do Solidity que estão lendo isso, os scripts de implantação no Hardhat são seus amigos.

Implantaremos o contrato PmknFarm (links na parte superior) em uma rede local, a rede de teste Kovan (Nota do tradutor: A rede Kovan foi descontinuada. Por favor, utilize a rede Goerli.) da Ethereum e a rede de teste Mumbai da Polygon. Vamos entrar nisso.

Dependências/Pré-requisitos

.env

Vamos precisar de um provedor web3 e de uma carteira Ethereum para implantar nossos contratos. Na raiz PmknFarm, digite: touch .env

Forneci um modelo simples. Basta adicionar isso ao seu arquivo .env:

KOVAN_KEY=<INSERT_API_KEY>
PRIVATE_KEY=<INSERT_PRIVATE_KEY>
Enter fullscreen mode Exit fullscreen mode

Agora, vamos pegar a chave privada.

Chave privada

Para simplificar, usaremos a MetaMask neste tutorial. Se você ainda não tem a MetaMask instalada, clique no link e siga as instruções. Depois de instalada, acompanhe as imagens para buscar sua chave privada.

Image description

Clique na extensão MetaMask

Image description

Clique em Opções de conta

Image description

Em seguida, detalhes da conta

Image description

Por fim, exporte a chave privada

Depois disso, você será solicitado a fornecer sua senha. A MetaMask apresentará sua chave privada. Copie/cole isso na variável PRIVATE_KEY no arquivo .env.

CHAVE DE API

Para adquirir uma chave de API (para que nossos contratos inteligentes possam interagir em uma rede pública), pegaremos uma gratuitamente na Infura. Cadastre-se com um e-mail e confirme seu endereço de e-mail. Clique na guia Ethereum e insira o nome do seu projeto (“PmknFarm”). Clique no menu suspenso de endpoints e selecione Kovan. Copie o endpoint aqui:

Image description

Cole o endpoint em sua variável KOVAN_KEY dentro de seu arquivo .env. Proximo passo: escrever os scripts.

Scripts

Implantação local

Escrever scripts de implantação vai parecer bastante familiar para as implantações executadas no teste. Basta dizer que você já fez a maior parte do trabalho se testou seu código corretamente. Os scripts a seguir podem atuar como um modelo para escrever scripts de Hardhat em seus futuros contratos inteligentes.

Na raiz do projeto, crie um diretório chamado scripts e adicione o arquivo deployFarm.ts:

scripts mkdir
touch scripts/deployFarm.ts
Enter fullscreen mode Exit fullscreen mode

Em seguida, adicione o esqueleto do script de implantação com tratamento de erros:

import { ethers } from "hardhat";

const main = async() => {}

main()
    .then(() => process.exit(0))
    .catch(error => {
        console.log(error)
        process.exit(1)
    })
Enter fullscreen mode Exit fullscreen mode

Novamente, semelhante aos testes PmknFarm, vamos incluir o implantador do contrato, buscar as fábricas de contratos (contract factories) de nossos contratos inteligentes e atribuir suas implantações. Depois, não se esqueça de transferir a propriedade do contrato PmknToken para o contrato PmknFarm. Dessa forma, o contrato PmknFarm pode cunhar PmknTokens para os usuários quando eles retirarem seu rendimento. Essa função deve ser chamada após a implantação dos contratos PmknToken e PmknFarm.

Sempre incluo um console.log() para cada nova implantação de contrato. Isso permite fácil acesso aos endereços ao integrar o back-end do contrato inteligente com o front-end. Eu encorajo você a fazer o mesmo. O script de implantação final para implantação local deve ter a seguinte aparência:

import { ethers } from "hardhat";

const main = async() => {
    const [deployer] = await ethers.getSigners()
    console.log(`Implantando contratos com ${deployer.address}`);

    const MockERC20 = await ethers.getContractFactory("MockERC20")
    const mockDai = await MockERC20.deploy("MockDai", "mDAI")
    console.log(`Endereço MockDai: ${mockDai.address}`)

    const PmknToken = await ethers.getContractFactory("PmknToken")
    const pmknToken = await PmknToken.deploy()
    console.log(`Endereço PmknToken: ${pmknToken.address}`)

    const PmknFarm = await ethers.getContractFactory("PmknFarm")
    const pmknFarm = await PmknFarm.deploy(mockDai.address, pmknToken.address)
    console.log(`Endereço PmknFarm: ${pmknFarm.address}`)

    await pmknToken._transferOwnership(pmknFarm.address)
    console.log(`Propriedade do PmknToken transferida para ${pmknFarm.address}`)
}

main()
    .then(() => process.exit(0))
    .catch(error => {
        console.log(error)
        process.exit(1)
    })
Enter fullscreen mode Exit fullscreen mode

Observe que incluí o contrato MockDai neste script. Incluir o contrato simulado libera você do incômodo de adquirir DAI real em um fork da mainnet. Eu recomendo incluir o fork da mainnet em sua caixa de ferramentas de teste; no entanto, isso está fora do escopo deste tutorial (o Hardhat oferece um ótimo tutorial para forks da mainnet aqui). Em seguida, execute o script que você acabou de criar no terminal. O Hardhat usará automaticamente a rede Hardhat quando uma rede específica não for especificada.

npx hardhat run scripts/deployFarm.ts
Enter fullscreen mode Exit fullscreen mode

Se a saída do seu terminal for semelhante a esta, parabéns! Você implantou com sucesso seus contratos inteligentes.

Image description

Implantação na Kovan

A principal diferença entre a implantação na rede local do Hardhat e uma rede pública real está em como construímos a configuração. Precisamos da carteira real da qual implantaremos, uma vez que a implantação de contratos inteligentes custa gás. Também precisaremos de um nó como nosso gateway para permitir que nossos contratos inteligentes interajam dentro da rede (como a KOVAN_KEY).

Se você acompanhou até este ponto, deve ter seu arquivo .env configurado — caso contrário, consulte o início do artigo. Em seguida, adicionamos a rede Kovan à nossa chave de redes no arquivo hardhat.config.ts. Dentro da chave kovan, precisaremos incluir uma chave de url e uma chave de contas. A MetaMask não inclui o prefixo 0x em sua chave privada; portanto, escolho usar a funcionalidade template literals e inserir o prefixo dessa maneira.

Também precisamos importar a função config() do DOTENV. Isso informa ao tempo de execução a localização de nossa PRIVATE_KEY e KOVAN_KEY. A configuração final, embora mínima, deve ficar assim:

import "@nomiclabs/hardhat-waffle";
import "@nomiclabs/hardhat-web3";
require('dotenv').config();

export default {
  solidity: {
    version: "0.8.4",
    },
  networks: {
    kovan: {
       url: process.env.KOVAN_KEY,
       accounts: [`0x${process.env.PRIVATE_KEY}`]
   }
Enter fullscreen mode Exit fullscreen mode

Também precisaremos trocar o contrato MockDAI em nosso script para o verdadeiro contrato DAI (kDAI) na rede Kovan. Incluí o endereço da Stablecoin DAI abaixo.

const kDAI = "0x4F96Fe3b7A6Cf9725f59d353F723c1bDb64CA6Aa";

Seu script deve ficar assim:

import { ethers } from "hardhat";

const kDAI = "0x4F96Fe3b7A6Cf9725f59d353F723c1bDb64CA6Aa";

const main = async() => {
    const [deployer] = await ethers.getSigners()
    console.log(`Deploying contracts with ${deployer.address}`);

    //const MockERC20 = await ethers.getContractFactory("MockERC20")
    //const mockDai = await MockERC20.deploy("MockDai", "mDAI")
    //console.log(`Endereço MockDai: ${mockDai.address}`)

    const PmknToken = await ethers.getContractFactory("PmknToken")
    const pmknToken = await PmknToken.deploy()
    console.log(`Endereço PmknToken: ${pmknToken.address}`)

    const PmknFarm = await ethers.getContractFactory("PmknFarm")
    const pmknFarm = await PmknFarm.deploy(kDAI, pmknToken.address)
    console.log(`Endereço PmknFarm: ${pmknFarm.address}`)

    await pmknToken._transferOwnership(pmknFarm.address)
    console.log(`PmknToken ownership transferred to ${pmknFarm.address}`)
}

main()
    .then(() => process.exit(0))
    .catch(error => {
        console.log(error)
        process.exit(1)
    })
Enter fullscreen mode Exit fullscreen mode

Você precisará de algum Kovan ETH em sua carteira antes da implantação. Para adquirir kETH, acesse a Torneira Kovan da Grid (eles exigem apenas que você tenha uma conta no GitHub).

Depois de ter algum Kovan ETH, digite no seu terminal:

npx hardhat run scripts/deployFarm.ts --network kovan
Enter fullscreen mode Exit fullscreen mode

*Além disso, esteja ciente de que, conforme programado nesta série, o PmknFarm aceita apenas DAI, e você precisará adquirir o DAI na Kovan no endereço que usamos. A maneira mais fácil de obter o kDAI é abrir uma posição de dívida colateralizada (CDP) com a MakerDAO. Clique aqui para acessar o Oasis dApp e abrir um CDP com seu kETH.

Implantação na Mumbai

Se você acompanhou a implantação na Kovan, isso deve ser excepcionalmente rápido e fácil. Primeiro, precisamos incluir uma chave de API para a rede Mumbai. A Infura oferece isso; no entanto, encontrei um erro consistente ao usar a RPC deles no momento em que este artigo foi escrito. Portanto, convido você a seguir a documentação da Matic e usar a RPC fornecida. Copie e cole o seguinte em seu arquivo .env:

MUMBAI_KEY=https://rpc-mumbai.maticvigil.com
Enter fullscreen mode Exit fullscreen mode

Em seguida, adicione Matic como uma chave de rede em seu arquivo hardhat.config.ts. Copie o URL e as chaves de contas para Kovan, mas inclua MUMBAI_KEY no lugar de KOVAN_KEY.

Você precisará adquirir algum MATIC de teste para implantação. A torneira (faucet) deles está localizada aqui.

Por fim, execute o seguinte script para implantar o PmknFarm na Mumbai:

npx hardhat run scripts/deployFarm.ts --network matic
Enter fullscreen mode Exit fullscreen mode

*Observe também que não existe uma DAI oficial na testnet Mumbai no momento em que este texto foi escrito. Você precisará implantar um contrato mockDAI assim como implantamos em nossa rede local para interagir com seu contrato na Mumbai.

Conclusão

Espero que este guia tenha fornecido alguns insights sobre a implantação de contratos inteligentes usando o Hardhat. O poderoso ecossistema de plug-ins do Hardhat oferece aos desenvolvedores uma incrível flexibilidade em relação ao teste e à implantação de contratos inteligentes. Eu criei um repositório do GitHub especificamente para esta série de tutoriais aqui. Entre em contato se tiver dúvidas ou problemas. Muito obrigado pela leitura! Espero que isso agregue valor para você como desenvolvedor.

*Gorjetas são muito apreciadas!

Endereço ETH: 0xD300fAeD55AE89229f7d725e0D710551927b5B15

Este artigo foi escrito por Andrew Fleming e traduzido por Diogo Jorge. O artigo original pode ser encontrado aqui.

Top comments (0)


Leia o próximo

ojedai85 profile image

Construindo seus próprios Plugins Hardhat Customizados a partir do zero (DEV)

Rafael Ojeda -

paulogio profile image

Criando um aplicativo DeFi Full-Stack com a Polygon

Paulo Gio -

isabelacnehme profile image

Como implantar seu primeiro contrato inteligente na Ethereum com Solidity e Hardhat

Isabela Curado Nehme -

idimitrisc47 profile image

Mergulhando no UniSwap

Dimitris Carvalho Calixto -