Tips on how to Use ChatGPT to Mint an NFT

ChatGPT is a groundbreaking AI device. Nonetheless, can we use this device in Web3 for, let’s say, NFT functions? Completely! We will really mint ChatGPT responses as NFTs, for instance. If that sounds fascinating and also you’d prefer to know how one can use ChatGPT to mint an NFT, learn on! As we transfer ahead, you’ll see how we constructed an instance dapp that makes use of OpenAI’s API to include the facility of ChatGPT. Now, so far as implementing the ChatGPT performance goes, the next code snippet does the trick: 

app.get(“/”, async (req, res) => {
const { question } = req;
attempt {
const response = await openai.createCompletion({
mannequin: “text-davinci-003”,
immediate: question.message,
max_tokens: 30,
temperature: 0,
});
return res.standing(200).json(response.information);
} catch (e) {
console.log(`One thing went fallacious ${e}`);
return res.standing(400).json();
}
});

To mint a ChatGPT NFT, you must use a sensible contract with a correct “mintNFT” operate:

operate mintNFT(tackle recipient, string reminiscence tokenURI)

For the good contract to deal with the chat in query, we have to retailer the chat in a decentralized method. Luckily, we will do that simply when utilizing the facility of IPFS and the Moralis IPFS API. Primarily, the next strains of code get the job carried out:

app.get(“/uploadtoipfs”, async (req, res) => {
const { question } = req;
attempt {
const response = await Moralis.EvmApi.ipfs.uploadFolder({
abi: [
{
path: “conversation.json”,
content: { chat: query.pair },
},
],
});
console.log(response.outcome);
return res.standing(200).json(response.outcome);
} catch (e) {
console.log(`One thing went fallacious ${e}`);
return res.standing(400).json();
}
});

If you wish to learn to correctly incorporate all the above-outlined elements to make use of ChatGPT to mint an NFT, create your free Moralis account and comply with our lead!

Overview

In right this moment’s article, we’ll present you how one can use ChatGPT to mint an NFT by taking you thru our Web3 ChatGPT tutorial. This implies you’ll have an opportunity to comply with our directions and create your individual occasion of our ChatGPT NFT minter Web3 app. As such, we’ll present you how one can implement the above-presented code snippets. Additionally, you don’t have to begin from scratch; as an alternative, you’ll be capable to use our repo to clone our scripts. That means, you’ll be capable to get to the end line in a matter of minutes.

Under the tutorial, you will discover the part the place we reveal our dapp in its ultimate type. Plus, that is the place we reply the “what’s a ChatGPT NFT?” query. Final however not least, we additionally focus on ChatGPT’s place in evolving Web3.   

ChatGPT NFT Tutorial – Tips on how to Use ChatGPT to Mint an NFT

Constructing a dapp that lets you mint ChatGPT NFTs from scratch is a multi-step course of. If you resolve to make use of JavaScript and the Moralis JS SDK, the next steps define this course of: 

Create and deploy a sensible contract that can mint a ChatGPT NFT. Construct your backend with NodeJS and Specific.Set up all required backend dependencies: Specific, Moralis, CORS, dotenv, and OpenAI.Write a correct backend (“index.js”) to include ChatGPT and the Moralis IPFS API.Construct your frontend with NextJS. Set up all required frontend dependencies: NextAuth, Moralis, wagmi, and so on. Write a number of frontend scrips, together with “.jsx” and “.js”.

As a substitute of diving into the above steps, you possibly can take a shortcut by accessing our “moralis-chatgpt” GitHub repo. The latter incorporates all of the frontend and backend scripts, in addition to the good contract template. Therefore, make certain to clone our code. Then, you’ll be capable to see the “backend”, “hardhat”, and “nextjs_moralis_auth” folders in Visible Studio Code (VSC): 

With the above three folders and their contents in place, it’s time you deploy your individual occasion of our ChatGPT NFT minting good contract.

Sensible Contract that Mints ChatGPT NFTs

Because the “hardhat” folder suggests, we used Hardhat to create and deploy our good contract. Nonetheless, there are different Ethereum growth instruments you should use. In case you are aware of Remix IDE, merely copy the content material of the “MessageNFT.sol” script and paste it into Remix. You will discover our contract template within the “hardhat/contracts” listing:

In case that is your first rodeo with Solidity good contracts, let’s rapidly undergo the strains of “MessageNFT.sol”. The latter begins with an MIT license and a pragma line:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;

Under the pragma line, we have now three OpenZeppelin imports that allow our good contract to inherit options from present verified contracts. So, our Web3 contract inherits the ERC-721 customary, the flexibility to depend NFTs and assign NFT IDs, and the “owner-minting” restriction:

import “@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol”;
import “@openzeppelin/contracts/utils/Counters.sol”;
import “@openzeppelin/contracts/entry/Ownable.sol”;

Subsequent, we outlined the contract identify and sort (ERC-721), the “constructor” and the “mintNFT” operate. The latter will mint ChatGPT NFTs everytime you (the proprietor of the contract) name it. So, to do that, the “mintNFT” operate wants to soak up an NFT recipient’s tackle and token URI:

contract messageNFT is ERC721URIStorage, Ownable {
utilizing Counters for Counters.Counter;
Counters.Counter non-public _tokenIds;

constructor() ERC721(“Chapt GPT Dialog”, “CGPTC”) {}

operate mintNFT(tackle recipient, string reminiscence tokenURI)
public
onlyOwner
returns (uint256)
{
_tokenIds.increment();

uint256 newItemId = _tokenIds.present();
_mint(recipient, newItemId);
_setTokenURI(newItemId, tokenURI);

return newItemId;
}
}

So far as the “tackle recipient” parameter goes, the contract will get it from the linked pockets’s tackle. To have the ability to mint, the recipient’s tackle must match the contract proprietor’s tackle. Then again, the token URI will come out of your backend as soon as the IPFS API uploads a selected ChatGPT dialog. 

Word: You possibly can deploy the above good contract to Ethereum or every other EVM-compatible chain. Nonetheless, to keep away from any confusion, we urge you to deal with the Goerli testnet. That is the community this tutorial use.

NodeJS Backend of Our ChatGPT NFT Minter Web3 App

After efficiently deploying your occasion of our “MessageNFT.sol” good contract, deal with the “backend” folder. There, you’ll discover the “index.js”, “package-lock.json”, and “bundle.json” recordsdata. The latter tells you which ones dependencies this challenge makes use of. Furthermore, you possibly can set up them with the “npm i” command. To make your backend operate correctly, create a “.env” file and retailer your Moralis Web3 API key within the “MORALIS_API_KEY” variable.

In case you haven’t created your Moralis account but, achieve this now. Then, log in to your account to entry your admin space. From there, you’ll be capable to copy your Web3 API key with the next two clicks:

Now that you simply’ve efficiently put in all of the required dependencies and set your API key in place, you possibly can run the backend’s “index.js” script. Nonetheless, since that is the script that does all of the heavy backend lifting, let’s stroll you thru its code. 

The highest strains of the script import all dependencies and outline the native port to run on:

const specific = require(“specific”);
const app = specific();
const port = 5001;
const Moralis = require(“moralis”).default;
const cors = require(“cors”);
require(“dotenv”).config();

Then it makes use of CORS and Specific and imports the API key out of your “.env” file:

app.use(cors());
app.use(specific.json());

const MORALIS_API_KEY = course of.env.MORALIS_API_KEY;

On the backside, the script initializes the above key by way of the “Moralis.begin” methodology:

Moralis.begin({
apiKey: MORALIS_API_KEY,
}).then(() => {
app.pay attention(port, () => {
console.log(`Listening for API Calls`);
});
});

As well as, this additionally imports the OpenAI API configuration strains, which we obtained from the OpenAI docs:

const { Configuration, OpenAIApi } = require(“openai”);
const configuration = new Configuration({
apiKey: course of.env.OPENAI_API_KEY,
});
const openai = new OpenAIApi(configuration);

The above-covered strains of code encompass the implementation of the basis and “uploadtoipfs” endpoints that you simply noticed within the introduction. Transferring on, we’ll go over these two Specific server endpoints.

Root Endpoint

As you in all probability keep in mind, the primary objective of right this moment’s tutorial is to construct a dapp that means that you can use ChatGPT to mint an NFT. You’ve already deployed the good contract that can do the minting, however you haven’t included ChatGPT into your backend. For that goal, let’s create a root endpoint incorporating the OpenAI API to fetch the entry message from the frontend, cross that message to ChatGPT, and return ChatGPT’s reply. Listed here are the strains of code that care for that:

app.get(“/”, async (req, res) => {
const { question } = req;
attempt {
const response = await openai.createCompletion({
mannequin: “text-davinci-003”,
immediate: question.message,
max_tokens: 30,
temperature: 0,
});
return res.standing(200).json(response.information);
} catch (e) {
console.log(`One thing went fallacious ${e}`);
return res.standing(400).json();
}
});

The “uploadtoipfs” Endpoint

The final piece of the backend puzzle revolves round importing a ChatGPT dialog to IPFS. By doing so, you get your token URI that your good contract makes use of to mint a ChatGPT NFT. To do that with minimal effort, we used the Moralis IPFS API and created the “uploadtoipfs” endpoint:  

app.get(“/uploadtoipfs”, async (req, res) => {
const { question } = req;
attempt {
const response = await Moralis.EvmApi.ipfs.uploadFolder({
abi: [
{
path: “conversation.json”,
content: { chat: query.pair },
},
],
});
console.log(response.outcome);
return res.standing(200).json(response.outcome);
} catch (e) {
console.log(`One thing went fallacious ${e}`);
return res.standing(400).json();
}
});

Wanting on the strains of code above, you possibly can see the “Moralis.EvmApi.ipfs.uploadFolder“ methodology. The latter makes use of “dialog.json” as an IPFS path and the present ChatGPT dialog because the corresponding content material.  

NextJS Frontend of Our ChatGPT NFT Minter Web3 App

You possibly can discover all frontend-related scripts contained in the “nextjs_moralis_auth” folder. Presuming that you’re JavaScript proficient and have some frontend mileage underneath the hood, we received’t spend a lot time on the frontend. In any case, you simply want to put in all of the required frontend dependencies. Nonetheless, let’s have a look at some mention-worthy features. For example, we wrap our app with “WagmiConfig” and “SessionProvider” to make use of authentication throughout your complete app:

operate MyApp({ Element, pageProps }) {
return (
<WagmiConfig consumer={consumer}>
<SessionProvider session={pageProps.session} refetchInterval={0}>
<Element {…pageProps} />
</SessionProvider>
</WagmiConfig>
);
}

One other vital side is the code that renders the header of our frontend, together with the “Join” button. For that goal, the “signin.jsx” script makes use of “handleAuth“, which lets you join or disconnect MetaMask. When you efficiently join MetaMask, the “person.jsx” web page takes over. The latter has a unique header than “signin.jsx”. The “person.js” script additionally makes use of the “loggedIn.js” element for frontend and backend communication. So, it’s the “loggedIn.js” script that renders your frontend:

return (
<part>
<part className={kinds.chat_box}>
<part className={kinds.chat_history} id=”chatHistory”></part>
<part className={kinds.message_input}>
<enter
kind=”textual content”
id=”inputField”
placeholder=”Kind your message…”
onChange={getMessage}
/>
<button onClick={sendMessage}>Ship</button>
</part>
</part>
{showMintBtn && (
<button className={kinds.mint_btn} onClick={mint}>
MINT NFT
</button>
)}
</part>
);
}

Word: If you’d like a extra detailed code walkthrough of the “loggedIn.js” script, use the video on the high (5:53). 

ChatGPT Minter Web3 App Demo

When you’ve used our code and ran each the backend and frontend dapps, now you can use your native host to take your occasion of our ChatGPT NFT minter for a spin:

To entry the app performance, you must hit the “Authenticate by way of MetaMask” button. The latter will immediate your MetaMask extension, asking you to signal the signature request:

When you click on on “Signal”, the Web3 app (dapp) makes use of the “person.jsx” script that shows a ChatGPT field and a unique header:

You should utilize the entry discipline to kind your query/command and hit “Ship” to get ChatGPT’s reply. As quickly as ChatGPT replies, our dapp presents you with the “Mint NFT” button:

So, when you resolve to transform your ChatGPT dialog into an NFT, you must use that button. Additionally, make certain to make use of the identical pockets tackle as it’s a must to deploy your good contract. When you click on on “Mint NFT”, MetaMask will pop up asking you to verify an NFT-minting transaction:  

As soon as the Goerli chain confirms the transaction, you possibly can view your new ChatGPT NFT on Etherscan. Nonetheless, when you have been to improve your Web3 app with the flexibility to fetch the NFT’s particulars, you’d wish to use the “Get NFTs by contract” API endpoint. You should utilize that endpoint’s API reference web page to check its energy:

To see the response after hitting the above “Attempt it” button, you’ll have to scroll down the “Get NFTs by contract” API reference web page: 

What’s a ChatGPT NFT?

A ChatGPT NFT is a non-fungible token (NFT) that’s ultimately related to ChatGPT – a sophisticated chatbot developed by OpenAI. For example, it might be an NFT that makes use of the ChatGPT brand as its NFT-representing file or an NFT that was minted by a sensible contract generated utilizing ChatGPT. 

ChatGPT and Web3

Customers across the globe are already utilizing ChatGPT for a lot of completely different functions. A few of the most typical ChatGPT use instances embrace producing programming code or code templates and discovering/fixing code errors, creating content material, producing advertising and gross sales pitches, performing accounting and information evaluation, and extra. 

ChatGPT can be utilized by way of its net dashboard or by way of OpenAI’s API (as within the above tutorial). The latter permits devs to implement the facility of AI into all kinds of dapps. Now, remember that to take advantage of out of ChatGPT, it’s possible you’ll want to coach it on particular datasets which can be related to your software. 

Web3 devs and communities are already utilizing ChatGPT to generate textual content (creating chatbots or digital assistants), translate textual content, carry out sentiment evaluation, generate good contracts and scripts for dapps, and so on. 

All in all, ChatGPT is an especially highly effective device. With the appropriate enter and correctly utilized output, it may be an important addition to numerous dapps and might enrich the Web3 expertise.  

Tips on how to Use ChatGPT to Mint an NFT – Abstract

In right this moment’s article, we confirmed you how one can create a ChatGPT NFT minter Web3 app (dapp). You now know that by deploying a correct good contract and creating an appropriate backend and frontend, you should use ChatGPT to mint an NFT. Additionally, through the use of our code, you have been capable of cowl all these features with minimal effort. Now you can mess around along with your occasion of our dapp and create as many ChatGPT NFTs as you want. 

Within the above tutorial, you additionally encountered the Moralis IPFS API, which is only one of many Web3 APIs from Moralis. Moreover, along with your Moralis API key, you should use the complete scope of the Moralis Web3 Knowledge API, Authentication API, and Moralis Streams API. The latter is a superior Notify API various poised to make Web3 libraries out of date. So, with these enterprise blockchain options from Moralis, you possibly can construct killer Web3 wallets, portfolio trackers, and different kinds of dapps. Moreover, because of Moralis’ cross-chain interoperability, you possibly can BUIDL on Ethereum, main EVM-compatible chains, Solana, and Aptos! When you select to construct on Aptos, make certain to make use of the Aptos testnet faucet earlier than going reside. 

Be taught extra about constructing dapps the straightforward means from the Moralis documentation, our YouTube channel, and our weblog. These free sources may help you grow to be a Web3 developer very quickly. When you want to take a extra skilled strategy to your blockchain growth training, enroll in Moralis Academy.