23.11.2024

Aula 116: Criando Tokens ERC20

Nesta aula, vamos aprender a criar um token ERC20 usando Solidity. O ERC20 é um padrão amplamente adotado para a criação de tokens fungíveis na blockchain do Ethereum. Ao final desta aula, você terá uma compreensão básica de como implementar e implantar seu próprio token ERC20.

O que é um Token ERC20?

Um token ERC20 é um ativo digital que segue um conjunto de regras predefinidas, permitindo que seja facilmente negociado, transferido e integrado dentro do ecossistema Ethereum. O padrão ERC20 define seis funções obrigatórias e três opcionais.

Funções Obrigatórias

1. totalSupply(): Retorna a oferta total do token.
2. balanceOf(endereco conta): Retorna o saldo de uma conta específica.
3. transfer(endereco destinatario, uint256 quantidade): Transfere tokens da conta do chamador para o destinatário.
4. allowance(endereco proprietario, endereco gastador): Retorna o número restante de tokens que um gastador está autorizado a gastar em nome do proprietário.
5. approve(endereco gastador, uint256 quantidade): Permite que um gastador retire da conta do chamador múltiplas vezes, até o valor especificado.
6. transferFrom(endereco remetente, endereco destinatario, uint256 quantidade): Move tokens de uma conta para outra, com base na autorização estabelecida.

Funções Opcionais

1. name(): Retorna o nome do token.
2. symbol(): Retorna o símbolo do token (como "ETH" ou "BTC").
3. decimals(): Retorna o número de casas decimais que o token pode ser dividido.

Estrutura Básica do Token ERC20

Vamos começar a codificar nosso token ERC20. Vamos criar um token simples chamado "MeuToken" com o símbolo "MTK" e 18 casas decimais. Usaremos a biblioteca da OpenZeppelin para implementar nosso token ERC20, que é uma biblioteca segura e validada pela comunidade para contratos inteligentes.

Passo 1: Configurando Seu Ambiente

Certifique-se de que você tem o Node.js e o npm instalados. Em seguida, crie um novo diretório para seu projeto e inicialize-o:

mkdir MeuToken
cd MeuToken
npm init -y

Instale os Contratos da OpenZeppelin:

npm install @openzeppelin/contracts

Passo 2: Escrevendo o Contrato Inteligente

Crie um novo arquivo chamado MeuToken.sol no diretório do seu projeto. Escreva o seguinte código:

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

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

contract MeuToken is ERC20, Ownable {
    constructor(uint256 ofertaInicial) ERC20("MeuToken", "MTK") {
        _mint(msg.sender, ofertaInicial);
    }

    function mint(uint256 quantidade) public onlyOwner {
        _mint(msg.sender, quantidade);
    }

    function burn(uint256 quantidade) public {
        _burn(msg.sender, quantidade);
    }
}

Explicação do Código

• Imports: Importamos ERC20 e Ownable da OpenZeppelin. O ERC20 implementa o padrão ERC20, e o Ownable restringe funções específicas ao proprietário do contrato.
• Construtor: O construtor inicializa o token com um nome e um símbolo. Ele também cria uma oferta inicial de tokens para o implantador do contrato.
• Função Mint: Permite que o proprietário crie novos tokens e os adicione ao seu saldo.
• Função Burn: Permite que os usuários queimem (destruam) seus tokens, reduzindo a oferta total.

Passo 3: Compilando e Implantando o Contrato

Use um framework de desenvolvimento como Truffle ou Hardhat para compilar e implantar seu contrato inteligente. Para simplicidade, forneceremos um exemplo usando Hardhat.

Inicializar um Projeto Hardhat

npm install --save-dev hardhat
npx hardhat

Crie um script para implantar o contrato. Na pasta scripts, crie um arquivo chamado deploy.js:

const hre = require("hardhat");

async function main() {
    const ofertaInicial = hre.ethers.utils.parseUnits("1000", 18); // 1000 MTK
    const Token = await hre.ethers.getContractFactory("MeuToken");
    const meuToken = await Token.deploy(ofertaInicial);

    await meuToken.deployed();

    console.log("Token implantado em:", meuToken.address);
}

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

Implantar o Contrato

Execute o script de implantação:

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

Certifique-se de substituir rinkeby pela rede na qual você deseja implantar. Você precisará de uma carteira com algum Ether para pagar pela transação de implantação.

Passo 4: Interagindo com Seu Token

Uma vez implantado, você pode interagir com seu token por meio de uma interface web ou usando scripts. Aqui está um exemplo simples de como transferir tokens.

const meuToken = await ethers.getContractAt("MeuToken", "<SEU_ENDERECO_CONTRATO>");

// Transferir tokens
const tx = await meuToken.transfer("<ENDERECO_DESTINATARIO>", ethers.utils.parseUnits("10", 18));
await tx.wait();
console.log("10 tokens transferidos!");

Conclusão

Parabéns! Agora você criou e implantou seu próprio token ERC20 na blockchain do Ethereum. Você pode aprimorar ainda mais seu token adicionando mais recursos ou integrando-o com um frontend.

Lembre-se de testar seus contratos inteligentes usando uma rede de teste e verificar sua segurança. Boa programação!

Video

Navigation