Funções e Eventos Padrão do Token ERC-721

ERC 721 é um padrão para tokens não fungíveis (NFTs) na blockchain Ethereum. Ao contrário dos tokens ERC 20 tradicionais, que são intercambiáveis ​​e idênticos, cada token ERC 721 é único e não pode ser replicado ou trocado por outro token. Isso os torna úteis para representar ativos digitais exclusivos, como itens colecionáveis, arte digital e outros itens digitais únicos.

Para criar um token ERC 721, primeiro você precisa criar um contrato inteligente na blockchain Ethereum usando uma linguagem de programação, como o Solidity. O padrão ERC 721 define várias funções e eventos necessários que devem ser implementados no contrato para que seja considerado um token ERC 721.

As funções necessárias são:

• name(): Retorna o nome do token.
• symbol(): Retorna o símbolo do token.
• totalSupply(): Retorna o fornecimento total de tokens.
• balanceOf(address _owner): Retorna o número de tokens pertencentes ao endereço fornecido.
• ownerOf(uint256 _tokenId): Retorna o endereço do proprietário do ID do token fornecido.
• approve(address _approved, uint256 _tokenId): Aprova o endereço fornecido para transferir o ID do token fornecido.
• getApproved(uint256 _tokenId): Retorna o endereço aprovado para transferir o ID do token fornecido.
• setApprovalForAll(address _operator, bool _approved): define ou desativa o endereço fornecido como um operador aprovado para o proprietário deste contrato.
• isApprovedForAll(address _owner, address _operator): Retorna um booleano indicando se o operador especificado é aprovado para o proprietário especificado.
• transferFrom(address _from, address _to, uint256 _tokenId): Transfere o ID do token fornecido do endereço fornecido para outro endereço.

Os eventos necessários são:

• Transfer(address indexed _from, address indexed _to, uint256 _tokenId): Emitido quando um token é transferido de um endereço para outro.
• Approval(address indexed _owner, address indexed _approved, uint256 _tokenId): Emitido quando um endereço é aprovado para transferir um token.
• ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved): Emitido quando um operador é aprovado ou não aprovado para um proprietário.

Além das funções e eventos necessários, os contratos ERC 721 também podem implementar funções e eventos opcionais, como:

• mint(...): Cria um novo token e o atribui a um endereço.
• burn(...): Queima (ou seja, destrói) um token.
• Metadata(...): Retorna metadados associados a um token.
• TokenMint(...): Emitido quando um novo token é cunhado.
• TokenBurn(...): Emitido quando um token é queimado.

Aqui está o exemplo simples do ERC-721:

pragma solidity ^0.8.0;

import "https://github.com/OpenZeppelin/openzeppelin-solidity/contracts/token/ERC721/ERC721.sol";

contract MyERC721Token is ERC721 {
   string public name = "Meu Token ERC721";
   string public symbol = "M721";
   uint256 public totalSupply = 100;

   // Mapeamento do ID do token para o endereço do proprietário
   mapping (uint256 => address) private _tokenOwners;

   // Mapeamento do ID do token para o URI de metadados
   mapping (uint256 => string) private _tokenMetadata;

   // Evento para quando um token é transferido
   event Transfer(
       address indexed _from,
       address indexed _to,
       uint256 indexed _tokenId
   );

   // Evento para quando os metadados são atualizados
   event Metadata(
       uint256 indexed _tokenId,
       string _metadata
   );

   constructor() public {
       // Cunha 100 tokens para o proprietário do contrato
       for (uint256 i = 0; i < totalSupply; i++) {
           _mint(msg.sender, i);
       }
   }

   function balanceOf(address _owner) public view returns (uint256) {
       return _balanceOf(_owner);
   }

   function ownerOf(uint256 _tokenId) public view returns (address) {
       return _tokenOwners[_tokenId];
   }

   function safeTransferFrom(
       address _from,
       address _to,
       uint256 _tokenId,
       bytes calldata _data
   ) public {
       // Verifica se o token existe e é de propriedade do remetente
       require(_exists(_tokenId), "Token does not exist");
       require(_tokenOwners[_tokenId] == _from, "Token is not owned by the sender");

       // Transfere o token
       _transfer(_from, _to, _tokenId);
       emit Transfer(_from, _to, _tokenId);
   }

   function setMetadata(
       uint256 _tokenId,
       string calldata _metadata
   ) public {
       // Verifica se o token existe e pertence ao chamador
       require(_exists(_tokenId), "Token does not exist");
       require(msg.sender == _tokenOwners[_tokenId], "Token is not owned by the caller");

       // Atualiza os metadados
       _tokenMetadata[_tokenId] = _metadata;
       emit Metadata(_tokenId, _metadata);
   }

   function tokenMetadata(uint256 _tokenId) public view returns (string) {
       // Retorna os metadados para o ID de token fornecido
       return _tokenMetadata[_tokenId];
   }

   function tokensOfOwner(address _owner) public view returns (uint256[] memory) {
       return _tokensOfOwner(_owner);
   }
}

Uma das principais vantagens dos tokens ERC 721 é que eles podem ser facilmente negociados e transferidos em corretoras descentralizadas (DEXs), permitindo um mercado próspero de ativos digitais exclusivos. Os tokens ERC 721 também são interoperáveis ​​com outros protocolos e aplicativos baseados na Ethereum, como carteiras, mercados e jogos.

Um dos exemplos mais conhecidos de um token ERC 721 é o CryptoKitties, um popular jogo de blockchain que permite aos jogadores coletar e criar gatos digitais únicos.

Artigo escrito por Charan e traduzido por Marcelo Panegali.