---
title: "Como Criar um NFT"
description: "Guia passo a passo para criar e fazer o deploy do seu próprio NFT na blockchain Ethereum usando Metamask, Solidity, Hardhat, Pinata e Alchemy."
---

# 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](https://metamask.io/), [Solidity](https://docs.soliditylang.org/en/v0.8.0/), [Hardhat](https://hardhat.org/), [Pinata](https://pinata.cloud/) e [Alchemy](https://alchemy.com/?r=affiliate:68212b46-a5c5-4f4c-bc8b-73f50536fcaf) \(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](/blog/how-to-mint-an-nft-using-web3-js), e na Parte III vamos cobrir como [visualizar seu NFT no Metamask](/blog/how-to-view-your-nft-in-your-mobile-wallet).

E claro, se tiver dúvidas a qualquer momento, visite a [central de suporte da Alchemy](https://www.alchemy.com/support)!

## 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](https://alchemy.com/?r=affiliate:68212b46-a5c5-4f4c-bc8b-73f50536fcaf), 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](https://alchemy.com/?r=affiliate:68212b46-a5c5-4f4c-bc8b-73f50536fcaf).

## 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](https://www.alchemy.com/docs/choosing-a-web3-network) 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"

<ImageBlock
  src="https://media.alchemy.com/1704631152-create-a-new-app.jpg"
  alt="Dashboard da Alchemy: criando um novo app no menu Apps"
  width={2880}
  height={1640}
  caption="Criar um novo 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.

<ImageBlock
  src="https://media.alchemy.com/1704802198-name-your-app.png"
  alt="Tela antiga de criação de app do dashboard da Alchemy com seletor de rede de teste"
  width={1518}
  height={912}
  caption="Dê um nome e uma descrição ao seu app"
/>

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](https://ethereum.org/en/developers/docs/transactions/) da Ethereum foundation.

Você pode baixar e criar uma conta Metamask gratuitamente [aqui](https://metamask.io/download.html). 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\).

<ImageBlock
  src="https://media.alchemy.com/1704802303-download-and-create-a-metamask-account.png"
  alt="Tela antiga de configuração da carteira MetaMask com o seletor de rede de teste"
  width={712}
  height={1194}
  caption="Baixe e crie uma conta na Metamask"
/>

## 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](/faucets/ethereum-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](https://www.alchemy.com/composer/?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D). 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](https://www.computerhope.com/jargon/c/commandi.htm) 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](https://nodejs.org/en/download/) \(também vamos precisar do [Node.js](https://nodejs.org/en/download/), 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](https://hardhat.org/getting-started/#overview)

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](https://www.alchemy.com/dapps/top/defi-dapps) 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](https://hardhat.org/getting-started/#overview).

## 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](https://code.visualstudio.com)\). Smart contracts são escritos em uma linguagem chamada [Solidity](https://www.alchemy.com/overviews/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](https://docs.openzeppelin.com/contracts/3.x/erc721). Copie e cole o conteúdo abaixo no seu arquivo MyNFT.sol.

<CalloutBlock>

NOTA: Se quiser anexar um preço ao NFT através do smart contract, confira [este tutorial](https://www.alchemy.com/docs/reference/nft-api-endpoints).

</CalloutBlock>

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](https://openzeppelin.com):

- @[openzeppelin](https://www.alchemy.com/dapps/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](https://eips.ethereum.org/EIPS/eip-721).

- @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](https://docs.openzeppelin.com/contracts/3.x/access-control) 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](https://docs.alchemy.com/docs/how-to-send-transactions-on-ethereum) 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](https://metamask.zendesk.com/hc/en-us/articles/360015289632-How-to-Export-an-Account-Private-Key) 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

<ImageBlock
  src="https://media.alchemy.com/1704631290-copy-your-alchemy-api-key.gif"
  alt="Dashboard da Alchemy: copiando a URL da API HTTP do app para o arquivo .env"
  width={843}
  height={480}
  caption="Copie sua chave de API da Alchemy"
/>

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](https://www.alchemy.com/docs) com métodos mais amigáveis ao usuário.

O Hardhat torna muito fácil integrar [Plugins](https://hardhat.org/plugins/) para ferramentas adicionais e funcionalidade estendida. Vamos aproveitar o [plugin Ethers](https://hardhat.org/plugins/nomiclabs-hardhat-ethers.html) para implantação de contratos \([Ethers.js](https://github.com/ethers-io/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](https://hardhat.org/tutorial/testing-contracts.html#writing-tests), adotamos as explicações deles aqui.

Um **ContractFactory** em [ethers.js](https://www.alchemy.com/dapps/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](https://sepolia.etherscan.io) 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:

<ImageBlock
  src="https://media.alchemy.com/1704803201-ropsten-etherscan.png"
  alt="Visualização de transação no Etherscan confirmando que o smart contract do NFT foi implantado com sucesso"
  width={2880}
  height={1646}
  caption="Endereço implantado com sucesso"
/>

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**:

<ImageBlock
  src="https://media.alchemy.com/1704803309-nft-deployed-successfully.png"
  alt="Prontinho! Você acabou de implantar seu smart contract de NFT na chain Ethereum 🎉"
  width={2880}
  height={1538}
  caption="Prontinho! Você acabou de implantar seu smart contract de NFT na chain Ethereum 🎉"
/>

Para entender o que está acontecendo por trás dos panos, vamos navegar até a aba Explorer no nosso [Alchemy dashboard ](https://dashboard.alchemy.com/signup?referral=affiliate:68212b46-a5c5-4f4c-bc8b-73f50536fcaf). Se tiver vários apps Alchemy, certifique-se de filtrar por app e selecionar "MyNFT".

<ImageBlock
  src="https://media.alchemy.com/1704803382-navigate-to-the-explorer-tab-in-our-alchemy-dashboard.jpg"
  alt="Aba Explorer do dashboard da Alchemy listando as chamadas JSON-RPC feitas durante a implantação do contrato"
  width={2880}
  height={1636}
  caption="Vá até a aba Explorer no nosso dashboard da Alchemy"
/>

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](https://docs.alchemy.com/docs/how-to-send-transactions-on-ethereum).

Isso é tudo para a Parte I deste tutorial. Na Parte II, vamos de fato interagir com nosso smart contract [criando um NFT](/blog/how-to-mint-an-nft-using-web3-js), e na Parte III vamos explicar como [visualizar seu NFT no Metamask](/blog/how-to-view-your-nft-in-your-mobile-wallet)! 🤑