ஒரு NFT-ஐ எழுதுவது மற்றும் நிலைநிறுத்துவது எப்படி (NFT பயிற்சித் தொடரின் பகுதி 1/3)

ERC-721

Alchemy

Solidity

திறன் ஒப்பந்தங்கள்

தொடக்கநிலை

சுமி முத்கில்

22 ஏப்ரல், 2021

12 நிமிட வாசிப்பு

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 சோதனை வலையமைப்பிற்குக் கோரிக்கைகளைச் செய்ய நம்மை அனுமதிக்கும். சோதனை வலையமைப்புகளைப் பற்றி மேலும் அறிய நீங்கள் ஆர்வமாக இருந்தால், இந்த வழிகாட்டியைப் (புதிய தாவலில் திறக்கும்) பார்க்கவும்.

வழிசெலுத்தல் பட்டியில் "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-இல்). இப்போதைக்கு, Solidity தொகுப்பியின் எந்தப் பதிப்பைப் பயன்படுத்த வேண்டும் என்பதை மட்டுமே இது Hardhat-க்குச் சொல்கிறது.

படி 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 நமது திறன் ஒப்பந்தத்தில் அணுகல் கட்டுப்பாட்டை (புதிய தாவலில் திறக்கும்) அமைக்கிறது, எனவே திறன் ஒப்பந்தத்தின் உரிமையாளர் (நீங்கள்) மட்டுமே NFT-களை அச்சிட முடியும். உரிமையாளர் என்பது ஆக்கிக்கு அனுப்பப்பட்ட initialOwner முகவரியாகும். (குறிப்பு, அணுகல் கட்டுப்பாட்டைச் சேர்ப்பது முற்றிலும் ஒரு விருப்பமாகும். உங்கள் திறன் ஒப்பந்தத்தைப் பயன்படுத்தி யார் வேண்டுமானாலும் NFT-ஐ அச்சிட விரும்பினால், ஒப்பந்த வரையறை மற்றும் ஆக்கியிலிருந்து Ownable மற்றும் Ownable(initialOwner) என்பதையும், mintNFT செயல்பாட்டிலிருந்து onlyOwner என்பதையும் அகற்றவும்.)
@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol ERC-721-ஐ நீட்டிக்கிறது, இதனால் ஒவ்வொரு வில்லையும் அதன் சொந்த மீத்தரவு URI-ஐச் சேமிக்க முடியும், இதை நாம் அச்சிடும்போது அமைக்கிறோம்.

நமது இறக்குமதி அறிக்கைகளுக்குப் பிறகு, நமது தனிப்பயன் NFT திறன் ஒப்பந்தம் உள்ளது, இது ஆச்சரியப்படும் விதமாகச் சிறியது — இது ஒரு கவுண்டர், ஒரு ஆக்கி மற்றும் ஒற்றைச் செயல்பாட்டை மட்டுமே கொண்டுள்ளது! இது நாம் பெற்ற ஓப்பன்செப்பெலின் ஒப்பந்தங்களுக்கு நன்றி, இது NFT-இன் உரிமையாளரைத் திருப்பித் தரும் ownerOf மற்றும் ஒரு கணக்கிலிருந்து மற்றொரு கணக்கிற்கு NFT-இன் உரிமையை மாற்றும் transferFrom போன்ற ஒரு NFT-ஐ உருவாக்க நமக்குத் தேவையான பெரும்பாலான முறைகளைச் செயல்படுத்துகிறது.

கவுண்டர், _nextTokenId, அச்சிடப்பட்ட NFT-களின் மொத்த எண்ணிக்கையைக் கண்காணித்து, நமது புதிய NFT-இல் தனிப்பட்ட ID-ஐ அமைக்கிறது. (ஒரு திறன் ஒப்பந்தத்தைப் பயன்படுத்தி அச்சிடப்படும் ஒவ்வொரு NFT-க்கும் ஒரு தனிப்பட்ட ID ஒதுக்கப்பட வேண்டும்—இங்கே நமது தனிப்பட்ட ID என்பது பயன்பாட்டில் உள்ள NFT-களின் மொத்த எண்ணிக்கையால் தீர்மானிக்கப்படுகிறது. ++_nextTokenId கவுண்டரைப் பயன்படுத்துவதற்கு முன்பு அதை அதிகரிக்கிறது, எனவே நமது திறன் ஒப்பந்தத்துடன் நாம் அச்சிடும் முதல் NFT-இன் ID "1", நமது இரண்டாவது NFT-இன் ID "2" போன்றவற்றைக் கொண்டிருக்கும்.)

நமது 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 கோப்புகளைப் படிக்க முடியும், எனவே நிறுவ கூடுதல் தொகுப்பு எதுவும் இல்லை.

.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")

// ஒரு ஒப்பந்தப் பொருளாகத் தீர்க்கப்படும் promise-ஐத் திருப்பி அளித்து, நிலைநிறுத்தத்தைத் தொடங்கவும்
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-க்குத் தீர்வு காணும் ஒரு Promise-ஐத் திருப்பித் தரும். இது நமது திறன் ஒப்பந்தச் செயல்பாடுகள் ஒவ்வொன்றிற்கும் ஒரு முறையைக் கொண்ட பொருளாகும். 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-ஐ எவ்வாறு பார்ப்பது என்பதை நாங்கள் உங்களுக்குக் காண்பிப்போம்!