M

MLOG

Português

Explore as complexidades dos contratos inteligentes ERC-721 para NFTs. Aprenda sobre sua arquitetura, implementação, considerações de segurança e aplicações no mundo real.

Contratos Inteligentes de NFT: Um Mergulho Profundo na Implementação do ERC-721

Os Tokens Não Fungíveis (NFTs) revolucionaram o cenário dos ativos digitais, permitindo a representação de itens únicos na blockchain. No cerne da maioria dos NFTs está o padrão ERC-721, um conjunto de regras que governam como esses tokens são criados, gerenciados e transferidos. Este guia abrangente oferece uma exploração aprofundada dos contratos inteligentes ERC-721, cobrindo sua arquitetura, detalhes de implementação, considerações de segurança e aplicações práticas.

O que é o ERC-721?

O ERC-721 é um padrão para representar tokens não fungíveis na blockchain Ethereum. Diferente dos tokens ERC-20, que são fungíveis (o que significa que cada token é idêntico a qualquer outro), os tokens ERC-721 são únicos. Cada token possui um ID distinto, tornando-o adequado para representar a propriedade de ativos digitais ou físicos únicos.

Principais Características dos Tokens ERC-721:

Arquitetura de Contratos Inteligentes ERC-721

Um contrato inteligente ERC-721 é um programa em Solidity que implementa o padrão ERC-721. Ele geralmente inclui os seguintes componentes:

Funções Principais:

Extensão de Metadados (Opcional):

Extensão de Enumeração (Opcional):

Implementando um Contrato Inteligente ERC-721 com OpenZeppelin

O OpenZeppelin fornece uma biblioteca segura e auditada de contratos inteligentes que simplifica o desenvolvimento de tokens ERC-721. Usar a implementação ERC721 do OpenZeppelin reduz o risco de introduzir vulnerabilidades em seu código. Aqui está um exemplo de como implementar um contrato inteligente ERC-721 usando o OpenZeppelin:

Pré-requisitos:

Passos:

  1. Inicialize um projeto Truffle ou Hardhat:
# Truffle
mkdir meu-projeto-nft
cd meu-projeto-nft
truffle init

# Hardhat
mkdir meu-projeto-nft
cd meu-projeto-nft
npx hardhat
  1. Instale os Contratos OpenZeppelin:
npm install @openzeppelin/contracts
  1. Crie um Contrato Inteligente ERC-721: Crie um novo arquivo Solidity (por exemplo, `MeuNFT.sol`) em seu diretório `contracts`.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

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

contract MyNFT is ERC721 {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;

    string private _baseURI;

    constructor(string memory name, string memory symbol, string memory baseURI) ERC721(name, symbol) {
        _baseURI = baseURI;
    }

    function mintNFT(address recipient) public returns (uint256) {
        _tokenIds.increment();

        uint256 newItemId = _tokenIds.current();
        _mint(recipient, newItemId);
        _setTokenURI(newItemId, string(abi.encodePacked(_baseURI, Strings.toString(newItemId), ".json")));

        return newItemId;
    }

    function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
        require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
        _tokenURIs[tokenId] = _tokenURI;
    }

    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        string memory _tokenURI = _tokenURIs[tokenId];
        return string(abi.encodePacked(_tokenURI));
    }

    mapping (uint256 => string) private _tokenURIs;

    function setBaseURI(string memory baseURI) public {
        _baseURI = baseURI;
    }



    // As funções a seguir são substituições exigidas pelo Solidity.

    function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721) {
        super._beforeTokenTransfer(from, to, tokenId);
    }
}

import "@openzeppelin/contracts/utils/Strings.sol";
  1. Compile o Contrato Inteligente: Use o Truffle ou o Hardhat para compilar seu contrato inteligente.
# Truffle
truffle compile

# Hardhat
npx hardhat compile
  1. Crie um Script de Implantação: Crie um novo arquivo JavaScript (por exemplo, `deploy.js`) em seu diretório `migrations` ou `scripts`.
// Exemplo de Migração com Truffle
const MyNFT = artifacts.require("MyNFT");

module.exports = async function (deployer) {
  await deployer.deploy(MyNFT, "MyNFT", "MNFT", "ipfs://SEU_CID_IPFS/");
};

// Exemplo de Script de Implantação com Hardhat
async function main() {
  const MyNFT = await ethers.getContractFactory("MyNFT");
  const myNFT = await MyNFT.deploy("MyNFT", "MNFT", "ipfs://SEU_CID_IPFS/");

  await myNFT.deployed();

  console.log("MyNFT implantado em:", myNFT.address);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });
  1. Implante o Contrato Inteligente: Implante seu contrato inteligente em uma blockchain local (por exemplo, Ganache) ou em uma rede de teste (por exemplo, Ropsten, Rinkeby).
# Truffle
truffle migrate

# Hardhat
npx hardhat run scripts/deploy.js --network localhost

Lembre-se de substituir `ipfs://SEU_CID_IPFS/` pelo seu CID (Content Identifier) real do IPFS. Esta URI base aponta para o local onde seus arquivos JSON de metadados de NFT serão armazenados.

Armazenando Metadados de NFT no IPFS

Os metadados de NFT são tipicamente armazenados fora da cadeia (off-chain) para reduzir o custo de armazenamento de dados na blockchain. O IPFS (InterPlanetary File System) é uma rede de armazenamento descentralizada que é comumente usada para armazenar metadados de NFT. Cada NFT tem uma `tokenURI` que aponta para um arquivo JSON no IPFS contendo metadados sobre o NFT, como seu nome, descrição, URL da imagem e outros atributos.

Exemplo de Metadados de NFT (JSON):

{
  "name": "Meu NFT Incrível",
  "description": "Este é um NFT único.",
  "image": "ipfs://SEU_CID_IPFS/image.png",
  "attributes": [
    {
      "trait_type": "Fundo",
      "value": "Azul"
    },
    {
      "trait_type": "Personagem",
      "value": "Robô"
    }
  ]
}

Substitua `ipfs://SEU_CID_IPFS/image.png` pelo CID real do IPFS da sua imagem.

Passos para Enviar Metadados para o IPFS:

  1. Escolha um Cliente IPFS: Selecione um cliente IPFS como IPFS Desktop, Pinata ou NFT.Storage.
  2. Envie seus Metadados: Envie seus arquivos JSON de metadados de NFT e imagens para o IPFS usando o cliente escolhido.
  3. Obtenha o CID do IPFS: Após enviar seus metadados, você receberá um CID do IPFS. Este é um identificador único para seus dados no IPFS.
  4. Atualize o Contrato Inteligente: Atualize a função `tokenURI` em seu contrato inteligente para apontar para o seu CID do IPFS.

Considerações de Segurança para Contratos Inteligentes ERC-721

A segurança é primordial ao desenvolver contratos inteligentes ERC-721. Aqui estão algumas considerações críticas de segurança:

Aplicações no Mundo Real de NFTs ERC-721

Os NFTs ERC-721 são usados em uma ampla gama de aplicações, incluindo:

Exemplos Internacionais:

Conceitos Avançados de ERC-721

ERC-721A

O ERC-721A é uma implementação mais eficiente em termos de gás do padrão ERC-721 que otimiza a cunhagem de múltiplos NFTs em uma única transação. Ele reduz os custos de gás ao amortizar os custos de armazenamento entre vários tokens. Isso pode ser benéfico para projetos que envolvem a cunhagem de um grande número de NFTs.

Lazy Minting (Cunhagem Preguiçosa)

A cunhagem preguiçosa (lazy minting) é uma técnica onde os NFTs são cunhados apenas quando são comprados. Isso pode economizar custos de gás para projetos que têm um grande número de NFTs, mas não esperam que todos sejam vendidos. Os metadados do NFT são armazenados fora da cadeia até que o NFT seja comprado, momento em que o token é cunhado e os metadados são adicionados à blockchain.

Tokens Soulbound

Os tokens Soulbound (vinculados à alma) são NFTs que estão permanentemente ligados a um endereço específico e não podem ser transferidos. Esses tokens podem ser usados para representar credenciais não transferíveis, como diplomas educacionais, certificações profissionais ou participação em uma comunidade. Isso é possível removendo ou restringindo a função `transferFrom`.

O Futuro do ERC-721 e dos NFTs

O padrão ERC-721 continua a evoluir, com pesquisas e desenvolvimento contínuos focados em melhorar sua eficiência, segurança e funcionalidade. Desenvolvimentos futuros podem incluir:

Conclusão

Os contratos inteligentes ERC-721 são uma ferramenta poderosa para representar a propriedade de ativos digitais e físicos únicos na blockchain. Ao entender a arquitetura, os detalhes de implementação, as considerações de segurança e as aplicações práticas do ERC-721, os desenvolvedores podem construir projetos de NFT inovadores e impactantes. À medida que o ecossistema de NFTs continua a crescer e evoluir, o padrão ERC-721 desempenhará um papel fundamental na formação do futuro da propriedade digital.

Este guia fornece uma base sólida para entender e implementar contratos inteligentes ERC-721. Lembre-se de sempre priorizar a segurança e seguir as melhores práticas ao desenvolver e implantar seus próprios projetos de NFT. Boa sorte!