NFTని ఎలా వ్రాయాలి & డిప్లాయ్ చేయాలి (NFT ట్యుటోరియల్ సిరీస్‌లో 1/3వ భాగం)

NFTలు బ్లాక్‌చైన్‌ను ప్రజల దృష్టికి తీసుకురావడంతో, ఎథీరియం బ్లాక్‌చైన్‌లో మీ స్వంత NFT కాంట్రాక్ట్‌ను (ERC-721 టోకెన్) ప్రచురించడం ద్వారా ఈ క్రేజ్‌ను మీరే అర్థం చేసుకోవడానికి ఇది ఒక అద్భుతమైన అవకాశం!

ఈ ట్యుటోరియల్‌లో, మెటామాస్క్ (కొత్త ట్యాబ్‌లో తెరవబడుతుంది), Solidity (కొత్త ట్యాబ్‌లో తెరవబడుతుంది), Hardhat (కొత్త ట్యాబ్‌లో తెరవబడుతుంది), Pinata (కొత్త ట్యాబ్‌లో తెరవబడుతుంది) మరియు Alchemy (కొత్త ట్యాబ్‌లో తెరవబడుతుంది) ఉపయోగించి Sepolia టెస్ట్‌నెట్ నెట్‌వర్క్‌లో ERC-721 స్మార్ట్ కాంట్రాక్ట్‌ను సృష్టించడం మరియు డిప్లాయ్ చేయడం గురించి తెలుసుకుందాం (వీటి అర్థం మీకు ఇంకా తెలియకపోతే చింతించకండి — మేము దానిని వివరిస్తాము!).

ఈ ట్యుటోరియల్ యొక్క 2వ భాగంలో, NFTని ముద్రించడానికి మన స్మార్ట్ కాంట్రాక్ట్‌ను ఎలా ఉపయోగించవచ్చో చూద్దాం, మరియు 3వ భాగంలో మెటామాస్క్‌లో మీ NFTని ఎలా చూడాలో వివరిస్తాము.

మరియు మీకు ఏ సమయంలోనైనా ఏవైనా ప్రశ్నలు ఉంటే, Alchemy డిస్కార్డ్ (కొత్త ట్యాబ్‌లో తెరవబడుతుంది)లో సంప్రదించడానికి సంకోచించకండి లేదా Alchemy యొక్క NFT API డాక్యుమెంట్స్ (కొత్త ట్యాబ్‌లో తెరవబడుతుంది)ని సందర్శించండి!

దశ 1: ఎథీరియం నెట్‌వర్క్‌కి కనెక్ట్ అవ్వండి

ఎథీరియం బ్లాక్‌చైన్‌కు అభ్యర్థనలు చేయడానికి అనేక మార్గాలు ఉన్నాయి, కానీ సులభంగా చేయడానికి, మనం Alchemy (కొత్త ట్యాబ్‌లో తెరవబడుతుంది)లో ఉచిత ఖాతాను ఉపయోగిస్తాము, ఇది మన స్వంత నోడ్‌లను రన్ చేయాల్సిన అవసరం లేకుండా ఎథీరియం చైన్‌తో కమ్యూనికేట్ చేయడానికి అనుమతించే బ్లాక్‌చైన్ డెవలపర్ ప్లాట్‌ఫారమ్ మరియు అప్లికేషన్ ప్రోగ్రామింగ్ ఇంటర్‌ఫేస్ (API).

ఈ ట్యుటోరియల్‌లో, మన స్మార్ట్ కాంట్రాక్ట్ డిప్లాయ్‌మెంట్‌లో అంతర్గతంగా ఏమి జరుగుతుందో అర్థం చేసుకోవడానికి పర్యవేక్షణ మరియు విశ్లేషణల కోసం Alchemy యొక్క డెవలపర్ సాధనాలను కూడా మనం ఉపయోగించుకుంటాము. మీకు ఇంకా Alchemy ఖాతా లేకపోతే, మీరు ఇక్కడ (కొత్త ట్యాబ్‌లో తెరవబడుతుంది) ఉచితంగా సైన్ అప్ చేయవచ్చు.

దశ 2: మీ యాప్‌ను (మరియు API కీని) సృష్టించండి

మీరు Alchemy ఖాతాను సృష్టించిన తర్వాత, యాప్‌ను సృష్టించడం ద్వారా మీరు API కీని రూపొందించవచ్చు. ఇది Sepolia టెస్ట్‌నెట్ నెట్‌వర్క్‌కు అభ్యర్థనలు చేయడానికి మనల్ని అనుమతిస్తుంది. టెస్ట్‌నెట్‌ల గురించి మరింత తెలుసుకోవాలనే ఆసక్తి ఉంటే ఈ గైడ్‌ని (కొత్త ట్యాబ్‌లో తెరవబడుతుంది) చూడండి.

1. నావిగేషన్ బార్‌లో "Select an app" ఎంచుకుని, "Create new app" క్లిక్ చేయడం ద్వారా మీ Alchemy డాష్‌బోర్డ్‌లోని "Create new app" పేజీకి వెళ్లండి

2. మీ యాప్‌కు పేరు పెట్టండి (మేము “My First NFT!” అని ఎంచుకున్నాము), చిన్న వివరణను అందించండి మరియు ఒక యూజ్ కేస్‌ను ఎంచుకోండి. తర్వాత, "Ethereum" కోసం వెతికి, నెట్‌వర్క్‌ను ఎంచుకోండి. అప్లికేషన్ డెవలప్‌మెంట్ కోసం సిఫార్సు చేయబడిన టెస్ట్‌నెట్ అయిన Sepoliaని మనం ఉపయోగిస్తాము (ఎథీరియం నెట్‌వర్క్‌లు చూడండి).

3. కొనసాగడానికి "Next" క్లిక్ చేయండి, ఆపై “Create app” క్లిక్ చేయండి, అంతే! కాపీ చేయడానికి అందుబాటులో ఉన్న API కీతో మీ యాప్ నావిగేషన్ బార్ డ్రాప్‌డౌన్ మెనులో కనిపించాలి.

దశ 3: ఎథీరియం ఖాతాను (చిరునామా) సృష్టించండి

లావాదేవీలను పంపడానికి మరియు స్వీకరించడానికి మనకు ఎథీరియం ఖాతా అవసరం. ఈ ట్యుటోరియల్ కోసం, మీ ఎథీరియం ఖాతా చిరునామాను నిర్వహించడానికి బ్రౌజర్‌లో ఉపయోగించే వర్చువల్ వాలెట్ అయిన మెటామాస్క్‌ను మనం ఉపయోగిస్తాము. ఎథీరియంలో లావాదేవీలు ఎలా పనిచేస్తాయో మీరు మరింత అర్థం చేసుకోవాలనుకుంటే, ఎథీరియం ఫౌండేషన్ నుండి ఈ పేజీని చూడండి.

మీరు ఇక్కడ (కొత్త ట్యాబ్‌లో తెరవబడుతుంది) ఉచితంగా మెటామాస్క్ ఖాతాను డౌన్‌లోడ్ చేసి సృష్టించవచ్చు. మీరు ఖాతాను సృష్టిస్తున్నప్పుడు, లేదా మీకు ఇప్పటికే ఖాతా ఉంటే, నెట్‌వర్క్ ఎంపిక మెనుని ఉపయోగించి "Sepolia" టెస్ట్‌నెట్ నెట్‌వర్క్‌కి మారారని నిర్ధారించుకోండి (తద్వారా మనం నిజమైన డబ్బుతో వ్యవహరించము). మీకు Sepolia జాబితాలో కనిపించకపోతే, కుడి ఎగువ మూలలో ఉన్న మెనుని తెరిచి, "Networks" ఎంచుకుని, "Show test networks" ఆన్ చేయండి (టెస్ట్‌నెట్‌లను చూడటానికి మెటామాస్క్ గైడ్ (కొత్త ట్యాబ్‌లో తెరవబడుతుంది) చూడండి).

దశ 4: ఫాసెట్ నుండి ఈథర్‌ను జోడించండి

మన స్మార్ట్ కాంట్రాక్ట్‌ను టెస్ట్‌నెట్ నెట్‌వర్క్‌కి డిప్లాయ్ చేయడానికి, మనకు కొంత నకిలీ ETH అవసరం. Sepolia ETHని పొందడానికి, Sepolia నెట్‌వర్క్ వివరాలలో జాబితా చేయబడిన ఫాసెట్‌లలో ఒకదాన్ని ఎంచుకుని, మీ ఖాతా చిరునామాను నమోదు చేయండి. ఒకటి పని చేయకపోతే, మరొకదాన్ని ప్రయత్నించండి ఎందుకంటే అవి కొన్నిసార్లు ఖాళీ కావచ్చు, మరియు కొన్నింటికి అర్హత నియమాలు ఉంటాయి: ఉదాహరణకు, Alchemy Sepolia ఫాసెట్ (కొత్త ట్యాబ్‌లో తెరవబడుతుంది)కి స్వీకరించే చిరునామా ఎథీరియం మెయిన్‌నెట్‌లో కనీసం 0.001 ETH కలిగి ఉండాలి. ఆ తర్వాత కొద్దిసేపటికే మీ మెటామాస్క్ ఖాతాలో ETHని మీరు చూడాలి!

దశ 5: మీ బ్యాలెన్స్‌ని తనిఖీ చేయండి

మన బ్యాలెన్స్ ఉందో లేదో ఒకసారి తనిఖీ చేయడానికి, Alchemy యొక్క శాండ్‌బాక్స్ సాధనాన్ని (కొత్త ట్యాబ్‌లో తెరవబడుతుంది) ఉపయోగించి eth_getBalance (కొత్త ట్యాబ్‌లో తెరవబడుతుంది) అభ్యర్థన చేద్దాం. ఇది మన వాలెట్‌లోని ETH మొత్తాన్ని తిరిగి ఇస్తుంది. మీరు మీ మెటామాస్క్ ఖాతా చిరునామాను నమోదు చేసి, “Send Request” క్లిక్ చేసిన తర్వాత, మీరు ఇలాంటి ప్రతిస్పందనను చూడాలి:

{ "jsonrpc": "2.0", "id": 0, "result": "0xde0b6b3a7640000" }

గమనిక ఈ ఫలితం Weiలో ఉంది, ETHలో కాదు. ఈథర్ యొక్క అతిచిన్న విలువగా Wei ఉపయోగించబడుతుంది. Wei నుండి ETHకి మార్పిడి 1 eth = 10¹⁸ Wei. కాబట్టి మనం 0xde0b6b3a7640000ని దశాంశానికి మారిస్తే మనకు 1*10¹⁸ Wei వస్తుంది, ఇది 1 ETHకి సమానం.

హమ్మయ్య! మన నకిలీ డబ్బు అంతా అక్కడే ఉంది.

దశ 6: మన ప్రాజెక్ట్‌ను ప్రారంభించండి

ముందుగా, మనం మన ప్రాజెక్ట్ కోసం ఒక ఫోల్డర్‌ను సృష్టించాలి. మీ కమాండ్ లైన్‌కి వెళ్లి ఇలా టైప్ చేయండి:

mkdir my-nft
cd my-nft

ఇప్పుడు మనం మన ప్రాజెక్ట్ ఫోల్డర్ లోపల ఉన్నాము కాబట్టి, ప్రాజెక్ట్‌ను ప్రారంభించడానికి మనం npm initని ఉపయోగిస్తాము. మీరు ఇంకా npmని ఇన్‌స్టాల్ చేయకపోతే, Node.js ఇన్‌స్టాలేషన్ సూచనలను (కొత్త ట్యాబ్‌లో తెరవబడుతుంది) అనుసరించండి (ఈ ట్యుటోరియల్ కోసం మనకు Node.js మరియు npm అవసరం).

npm init

ఇన్‌స్టాలేషన్ ప్రశ్నలకు మీరు ఎలా సమాధానం ఇస్తారనేది పెద్దగా ముఖ్యం కాదు; సూచన కోసం మేము దీన్ని ఎలా చేశామో ఇక్కడ ఉంది:

package name: (my-nft)
version: (1.0.0)
description: My first NFT!
entry point: (index.js)
test command:
git repository:
keywords:
author:
license: (ISC)
About to write to /Users/thesuperb1/Desktop/my-nft/package.json:

{
  "name": "my-nft",
  "version": "1.0.0",
  "description": "My first NFT!",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC"
}

package.jsonని ఆమోదించండి. మనం తర్వాత ఇన్‌స్టాల్ చేసే Hardhat 3, ES మాడ్యూల్ ప్రాజెక్ట్‌లకు మాత్రమే మద్దతు ఇస్తుంది, కాబట్టి ప్రాజెక్ట్‌ను ఆ విధంగా మార్క్ చేయండి:

npm pkg set type=module

ఇక మనం ముందుకు వెళ్లవచ్చు!

దశ 7: Hardhat (కొత్త ట్యాబ్‌లో తెరవబడుతుంది)ని ఇన్‌స్టాల్ చేయండి

Hardhat అనేది మీ ఎథీరియం సాఫ్ట్‌వేర్‌ను కంపైల్ చేయడానికి, డిప్లాయ్ చేయడానికి, పరీక్షించడానికి మరియు డీబగ్ చేయడానికి ఒక డెవలప్‌మెంట్ వాతావరణం. లైవ్ చైన్‌కి డిప్లాయ్ చేయడానికి ముందు స్థానికంగా స్మార్ట్ కాంట్రాక్ట్‌లు మరియు వికేంద్రీకృత అప్లికేషన్ (dapp)లను నిర్మించేటప్పుడు ఇది డెవలపర్‌లకు సహాయపడుతుంది.

Hardhat 3కి Node.js v22.13.0 లేదా ఆ తర్వాతి వెర్షన్ అవసరం. మన my-nft ప్రాజెక్ట్ లోపల దీన్ని రన్ చేయండి:

npm install --save-dev hardhat

ఇన్‌స్టాలేషన్ సూచనల (కొత్త ట్యాబ్‌లో తెరవబడుతుంది)పై మరిన్ని వివరాల కోసం ఈ పేజీని చూడండి.

దశ 8: Hardhat ప్రాజెక్ట్‌ను సృష్టించండి

npx hardhat --initని రన్ చేయడం ద్వారా పూర్తి నమూనా ప్రాజెక్ట్ రూపొందించబడుతుంది, కానీ ఈ ట్యుటోరియల్ కోసం మనం ప్రతి భాగాన్ని మీరు చూసేలా మాన్యువల్‌గా సెటప్ చేస్తాము. మీ ప్రాజెక్ట్ ఫోల్డర్ యొక్క రూట్‌లో, కింది కంటెంట్‌లతో hardhat.config.js అనే ఫైల్‌ను సృష్టించండి:

import { defineConfig } from "hardhat/config"

export default defineConfig({
  solidity: "0.8.34",
})

ఇక్కడే మనం మన ప్రాజెక్ట్ కోసం సెటప్ అంతా పేర్కొంటాము (దశ 13లో). ప్రస్తుతానికి, ఇది Solidity కంపైలర్ యొక్క ఏ వెర్షన్‌ను ఉపయోగించాలో Hardhatకి చెబుతుంది.

దశ 9: ప్రాజెక్ట్ ఫోల్డర్‌లను జోడించండి

మన ప్రాజెక్ట్‌ను క్రమబద్ధంగా ఉంచడానికి, మనం రెండు కొత్త ఫోల్డర్‌లను సృష్టిస్తాము. మీ కమాండ్ లైన్‌లో మీ ప్రాజెక్ట్ యొక్క రూట్ డైరెక్టరీకి వెళ్లి ఇలా టైప్ చేయండి:

mkdir contracts
mkdir scripts

• contracts/ అనేది మన NFT స్మార్ట్ కాంట్రాక్ట్ కోడ్‌ను ఉంచే ప్రదేశం

• scripts/ అనేది మన స్మార్ట్ కాంట్రాక్ట్‌ను డిప్లాయ్ చేయడానికి మరియు ఇంటరాక్ట్ అవ్వడానికి స్క్రిప్ట్‌లను ఉంచే ప్రదేశం

దశ 10: మన కాంట్రాక్ట్‌ను వ్రాయండి

ఇప్పుడు మన వాతావరణం సెటప్ చేయబడింది కాబట్టి, మరింత ఆసక్తికరమైన విషయానికి వెళ్దాం: మన స్మార్ట్ కాంట్రాక్ట్ కోడ్‌ను వ్రాయడం!

మీకు ఇష్టమైన ఎడిటర్‌లో my-nft ప్రాజెక్ట్‌ను తెరవండి (మాకు VSCode (కొత్త ట్యాబ్‌లో తెరవబడుతుంది) ఇష్టం). స్మార్ట్ కాంట్రాక్ట్‌లు Solidity అనే భాషలో వ్రాయబడతాయి, మన MyNFT.sol స్మార్ట్ కాంట్రాక్ట్‌ను వ్రాయడానికి మనం దీనినే ఉపయోగిస్తాము.‌

1. contracts ఫోల్డర్‌కి వెళ్లి MyNFT.sol అనే కొత్త ఫైల్‌ను సృష్టించండి

2. కింద మన NFT స్మార్ట్ కాంట్రాక్ట్ కోడ్ ఉంది, ఇది ఓపెన్‌జెప్పెలిన్ (కొత్త ట్యాబ్‌లో తెరవబడుతుంది) లైబ్రరీ యొక్క ERC-721 అమలుపై ఆధారపడి ఉంటుంది. కింది కంటెంట్‌లను కాపీ చేసి మీ MyNFT.sol ఫైల్‌లో పేస్ట్ చేయండి.

   // https://docs.openzeppelin.com/contracts/5.x/erc721 ఆధారిత కాంట్రాక్ట్
   // SPDX-License-Identifier: MIT
   pragma solidity ^0.8.24;
   
   import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
   import "@openzeppelin/contracts/access/Ownable.sol";
   import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
   
   contract MyNFT is ERC721URIStorage, Ownable {
       uint256 private _nextTokenId;
   
       constructor(address initialOwner)
           ERC721("MyNFT", "NFT")
           Ownable(initialOwner)
       {}
   
       function mintNFT(address recipient, string memory tokenURI)
           public onlyOwner
           returns (uint256)
       {
           uint256 newItemId = ++_nextTokenId;
           _mint(recipient, newItemId);
           _setTokenURI(newItemId, tokenURI);
   
           return newItemId;
       }
   }
   

   కాపీ చేయండిSolidity

   అన్నీ చూపించు (27)

3. మనం ఓపెన్‌జెప్పెలిన్ కాంట్రాక్ట్‌ల లైబ్రరీ నుండి క్లాస్‌లను ఇన్‌హెరిట్ చేస్తున్నందున, మన ఫోల్డర్‌లోకి లైబ్రరీని ఇన్‌స్టాల్ చేయడానికి మీ కమాండ్ లైన్‌లో npm install @openzeppelin/contractsని రన్ చేయండి. ఈ ట్యుటోరియల్ ఓపెన్‌జెప్పెలిన్ కాంట్రాక్ట్స్ 5.xని ఉపయోగిస్తుంది, దీనికి Solidity 0.8.24 లేదా ఆ తర్వాతి వెర్షన్ అవసరం.

కాబట్టి, ఈ కోడ్ ఖచ్చితంగా ఏమి చేస్తుంది? దీన్ని లైన్-బై-లైన్‌గా విడదీసి చూద్దాం.

మన స్మార్ట్ కాంట్రాక్ట్ ఎగువన, మనం మూడు ఓపెన్‌జెప్పెలిన్ (కొత్త ట్యాబ్‌లో తెరవబడుతుంది) స్మార్ట్ కాంట్రాక్ట్ క్లాస్‌లను దిగుమతి చేసుకుంటాము:

• @openzeppelin/contracts/token/ERC721/ERC721.sol అనేది ERC-721 ప్రమాణం యొక్క అమలును కలిగి ఉంటుంది, దీనిని మన NFT స్మార్ట్ కాంట్రాక్ట్ ఇన్‌హెరిట్ చేస్తుంది. (చెల్లుబాటు అయ్యే NFT కావాలంటే, మీ స్మార్ట్ కాంట్రాక్ట్ తప్పనిసరిగా ERC-721 ప్రమాణం యొక్క అన్ని పద్ధతులను అమలు చేయాలి.) ఇన్‌హెరిట్ చేయబడిన ERC-721 ఫంక్షన్‌ల గురించి మరింత తెలుసుకోవడానికి, ఇంటర్‌ఫేస్ నిర్వచనాన్ని ఇక్కడ (కొత్త ట్యాబ్‌లో తెరవబడుతుంది) చూడండి.

• @openzeppelin/contracts/access/Ownable.sol మన స్మార్ట్ కాంట్రాక్ట్‌పై యాక్సెస్ నియంత్రణను (కొత్త ట్యాబ్‌లో తెరవబడుతుంది) సెటప్ చేస్తుంది, కాబట్టి స్మార్ట్ కాంట్రాక్ట్ యజమాని (మీరు) మాత్రమే NFTలను ముద్రించగలరు. కన్స్ట్రక్టర్‌కు పంపబడిన initialOwner చిరునామా యజమాని అవుతుంది. (గమనిక, యాక్సెస్ నియంత్రణను చేర్చడం పూర్తిగా మీ ఇష్టం. మీ స్మార్ట్ కాంట్రాక్ట్‌ని ఉపయోగించి ఎవరైనా NFTని ముద్రించగలగాలని మీరు కోరుకుంటే, కాంట్రాక్ట్ నిర్వచనం మరియు కన్స్ట్రక్టర్ నుండి Ownable మరియు Ownable(initialOwner)ని, మరియు mintNFT ఫంక్షన్ నుండి onlyOwnerని తీసివేయండి.)

• @openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol అనేది ERC-721ని విస్తరిస్తుంది, తద్వారా ప్రతి టోకెన్ దాని స్వంత మెటాడేటా URIని నిల్వ చేయగలదు, దీనిని మనం ముద్రించేటప్పుడు సెట్ చేస్తాము.

మన దిగుమతి స్టేట్‌మెంట్‌ల తర్వాత, మన కస్టమ్ NFT స్మార్ట్ కాంట్రాక్ట్ ఉంది, ఇది ఆశ్చర్యకరంగా చాలా చిన్నది — ఇది కేవలం ఒక కౌంటర్, ఒక కన్స్ట్రక్టర్ మరియు ఒకే ఫంక్షన్‌ను మాత్రమే కలిగి ఉంటుంది! ఇది మనం ఇన్‌హెరిట్ చేసిన ఓపెన్‌జెప్పెలిన్ కాంట్రాక్ట్‌ల వల్లే సాధ్యమైంది, ఇవి NFTని సృష్టించడానికి మనకు అవసరమైన చాలా పద్ధతులను అమలు చేస్తాయి, ఉదాహరణకు NFT యజమానిని తిరిగి ఇచ్చే ownerOf మరియు ఒక ఖాతా నుండి మరొక ఖాతాకు NFT యాజమాన్యాన్ని బదిలీ చేసే transferFrom.

కౌంటర్, _nextTokenId, ముద్రించబడిన మొత్తం NFTల సంఖ్యను ట్రాక్ చేస్తుంది మరియు మన కొత్త NFTపై ప్రత్యేక IDని సెట్ చేస్తుంది. (స్మార్ట్ కాంట్రాక్ట్‌ని ఉపయోగించి ముద్రించబడిన ప్రతి NFTకి తప్పనిసరిగా ఒక ప్రత్యేక ID కేటాయించబడాలి—ఇక్కడ మన ప్రత్యేక ID కేవలం ఉనికిలో ఉన్న మొత్తం NFTల సంఖ్య ద్వారా నిర్ణయించబడుతుంది. ++_nextTokenId కౌంటర్‌ను ఉపయోగించడానికి ముందే పెంచుతుంది, కాబట్టి మన స్మార్ట్ కాంట్రాక్ట్‌తో మనం ముద్రించే మొదటి NFTకి "1" అనే ID ఉంటుంది, మన రెండవ NFTకి "2" అనే ID ఉంటుంది, మొదలైనవి.)

మన ERC-721 కన్స్ట్రక్టర్‌లో, మనం “MyNFT” మరియు “NFT” అనే 2 స్ట్రింగ్‌లను పంపడాన్ని మీరు గమనించవచ్చు. మొదటి వేరియబుల్ స్మార్ట్ కాంట్రాక్ట్ పేరు, మరియు రెండవది దాని చిహ్నం. మీరు ఈ వేరియబుల్స్ ప్రతిదానికీ మీకు నచ్చిన పేరు పెట్టుకోవచ్చు!

చివరగా, NFTని ముద్రించడానికి మనల్ని అనుమతించే mintNFT(address recipient, string memory tokenURI) ఫంక్షన్ మనకు ఉంది! ఈ ఫంక్షన్ రెండు వేరియబుల్స్‌ను తీసుకోవడాన్ని మీరు గమనించవచ్చు:

• address recipient అనేది మీరు కొత్తగా ముద్రించిన NFTని స్వీకరించే చిరునామాను నిర్దేశిస్తుంది

• string memory tokenURI అనేది NFT యొక్క మెటాడేటాను వివరించే JSON డాక్యుమెంట్‌కి రిజాల్వ్ అయ్యే స్ట్రింగ్. NFT యొక్క మెటాడేటా నిజంగా దానికి ప్రాణం పోస్తుంది, పేరు, వివరణ, చిత్రం మరియు ఇతర లక్షణాల వంటి కాన్ఫిగర్ చేయగల ప్రాపర్టీలను కలిగి ఉండటానికి ఇది అనుమతిస్తుంది. ఈ ట్యుటోరియల్ యొక్క 2వ భాగంలో, ఈ మెటాడేటాను ఎలా కాన్ఫిగర్ చేయాలో మేము వివరిస్తాము.

mintNFT ఇన్‌హెరిట్ చేయబడిన ERC-721 లైబ్రరీ నుండి కొన్ని పద్ధతులను కాల్ చేస్తుంది, మరియు అంతిమంగా కొత్తగా ముద్రించబడిన NFT యొక్క IDని సూచించే సంఖ్యను తిరిగి ఇస్తుంది.

దశ 11: మీ ప్రాజెక్ట్‌కి మెటామాస్క్ & Alchemyని కనెక్ట్ చేయండి

ఇప్పుడు మనం మెటామాస్క్ వాలెట్, Alchemy ఖాతాను సృష్టించాము మరియు మన స్మార్ట్ కాంట్రాక్ట్‌ను వ్రాశాము కాబట్టి, ఈ మూడింటినీ కనెక్ట్ చేయడానికి ఇది సమయం.

మీ వర్చువల్ వాలెట్ నుండి పంపబడే ప్రతి లావాదేవీకి మీ ప్రత్యేక ప్రైవేట్ కీని ఉపయోగించి సంతకం అవసరం. మన ప్రోగ్రామ్‌కు ఈ అనుమతిని అందించడానికి, మనం మన ప్రైవేట్ కీని (మరియు Alchemy API కీని) ఎన్విరాన్‌మెంట్ ఫైల్‌లో సురక్షితంగా నిల్వ చేయవచ్చు.

లావాదేవీలను పంపడం గురించి మరింత తెలుసుకోవడానికి, లావాదేవీల డాక్యుమెంటేషన్‌ను చూడండి.

మన ప్రాజెక్ట్ యొక్క రూట్ డైరెక్టరీలో .env ఫైల్‌ను సృష్టించండి మరియు దానికి మీ మెటామాస్క్ ప్రైవేట్ కీ మరియు HTTP Alchemy API URLని జోడించండి.

• మెటామాస్క్ నుండి మీ ప్రైవేట్ కీని ఎగుమతి చేయడానికి ఈ సూచనలను (కొత్త ట్యాబ్‌లో తెరవబడుతుంది) అనుసరించండి

• HTTP Alchemy API URLని పొందడానికి మరియు దానిని మీ క్లిప్‌బోర్డ్‌కి కాపీ చేయడానికి కింద చూడండి

మీ .env ఇప్పుడు ఇలా కనిపించాలి:

API_URL="https://eth-sepolia.g.alchemy.com/v2/your-api-key"
PRIVATE_KEY="your-metamask-private-key"

వీటిని వాస్తవానికి మన కోడ్‌కి కనెక్ట్ చేయడానికి, మనం దశ 13లో మన hardhat.config.js ఫైల్‌లో ఈ వేరియబుల్స్‌ను సూచిస్తాము. Node.js స్వంతంగా .env ఫైల్‌లను చదవగలదు, కాబట్టి ఇన్‌స్టాల్ చేయడానికి అదనపు ప్యాకేజీ ఏమీ లేదు.

దశ 12: Ethers.jsని ఇన్‌స్టాల్ చేయండి

Ethers.js అనేది ప్రామాణిక జేసన్-ఆర్‌పీసీ పద్ధతులను మరింత యూజర్ ఫ్రెండ్లీ పద్ధతులతో ర్యాప్ చేయడం ద్వారా ఎథీరియంతో ఇంటరాక్ట్ అవ్వడాన్ని మరియు అభ్యర్థనలు చేయడాన్ని సులభతరం చేసే లైబ్రరీ.

అదనపు టూలింగ్ మరియు విస్తరించిన కార్యాచరణ కోసం ప్లగిన్‌లను (కొత్త ట్యాబ్‌లో తెరవబడుతుంది) ఏకీకృతం చేయడాన్ని Hardhat చాలా సులభతరం చేస్తుంది. కాంట్రాక్ట్ డిప్లాయ్‌మెంట్ కోసం మనం Ethers ప్లగిన్‌ను (కొత్త ట్యాబ్‌లో తెరవబడుతుంది) ఉపయోగించుకుంటాము (Ethers.js (కొత్త ట్యాబ్‌లో తెరవబడుతుంది) కొన్ని చాలా స్పష్టమైన కాంట్రాక్ట్ డిప్లాయ్‌మెంట్ పద్ధతులను కలిగి ఉంది).

మీ ప్రాజెక్ట్ డైరెక్టరీలో ఇలా టైప్ చేయండి:

npm install --save-dev @nomicfoundation/hardhat-ethers ethers

తదుపరి దశలో మనం మన hardhat.config.jsకి ప్లగిన్‌ను కూడా జోడిస్తాము.

దశ 13: hardhat.config.jsని అప్‌డేట్ చేయండి

మనం ఇప్పటివరకు అనేక డిపెండెన్సీలు మరియు ప్లగిన్‌లను జోడించాము, ఇప్పుడు మన ప్రాజెక్ట్‌కి వాటన్నింటి గురించి తెలిసేలా మనం hardhat.config.jsని అప్‌డేట్ చేయాలి.

మీ hardhat.config.js ఇలా కనిపించేలా అప్‌డేట్ చేయండి:

import { existsSync } from "node:fs"
import hardhatEthers from "@nomicfoundation/hardhat-ethers"
import { configVariable, defineConfig } from "hardhat/config"

// .env ఫైల్ ఉంటే, దాని నుండి API_URL మరియు PRIVATE_KEY లను process.env లోకి లోడ్ చేయండి
if (existsSync(".env")) process.loadEnvFile()

export default defineConfig({
  plugins: [hardhatEthers],
  solidity: "0.8.34",
  networks: {
    sepolia: {
      type: "http",
      url: configVariable("API_URL"),
      accounts: [configVariable("PRIVATE_KEY")],
    },
  },
})

configVariable ఎన్విరాన్‌మెంట్ వేరియబుల్ నుండి ప్రతి విలువను అవసరమైనప్పుడు మాత్రమే చదవమని Hardhatకి చెబుతుంది, కాబట్టి విలువలు సెట్ చేయబడక ముందే compile లాంటి కమాండ్‌లు పనిచేస్తాయి. మీరు మీ ప్రైవేట్ కీని ప్లెయిన్ టెక్స్ట్ ఫైల్‌లో ఉంచకూడదనుకుంటే, Hardhat ఎన్‌క్రిప్ట్ చేయబడిన కీస్టోర్ నుండి కాన్ఫిగరేషన్ వేరియబుల్స్‌ను (కొత్త ట్యాబ్‌లో తెరవబడుతుంది) కూడా చదవగలదు.

దశ 14: మన కాంట్రాక్ట్‌ను కంపైల్ చేయండి

ఇప్పటివరకు అంతా సరిగ్గా పనిచేస్తుందో లేదో నిర్ధారించుకోవడానికి, మన కాంట్రాక్ట్‌ను కంపైల్ చేద్దాం. కంపైల్ టాస్క్ అనేది అంతర్నిర్మిత hardhat టాస్క్‌లలో ఒకటి.

కమాండ్ లైన్ నుండి దీన్ని రన్ చేయండి:

npx hardhat compile

మీరు మొదటిసారి కంపైల్ చేసినప్పుడు, Hardhat Solidity కంపైలర్‌ను డౌన్‌లోడ్ చేస్తుంది. ఆ తర్వాత మీరు Compiled 1 Solidity file with solc 0.8.34 లాంటిది చూడాలి. అలా కాకపోతే, మీరు ఎప్పుడైనా Alchemy డిస్కార్డ్ (కొత్త ట్యాబ్‌లో తెరవబడుతుంది)లో మెసేజ్ చేయవచ్చు.

దశ 15: మన డిప్లాయ్ స్క్రిప్ట్‌ను వ్రాయండి

ఇప్పుడు మన కాంట్రాక్ట్ వ్రాయబడింది మరియు మన కాన్ఫిగరేషన్ ఫైల్ సిద్ధంగా ఉంది కాబట్టి, మన కాంట్రాక్ట్ డిప్లాయ్ స్క్రిప్ట్‌ను వ్రాయడానికి ఇది సమయం.

scripts/ ఫోల్డర్‌కి వెళ్లి deploy.js అనే కొత్త ఫైల్‌ను సృష్టించండి, దానికి కింది కంటెంట్‌లను జోడించండి:

import { network } from "hardhat"

const { ethers } = await network.create()

const [deployer] = await ethers.getSigners()
const MyNFT = await ethers.getContractFactory("MyNFT")

// డిప్లాయ్‌మెంట్ ప్రారంభించండి, కాంట్రాక్ట్ ఆబ్జెక్ట్‌గా రిజాల్వ్ అయ్యే ప్రామిస్‌ను అందిస్తుంది
const myNFT = await MyNFT.deploy(deployer.address)
await myNFT.waitForDeployment()
console.log("Contract deployed to address:", await myNFT.getAddress())

ఈ కోడ్ లైన్‌లలో ప్రతిదీ ఏమి చేస్తుందో చూద్దాం.

const { ethers } = await network.create()

Hardhat 3లో, స్క్రిప్ట్ నెట్‌వర్క్‌కి కనెక్షన్‌ను స్పష్టంగా తెరుస్తుంది. మీరు స్క్రిప్ట్‌ను రన్ చేసినప్పుడు --network ఎంపికతో మీరు ఎంచుకున్న నెట్‌వర్క్‌కి network.create() కనెక్ట్ అవుతుంది, మరియు hardhat-ethers ప్లగిన్ ఆ కనెక్షన్‌కి ethers ఆబ్జెక్ట్‌ను జోడిస్తుంది.

const [deployer] = await ethers.getSigners()

getSigners() నెట్‌వర్క్ కోసం కాన్ఫిగర్ చేయబడిన ఖాతాలను తిరిగి ఇస్తుంది. Sepoliaలో, అది మీరు .envలో ఉంచిన ప్రైవేట్ కీకి సంబంధించిన ఖాతా. మీరు కాంట్రాక్ట్ యజమాని అయ్యేలా మేము దాని చిరునామాను కన్స్ట్రక్టర్‌కు పంపుతాము.

const MyNFT = await ethers.getContractFactory("MyNFT")

ethers.jsలోని ContractFactory అనేది కొత్త స్మార్ట్ కాంట్రాక్ట్‌లను డిప్లాయ్ చేయడానికి ఉపయోగించే ఒక అబ్‌స్ట్రాక్షన్, కాబట్టి ఇక్కడ MyNFT అనేది మన NFT కాంట్రాక్ట్ ఇన్‌స్టాన్స్‌ల కోసం ఒక ఫ్యాక్టరీ. hardhat-ethers ప్లగిన్‌ను ఉపయోగిస్తున్నప్పుడు ContractFactory మరియు Contract ఇన్‌స్టాన్స్‌లు డిఫాల్ట్‌గా మొదటి సంతకందారుకి కనెక్ట్ చేయబడతాయి.

const myNFT = await MyNFT.deploy(deployer.address)

ContractFactoryపై deploy()ని కాల్ చేయడం డిప్లాయ్‌మెంట్‌ను ప్రారంభిస్తుంది మరియు Contractకి రిజాల్వ్ అయ్యే ప్రామిస్‌ను తిరిగి ఇస్తుంది. ఇది మన స్మార్ట్ కాంట్రాక్ట్ ఫంక్షన్‌లలో ప్రతిదానికీ ఒక పద్ధతిని కలిగి ఉన్న ఆబ్జెక్ట్. మీరు deploy()కి పంపే ఆర్గ్యుమెంట్‌లు కాంట్రాక్ట్ కన్స్ట్రక్టర్‌కి వెళ్తాయి, ఇక్కడ అది initialOwner చిరునామా.

డిప్లాయ్‌మెంట్ లావాదేవీ బ్లాక్‌లో చేర్చబడే వరకు waitForDeployment() వేచి ఉంటుంది, మరియు getAddress() కొత్త కాంట్రాక్ట్ చిరునామాను తిరిగి ఇస్తుంది. మరిన్ని వివరాల కోసం ethers.js కాంట్రాక్ట్ డాక్యుమెంటేషన్‌ను (కొత్త ట్యాబ్‌లో తెరవబడుతుంది) చూడండి.

దశ 16: మన కాంట్రాక్ట్‌ను డిప్లాయ్ చేయండి

మనం చివరగా మన స్మార్ట్ కాంట్రాక్ట్‌ను డిప్లాయ్ చేయడానికి సిద్ధంగా ఉన్నాము! మీ ప్రాజెక్ట్ డైరెక్టరీ యొక్క రూట్‌కి తిరిగి వెళ్లి, కమాండ్ లైన్‌లో దీన్ని రన్ చేయండి:

npx hardhat run scripts/deploy.js --network sepolia

ఆ తర్వాత మీరు ఇలాంటిది చూడాలి:

Contract deployed to address: 0x4C5266cCc4b3F426965d2f51b6D910325a0E7650

మనం Sepolia Etherscan (కొత్త ట్యాబ్‌లో తెరవబడుతుంది)కి వెళ్లి మన కాంట్రాక్ట్ చిరునామా కోసం వెతికితే, అది విజయవంతంగా డిప్లాయ్ చేయబడిందని మనం చూడగలగాలి. మీకు అది వెంటనే కనిపించకపోతే, దానికి కొంత సమయం పట్టవచ్చు కాబట్టి దయచేసి కాసేపు వేచి ఉండండి. లావాదేవీ ఇలా కనిపిస్తుంది:

From చిరునామా మీ మెటామాస్క్ ఖాతా చిరునామాతో సరిపోలాలి మరియు To చిరునామా “Contract Creation” అని చెబుతుంది. మనం లావాదేవీపై క్లిక్ చేస్తే, To ఫీల్డ్‌లో మన కాంట్రాక్ట్ చిరునామాను చూస్తాము:

అద్భుతం! మీరు ఇప్పుడే మీ NFT స్మార్ట్ కాంట్రాక్ట్‌ను ఎథీరియం (టెస్ట్‌నెట్) చైన్‌కి డిప్లాయ్ చేశారు!

అంతర్గతంగా ఏమి జరుగుతుందో అర్థం చేసుకోవడానికి, మీ Alchemy డాష్‌బోర్డ్‌లో (కొత్త ట్యాబ్‌లో తెరవబడుతుంది) మీ యాప్ స్వీకరించిన అభ్యర్థనలను మీరు చూడవచ్చు.

మనం .deploy() ఫంక్షన్‌ను కాల్ చేసినప్పుడు Hardhat/Ethers మన కోసం అంతర్గతంగా చేసిన కొన్ని జేసన్-ఆర్‌పీసీ కాల్‌లను మీరు అక్కడ చూస్తారు. ఇక్కడ పేర్కొనవలసిన రెండు ముఖ్యమైనవి eth_sendRawTransaction, ఇది వాస్తవానికి మన స్మార్ట్ కాంట్రాక్ట్‌ను Sepolia చైన్‌లో వ్రాయడానికి చేసే అభ్యర్థన, మరియు eth_getTransactionByHash ఇది హాష్ ఇవ్వబడినప్పుడు మన లావాదేవీ గురించిన సమాచారాన్ని చదవడానికి చేసే అభ్యర్థన (లావాదేవీలను పంపేటప్పుడు ఇది ఒక సాధారణ పద్ధతి). లావాదేవీలను పంపడం గురించి మరింత తెలుసుకోవడానికి, లావాదేవీల డాక్యుమెంటేషన్‌ను చూడండి.

ఈ ట్యుటోరియల్ యొక్క 1వ భాగానికి అంతే. 2వ భాగంలో, మనం NFTని ముద్రించడం ద్వారా మన స్మార్ట్ కాంట్రాక్ట్‌తో వాస్తవానికి ఇంటరాక్ట్ అవుతాము, మరియు 3వ భాగంలో మీ ఎథీరియం వాలెట్‌లో మీ NFTని ఎలా చూడాలో మేము మీకు చూపుతాము!