Ir para o conteúdo
Buscar

WEB3DEV

Cover image for Como Cunhar um NFT com ChatGPT, Infura e Truffle
Fatima Lima
Fatima Lima

Posted on

Como Cunhar um NFT com ChatGPT, Infura e Truffle

#chatgpt #infura #truffle

Image description

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:

Image description

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.

Image description

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>
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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:

  1. Crie um repositório do node vazio.
  2. Instale o Truffle e configure um novo projeto.
  3. Instale o OpenZeppelin para obter acesso às implementações básicas do padrão ERC-721.
  4. Instale o hdwalletprovider para gerenciamento de carteiras e chaves.
  5. 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
Enter fullscreen mode Exit fullscreen mode

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:

Image description

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.
Enter fullscreen mode Exit fullscreen mode

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:
Enter fullscreen mode Exit fullscreen mode 
// 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;
    }
}
Enter fullscreen mode Exit fullscreen mode 
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.
Enter fullscreen mode Exit fullscreen mode

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;
    }
}
Enter fullscreen mode Exit fullscreen mode

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",
    }
  }
};
Enter fullscreen mode Exit fullscreen mode

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>"
Enter fullscreen mode Exit fullscreen mode

Está tudo pronto! Vamos compilar o contrato inteligente da etapa anterior, executando:

npx truffle compile
Enter fullscreen mode Exit fullscreen mode

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:

Image description

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.
Enter fullscreen mode Exit fullscreen mode

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:
Enter fullscreen mode Exit fullscreen mode

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.
Enter fullscreen mode Exit fullscreen mode

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);
};
Enter fullscreen mode Exit fullscreen mode

Implante na Sepolia usando:

npx truffle migrate --network sepolia
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

O contrato inteligente também estará disponível no Etherscan da Sepolia e você poderá pesquisá-lo por seu endereço.

Image description

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)


Leia o próximo

isabelacnehme profile image

Vert Finance: Arquitetura de uma Exchange de Criptomoeda Para Fiat

Isabela Curado Nehme -

isabelacnehme profile image

Proteja Seu Contrato Inteligente Com Diligence Fuzzing

Isabela Curado Nehme -

diogojorg3 profile image

Crie facilmente um aplicativo NFT usando o novo Infura SDK para NFT TypeScript

Diogo Jorge -

diogojorg3 profile image

Matemática de ponto fixo no Solidity

Diogo Jorge -