Sumário
- Como criar um NFT com Infura
- O que são NFTs?
- O que significa "emitir" um NFT?
- Onde entra o Infura ao criar os NFTs?
- Requisitos para a criação de um NFT
- Como escrever um contrato inteligente NFT
- Implante seu contrato inteligente NFT para o testnet público Goerli
- Upload de ativos NFT e metadados para IPFS através do Infura
- Chamando a função emitir no contrato inteligente NFT
- Conclusão: agora você sabe como criar um NFT
Como criar um NFT com Infura
Aqui estão todas as etapas necessárias para criar um NFT com Infura.
Você está curioso sobre os NFTs e quer criar o seu próprio NFT? O Infura é uma ferramenta poderosa que facilita a criação e o gerenciamento de NFTs na Ethereum e em outras blockchains. Neste tutorial, mostraremos a você como criar seu próprio NFT usando o Infura, passo a passo.
Explicarei os NFTs e o que significa emitir um NFT. Também vou fornecer uma visão geral de alto nível sobre como o Infura funciona e o que você precisa para começar.
Ao final deste guia, você terá uma compreensão sólida do que é necessário para criar um NFT e como o Infura pode ajudá-lo a fazê-lo rápida e facilmente, permitindo que você se concentre na lógica da aplicação central, enquanto cuidamos da infraestrutura necessária para o seu nó.
O que são NFTs?
Os Tokens Não Fungíveis (NFTs) são ativos digitais únicos que representam a propriedade de um item específico, tal como uma obra de arte, música ou conteúdo. Os NFTs diferem dos tokens regulares por serem não-fungíveis e não podem ser trocados por um item ou valor idêntico.
Cada NFT é único e tem um valor distinto determinado pela oferta e demanda. Além disso, os NFTs são frequentemente armazenados em tecnologias de blockchain como Ethereum ou Polygon, proporcionando uma maneira segura e transparente de verificar a propriedade e autenticidade do bem digital.
O que significa "emitir" um NFT?
"Emitir" um NFT significa simplesmente criar um novo e único NFT em uma rede de blockchain. É o processo de atribuição de um token a um endereço, com alguns metadados que descrevem o token.
Este processo normalmente começa com a criação e implantação de um contrato inteligente ERC721 ou ERC1155 que contém os detalhes específicos do NFT, tais como seu nome e símbolo.
Seguido pela criação e upload dos ativos do NFT - imagens, música ou conteúdo e metadados para o serviço de hospedagem de sua escolha - falaremos mais sobre isso mais tarde.
Em seguida, chamando a função de cunhagem a partir de seu contrato de implantação com o endereço do destinatário e os metadados NFT URI "Uniform Resource Identifier" (Identificador Uniforme de Recursos) fornecidos por um serviço de hospedagem.
Para hospedagem de ativos e metadados para projetos NFT, há três opções à sua escolha:
Serviços de hospedagem centralizados como AWS "Amazon Web Services" - não são resistentes à censura.
Armazenamento na cadeia - é muito caro
3 O armazenamento descentralizado como o Sistema de Arquivo Interplanetário (IPFS) - é a melhor aposta, já que não é tão caro quanto o armazenamento em cadeia, mas descentralizado o suficiente para ser resistente à censura.
Onde entra o Infura ao criar os NFTs?
Seja para implantar um contrato inteligente NFT em Ethereum, Polygon ou Arbitrium, ou hospedar ativos e metadados NFT em IPFS, você precisará de uma conexão a estas redes operando softwares de servidor (nós) complexos e caros que são demorados e suscetíveis a erros.
O Infura resolve estes problemas fornecendo um conjunto de APIs "Application Programming Interface" (Interface de Programação de Aplicativos) robustas e fáceis de usar para que os desenvolvedores comecem a construir rapidamente sem ter que se preocupar em operar e manter os nós da blockchain.
A partir de hoje, o Infura suporta 11 redes, incluindo Ethereum, IPFS, Filecoin, Polygon, Arbitrum, Avalanche, Optimism, Celo, Near, Aurora, e StarkNet.
Agora que já tiramos a maior parte das teorias do caminho, vamos entrar e começar a emitir NFTs!
Requisitos para a criação de um NFT
Para poder seguir adiante com o conteúdo deste tutorial, você precisará ter os seguintes requisitos:
Node.js instalado. É aconselhável instalar o node.js usando o NVM.
Truffle instalado.
Uma conta Infura gratuita.
Uma carteira da MetaMask.
Um editor de código - VS Code de preferência.
Alguns Goerli testnet ETH.
Como escrever um contrato inteligente NFT
Para começar, precisaremos de um projeto Truffle para abrigar os contratos inteligentes de NFT. O Truffle facilita a construção, compilação e implementação de contratos inteligentes para redes pré-definidas. Em nosso caso, vamos implantar e emitir nosso NFT na rede de testes Goerli e, na próxima seção, vamos montar o Truffle para fazer isso.
truffle init infura-nft-project
cd infura-nft-project
truffle create contract InfuraNFTProject
A estrutura de seu projeto deve ter este aspecto:
Para desenvolver rapidamente o contrato inteligente para este projeto, usaremos o assistente de contratos do OpenZeppelin, um gerador interativo para contratos inteligentes baseados nas implementações do OpenZeppelin.
Vou verificar algumas caixas e pedir ao assistente para gerar o contrato para mim, que depois posso copiar para InfuraNFTProject.sol e compilar.
// InfuraNFTProject.sol file
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract InfuraNFTProject is ERC721, ERC721URIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
constructor() ERC721("InfuraNFTProject", "INP") {}
function safeMint(address to, string memory uri) public onlyOwner {
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_safeMint(to, tokenId);
_setTokenURI(tokenId, uri);
}
// As funções a seguir são anulações requeridas pela Solidity.
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
super._burn(tokenId);
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
return super.tokenURI(tokenId);
}
}
Para compilar este contrato com sucesso, teremos que nos certificar de que as dependências listadas no início do arquivo estejam instaladas corretamente.
Vá em frente e instale a biblioteca de contratos do OpenZeppelin com este comando npm install -dev @openzeppelin/contracts .
Agora compile os contratos com o truffle compile, você deve obter uma resposta que se pareça com a imagem abaixo junto com uma nova pasta de compilação.
Implante seu contrato inteligente NFT para o testnet público Goerli
Com o contrato inteligente compilado com sucesso, o próximo passo é implantá-lo em uma rede pública para que possamos emitir o NFT e vê-lo em nossa carteira móvel MetaMask.
O primeiro passo para implantar qualquer contrato na blockchain usando Truffle é criar um script de implantação, também conhecido como um arquivo de migração. Na pasta de migrações, criar um novo arquivo 1_deploy_contracts.js e adicionar o seguinte conteúdo a ele.
// 1_deploy_contracts.js
const InfuraNFTProject = artifacts.require("InfuraNFTProject");
module.exports = function (deployer) {
deployer.deploy(InfuraNFTProject);
};
O segundo passo é acessar a rede blockchain para a qual você deseja implantar seu NFT. Para nos ajudar com o acesso a uma rede pública como a Goerli, usaremos o Infura. Com uma ferramenta como o Infura, não teremos que montar e manter nosso próprio nó na rede para a qual escolhemos implantar, isso é muito trabalho.
O Infura nos poupa tempo e energia ao configurar e manter esses nós em nosso nome, para uma variedade de redes, incluindo a Goerli, fornecendo um ponto final (endpoint) com o qual podemos acessar a blockchain pública.
Dirija-se ao painel de controle do INFURA e crie um novo projeto sob Web3API e recupere suas chaves de projeto. No cartão Ethereum, selecione Goerli para expor seu terminal de projeto Goerli exclusivo.
Para implantar com sucesso o contrato inteligente na rede Goerli usando o API do Infura através do Truffle, precisaremos criar um provedor que assinará transações em nosso nome.
Uma maneira de fazer isso é obter a frase semente mnemônica de sua carteira MetaMask e entregá-la ao Truffle. Uma maneira alternativa e mais fácil de fazer isso seria usar o painel de controle do Truffle que encaminharia as transações para sua carteira MetaMask quando necessário, evitando a necessidade de expor suas chaves privadas.
Como o objetivo deste tutorial é entrar nos detalhes e mostrar como as coisas funcionam sob o capô, usaremos a primeira abordagem, pois também nos permite a capacidade de monitorar transações através do painel do projeto Infura.
Vá até sua carteira MetaMask e clique no ícone de perfil no canto superior direito -> Clique em configurações -> Segurança e Privacidade -> Revelar Frase de Recuperação Secreta -> Digite sua senha e copie sua frase de recuperação secreta.
Na raiz de seu projeto Truffle, crie um arquivo .env e adicione o seguinte conteúdo a ele. Por favor, certifique-se de que este arquivo não seja rastreado por um controle de versão, pois o comprometimento deste arquivo com um controle de versão pode causar danos significativos.
IMPORTANTE: Adicione .env ao .gitignore se você usar o controle de versão GIT.
// arquivo .env
“MNEMONIC="YOUR METAMASK SECRET RECOVERY PHRASE"
“INFURA_API_KEY="YOUR INFURA_API_KEY"
Agora que temos estas chaves prontas, vamos atualizar o arquivo truffle-config.js e configurar a rede Goerli como nossa rede de preferência.
// arquivo truffle-config.js
require("dotenv").config();
const { MNEMONIC, INFURA_API_KEY } = process.env;
const HDWalletProvider = require("@truffle/hdwallet-provider");
module.exports = {
networks: {
goerli: {
provider: () =>
new HDWalletProvider(
MNEMONIC,
https://goerli.infura.io/v3/${INFURA_API_KEY}
),
network_id: 5, // id de rede Goerli
chain_id: 5, // id de cadeia Goerli
gas: 5500000, // Limite de gas usado para implantações.
confirmations: 2, // # de confirmações a esperar entre as implantações. (padrão: 0)
timeoutBlocks: 200, // # de blocos antes que uma implantação expire (mínimo/padrão: 50)
skipDryRun: true, // Ignorar a execução a seco antes das migrações? (padrão: false para redes públicas)
},
},
// Defina as opções padrão do mocha aqui, use relatórios especiais, etc.
mocha: {
// timeout: 100000
},
// Configure seus compiladores
compilers: {
solc: {
version: "0.8.17", // Busque a versão exata a partir do solc-bin (padrão: versão do truffle)
},
},
};
Para que isto funcione, precisaremos baixar as dependências dotenv e @truffle/hdwallet-provider referidas no arquivo de configuração. Execute este comando para obter aqueles instalados "npm install -dev dotenv @truffle/hdwallet-provider".
Agora que tudo está definido, podemos implantar o contrato inteligente para a rede Goerli com este simples comando: "truffle migrate --network goerli".
Se você tiver feito tudo corretamente e tiver bastante goerli ETH em sua carteira MetaMask, você deve obter uma resposta como a mostrada abaixo:
Se você procurar o endereço do contrato no Etherscan, você deve poder ver seu contrato. Ótimo trabalho!
Upload de ativos NFT e metadados para IPFS através do Infura
Outro lugar que o Infura facilita nossas vidas é fornecendo acesso ao IPFS através do painel de controle do Infura. Dirija-se ao painel do Infura e crie um projeto IPFS.
Para poder avaliar o conteúdo IPFS através do Infura, você precisa habilitar um gateway dedicado, siga este simples guia sobre como criar um gateway dedicado para se atualizar.
O próximo passo é fazer o upload dos arquivos de imagem NFT para IPFS. Pegue sua ID do projeto IPFS e sua chave secreta e navegue até o diretório raiz que contém sua imagem NFT.
Execute o seguinte comando, substituindo "InfuraNFT.jpg" pelo nome de sua imagem e : por sua ID do Projeto e Chave Secreta, respectivamente.
curl "https://ipfs.infura.io:5001/api/v0/add" \
-X POST \
-F file=@"InfuraNFT.jpg" \
-u "<API-Key>:<API-Key-Secret>"
Você deve obter uma resposta que se pareça com esta:
{"Name":"meme-nft.jpeg","Hash":"QmW5sPVbZDueZwvSuibteAwDFwFXhF8gebfptGBx1DZq1j","Size":"78353"}
Copie o hash de imagem da resposta e armazene-o em algum lugar, pois o estaremos usando para o próximo passo.
O próximo passo é criar e carregar um arquivo JSON descrevendo a imagem NFT que acabamos de carregar, seguiremos o padrão Opensea para garantir que possamos ver nosso NFT no Opensea, uma vez cunhado.
Copie o conteúdo a seguir para um arquivo JSON, substituindo "/ipfs/" pelo subdomínio de gateway dedicado que você ativou anteriormente e o hash de imagem que você copiou acima.
// InfuraNFT.json
{
"name": "Infura NFT",
"description": "How to mint an NFT with Infura tutorial",
"image": "<DEDICATED GATEWAY SUBDOMAIN>/ipfs/<NFT IMAGE HASH>", // e.g "https://infura-nfts.infura-ipfs.io/ipfs/QmRmUJiwcKSp2Tq5MdNvkkuQFktbeEgJHwfv9SbYX6uhGk"
"attributes": [
{ "trait_type": "content", "value": "tutorial"},
{ "trait_type": "product", "value": "Infura"},
{ "trait_type": "author", "value": "Kingsley"}
]
}
Para carregar este arquivo JSON para IPFS, em sua linha de comando, navegue até a raiz do diretório que contém o arquivo JSON e execute o seguinte comando:
curl "https://ipfs.infura.io:5001/api/v0/add" \
-X POST \
-F file=@"InfuraNFT.json" \
-u "<API-Key>:<API-Key-Secret>"
Lembre-se de substituir o nome do arquivo, a chave API e a chave API-Key-Secret por seu nome de arquivo, ID do projeto e chave secreta, respectivamente. Consulte este guia para obter mais informações sobre como carregar imagens e metadados para IPFS usando o método API IPFS.
Se você tiver feito isso corretamente, você deve ter dois itens com pinos no painel IPFS do seu Infura.
Chamando a função emitir no contrato inteligente NFT
Com o contrato NFT implantado e o recurso de imagem e metadados carregados no IPFS, estamos prontos para chamar a função emitir e atribuir este NFT a um endereço Ethereum.
Para nos ajudar a conseguir isto, usaremos o console Truffle. Vá até a raiz do diretório de seu projeto contendo os arquivos truffle-config.js e .env e execute os seguintes comandos para conectar o console do Truffle à rede Goerli que definimos em nosso arquivo truffle-config.json.
source .env
truffle console --network goerli
No console aberto, pegue o contrato NFT implantado e chame a função emitir, substituindo o endereço e metadados do destinatário URI pelo seu endereço Ethereum e o URI pelos metadados que você carregou no IPFS.
const contract = await InfuraNFTProject.deployed()
await contract.safeMint("<RECIPIENT’S ADDRESS>", "<DEDICATED GATEWAY SUBDOMAIN>/ipfs/<NFT METADATA FILE HASH>")
Você deve obter uma resposta que se pareça com esta:
Agora, se você for para sua carteira móvel MetaMask, você deve ver seu novo NFT emitido sob a aba NFT. Certifique-se de que você está na rede Goerli. Você também pode ir para https://testnets.opensea.io/ e conectar sua carteira para ver seu NFT no Opensea.
Conclusão: agora você sabe como criar um NFT
É isso aí! Você escreveu e implantou um token ERC 721, carregou uma imagem NFT e metadados para IPFS usando as APIs do Infura e invocou a função emitir em seu contrato NFT para atribuir este NFT a um endereço do destinatário usando o console Truffle.
Você pode ver como confiar no Infura pode melhorar muito sua produtividade, permitindo que você se concentre em seu aplicativo, enquanto o Infura gerencia seus nós e lhe fornece um painel de controle robusto para rastrear e monitorar as solicitações em tempo real.
Artigo escrito por Kingsley Okonkwo e traduzido para o português por Rafael Ojeda
Você pode ler o artigo original aqui
Abrace a oportunidade de elevar sua jornada de desenvolvimento para um nível superior. A criação de NFTs é apenas o começo; os builds incríveis da WEB3DEV representam a chave de entrada para o emocionante cenário web3. 🚀🧑💻
Não perca tempo, 👉inscreva-se👈 agora mesmo e comece a desbravar o universo Blockchain!
Seja também WEB3DEV!
Top comments (0)