Saiba como usar o ChatGPT com o Infura e o Truffle para cunhar seu próximo NFT.
Na parte um da série ChatGPT + Infura, aprendemos quatro maneiras de usar o ChatGPT para melhorar o desenvolvimento do seu dapp: fazer perguntas, compilar código, testar código e praticar codificação para aprimorar suas habilidades. Na segunda parte, você aprenderá a usar o ChatGPT e o Infura para cunhar um NFT.
O aspecto mais valioso de incorporar o ChatGPT em meu processo de desenvolvimento foi o tempo que economizei ao compilar meu código de contrato inteligente. Dito isso, vamos passar por uma rápida isenção de responsabilidade antes de começarmos a cunhar.
Isenção de Responsabilidade do ChatGPT
Embora o ChatGPT seja bom em explicar conceitos relevantes da Web3 e, em alguns casos, até mesmo em auditar o código em busca de brechas de segurança, as respostas que ele fornece nem sempre são precisas. O ChatGPT pode produzir códigos errados ou, pior, repletos de brechas das quais uma pessoa mal intencionada pode se aproveitar.
Portanto, embora o ChatGPT possa ser usado para acelerar significativamente o processo de desenvolvimento, ele NÃO substitui um desenvolvedor com fundamentos sólidos. Também não é aconselhável usar o código gerado pelo ChatGPT, a menos que você mesmo possa verificar o código.
Tenha em mente que o ChatGPT está ciente apenas das práticas de desenvolvimento até 2021 e, em um setor de ritmo acelerado como o da web3, isso pode ser um problema.
Passo 1: Instalar a MetaMask e Adquirir SepoliaETH
Para implantar contratos inteligentes localmente ou em uma blockchain pública, você precisará de uma carteira web3 e de algum gas para a blockchain que deseja implantar.
Se você não tiver uma carteira instalada, uma das mais confiáveis e fáceis de usar é a MetaMask. Você pode instalar a carteira Metamask como uma extensão do seu navegador da Web. A configuração da carteira é bastante simples. Siga cuidadosamente as instruções fornecidas pela MetaMask e salve a frase secreta da carteira em um local seguro.
Você pode alternar para a rede de teste Sepolia clicando na guia Network (Rede) no canto superior direito da extensão e, em seguida, clicando em show/hide networks (mostrar/ocultar redes). Quando a MetaMask exibir as redes de teste, mude para a Sepolia.
Se esta for sua primeira vez usando a Sepolia, é provável que você não tenha nenhum SepoliaETH. Felizmente, é fácil adquirir alguns gratuitamente usando a torneira (faucet) Infura. Uma vez feito isso, você deverá ver até 0,5 ETH de teste da Sepolia em sua carteira:
Passo 2: Configurar um endpoint RPC Sepolia Infura
Para enviar solicitações à rede Sepolia a fim de implantar contratos inteligentes e cunhar NFTs, primeiro você precisa de um endpoint RPC. Isso é fácil de fazer com o Infura!
Basta criar uma conta Infura e configurar um novo projeto. Você pode criar uma conta Infura aqui. Em seguida, você pode gerar um endpoint RPC Sepolia criando uma nova chave aqui.
Escolha a API Web3 no menu suspenso da rede. Você pode nomear a chave como quiser. Lembre-se de que você pode usar uma única chave para alimentar vários projetos. Os RPCs Infura são capazes de processar milhares de solicitações por dia gratuitamente.
A criação de uma chave lhe dará acesso a várias redes de blockchain, incluindo a rede principal da Ethereum e a Sepolia.
Seu endpoint RPC da Sepolia terá o seguinte formato:
sepolia.infura.io/vs/<SUA CHAVE DE API>
Passo 3: Configure um projeto de NFT usando o Truffle
Agora vamos configurar um projeto Truffle e instalar todos os pacotes e bibliotecas necessários para escrever contratos inteligentes. O Truffle é um framework de desenvolvimento com ferramentas e redes de desenvolvimento (devnets) para compilar e testar seu código.
Primeiro, verifique se você tem o node e o npm instalados executando o seguinte prompt:
$ node -v
$ npm -v
Se você obtiver um número de versão para cada comando, está tudo certo. Caso contrário, instale ambos em seu computador local aqui e tente de novo.
Depois que o node estiver instalado, vá em frente e configure o projeto com estas etapas:
- Crie um repositório do node vazio.
- Instale o Truffle e configure um novo projeto.
- Instale o OpenZeppelin para obter acesso às implementações básicas do padrão ERC-721.
- Instale o hdwalletprovider para gerenciamento de carteiras e chaves.
- Instale o dotenv para manter o segredo.
Em seguida, execute os seguintes comandos, um após o outro:
$ mkdir my-nft && cd my-nft
$ npm init -y
$ npm install -save truffle
$ npx truffle init && npx truffle test
$ npm install @openzeppelin/contracts @truffle/hdwallet-provider dotenv
Passo 4: Criar uma conta OpenAI e acessar o ChatGPT
No momento em que este artigo está sendo escrito, a versão 3.5 do ChatGPT é gratuita. Tudo o que você precisa é de uma conta OpenAI gratuita. Você pode criar uma aqui e acessar a interface do ChatGPT aqui. Vai ficar assim:
Familiarize-se com a interface fazendo algumas perguntas como, por exemplo, quais são alguns dos melhores poemas de E. E. Cummings? Ou qual é a diferença entre as linguagens de programação Solidity e Rust?
Passo 5: Pedir ao ChatGPT para gerar o código de contrato inteligente de NFT
Agora, vamos solicitar ao ChatGPT que crie um contrato inteligente de NFT com estas instruções:
Quero criar um contrato inteligente de NFT.
O contrato cunhará um único NFT e atribuirá um URL que aponta para seus metadados.
Use o OpenZeppelin como base para esse contrato.
O ChatGPT produzirá um resultado parecido com este:
Certamente, aqui está um exemplo de um contrato inteligente de NFT que cunhou um único NFT e atribuiu um URL apontando para seus metadados usando o OpenZeppelin como base:
// 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 _metadataUrl;
constructor(string memory name, string memory symbol, string memory metadataUrl) ERC721(name, symbol) {
_metadataUrl = metadataUrl;
}
function mintNFT(address recipient) public returns (uint256) {
_tokenIds.increment();
uint256 newItemId = _tokenIds.current();
_mint(recipient, newItemId);
_setTokenURI(newItemId, _metadataUrl);
return newItemId;
}
}
Nesse exemplo, importamos o `ERC721` do OpenZeppelin, que fornece a funcionalidade principal para a criação de NFTs. Também usamos `Counters` para manter o controle dos IDs de token e `_metadataUrl` para armazenar o URL dos metadados do NFT.
O construtor recebe três parâmetros: `name` e `symbol`, que são usados para identificar o NFT, e `metadataUrl`, que é o URL dos metadados do NFT.
A função `mintNFT` recebe um argumento `address` para o destinatário do NFT e retorna o ID do token recém-criado. Ela incrementa o ID do token usando `Counters`, cunha um novo token usando `_mint` e define o URI do token usando `_setTokenURI` com o valor `_metadataUrl`.
Você pode implantar esse contrato na rede Ethereum de sua preferência usando uma ferramenta como Remix ou Truffle e, em seguida, chamar a função `mintNFT` para cunhar um novo NFT e atribuir seu URL de metadados.
Como você pode ver, o trecho de código que o ChatGPT fornece está praticamente correto.
O único erro está na importação do ERC721 em vez do ERC721Storage, que tem a implementação do método _setTokenURI.
Ele também fornece uma explicação muito útil sobre o que o código faz.
Em seguida, crie um novo arquivo na pasta de contratos chamado MyNft.sol e copie e cole o seguinte código corrigido:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract MyNft is ERC721URIStorage {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
string private _metadataUrl;
constructor(string memory name, string memory symbol, string memory metadataUrl) ERC721(name, symbol) {
_metadataUrl = metadataUrl;
}
function mintNFT(address recipient) public returns (uint256) {
_tokenIds.increment();
uint256 newItemId = _tokenIds.current();
_mint(recipient, newItemId);
_setTokenURI(newItemId, _metadataUrl);
return newItemId;
}
}
Passo 6: Definir as configurações do Truffle
Agora vamos configurar o Truffle para que possamos implementar esse contrato inteligente na rede Sepolia. Substitua o conteúdo do arquivo truffle-config.js pelo seguinte:
require('dotenv').config();
const HDWalletProvider = require('@truffle/hdwallet-provider');
const { INFURA_API_KEY, MNEMONIC } = process.env;
module.exports = {
networks: {
development: {
host: "127.0.0.1",
port: 8545,
network_id: "*"
},
sepolia: {
provider: () => new HDWalletProvider(MNEMONIC, INFURA_API_KEY),
network_id: '11155111',
},
},
compilers: {
solc: {
version: "0.8.19",
}
}
};
Não queremos expor informações privadas, como a chave da carteira ou a chave da API do Infura, ao fazer upload do seu projeto para um serviço como o GitHub.
Portanto, vamos criar um arquivo .env para armazenar nossas informações confidenciais. Adicione o seguinte ao arquivo mencionado acima.
INFURA_API_KEY = "https://sepolia.infura.io/v3/<Your-API-Key>"
MNEMONIC = "<Your-MetaMask-Secret-Recovery-Phrase>"
Está tudo pronto! Vamos compilar o contrato inteligente da etapa anterior, executando:
npx truffle compile
Passo 7: Fazer upload da imagem e dos metadados do NFT para o Infura IPFS (opcional)
Em seguida, você pode carregar a imagem e os metadados que representam o NFT na Internet, usando um sistema de armazenamento descentralizado como o IPFS. Observe que o upload de sua própria imagem e metadados é opcional para este tutorial.
O Infura tem um serviço que permite que você faça isso. Entretanto, como o ChatGPT detém conhecimento somente até 2021, ele não está em condições de fornecer instruções sobre como usar esse serviço. O Infura tem uma documentação útil sobre como fazer isso aqui.
Se não quiser fazer isso, você pode simplesmente usar os metadados que fornecemos aqui: ipfs://QmUyZoK21qb8YknXGfDB34RTY8vMqPb6Bsj9U9iLEnyrZR
Esta é a imagem que converteremos em um NFT:
Você pode abrir esse link do IPFS colando-o diretamente na barra de endereços de um navegador compatível, como o Brave.
Passo 8: Implantar o contrato inteligente de NFT na Sepolia
Agora você pode implantar seu contrato inteligente na Sepolia, então vamos pedir ao ChatGPT o script de implantação com o prompt abaixo:
Certo, agora me dê um script que implante esse contrato na Sepolia. Estou usando o Truffle.
O ChatGPT lhe dará uma resposta semelhante a esta:
Certo, aqui está um script de exemplo que implementa o contrato inteligente NFT que você forneceu para a rede de teste Sepolia usando o Truffle:
1. Primeiro, verifique se você tem o Truffle instalado globalmente. Você pode instalá-lo executando `npm install -g truffle`.
2. No diretório raiz do seu projeto Truffle, crie um novo arquivo JavaScript (por exemplo, `deploy.js`) e cole o seguinte código:
const MyNFT = artifacts.require("MyNFT");
module.exports = async function(deployer) {
const name = "My NFT";
const symbol = "NFT";
const metadataUrl = "https://example.com/metadata.json";
await deployer.deploy(MyNFT, name, symbol, metadataUrl);
};
Nesse código, primeiro importamos o contrato `MyNFT`. Em seguida, na função `module.exports`, definimos os valores `name`, `symbol` e `metadataUrl` e usamos `deployer.deploy` para implantar o contrato com esses valores.
3. Em seu terminal, navegue até o diretório raiz de seu projeto Truffle e execute `truffle migrate --network ropsten`. Isso implantará o contrato na rede de teste Sepolia.
Certifique-se de substituir `ropsten` pelo nome da rede que você deseja implantar no arquivo `truffle-config.js`.
4. Quando a migração estiver concluída, você poderá verificar a rede de teste Sepolia para confirmar que o contrato foi implantado.
É isso aí! Agora você tem um script que implementa seu contrato inteligente de NFT na Sepolia usando o Truffle.
Embora algumas das informações fornecidas pela IA estejam incorretas, como a confusão entre as redes de teste Sepolia e Ropsten, o código fornecido é útil.
Na pasta migration, crie um novo arquivo chamado 1_deploy_contract.js (o prefixo é novamente algo que o ChatGPT se esquece de mencionar) e adicione o seguinte código:
const MyNft = artifacts.require("MyNft");
module.exports = async function (deployer) {
const name = "My NFT";
const symbol = "NFT";
const metadataUrl = "ipfs://QmUyZoK21qb8YknXGfDB34RTY8vMqPb6Bsj9U9iLEnyrZR";
await deployer.deploy(MyNft, name, symbol, metadataUrl);
};
Implante na Sepolia usando:
npx truffle migrate --network sepolia
Você deverá ver um output parecido com este:
Compiling your contracts...
===========================
> Everything is up to date, there is nothing to compile.
Migrations dry-run (simulation)
===============================
> Network name: 'sepolia-fork'
> Network id: 11155111
> Block gas limit: 30000000 (0x1c9c380)
1_deploy_contract.js
====================
Deploying 'MyNFT'
-----------------
> block number: 3445254
> block timestamp: 1683573071
> account: 0xc361Fc33b99F88612257ac8cC2d852A5CEe0E217
> balance: 0.500641134976595178
> gas used: 2493990 (0x260e26)
> gas price: 2.500000007 gwei
> value sent: 0 ETH
> total cost: 0.00623497501745793 ETH
-------------------------------------
> Total cost: 0.00623497501745793 ETH
Summary
=======
> Total deployments: 1
> Final cost: 0.00623497501745793 ETH
Starting migrations...
======================
> Network name: 'sepolia'
> Network id: 11155111
> Block gas limit: 30000000 (0x1c9c380)
1_deploy_contract.js
====================
Deploying 'MyNFT'
-----------------
> transaction hash: 0x14a189d5c84c2b80fb45991e45557aeecd236c07664db30ee76b21a5c5e18dfc
> Blocks: 2 Seconds: 17
> contract address: 0xD5B63A037FfF90ca3a73506e9856E543dE42CAA1
> block number: 3445261
> block timestamp: 1683573096
> account: 0xc361Fc33b99F88612257ac8cC2d852A5CEe0E217
> balance: 0.500641134976595178
> gas used: 2493990 (0x260e26)
> gas price: 2.500000007 gwei
> value sent: 0 ETH
> total cost: 0.00623497501745793 ETH
> Saving artifacts
-------------------------------------
> Total cost: 0.00623497501745793 ETH
Summary
=======
> Total deployments: 1
> Final cost: 0.00623497501745793 ETH
O contrato inteligente também estará disponível no Etherscan da Sepolia e você poderá pesquisá-lo por seu endereço.
Aprimore suas devops com o ChatGPT e o Infura
Neste tutorial, você aprendeu a usar o ChatGPT para cunhar um contrato inteligente usando Infura e Truffle. Perdeu a primeira parte, em que analisamos casos de uso de desenvolvimento mais gerais? Você pode dar uma olhada aqui.
Lembre-se de pensar no ChatGPT como um assistente útil, não como uma ferramenta capaz de escrever códigos perfeitos que substituiriam um desenvolvedor experiente. Como vimos, o ChatGPT não possui informações anteriores a 2021, o que afeta seu conhecimento e a produção de código.
Na terceira parte desta série, lançaremos um dapp totalmente funcional usando instruções e código gerados pelo ChatGPT. Fique ligado!
Esse artigo foi escrito por Infura e traduzido por Fátima Lima. O original pode ser lido aqui.
Top comments (0)