Como criar seu próprio token ERC-20 passo a passo (2025)

作者

Como criar seu próprio token ERC-20 passo a passo

O universo das criptomoedas evolui rapidamente, e criar um token ERC-20 pode ser a porta de entrada para quem deseja lançar um projeto próprio, levantar fundos ou simplesmente experimentar a tecnologia blockchain. Este guia completo, pensado para usuários brasileiros iniciantes e intermediários, traz tudo que você precisa saber – desde conceitos básicos até a publicação do contrato na rede Ethereum.

  • Entenda o padrão ERC-20 e suas funcionalidades.
  • Configure seu ambiente de desenvolvimento local.
  • Escreva, compile e teste o contrato inteligente.
  • Realize o deploy na testnet e, depois, na mainnet.
  • Confira boas práticas de segurança e auditoria.

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

ERC-20 é o Ethereum Request for Comments 20, um padrão técnico que define como um token deve ser implementado na blockchain Ethereum. Ele garante interoperabilidade entre carteiras, exchanges e dApps, permitindo que qualquer token que siga o padrão seja reconhecido e manipulado de forma uniforme.

As funções essenciais do ERC-20 incluem totalSupply, balanceOf, transfer, approve e transferFrom. Cada uma tem um papel específico na gestão de saldos e permissões.

Benefícios de usar ERC-20

  • Compatibilidade com a maioria das infraestruturas de Ethereum.
  • Facilidade de integração em exchanges descentralizadas (DEX).
  • Ampla documentação e comunidade ativa.

2. Pré-requisitos para criar seu token

Antes de escrever código, certifique‑se de que tem os seguintes itens:

  • Conhecimento básico de Solidity – a linguagem de programação dos contratos Ethereum.
  • Uma carteira Ethereum (MetaMask, Trust Wallet, etc.) com alguns ETH para pagar gas.
  • Conta no Infura ou Alchemy para acessar nós Ethereum.
  • Node.js (versão 18 ou superior) e npm instalados.
  • Editor de código (VS Code recomendado).

3. Configurando o ambiente de desenvolvimento

Vamos montar um workspace completo usando Hardhat, uma das ferramentas mais populares para desenvolvimento de contratos Solidity.

mkdir meu-token-erc20
cd meu-token-erc20
npm init -y
npm install --save-dev hardhat @nomiclabs/hardhat-ethers ethers
npx hardhat
# Selecione "Create a basic sample project"

Após a inicialização, a estrutura de pastas será semelhante a:

meu-token-erc20/
├─ contracts/
│   └─ Token.sol
├─ scripts/
│   └─ deploy.js
├─ test/
│   └─ Token.test.js
├─ hardhat.config.js
└─ package.json

4. Escrevendo o contrato inteligente

Crie o arquivo contracts/Token.sol com o código abaixo. Ele segue o padrão ERC-20 e inclui funcionalidades de mint e burn para maior flexibilidade.

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

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

/**
 * @title MeuTokenERC20
 * @dev Implementação básica de um token ERC-20 usando OpenZeppelin.
 */
contract MeuTokenERC20 is ERC20, Ownable {
    /**
     * @dev Construtor que define o nome, símbolo e a quantidade inicial.
     * @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 de mint apenas para o proprietário.
     * @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);
    }

    /**
     * @dev Função de burn permite que o proprietário destrua tokens.
     * @param amount Quantidade a ser queimada.
     */
    function burn(uint256 amount) external onlyOwner {
        _burn(msg.sender, amount);
    }
}

Utilizamos a biblioteca OpenZeppelin, amplamente auditada e recomendada para produção.

Compilando o contrato

npx hardhat compile

Se tudo estiver correto, o Hardhat gerará os artefatos JSON na pasta artifacts/.

5. Testando localmente

Escreva testes unitários em test/Token.test.js usando Mocha e Chai. Um exemplo simples:

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

describe("MeuTokenERC20", function () {
  let Token, token, owner, addr1;

  beforeEach(async function () {
    [owner, addr1] = await ethers.getSigners();
    Token = await ethers.getContractFactory("MeuTokenERC20");
    token = await Token.deploy("Meu Token", "MTK", ethers.utils.parseUnits("1000", 18));
    await token.deployed();
  });

  it("Deve atribuir o totalSupply ao proprietário", async function () {
    const ownerBalance = await token.balanceOf(owner.address);
    expect(await token.totalSupply()).to.equal(ownerBalance);
  });

  it("Deve permitir transferir tokens", async function () {
    await token.transfer(addr1.address, ethers.utils.parseUnits("10", 18));
    const addr1Balance = await token.balanceOf(addr1.address);
    expect(addr1Balance).to.equal(ethers.utils.parseUnits("10", 18));
  });
});

Execute os testes:

npx hardhat test

Todos os testes devem passar antes de avançar para a rede de teste.

6. Deploy na testnet (Goerli ou Sepolia)

Escolha uma testnet. Goerli ainda é amplamente suportada, mas Sepolia está ganhando tração. Crie uma conta no Goerli Faucet ou Sepolia Faucet para obter ETH de teste.

Configuração do Hardhat

// hardhat.config.js
require("@nomiclabs/hardhat-ethers");
require("dotenv").config();

module.exports = {
  solidity: "0.8.24",
  networks: {
    goerli: {
      url: process.env.INFURA_GOERLI_URL,
      accounts: [process.env.PRIVATE_KEY]
    },
    sepolia: {
      url: process.env.INFURA_SEPOLIA_URL,
      accounts: [process.env.PRIVATE_KEY]
    }
  }
};

Crie um arquivo .env (não versionado) contendo:

INFURA_GOERLI_URL=https://goerli.infura.io/v3/SEU_PROJETO_ID
INFURA_SEPOLIA_URL=https://sepolia.infura.io/v3/SEU_PROJETO_ID
PRIVATE_KEY=0xSEU_PRIVATE_KEY

Script de deploy

// 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("MeuTokenERC20");
  const token = await Token.deploy(
    "Meu Token",
    "MTK",
    ethers.utils.parseUnits("1000000", 18) // 1 milhão de MTK
  );

  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 na testnet escolhida:

npx hardhat run scripts/deploy.js --network goerli
# ou
npx hardhat run scripts/deploy.js --network sepolia

Copie o endereço do contrato e verifique no Etherscan Goerli ou Sepolia Etherscan.

7. Deploy na mainnet Ethereum

Depois de validar tudo na testnet, você pode publicar na rede principal. Atenção: o custo de gas na mainnet pode variar bastante. Em 20/11/2025, o preço médio de gas está em torno de 30 gwei, o que pode gerar um custo de aproximadamente R$ 150 a R$ 300 para um contrato simples.

Recomenda‑se usar blocknative gas estimator ou a ferramenta da ETH Gas Station para estimar custos.

Proceda da mesma forma do script de deploy, mas altere a rede para mainnet no hardhat.config.js e assegure que sua carteira possui ETH suficiente.

8. Verificando e interagindo com o token

Após o contrato estar na blockchain, você pode:

  • Adicionar o token manualmente na sua carteira MetaMask usando o endereço do contrato.
  • Consultar saldos e transações via Etherscan.
  • Utilizar Uniswap ou outra DEX para criar um par de liquidez.
  • Integrar o token em seu próprio dApp usando a ABI gerada pelo Hardhat.

9. Segurança e auditoria

Mesmo um contrato pequeno pode conter vulnerabilidades. Siga estas boas práticas:

  • Use bibliotecas battle‑tested como OpenZeppelin.
  • Implemente Ownable para restringir funções críticas.
  • Realize testes de fuzzing com foundry ou echidna.
  • Considere contratar uma auditoria externa (por exemplo, CertiK, Quantstamp) se o token for usado em produção.
  • Evite usar selfdestruct ou funções de upgrade sem cuidado.

10. Custos operacionais e tributação no Brasil

Ao criar e distribuir tokens, você pode incorrer em custos de:

  • Taxas de gas (pagas em ETH, convertidas para R$ na hora da transação).
  • Serviços de infraestrutura (Infura/Alchemy – planos gratuitos até certo limite).
  • Auditoria de segurança (variando de R$ 10.000 a R$ 50.000, dependendo da complexidade).

Quanto à tributação, o Receita Federal considera tokens como bens digitais. Ganhos de capital na venda de tokens são tributados em 15 % (até R$ 5 mil mensais) ou 22,5 % acima desse limite, conforme a Instrução Normativa 1.888/2022. Recomenda‑se registrar todas as operações em planilhas ou usar softwares como CryptoTax Brasil.

Conclusão

Desenvolver um token ERC-20 no Brasil hoje é mais acessível que nunca. Com as ferramentas corretas – Hardhat, OpenZeppelin e um pouco de conhecimento em Solidity – você pode criar, testar e publicar seu próprio contrato em poucas horas. No entanto, lembre‑se de validar a segurança, estimar custos de gas e observar a regulamentação fiscal antes de lançar seu token ao público.

Se você ainda tem dúvidas, explore nossos outros artigos como Guia Ethereum para iniciantes e Como funciona Smart Contract. Boa codificação e sucesso na sua jornada cripto!