Como Criar um NFT

Este tutorial vai te guiar pela escrita e implantação de um smart contract de Token Não Fungível (ERC721) usando Ethereum e Inter Planetary File System (IPFS).

Tempo estimado para concluir este guia: ~15 minutos

Mesmo se você estivesse vivendo debaixo de uma pedra, teria notado que todo grande veículo de notícias vem cobrindo a ascensão dos NFTs.

Com os NFTs trazendo blockchain para o público em geral, agora é uma excelente oportunidade de entender o hype por conta própria publicando seu próprio NFT (Token ERC-721) na blockchain Ethereum!

Neste tutorial, vamos passar pela criação e implantação de um smart contract ERC-721 na rede de teste Sepolia usando Metamask, Solidity, Hardhat, Pinata e Alchemy (não se preocupe se ainda não entender o que tudo isso significa; vamos explicar). Na Parte II deste tutorial, veremos como podemos usar nosso smart contract para criar um NFT, e na Parte III vamos cobrir como visualizar seu NFT no Metamask.

E claro, se tiver dúvidas a qualquer momento, visite a central de suporte da Alchemy!

Passo 1: conecte-se à rede Ethereum

Existem várias formas de fazer requisições para a blockchain Ethereum, mas para facilitar as coisas, vamos usar uma conta gratuita na Alchemy, uma plataforma de desenvolvimento blockchain e API que nos permite comunicar com a chain Ethereum sem precisar rodar nossos próprios nós.

Neste tutorial, também vamos aproveitar as ferramentas de desenvolvedor da Alchemy para monitoramento e análise, para entender o que está acontecendo por trás dos panos na implantação do nosso smart contract. Se você ainda não tem uma conta Alchemy, pode se cadastrar gratuitamente aqui.

Passo 2: crie seu app (e API key)

Depois de criar uma conta Alchemy, você pode gerar uma API key criando um app. Isso vai nos permitir fazer requisições para a rede de teste Sepolia. Confira este guia se tiver curiosidade em aprender mais sobre redes de teste.

1. Navegue até a página "Create App" no seu Alchemy Dashboard passando o mouse sobre "Apps" na barra de navegação e clicando em "Create App"

2. Dê um nome ao seu app (escolhemos "My First NFT!"), ofereça uma breve descrição, selecione "Staging" para o Environment (usado para organização do seu app), e escolha "Sepolia" para sua rede.

3. Clique em "Create app" e pronto! Seu app deve aparecer na tabela abaixo.

Passo 3: crie uma conta Ethereum (endereço)

Precisamos de uma conta Ethereum para enviar e receber transações. Para este tutorial, vamos usar o Metamask, uma carteira virtual no navegador usada para gerenciar o endereço da sua conta Ethereum. Se quiser entender melhor como funcionam as transações no Ethereum, confira esta página da Ethereum foundation.

Você pode baixar e criar uma conta Metamask gratuitamente aqui. Ao criar uma conta, ou se já tiver uma, certifique-se de mudar para a rede de teste Sepolia (para não lidarmos com dinheiro de verdade).

Passo 4: adicione ether de um faucet

Para implantar nosso smart contract na rede de teste, vamos precisar de algum Eth falso. Para obter Eth, você pode ir ao faucet da Sepolia, inserir o endereço da sua conta Sepolia e solicitar Sepolia Eth. Você deve ver Eth na sua conta Metamask logo em seguida!

Passo 5: verifique seu saldo

Para conferir se nosso saldo está lá, vamos fazer uma requisição eth_getBalance usando a ferramenta de composição da Alchemy. Isso vai retornar a quantidade de Eth na nossa carteira. Depois de inserir o endereço da sua conta Metamask e clicar em "Send Request", você deve ver uma resposta como esta:

{"jsonrpc": "2.0", "id": 0, "result": "0xde0b6b3a7640000"}

NOTA: Esse resultado está em wei, não em eth. Wei é usado como a menor denominação de ether. A conversão de wei para eth é: 1 eth = 10¹⁸ wei. Então, se convertermos 0xde0b6b3a7640000 para decimal, obtemos 110¹⁸ que equivale a 1 eth.

Ufa! Nosso dinheiro falso está todo lá! 🤑

Passo 6: inicialize nosso projeto

Primeiro, vamos precisar criar uma pasta para nosso projeto. Navegue até sua linha de comando e digite:

Agora que estamos dentro da nossa pasta de projeto, vamos usar npm init para inicializar o projeto. Se ainda não tiver o npm instalado, siga estas instruções (também vamos precisar do Node.js, então baixe isso também!).

Não importa muito como você responde às perguntas de instalação, aqui está como fizemos, como referência:

Aprove o package.json, e estamos prontos!

Passo 7: Baixe o Hardhat

Hardhat é um ambiente de desenvolvimento para compilar, implantar, testar e depurar seu software Ethereum. Ele ajuda desenvolvedores na construção de smart contracts e apps localmente antes de implantar na chain ativa.

Navegue até o terminal e certifique-se de estar dentro da pasta de projeto my-nft, então execute:

Confira esta página para mais detalhes sobre as instruções de instalação.

Passo 8: crie o projeto Hardhat

Dentro da nossa pasta de projeto, execute:

Você deve então ver uma mensagem de boas-vindas e a opção de selecionar o que deseja fazer. Selecione "create an empty hardhat.config.js":

Isso vai gerar um arquivo hardhat.config.js para nós, que é onde vamos especificar toda a configuração do nosso projeto (no passo 13).

Passo 9: adicione pastas do projeto

Para manter nosso projeto organizado, vamos criar duas novas pastas. Navegue até o diretório raiz do seu projeto na sua linha de comando e digite:

contracts/ é onde vamos manter o código do nosso smart contract NFT

scripts/ é onde vamos manter os scripts para implantar e interagir com nosso smart contract

Passo 10: escreva nosso contrato

Agora que nosso ambiente está configurado, vamos para algo mais empolgante: escrever o código do nosso smart contract!

Abra o projeto my-nft no seu editor favorito (gostamos do VSCode). Smart contracts são escritos em uma linguagem chamada Solidity, que é o que vamos usar para escrever nosso smart contract MyNFT.sol.‌

1. Navegue até a pasta "contracts" e crie um novo arquivo chamado MyNFT.sol

2. Abaixo está o código do nosso smart contract NFT, baseado na implementação ERC721 da biblioteca OpenZeppelin. Copie e cole o conteúdo abaixo no seu arquivo MyNFT.sol.

1. Como estamos herdando classes da biblioteca de contratos OpenZepplin, na sua linha de comando execute o seguinte para instalar a biblioteca na nossa pasta:

textnpm install @openzeppelin/contracts@3.1.0-solc-0.7

Então, o que exatamente esse código faz? Vamos analisar, linha por linha.

Nas linhas 5-7, nosso código herda três classes de smart contract da OpenZepplin:

• @openzeppelin/contracts/token/ERC721/ERC721.sol contém a implementação do padrão ERC721, que nosso smart contract NFT vai herdar. (Para ser um NFT válido, seu smart contract precisa implementar todos os métodos do padrão ERC721.) Para saber mais sobre as funções ERC721 herdadas, confira a definição de interface aqui.

• @openzeppelin/contracts/utils/Counters.sol fornece contadores que só podem ser incrementados ou decrementados de um em um. Nosso smart contract usa um contador para acompanhar o número total de NFTs criados e definir o ID único do nosso novo NFT. Cada NFT criado usando um smart contract precisa ter um ID único atribuído — aqui, nosso ID único é simplesmente determinado pelo número total de NFTs em existência. Por exemplo, o primeiro NFT que criamos com nosso smart contract tem ID "1", o segundo NFT tem ID "2", etc.

• @openzeppelin/contracts/access/Ownable.sol configura o controle de acesso no nosso smart contract, de modo que apenas o dono do smart contract (você) possa criar NFTs. Observe que incluir controle de acesso é totalmente uma questão de preferência. Se quiser que qualquer pessoa possa criar um NFT usando seu smart contract, remova a palavra Ownable na linha 10 e onlyOwner na linha 17.

Nas linhas 10-28, temos nosso smart contract NFT personalizado, que é surpreendentemente curto — contém apenas um contador, um construtor e uma única função! Isso graças aos contratos OpenZepplin herdados, que implementam a maioria dos métodos que precisamos para criar um NFT, como ownerOf (retorna o dono do NFT) e transferFrom (transfere a propriedade do NFT).

Na linha 14, você vai notar que passamos 2 strings, "MyNFT" e "NFT", para o construtor ERC721. A primeira variável é o nome do smart contract, e a segunda é seu símbolo. Você pode nomear cada uma dessas variáveis como quiser!

Por fim, a partir da linha 16, temos nossa função mintNFT() que nos permite criar um NFT! Você vai notar que essa função recebe duas variáveis:

• address recipient especifica o endereço que vai receber seu NFT recém-criado

• string memory tokenURI é uma string que deve resolver para um documento JSON que descreve os metadados do NFT. Os metadados de um NFT são o que realmente o trazem à vida, permitindo que ele tenha propriedades adicionais, como nome, descrição, imagem e outros atributos. Na parte 2 deste tutorial, vamos descrever como configurar esses metadados.

mintNFT chama alguns métodos da biblioteca ERC721 herdada, e por fim retorna um número que representa o ID do NFT recém-criado.

Passo 11: conecte o MetaMask e a Alchemy ao seu projeto

Agora que criamos uma carteira Metamask, uma conta Alchemy e escrevemos nosso smart contract, é hora de conectar os três.

Toda transação enviada da sua carteira virtual requer uma assinatura usando sua chave privada exclusiva. Para fornecer essa permissão ao nosso programa, podemos armazenar com segurança nossa chave privada (e a API key da Alchemy) em um arquivo de ambiente.

Para saber mais sobre o envio de transações, confira este tutorial sobre envio de transações usando web3.

Primeiro, instale o pacote dotenv no diretório do seu projeto:

Depois, crie um arquivo .env no diretório raiz do nosso projeto, e adicione sua chave privada do Metamask e a URL HTTP da API Alchemy a ele.

NOTA: Seu arquivo .env precisa se chamar .env! Não mude o nome para xx.env

• Siga estas instruções para exportar sua chave privada do Metamask

• Veja abaixo como obter a URL HTTP da API Alchemy e copiá-la para a área de transferência

Seu .env deve ficar assim:

Passo 12: instale o Ethers.js

Ethers.js é uma biblioteca que facilita a interação e o envio de requisições ao Ethereum, encapsulando métodos JSON-RPC padrão com métodos mais amigáveis ao usuário.

O Hardhat torna muito fácil integrar Plugins para ferramentas adicionais e funcionalidade estendida. Vamos aproveitar o plugin Ethers para implantação de contratos (Ethers.js tem métodos de implantação de contrato bem práticos).

No diretório do seu projeto, digite:

Também vamos precisar do ethers no nosso hardhat.config.js no próximo passo.

Passo 13: atualize o hardhat.config.js

Adicionamos várias dependências e plugins até agora, agora precisamos atualizar o hardhat.config.js para que nosso projeto saiba sobre todos eles.

Atualize seu hardhat.config.js para ficar assim:

Passo 14: compile nosso contrato

Para garantir que tudo está funcionando até aqui, vamos compilar nosso contrato. A tarefa compile é uma das tarefas integradas do hardhat.

Na linha de comando, execute:

Você pode receber um aviso sobre SPDX license identifier not provided in source file, mas não precisa se preocupar com isso — esperamos que tudo o mais esteja bem! Caso contrário, você pode abrir um ticket de suporte pelo Alchemy Dashboard.

Passo 15: escreva nosso script de implantação

Agora que nosso contrato está escrito e nosso arquivo de configuração está pronto, é hora de escrever o script de implantação do nosso contrato.

Navegue até a pasta scripts/ e crie um novo arquivo chamado deploy.js, adicionando o seguinte conteúdo a ele:

O Hardhat faz um trabalho incrível explicando o que cada uma dessas linhas de código faz no seu tutorial de Contracts, adotamos as explicações deles aqui.

Um ContractFactory em ethers.js é uma abstração usada para implantar novos smart contracts, então MyNFT aqui é uma factory para instâncias do nosso contrato NFT. Ao usar o plugin hardhat-ethers, as instâncias de ContractFactory e Contract são conectadas ao primeiro signer por padrão.

Chamar deploy() em um ContractFactory vai iniciar a implantação, e retornar uma Promise que se resolve em um Contract. Este é o objeto que tem um método para cada uma das funções do nosso smart contract.

Passo 16: implante nosso contrato

Finalmente estamos prontos para implantar nosso smart contract! Navegue de volta para a raiz do diretório do seu projeto, e na linha de comando execute:

Você deve então ver algo como:

Se formos ao Sepolia Etherscan e procurarmos pelo endereço do nosso contrato, devemos conseguir ver que ele foi implantado com sucesso. A transação vai se parecer com algo assim:

O endereço From deve corresponder ao endereço da sua conta Metamask e o endereço To vai dizer "Contract Creation." Se clicarmos na transação, veremos o endereço do nosso contrato no campo To:

Para entender o que está acontecendo por trás dos panos, vamos navegar até a aba Explorer no nosso Alchemy dashboard . Se tiver vários apps Alchemy, certifique-se de filtrar por app e selecionar "MyNFT".

Aqui você verá algumas chamadas JSON-RPC que o Hardhat/Ethers fez por trás dos panos para nós quando chamamos a função .deploy().

Duas importantes para destacar aqui são eth_sendRawTransaction, que é a requisição para de fato escrever nosso smart contract na chain Sepolia, e eth_getTransactionByHash, que é uma requisição para ler informações sobre nossa transação dado o hash (um padrão típico ao enviar transações).

Para saber mais sobre o envio de transações, confira este tutorial sobre envio de transações usando Web3.

Isso é tudo para a Parte I deste tutorial. Na Parte II, vamos de fato interagir com nosso smart contract criando um NFT, e na Parte III vamos explicar como visualizar seu NFT no Metamask! 🤑