23.11.2024

Lição 119: Tokens Não Fungíveis ERC721

Nesta lição, vamos explorar os tokens ERC721, que são um padrão para Tokens Não Fungíveis (NFTs) na blockchain Ethereum. Os tokens não fungíveis são únicos e não podem ser substituídos por outros. Cada NFT possui propriedades e valores distintos, tornando-os ideais para representar a propriedade de arte digital, colecionáveis, jogos e outros itens únicos.

O que é ERC721?

O padrão ERC721 define um conjunto de regras que cada contrato de NFT deve seguir. Isso inclui como transferir tokens, como verificar propriedade e como recuperar metadados. As principais características dos tokens ERC721 são:

1. Unicidade: Cada token possui um identificador único (ID do token).
2. Propriedade: Apenas um endereço pode possuir um token específico em um dado momento.
3. Transferibilidade: Os tokens podem ser transferidos de um proprietário para outro.

Implementação Básica do ERC721

Para criar um token ERC721, você normalmente usará a biblioteca OpenZeppelin, que fornece uma implementação robusta dos padrões ERC. Abaixo, um exemplo simples de um contrato de token ERC721.

Configurando o Ambiente

Primeiro, certifique-se de que você tem o Node.js e o npm instalados. Em seguida, você pode criar um novo projeto e instalar a biblioteca OpenZeppelin:

mkdir MeuNFT
cd MeuNFT
npm init -y
npm install @openzeppelin/contracts

Escrevendo o Contrato

Crie um novo arquivo chamado MeuNFT.sol e adicione o seguinte código:

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract MeuNFT is ERC721, Ownable {
    using Counters for Counters.Counter;
    Counters.Counter private _contadorTokenId;

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

    constructor() ERC721("MeuNFT", "MNFT") {}

    // Criar um novo NFT
    function mint(string memory tokenURI) public onlyOwner {
        uint256 tokenId = _contadorTokenId.current();
        _contadorTokenId.increment();
        _mint(msg.sender, tokenId);
        _setTokenURI(tokenId, tokenURI);
    }

    // Definir o URI do token
    function _setTokenURI(uint256 tokenId, string memory tokenURI) internal {
        _tokenURIs[tokenId] = tokenURI;
    }

    // Recuperar o URI do token
    function tokenURI(uint256 tokenId) public view override returns (string memory) {
        require(_exists(tokenId), "Consulta de URI para token inexistente");
        return _tokenURIs[tokenId];
    }
}

Explicação do Código

1. Importações: Importamos contratos necessários da biblioteca OpenZeppelin: ERC721 para a funcionalidade básica de NFT, Counters para gerenciar os IDs dos tokens e Ownable para restringir certas ações ao proprietário do contrato.

2. Variáveis de Estado:

   • _contadorTokenId: Um contador para acompanhar os IDs dos tokens criados.
   • _tokenURIs: Um mapeamento para armazenar os URIs de metadados para cada token.

3. Construtor: Inicializa o NFT com um nome (“MeuNFT”) e um símbolo (“MNFT”).

4. Função mint: Esta função permite ao proprietário do contrato criar novos tokens. Ela gera um novo ID de token, cria o token para o endereço do proprietário e define seu URI.

5. _setTokenURI: Uma função interna para definir o URI do token para um ID específico de token.

6. Sobrescrição do tokenURI: Esta função retorna o URI para o ID de token especificado, se ele existir.

Implantando o Contrato

Você pode implantar este contrato usando ferramentas como Hardhat ou Truffle. Abaixo, um exemplo usando Hardhat.

1. Inicializar o Hardhat:

npm install --save-dev hardhat
npx hardhat

2. Criar um Script de Implantação no diretório scripts chamado deploy.js:

async function main() {
    const MeuNFT = await ethers.getContractFactory("MeuNFT");
    const meuNFT = await MeuNFT.deploy();

    await meuNFT.deployed();
    console.log("MeuNFT implantado em:", meuNFT.address);
}

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

3. Executar o Script de Implantação:

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

Substitua sua_rede pela rede na qual você está implantando (por exemplo, Rinkeby, Mainnet, etc.).

Conclusão

Nesta lição, cobrimos os fundamentos dos tokens ERC721 e como implementar um contrato NFT simples usando a biblioteca OpenZeppelin. Você pode expandir este contrato com funcionalidades adicionais, como mecanismos de leilão, royalties ou manipulação avançada de metadados à medida que se familiariza mais com o desenvolvimento de contratos inteligentes. Boa codificação!

Video

Navigation