Crie e implante um token ERC-20 em 15 minutos (Truffle, OpenZeppelin, Goerli)

Crie e implante um token ERC-20 em 15 minutos (Truffle, OpenZeppelin, Goerli)

#solidity#javascript#truffle#web3

O espaço Web3 movimenta-se rapidamente! Isso é ótimo, no entanto, significa que a maioria dos guias sobre como criar tokens ERC-20 estão usando versões desatualizadas e utilizando recursos obsoletos (por exemplo, a testnet Rinkeby). Portanto, aqui está um retrato atualizado, escrito em novembro de 2022...

Eis o que vamos fazer:

• Alavancar os contratos revisados de segurança e comunitários do OpenZeppelin para criar um token ERC-20.
• Usar o pacote de ferramentas do Truffle para compilar e implantar o contrato localmente, em uma rede Ethereum e depois interagir com vários métodos.
• Utilizar a plataforma de infraestrutura de Web3 Infura para implantar o contrato na testnet Goerli.
• Encontrar o token recém implantado no Etherscan e importar os tokens para a MetaMask.

Configuração do projeto

Pré-requisito: Instalar o Truffle (no momento que escrevo isto, estou usando [email protected]):

npm install -g truffle

Nota: Para o bem desta demonstração, vou chamar o token de MyToken, então sempre que eu fizer referência a MyToken, substitua-o pelo nome que você quiser dar ao seu token.

1) Inicializar um modelo de projeto vazio e mudar para o diretório com cd:

truffle init MyToken && cd MyToken

2) Instalar o OpenZeppelin para que possamos alavancar os contratos inteligentes:

npm install @openzeppelin/contracts

3) Abra o projeto em seu editor de escolha (provavelmente code .

se você estiver usando VSCode, use qualquer atalho que você tenha definido, ou abra-o manualmente)

Criando o Token

Reserve um tempo para olhar a estrutura do projeto e você vai notar o seguinte:

contracts/: Diretório dos contratos de Solidity

migrations/: Diretório dos arquivos de implantação scriptable

test/: Diretório dos arquivos de teste para testar seu aplicativo e contratos

truffle.js: Artigo de configuração Truffle

Criar um arquivo dentro de contracts/ chamado MyToken.sol. A extensão .sol se refere à Solidity, que é a linguagem orientada a objetos para a implementação dos contratos inteligentes que vamos utilizar.

Dentro do MyToken.sol, acrescente o seguinte:

MyToken.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.17;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

• A primeira linha se refere a qual identificador de licença que o contrato utiliza. Os identificadores de licença SPDX foram introduzidos em v0.6.8.
• pragma é uma diretiva que especifica qual versão do compilador o arquivo deve usar.
• A linha de importação está importando o conteúdo deste arquivo que está disponível dentro de nossos node_modules a partir da instalação anterior do OpenZeppelin.
• Agora, é hora de criar o contrato:

MyToken.sol

// ...

contract MyToken is ERC20 {

    constructor(

        string memory name,

        string memory symbol,

        uint initialSupply

    ) ERC20(name, symbol) {

        require(initialSupply > 0, “O suprimento inicial deve ser maior que 0");

        _mint(msg.sender, initialSupply * 10**18);

    }

}

Algumas notas sobre o código acima:

• O contrato está herdando do contrato ERC20 do OpenZeppelin com a palavra-chave is.
• O construtor está recebendo o name, symbol e initialSupply que passaremos do implantador mais tarde.
• Após uma rápida validação usando require, estamos usando a função _mint que foi herdada do OpenZeppelin para emitir os tokens.
• O initialSupply * 10**18 está representando o saldo com 18 decimais. Por quê? Porque os decimais não são suportados pela Solidity nem pela EVM. Da mesma forma que 1 ETH é representado por 10^18 de sua unidade natural (1 Ether = 1.000.000.000.000.000.000.000 Wei), nós estaremos fazendo o mesmo para nosso token. Isto nos permite enviar valores arbitrários (por exemplo, 0,0004 MyTokens).

Configurando oTruffle

Em um projeto Truffle recém-criado, há uma grande quantidade de modelos para ajudar você a ir em frente, você pode reduzi-la a isto:

truffle-config.js

require("dotenv").config();

const { MNEMONIC, PROJECT_ID } = process.env;

const HDWalletProvider = require("@truffle/hdwallet-provider");

module.exports = {

    networks: {

        development: {

            host: "127.0.0.1", // Localhost (default: none)

            port: 9545, //Porta padrão da Ethereum (default: none)

            network_id: "*", // Qualquer rede (default: none)

        },

        goerli: {

            provider: () =>

                new HDWalletProvider(

                    MNEMONIC,

                    `https://goerli.infura.io/v3/${PROJECT_ID}`,

                ),

            network_id: 5, // Goerli's id

            confirmations: 2, // #de confirmações para aguardar entre as implantações. (default: 0)

            timeoutBlocks: 200, // # de blocos antes de um intervalo de implantação  (minimum/default: 50)

            skipDryRun: true, // Pular a simulação antes das migrações? (default: falso para redes públicas )

        },

    },

    compilers: {

        solc: {

            version: "0.8.17",

        },

    },

};

A seguir:

1)Instale o HDWalletProvider:

npm install @truffle/hdwallet-provider.

2) Instale o dotenv:

npm install dotenv.

3) Crie um arquivo .env na raiz do diretório do projeto com o seguinte conteúdo:

MNEMONIC=

PROJECT_ID=

(Não se esqueça de acrescentar o arquivo .env para o seu .gitignore!)

Tempo para preencher os valores MNEMONIC e PROJECT_ID...

Obtendo o MNEMONIC da MetaMask

Pré-requisito: Instalar o navegador MetaMask a partir de https://metamask.io/download/, se você ainda não possui.

1) Seguir estas instruções para revelar sua frase secreta de recuperação. Nota: Não compartilhe esta chave com ninguém, nem armazene-a on-line em nenhum lugar.

2) Copie o valor para a chave MNEMONIC correspondente no arquivo .env.

Obter o PROJECT_ID do Infura

1) Inscreva-se em https://infura.io/ (é gratuito!)

2) Uma vez confirmado e logado, clique no botão "CREATE NEW KEY" na parte superior direita do dashboard. Digite um Name e selecione Web3 API como uma Rede e depois crie.

3) Selecione Görli abaixo de Network Endpoints:

4) Copie o ID que está no URL HTTPS para a chave PROJECT_ID correspondente no arquivo.env.

Criando a migração

Para implantar o contrato, você precisará criar um arquivo na pasta de migrations/:

1_initial_migration.js

const MyToken = artifacts.require("MyToken");

module.exports = (deployer) => {

    deployer.deploy(MyToken, "MyToken", "MYT", 100000);

};

Algumas observações sobre o código acima:

• Dizemos ao Truffle com quais contratos gostaríamos de interagir através do método artifacts.require(). O nome deve corresponder ao nome da definição do contrato dentro desse arquivo fonte, não ao nome do arquivo fonte (pois os arquivos podem conter mais de um contrato).
• A API do implantador (deployer.deploy(contract, args..., options)) pode ser encontrada aqui. Estamos passando pelo contrato, seguido dos argumentos opcionais do construtor.
• Os argumentos do construtor são "MyToken" (o nome), "MYT" (o símbolo) e 100000 (o fornecimento inicial).

Deve ser isto para a configuração! ⚙️

Implantando o contrato localmente

Para implantar o contrato inteligente, vamos precisar nos conectar a uma blockchain. O Truffle tem uma blockchain pessoal embutida que pode ser usada para testes. Esta blockchain é local para seu sistema e não interage com a rede principal da Ethereum.

1) Abra uma janela do terminal e cd para seu diretório de projetos da Truffle.

2) Execute o truffle develop que iniciará uma rede local da Ethereum.

3) Execute compile que compilará os arquivos do contrato Solidity, o que deve lhe dar algo assim:

truffle(develop)> compile

Compiling your contracts...

===========================

> Compiling ./contracts/MyToken.sol

> Compiling @openzeppelin/contracts/token/ERC20/ERC20.sol

> Compiling @openzeppelin/contracts/token/ERC20/IERC20.sol

> Compiling @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol

> Compiling @openzeppelin/contracts/utils/Context.sol

> Artifacts written to /Users/ME/MyToken/build/contracts

> Compiled successfully using:

   - solc: 0.8.17+commit.8d345f5f.Emscripten.clang

truffle(develop)>

Nota: Conforme indicado pela mensagem de sucesso, foram criados artefatos dentro de seu diretório /build/contracts. O nome dos arquivos .json do artefato gerado não reflete o nome do arquivo fonte, mas o nome da definição do contrato.

5)Finalmente, execute migrate--reset para implantar seu contrato na rede local em execução.

-reset executa todas as migrações desde o início, em vez de executar a partir da última migração concluída

Interagindo com o token

É hora de fazer algumas verificações básicas para ver se tudo funcionou como esperado:

1) Execute token = await MyToken.deployed(); para acessar o TruffleContract. Isto também deve gerar uma saída da instância do contrato completa com todos os métodos e propriedades disponíveis etc.

2) A partir daqui, podemos testar alguns métodos:

truffle(develop)> name = await token.name();

'MyToken'

truffle(develop)> symbol = await token.symbol();

'MYT'

truffle(develop)> decimals = (await token.decimals()).toString()

'18'

Eu os encorajo a experimentar com outros métodos disponíveis!

Implantando o contrato para a testnet Goerli

Antes que você possa implantar o contrato para Goerli, precisaremos de alguns Ethers da testnet! Antes de mais nada, mude para a rede Goerli em sua MetaMask (se não for uma opção para você, você pode precisar ativar a opção "Show test networks" [Mostrar redes de teste] nas configurações avançadas):

A seguir, vá até https://goerlifaucet.com, digite seu endereço e pressione o botão "Send me ETH". Uma vez confirmada a transação, verifique sua MetaMask para confirmar a chegada do ETH, se não - tente outra faucet (torneira).

Hora de migrar! Execute migrate --reset --network goerli, que deve fornecer algo como isto:

truffle(develop)> migrate --reset --network goerli

Compiling your contracts...

===========================

>Everything is up to date, there is nothing to compile.

Starting migrations...

======================

> Network name:    'goerli'

> Network id:      5

> Block gas limit: 30000000 (0x1c9c380)

1_initial_migration.js

======================

   Deploying 'MyToken'

   -------------------

   > transaction hash:    0x31b69373bdfdabb20e205746150d5c4845b363e9a3755450d23adbad1a736c04

   > Blocks: 1            Seconds: 4

   > contract address:    0x904609375980165691D587386A0163aa7d8D00A6

   > block number:        7875096

   > block timestamp:     1667350704

   > account:             0xEb390e921A349e2434871D989c9AD74bB8de10c0

   > balance:             0.047005278846168288

   > gas used:            1186096 (0x121930)

   > gas price:           2.524855622 gwei

   > value sent:          0 ETH

   > total cost:          0.002994721153831712 ETH

   Pausing for 2 confirmations...

   -------------------------------

   > confirmation number: 1 (block: 7875097)

   > confirmation number: 2 (block: 7875098)

   > Saving artifacts

   -------------------------------------

   > Total cost:     0.002994721153831712 ETH

Summary

=======

> Total deployments:   1

> Final cost:          0.002994721153831712 ETH

Visualizando o contrato no Etherscan

No meu caso, você verá como parte do resultado da migração que o endereço do contrato é: 0x904609375980165691D587386A0163aa7d8D00A6. Usando isto, podemos ir até o Etherscan para visualizar o contrato criado!

Adicionando o token à MetaMask

Usando o mesmo endereço de contrato, volte à MetaMask e clique em "Import token" (Importar token). Ao inserir o endereço do contrato, o símbolo e as casas decimais devem ser preenchidos automaticamente:

e clicando "Add custom token"...

você deve conseguir visualizar seu saldo! 🪄

É isso! 🏁

Se você estiver interessado em aprender mais sobre Solidity, Crypto Zombies é um ótimo lugar para começar. Solidity by example também tem bons exemplos do mundo real digerível de até onde os contratos inteligentes podem ir.

Esse artigo foi escrito por Will e traduzido por Fátima Lima. O original pode ser lido aqui.