Lição 248: Entendendo EIP-20, EIP-721, EIP-1155
No mundo do Ethereum, diversos padrões foram estabelecidos para criar e gerenciar tokens na blockchain. Três dos padrões mais proeminentes são EIP-20, EIP-721 e EIP-1155. Esta lição fornecerá uma visão geral de cada padrão, seu propósito e como implementá-lo em Solidity.
EIP-20: Padrão de Token ERC-20
O padrão EIP-20, comumente referido como o padrão ERC-20, define um conjunto de regras para a criação de tokens fungíveis na blockchain do Ethereum. Tokens fungíveis são intercambiáveis e têm o mesmo valor; por exemplo, um token ERC-20 tem o mesmo valor que outro do mesmo tipo.
Funções Básicas do ERC-20
As principais funções de um token ERC-20 incluem:
transfer: Permite a transferência de tokens do remetente para outro endereço.approve: Permite que um gastador retire tokens da conta do proprietário.transferFrom: Transfere tokens de um endereço para outro em nome do proprietário.
Exemplo de Implementação de um Token ERC-20
Aqui está uma implementação simples de um token ERC-20:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract MeuToken {
string public nome = "MeuToken";
string public simbolo = "MTK";
uint8 public decimals = 18;
uint256 public suprimentoTotal = 1000000 * (10 ** uint256(decimals));
mapping(address => uint256) public saldoDe;
mapping(address => mapping(address => uint256)) public autorização;
constructor() {
saldoDe[msg.sender] = suprimentoTotal;
}
function transfer(address _para, uint256 _valor) public returns (bool sucesso) {
require(saldoDe[msg.sender] >= _valor, "Saldo insuficiente.");
saldoDe[msg.sender] -= _valor;
saldoDe[_para] += _valor;
emit Transfer(msg.sender, _para, _valor);
return true;
}
function approve(address _gasteiro, uint256 _valor) public returns (bool sucesso) {
autorização[msg.sender][_gasteiro] = _valor;
emit Approval(msg.sender, _gasteiro, _valor);
return true;
}
function transferFrom(address _de, address _para, uint256 _valor) public returns (bool sucesso) {
require(saldoDe[_de] >= _valor, "Saldo insuficiente.");
require(autorização[_de][msg.sender] >= _valor, "Autorização excedida.");
saldoDe[_de] -= _valor;
saldoDe[_para] += _valor;
autorização[_de][msg.sender] -= _valor;
emit Transfer(_de, _para, _valor);
return true;
}
event Transfer(address indexed _de, address indexed _para, uint256 _valor);
event Approval(address indexed _proprietário, address indexed _gasteiro, uint256 _valor);
}EIP-721: Padrão de Token ERC-721
O padrão ERC-721 define um protocolo para tokens não-fungíveis (NFTs). Ao contrário dos tokens fungíveis, os NFTs são únicos e não podem ser trocados um a um. Este padrão é amplamente utilizado para colecionáveis digitais, obras de arte e outros itens onde a singularidade é importante.
Funções Principais do ERC-721
As funções principais que costumam ser encontradas em um contrato ERC-721 incluem:
ownerOf: Retorna o proprietário de um token específico.transferFrom: Transfere um token de um endereço para outro.approve: Concede permissão a outro endereço para transferir um token.
Exemplo de Implementação de um Token ERC-721
Abaixo está uma implementação básica de um token ERC-721:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract MeuNFT {
string public nome = "MeuNFT";
string public simbolo = "MNFT";
mapping(uint256 => address) private _proprietarios;
mapping(address => uint256) private _saldos;
uint256 private _proximoIdToken;
function criar() public {
uint256 idToken = _proximoIdToken++;
_proprietarios[idToken] = msg.sender;
_saldos[msg.sender] += 1;
emit Transfer(address(0), msg.sender, idToken);
}
function ownerOf(uint256 idToken) public view returns (address) {
require(_proprietarios[idToken] != address(0), "Token não existe.");
return _proprietarios[idToken];
}
function transferFrom(address de, address para, uint256 idToken) public {
require(_proprietarios[idToken] == de, "Você não possui este token.");
require(para != address(0), "Não pode transferir para o endereço zero.");
_proprietarios[idToken] = para;
_saldos[de] -= 1;
_saldos[para] += 1;
emit Transfer(de, para, idToken);
}
event Transfer(address indexed de, address indexed para, uint256 indexed idToken);
}EIP-1155: Padrão de Token ERC-1155
O padrão ERC-1155 foi projetado para criar uma forma mais flexível e eficiente de gerenciar tokens fungíveis e não-fungíveis dentro de um único contrato. Isso permite a criação de ambientes complexos de jogos e ativos digitais.
Principais Recursos do ERC-1155
Os principais recursos do ERC-1155 incluem:
- Transferências em lote de tokens para otimizar o uso de gás.
- Suporte para tanto tokens fungíveis quanto não-fungíveis.
- IDs únicos para cada tipo de token.
Exemplo de Implementação de um Token ERC-1155
Aqui está um exemplo simples de uma implementação ERC-1155:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract MeuMultiToken {
mapping(uint256 => mapping(address => uint256)) public saldos;
function criar(uint256 id, uint256 quantidade) public {
saldos[id][msg.sender] += quantidade;
}
function transfer(address para, uint256 id, uint256 quantidade) public {
require(saldos[id][msg.sender] >= quantidade, "Saldo insuficiente.");
saldos[id][msg.sender] -= quantidade;
saldos[id][para] += quantidade;
}
function saldoOf(address proprietário, uint256 id) public view returns (uint256) {
return saldos[id][proprietário];
}
}Conclusão
Em conclusão, entender EIP-20, EIP-721 e EIP-1155 é crucial para qualquer desenvolvedor de Solidity interessado no ecossistema Ethereum. Cada padrão serve a um propósito único: EIP-20 para tokens fungíveis, EIP-721 para tokens não-fungíveis e EIP-1155 para uma abordagem mais versátil na gestão de tokens. Ao aproveitar esses padrões, os desenvolvedores podem criar contratos de tokens robustos e eficientes adaptados às suas necessidades específicas.