NFT कसे लिहावे आणि प्रस्थापित करावे (NFT ट्युटोरियल मालिकेचा भाग 1/3)

ERC-721

Alchemy

Solidity

स्मार्ट कॉन्ट्रॅक्ट्स

नवशिक्या

सुमी मुदगील

22 एप्रिल, 2021

14 मिनिटांचे वाचन

NFT मुळे ब्लॉकचेन लोकांच्या नजरेत येत असल्याने, इथेरियम ब्लॉकचेनवर तुमचे स्वतःचे NFT कॉन्ट्रॅक्ट (ERC-721 टोकन) प्रकाशित करून स्वतः ही चर्चा समजून घेण्याची आता एक उत्तम संधी आहे!

या ट्युटोरियलमध्ये, आम्ही MetaMask (नवीन टॅबमध्ये उघडते), 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 टेस्टनेटवर विनंत्या करण्याची अनुमती देईल. तुम्हाला टेस्टनेटबद्दल अधिक जाणून घेण्याची उत्सुकता असल्यास हे मार्गदर्शक (नवीन टॅबमध्ये उघडते) तपासा.

नॅव्हिगेशन बारमध्ये "Select an app" निवडून आणि "Create new app" वर क्लिक करून तुमच्या Alchemy डॅशबोर्डमधील "Create new app" पेजवर जा.

तुमच्या ॲपला नाव द्या (आम्ही “My First NFT!” निवडले), एक लहान वर्णन द्या आणि युज केस निवडा. पुढे, "Ethereum" शोधा आणि नेटवर्क निवडा. आम्ही ॲप्लिकेशन डेव्हलपमेंटसाठी शिफारस केलेले टेस्टनेट, Sepolia वापरू (इथेरियम नेटवर्क पहा).
पुढे जाण्यासाठी "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 वर). आत्तासाठी, ते फक्त Hardhat ला Solidity कंपायलरची कोणती आवृत्ती वापरायची ते सांगते.

पायरी 9: प्रोजेक्ट फोल्डर्स जोडा

आमचा प्रोजेक्ट व्यवस्थित ठेवण्यासाठी, आम्ही दोन नवीन फोल्डर्स तयार करू. तुमच्या कमांड लाईनमध्ये तुमच्या प्रोजेक्टच्या रूट डिरेक्टरीवर जा आणि टाइप करा:

mkdir contracts
mkdir scripts

contracts/ येथे आम्ही आमचा NFT स्मार्ट कॉन्ट्रॅक्ट कोड ठेवू
scripts/ येथे आम्ही आमचे स्मार्ट कॉन्ट्रॅक्ट प्रस्थापित करण्यासाठी आणि त्याच्याशी संवाद साधण्यासाठी स्क्रिप्ट्स ठेवू

पायरी 10: आमचे कॉन्ट्रॅक्ट लिहा

आता आमचे एन्वायरमेंट सेट झाले आहे, अधिक रोमांचक गोष्टींकडे वळूया: आमचा स्मार्ट कॉन्ट्रॅक्ट कोड लिहिणे!

तुमच्या आवडत्या एडिटरमध्ये my-nft प्रोजेक्ट उघडा (आम्हाला VSCode (नवीन टॅबमध्ये उघडते) आवडते). स्मार्ट कॉन्ट्रॅक्ट्स Solidity नावाच्या भाषेत लिहिलेले असतात जे आम्ही आमचे MyNFT.sol स्मार्ट कॉन्ट्रॅक्ट लिहिण्यासाठी वापरू.‌

contracts फोल्डरवर जा आणि MyNFT.sol नावाची नवीन फाईल तयार करा

खाली आमचा 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;
    }
}

कारण आम्ही ओपनझेपलिन कॉन्ट्रॅक्ट्स लायब्ररीमधून क्लासेस इनहेरिट करत आहोत, आमच्या फोल्डरमध्ये लायब्ररी इन्स्टॉल करण्यासाठी तुमच्या कमांड लाईनमध्ये 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 आमच्या स्मार्ट कॉन्ट्रॅक्टवर ॲक्सेस कंट्रोल (नवीन टॅबमध्ये उघडते) सेट करते, त्यामुळे फक्त स्मार्ट कॉन्ट्रॅक्टचा मालक (तुम्ही) NFTs मिंट करू शकतो. मालक हा कन्स्ट्रक्टरला पास केलेला initialOwner पत्ता असतो. (लक्षात घ्या, ॲक्सेस कंट्रोल समाविष्ट करणे ही पूर्णपणे एक पसंती आहे. जर तुम्हाला कोणीही तुमचे स्मार्ट कॉन्ट्रॅक्ट वापरून NFT मिंट करू शकावे असे वाटत असेल, तर कॉन्ट्रॅक्ट व्याख्या आणि कन्स्ट्रक्टरमधून Ownable आणि Ownable(initialOwner) काढून टाका, आणि mintNFT फंक्शनमधून onlyOwner काढून टाका.)
@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol ERC-721 चा विस्तार करते जेणेकरून प्रत्येक टोकन स्वतःचा मेटाडेटा URI स्टोअर करू शकेल, जो आम्ही मिंटिंग करताना सेट करतो.

आमच्या इम्पोर्ट स्टेटमेंट्सनंतर, आमच्याकडे आमचे कस्टम NFT स्मार्ट कॉन्ट्रॅक्ट आहे, जे आश्चर्यकारकपणे लहान आहे — त्यात फक्त एक काउंटर, एक कन्स्ट्रक्टर आणि एकच फंक्शन आहे! हे आमच्या इनहेरिट केलेल्या ओपनझेपलिन कॉन्ट्रॅक्ट्समुळे आहे, जे आम्हाला NFT तयार करण्यासाठी आवश्यक असलेल्या बहुतेक पद्धती लागू करतात, जसे की ownerOf जे NFT चा मालक परत करते, आणि transferFrom, जे एका खात्यातून दुसऱ्या खात्यात NFT ची मालकी हस्तांतरित करते.

काउंटर, _nextTokenId, मिंट केलेल्या एकूण NFTs ची नोंद ठेवतो आणि आमच्या नवीन NFT वर युनिक ID सेट करतो. (स्मार्ट कॉन्ट्रॅक्ट वापरून मिंट केलेल्या प्रत्येक NFT ला एक युनिक ID नियुक्त करणे आवश्यक आहे—येथे आमचा युनिक ID फक्त अस्तित्वात असलेल्या एकूण NFTs च्या संख्येवरून निर्धारित केला जातो. ++_nextTokenId वापरण्यापूर्वी काउंटर वाढवतो, त्यामुळे आम्ही आमच्या स्मार्ट कॉन्ट्रॅक्टसह मिंट केलेल्या पहिल्या NFT चा ID "1" असतो, आमच्या दुसऱ्या NFT चा ID "2" असतो, इ.)

आमच्या ERC-721 कन्स्ट्रक्टरमध्ये, तुमच्या लक्षात येईल की आम्ही 2 स्ट्रिंग्स पास करतो, “MyNFT” आणि “NFT.” पहिले व्हेरिएबल स्मार्ट कॉन्ट्रॅक्टचे नाव आहे आणि दुसरे त्याचे चिन्ह आहे. तुम्ही या प्रत्येक व्हेरिएबलला तुम्हाला हवे ते नाव देऊ शकता!

शेवटी, आमच्याकडे आमचे फंक्शन mintNFT(address recipient, string memory tokenURI) आहे जे आम्हाला NFT मिंट करण्याची अनुमती देते! तुमच्या लक्षात येईल की हे फंक्शन दोन व्हेरिएबल्स घेते:

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 फाईल्स वाचू शकते, त्यामुळे इन्स्टॉल करण्यासाठी कोणतेही अतिरिक्त पॅकेज नाही.

.env कमिट करू नका! कृपया तुमची .env फाईल कोणाशीही शेअर किंवा उघड न करण्याची खात्री करा, कारण असे केल्याने तुम्ही तुमची गुपिते धोक्यात आणत आहात. जर तुम्ही व्हर्जन कंट्रोल वापरत असाल, तर तुमची .env फाईल gitignore फाईलमध्ये जोडा.

पायरी 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.create() तुम्ही --network पर्यायासह निवडलेल्या नेटवर्कशी कनेक्ट होते आणि 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 तुमच्या इथेरियम वॉलेटमध्ये कसे पाहायचे ते दाखवू!