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_modulesa 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,symboleinitialSupplyque passaremos do implantador mais tarde. - Após uma rápida validação usando
require, estamos usando a função_mintque foi herdada do OpenZeppelin para emitir os tokens. - O
initialSupply * 10**18está 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) e100000(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.
Top comments (0)