Como criar o seu próprio token ERC-20

Os tokens ERC-20 são a espinha dorsal de milhares de projetos na blockchain Ethereum. Seja para lançar uma moeda de utilidade, representar ativos digitais ou criar um sistema de recompensas, entender como desenvolver e publicar seu próprio token pode abrir portas para oportunidades no universo DeFi, NFTs e além.

1. O que é o padrão ERC-20?

ERC-20 é um standard (padrão) de contrato inteligente que define um conjunto de funções básicas que um token deve implementar. Esse padrão garante interoperabilidade entre carteiras, exchanges e outras dApps. Para detalhes oficiais, consulte a Ethereum.org.

2. Por que você deve conhecer o Ethereum antes de criar um token?

Antes de mergulhar no código, é essencial entender como a rede Ethereum funciona, seu modelo de gas, consenso e segurança. Nosso artigo Como funciona o Ethereum: Guia completo para entender a blockchain, contratos inteligentes e seu ecossistema oferece uma visão aprofundada que complementa este tutorial.

3. Pré‑requisitos técnicos

• Conhecimento básico de programação: especialmente JavaScript e Solidity.
• Ambiente de desenvolvimento: Node.js, npm, e um editor de código (VS Code é o mais usado).
• Carteira Web3: MetaMask ou outra carteira que permita conexão com redes de teste. Veja nosso passo a passo em Como usar a MetaMask: Guia completo passo a passo para iniciantes e avançados.
• Rede de teste: Ropsten, Goerli ou Sepolia (recomendo Goerli por ser amplamente suportada).

4. Configurando o ambiente

Execute os comandos abaixo em um terminal limpo:

mkdir meu-token-erc20 && cd meu-token-erc20
npm init -y
npm install --save-dev hardhat @nomiclabs/hardhat-ethers ethers @openzeppelin/contracts
npx hardhat

Escolha a opção “Create a basic sample project” e siga as instruções. Em seguida, abra o arquivo hardhat.config.js e adicione a configuração da rede de teste:

require("@nomiclabs/hardhat-ethers");
module.exports = {
  solidity: "0.8.20",
  networks: {
    goerli: {
      url: "https://eth-goerli.alchemyapi.io/v2/SEU_ALCHEMY_KEY",
      accounts: ["0xSUA_PRIVATE_KEY"]
    }
  }
};

5. Escrevendo o contrato inteligente

Crie o arquivo contracts/MeuToken.sol com o seguinte código. Utilizamos a biblioteca OpenZeppelin para garantir segurança e boas práticas.

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

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

/**
 * @title MeuToken
 * @dev Implementação simples de um token ERC‑20 usando OpenZeppelin.
 */
contract MeuToken is ERC20, Ownable {
    /**
     * @dev Construtor que define nome, símbolo e a quantidade inicial de tokens.
     * @param name Nome do token.
     * @param symbol Símbolo do token.
     * @param initialSupply Quantidade inicial (em wei).
     */
    constructor(string memory name, string memory symbol, uint256 initialSupply) ERC20(name, symbol) {
        _mint(msg.sender, initialSupply);
    }

    /**
     * @dev Função opcional para que o proprietário possa mintar novos tokens.
     * @param to Endereço que receberá os novos tokens.
     * @param amount Quantidade a ser mintada.
     */
    function mint(address to, uint256 amount) external onlyOwner {
        _mint(to, amount);
    }
}

Este contrato já implementa todas as funções exigidas pelo padrão ERC‑20 (balanceOf, transfer, approve, allowance, etc.) e ainda permite que o proprietário crie tokens adicionais de forma controlada.

6. Compilando e testando

Compile o contrato:

npx hardhat compile

Crie um teste simples em test/MeuToken.test.js:

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("MeuToken", function () {
  it("Deve atribuir o supply total ao deployer", async function () {
    const [deployer, addr1] = await ethers.getSigners();
    const Token = await ethers.getContractFactory("MeuToken");
    const token = await Token.deploy("Meu Token", "MTK", ethers.utils.parseUnits("1000", 18));
    await token.deployed();

    const deployerBalance = await token.balanceOf(deployer.address);
    expect(await token.totalSupply()).to.equal(deployerBalance);
  });
});

Execute os testes:

npx hardhat test

Se tudo passar, seu contrato está pronto para ser implantado.

7. Deploy na rede de teste

Crie o script scripts/deploy.js:

async function main() {
  const [deployer] = await ethers.getSigners();
  console.log("Deploying contracts with the account:", deployer.address);
  console.log("Account balance:", (await deployer.getBalance()).toString());

  const Token = await ethers.getContractFactory("MeuToken");
  const token = await Token.deploy("Meu Token", "MTK", ethers.utils.parseUnits("1000000", 18));
  await token.deployed();

  console.log("Token deployed to:", token.address);
}

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

Execute o deploy:

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

Após a transação ser confirmada, anote o endereço do contrato. Você pode verificá‑lo no Etherscan da rede Goerli para garantir que o código-fonte está publicado.

8. Segurança e boas práticas

Mesmo que o contrato acima seja simples, há vulnerabilidades comuns que você deve evitar:

• Reentrancy: Use o modificador nonReentrant da OpenZeppelin quando seu contrato interage com outros contratos.
• Overflow/Underflow: A partir do Solidity ^0.8, os checks são automáticos, mas sempre revise.
• Controle de acesso: Apenas o proprietário deve poder mintar ou pausar o contrato. Considere usar Pausable para emergências.
• Auditoria de código: Se seu token for usado por terceiros, contrate uma auditoria externa.

Para aprofundar em segurança de contratos, consulte o Consensys Smart Contract Best Practices.

9. Publicando e listando seu token

Depois de validar o contrato na rede de teste, repita o processo na mainnet. Lembre‑se de que o custo de gas pode ser alto; use ETH Gas Station para escolher o momento adequado.

Para que seu token seja reconhecido em exchanges e carteiras, siga estes passos:

1. Registre o token no Etherscan (verificação de código).
2. Envie a lista de informações (nome, símbolo, endereço, decimais) para plataformas como CoinGecko e CoinMarketCap.
3. Divulgue seu projeto nas comunidades de cripto, redes sociais e grupos especializados.

10. Casos de uso e exemplos práticos

Tokens ERC‑20 podem ser usados para:

• Moedas de utilidade dentro de um ecossistema de jogos.
• Representar ações ou participação em projetos de crowdfunding.
• Facilitar pagamentos em DApps DeFi (staking, liquidity pools).

Se quiser explorar ideias avançadas, dê uma olhada no artigo Guia Definitivo para Evitar Scams de Cripto no Brasil em 2025 para entender como proteger seu projeto contra fraudes.

Conclusão

Criar seu próprio token ERC‑20 não é apenas uma questão de copiar código; envolve planejamento, segurança e integração com o ecossistema Ethereum. Seguindo este guia passo a passo, você terá uma base sólida para lançar um token confiável, pronto para ser adotado por usuários e parceiros.