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

ERC-721

Alchemy

Solidity

ஸ்மார்ட் ஒப்பந்தங்கள்

தொடக்கநிலையாளர்

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

22 ஏப்ரல், 2021

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

NFTகள் பிளாக்செயினை பொதுமக்களின் கவனத்திற்குக் கொண்டு வருவதால், Ethereum பிளாக்செயினில் உங்கள் சொந்த NFT ஒப்பந்தத்தை (ERC-721 டோக்கன்) வெளியிடுவதன் மூலம் இந்த ஆர்வத்தை நீங்களே புரிந்துகொள்ள இது ஒரு சிறந்த வாய்ப்பாகும்!

Makersplace (சமீபத்தில் Christie’s-ல் $69 மில்லியனுக்கு டிஜிட்டல் கலைப்படைப்பு விற்பனையில் சாதனை படைத்தது), Dapper Labs (NBA Top Shot & Crypto Kitties-ன் உருவாக்குநர்கள்), OpenSea (உலகின் மிகப்பெரிய NFT சந்தை), Zora, Super Rare, NFTfi, Foundation, Enjin, Origin Protocol, Immutable மற்றும் பலவற்றை உள்ளடக்கிய NFT துறையில் உள்ள மிகப்பெரிய பெயர்களுக்கு ஆற்றல் அளிப்பதில் Alchemy மிகவும் பெருமை கொள்கிறது.

இந்தப் பயிற்சியில், MetaMask (opens in a new tab), Solidity (opens in a new tab), Hardhat (opens in a new tab), Pinata (opens in a new tab) மற்றும் Alchemy (opens in a new tab) ஆகியவற்றைப் பயன்படுத்தி Sepolia சோதனை நெட்வொர்க்கில் ERC-721 ஸ்மார்ட் ஒப்பந்தத்தை உருவாக்கி வெளியிடுவதைப் பார்ப்போம் (இதன் அர்த்தம் என்னவென்று உங்களுக்கு இன்னும் புரியவில்லை என்றால் கவலைப்பட வேண்டாம் — நாங்கள் அதை விளக்குவோம்!).

இந்தப் பயிற்சியின் பகுதி 2-ல், NFT-ஐ உருவாக்க (mint) நமது ஸ்மார்ட் ஒப்பந்தத்தை எவ்வாறு பயன்படுத்தலாம் என்பதைப் பார்ப்போம், மேலும் பகுதி 3-ல் MetaMask-ல் உங்கள் NFT-ஐ எவ்வாறு பார்ப்பது என்பதை விளக்குவோம்.

நிச்சயமாக, எந்த நேரத்திலும் உங்களுக்குக் கேள்விகள் இருந்தால், Alchemy Discord (opens in a new tab)-ல் தொடர்புகொள்ளத் தயங்க வேண்டாம் அல்லது Alchemy-ன் NFT API ஆவணங்களை (opens in a new tab) பார்வையிடவும்!

படி 1: Ethereum நெட்வொர்க்குடன் இணைக்கவும்

Ethereum பிளாக்செயினுக்கு கோரிக்கைகளைச் செய்ய பல வழிகள் உள்ளன, ஆனால் விஷயங்களை எளிதாக்க, Alchemy (opens in a new tab)-ல் ஒரு இலவசக் கணக்கைப் பயன்படுத்துவோம், இது ஒரு பிளாக்செயின் டெவலப்பர் தளம் மற்றும் API ஆகும், இது நமது சொந்த நோடுகளை இயக்காமலேயே Ethereum செயினுடன் தொடர்புகொள்ள அனுமதிக்கிறது.

இந்தப் பயிற்சியில், நமது ஸ்மார்ட் ஒப்பந்த வெளியீட்டில் என்ன நடக்கிறது என்பதைப் புரிந்துகொள்ள, கண்காணிப்பு மற்றும் பகுப்பாய்விற்கான Alchemy-ன் டெவலப்பர் கருவிகளையும் பயன்படுத்திக் கொள்வோம். உங்களிடம் ஏற்கனவே Alchemy கணக்கு இல்லையென்றால், இங்கே (opens in a new tab) இலவசமாகப் பதிவு செய்யலாம்.

படி 2: உங்கள் பயன்பாட்டை (மற்றும் API திறவுகோலை) உருவாக்கவும்

நீங்கள் Alchemy கணக்கை உருவாக்கியதும், ஒரு பயன்பாட்டை உருவாக்குவதன் மூலம் API திறவுகோலை உருவாக்கலாம். இது Sepolia சோதனை நெட்வொர்க்கிற்கு கோரிக்கைகளைச் செய்ய அனுமதிக்கும். சோதனை நெட்வொர்க்குகளைப் பற்றி மேலும் அறிய நீங்கள் ஆர்வமாக இருந்தால் இந்த வழிகாட்டியைப் (opens in a new tab) பார்க்கவும்.

நேவிகேஷன் பட்டியில் உள்ள “Apps” என்பதன் மீது கர்சரை வைத்து, “Create App” என்பதைக் கிளிக் செய்வதன் மூலம் உங்கள் Alchemy டேஷ்போர்டில் உள்ள “Create App” பக்கத்திற்குச் செல்லவும்.

உங்கள் பயன்பாட்டிற்குப் பெயரிடவும் (நாங்கள் “My First NFT!” என்பதைத் தேர்ந்தெடுத்தோம்), ஒரு சிறிய விளக்கத்தை வழங்கவும், செயினுக்கு “Ethereum” என்பதைத் தேர்ந்தெடுத்து, உங்கள் நெட்வொர்க்கிற்கு “Sepolia” என்பதைத் தேர்ந்தெடுக்கவும். மெர்ஜிற்குப் பிறகு மற்ற சோதனை நெட்வொர்க்குகள் கைவிடப்பட்டன.

“Create app” என்பதைக் கிளிக் செய்யவும், அவ்வளவுதான்! உங்கள் பயன்பாடு கீழே உள்ள அட்டவணையில் தோன்ற வேண்டும்.

படி 3: ஒரு Ethereum கணக்கை (முகவரியை) உருவாக்கவும்

பரிவர்த்தனைகளை அனுப்பவும் பெறவும் நமக்கு ஒரு Ethereum கணக்கு தேவை. இந்தப் பயிற்சிக்காக, உங்கள் Ethereum கணக்கு முகவரியை நிர்வகிக்கப் பயன்படும் உலாவியில் உள்ள மெய்நிகர் வாலட்டான MetaMask-ஐப் பயன்படுத்துவோம். Ethereum-ல் பரிவர்த்தனைகள் எவ்வாறு செயல்படுகின்றன என்பதைப் பற்றி மேலும் புரிந்துகொள்ள விரும்பினால், Ethereum அறக்கட்டளையின் இந்தப் பக்கத்தைப் பார்க்கவும்.

நீங்கள் இங்கே (opens in a new tab) இலவசமாக MetaMask கணக்கைப் பதிவிறக்கம் செய்து உருவாக்கலாம். நீங்கள் ஒரு கணக்கை உருவாக்கும்போது, அல்லது உங்களிடம் ஏற்கனவே கணக்கு இருந்தால், மேல் வலதுபுறத்தில் உள்ள “Sepolia Test Network”-க்கு மாறுவதை உறுதிசெய்து கொள்ளவும் (இதனால் நாம் உண்மையான பணத்தைக் கையாள மாட்டோம்).

படி 4: ஒரு Faucet-லிருந்து ஈதரைச் சேர்க்கவும்

நமது ஸ்மார்ட் ஒப்பந்தத்தை சோதனை நெட்வொர்க்கில் வெளியிட, நமக்குச் சில போலி ETH தேவைப்படும். ETH-ஐப் பெற, Alchemy வழங்கும் Sepolia Faucet (opens in a new tab)-க்குச் சென்று, உள்நுழைந்து உங்கள் கணக்கு முகவரியை உள்ளிட்டு, “Send Me ETH” என்பதைக் கிளிக் செய்யலாம். சிறிது நேரத்திலேயே உங்கள் MetaMask கணக்கில் ETH-ஐக் காண முடியும்!

படி 5: உங்கள் இருப்பைச் சரிபார்க்கவும்

நமது இருப்பு அங்கு உள்ளதா என்பதை இருமுறை சரிபார்க்க, Alchemy-ன் composer கருவியைப் (opens in a new tab) பயன்படுத்தி eth_getBalance (opens in a new tab) கோரிக்கையைச் செய்வோம். இது நமது வாலட்டில் உள்ள ETH அளவை வழங்கும். உங்கள் MetaMask கணக்கு முகவரியை உள்ளிட்டு “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 நிறுவப்படவில்லை என்றால், இந்த வழிமுறைகளைப் (opens in a new tab) பின்பற்றவும் (நமக்கு Node.js (opens in a new tab)-ம் தேவைப்படும், எனவே அதையும் பதிவிறக்கம் செய்யவும்!).

npm init

நிறுவல் கேள்விகளுக்கு நீங்கள் எவ்வாறு பதிலளிக்கிறீர்கள் என்பது முக்கியமல்ல; குறிப்புக்காக நாங்கள் அதை எவ்வாறு செய்தோம் என்பது இங்கே:

1    package name: (my-nft)
2    version: (1.0.0)
3    description: My first NFT!
4    entry point: (index.js)
5    test command:
6    git repository:
7    keywords:
8    author:
9    license: (ISC)
10    About to write to /Users/thesuperb1/Desktop/my-nft/package.json:
11
12    {
13      "name": "my-nft",
14      "version": "1.0.0",
15      "description": "My first NFT!",
16      "main": "index.js",
17      "scripts": {
18        "test": "echo \"Error: no test specified\" && exit 1"
19      },
20      "author": "",
21      "license": "ISC"
22    }

package.json-ஐ அங்கீகரிக்கவும், நாம் தொடரத் தயாராக உள்ளோம்!

படி 7: Hardhat (opens in a new tab)-ஐ நிறுவவும்

Hardhat என்பது உங்கள் Ethereum மென்பொருளைத் தொகுக்க, வெளியிட, சோதிக்க மற்றும் பிழைத்திருத்தம் செய்வதற்கான ஒரு மேம்பாட்டுச் சூழலாகும். நேரடிச் செயினில் வெளியிடுவதற்கு முன்பு ஸ்மார்ட் ஒப்பந்தங்கள் மற்றும் டாப்களை உள்ளூரில் உருவாக்கும்போது இது டெவலப்பர்களுக்கு உதவுகிறது.

நமது my-nft திட்டத்திற்குள் இயக்கவும்:

npm install --save-dev hardhat

நிறுவல் வழிமுறைகள் (opens in a new tab) குறித்த கூடுதல் விவரங்களுக்கு இந்தப் பக்கத்தைப் பார்க்கவும்.

படி 8: Hardhat திட்டத்தை உருவாக்கவும்

நமது திட்டக் கோப்புறைக்குள் இயக்கவும்:

npx hardhat

நீங்கள் ஒரு வரவேற்புச் செய்தியையும், நீங்கள் என்ன செய்ய விரும்புகிறீர்கள் என்பதைத் தேர்ந்தெடுப்பதற்கான விருப்பத்தையும் காண வேண்டும். “create an empty hardhat.config.js” என்பதைத் தேர்ந்தெடுக்கவும்:

888 888 888 888 888 888 888 888 888 888 888 888 888 888 888 8888888888 8888b. 888d888 .d88888 88888b. 8888b. 888888 888 888 "88b 888P" d88" 888 888 "88b "88b 888 888 888 .d888888 888 888 888 888 888 .d888888 888 888 888 888 888 888 Y88b 888 888 888 888 888 Y88b. 888 888 "Y888888 888 "Y88888 888 888 "Y888888 "Y888 👷 Welcome to Hardhat v2.0.11 👷‍ ? What do you want to do? … Create a sample project ❯ Create an empty hardhat.config.js Quit

இது நமக்காக ஒரு hardhat.config.js கோப்பை உருவாக்கும், அங்குதான் நமது திட்டத்திற்கான அனைத்து அமைப்புகளையும் குறிப்பிடுவோம் (படி 13-ல்).

படி 9: திட்டக் கோப்புறைகளைச் சேர்க்கவும்

நமது திட்டத்தை ஒழுங்கமைக்க, இரண்டு புதிய கோப்புறைகளை உருவாக்குவோம். உங்கள் கமாண்ட் லைனில் உங்கள் திட்டத்தின் ரூட் டைரக்டரிக்குச் சென்று தட்டச்சு செய்யவும்:

mkdir contracts mkdir scripts

contracts/ என்பது நமது NFT ஸ்மார்ட் ஒப்பந்தக் குறியீட்டை வைத்திருக்கும் இடமாகும்
scripts/ என்பது நமது ஸ்மார்ட் ஒப்பந்தத்தை வெளியிடவும் அதனுடன் தொடர்புகொள்ளவுமான ஸ்கிரிப்ட்களை வைத்திருக்கும் இடமாகும்

படி 10: நமது ஒப்பந்தத்தை எழுதவும்

இப்போது நமது சூழல் அமைக்கப்பட்டுள்ளதால், மேலும் சுவாரஸ்யமான விஷயங்களுக்குச் செல்வோம்: நமது ஸ்மார்ட் ஒப்பந்தக் குறியீட்டை எழுதுதல்!

உங்களுக்குப் பிடித்த எடிட்டரில் my-nft திட்டத்தைத் திறக்கவும் (நாங்கள் VSCode (opens in a new tab)-ஐ விரும்புகிறோம்). ஸ்மார்ட் ஒப்பந்தங்கள் Solidity எனப்படும் மொழியில் எழுதப்படுகின்றன, இதைத்தான் நமது MyNFT.sol ஸ்மார்ட் ஒப்பந்தத்தை எழுதப் பயன்படுத்துவோம்.‌

contracts கோப்புறைக்குச் சென்று MyNFT.sol என்ற புதிய கோப்பை உருவாக்கவும்

கீழே நமது NFT ஸ்மார்ட் ஒப்பந்தக் குறியீடு உள்ளது, இது OpenZeppelin (opens in a new tab) லைப்ரரியின் ERC-721 செயலாக்கத்தை அடிப்படையாகக் கொண்டது. கீழே உள்ள உள்ளடக்கங்களை நகலெடுத்து உங்கள் MyNFT.sol கோப்பில் ஒட்டவும்.

1// [https://docs.openzeppelin.com/contracts/3.x/erc721](https://docs.openzeppelin.com/contracts/3.x/erc721) அடிப்படையில் அமைந்த ஒப்பந்தம்
2// SPDX-License-Identifier: MIT
3pragma solidity ^0.8.0;
4
5import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
6import "@openzeppelin/contracts/utils/Counters.sol";
7import "@openzeppelin/contracts/access/Ownable.sol";
8import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
9
10contract MyNFT is ERC721URIStorage, Ownable {
11    using Counters for Counters.Counter;
12    Counters.Counter private _tokenIds;
13
14    constructor() ERC721("MyNFT", "NFT") {}
15
16    function mintNFT(address recipient, string memory tokenURI)
17        public onlyOwner
18        returns (uint256)
19    {
20        _tokenIds.increment();
21
22        uint256 newItemId = _tokenIds.current();
23        _mint(recipient, newItemId);
24        _setTokenURI(newItemId, tokenURI);
25
26        return newItemId;
27    }
28}

நாம் OpenZeppelin ஒப்பந்தங்கள் லைப்ரரியிலிருந்து கிளாஸ்களைப் பெறுவதால், நமது கோப்புறையில் லைப்ரரியை நிறுவ உங்கள் கமாண்ட் லைனில் npm install @openzeppelin/contracts^4.0.0 என்பதை இயக்கவும்.

எனவே, இந்தக் குறியீடு சரியாக என்ன செய்கிறது? இதை வரியாகப் பிரித்துப் பார்ப்போம்.

நமது ஸ்மார்ட் ஒப்பந்தத்தின் மேற்புறத்தில், மூன்று OpenZeppelin (opens in a new tab) ஸ்மார்ட் ஒப்பந்த கிளாஸ்களை இறக்குமதி செய்கிறோம்:

@openzeppelin/contracts/token/ERC721/ERC721.sol என்பது ERC-721 தரநிலையின் செயலாக்கத்தைக் கொண்டுள்ளது, இதை நமது NFT ஸ்மார்ட் ஒப்பந்தம் பெறும். (செல்லுபடியாகும் NFT ஆக இருக்க, உங்கள் ஸ்மார்ட் ஒப்பந்தம் ERC-721 தரநிலையின் அனைத்து முறைகளையும் செயல்படுத்த வேண்டும்.) பெறப்பட்ட ERC-721 செயல்பாடுகளைப் பற்றி மேலும் அறிய, இடைமுக வரையறையை இங்கே (opens in a new tab) பார்க்கவும்.
@openzeppelin/contracts/utils/Counters.sol என்பது ஒன்றால் மட்டுமே அதிகரிக்க அல்லது குறைக்கக்கூடிய கவுண்டர்களை வழங்குகிறது. உருவாக்கப்பட்ட NFTகளின் மொத்த எண்ணிக்கையைக் கண்காணிக்கவும், நமது புதிய NFT-ல் தனித்துவமான ID-ஐ அமைக்கவும் நமது ஸ்மார்ட் ஒப்பந்தம் ஒரு கவுண்டரைப் பயன்படுத்துகிறது. (ஸ்மார்ட் ஒப்பந்தத்தைப் பயன்படுத்தி உருவாக்கப்படும் ஒவ்வொரு NFT-க்கும் ஒரு தனித்துவமான ID ஒதுக்கப்பட வேண்டும்—இங்கே நமது தனித்துவமான ID என்பது பயன்பாட்டில் உள்ள NFTகளின் மொத்த எண்ணிக்கையால் தீர்மானிக்கப்படுகிறது. எடுத்துக்காட்டாக, நமது ஸ்மார்ட் ஒப்பந்தத்துடன் நாம் உருவாக்கும் முதல் NFT-ன் ID "1", நமது இரண்டாவது NFT-ன் ID "2" போன்றவை.)
@openzeppelin/contracts/access/Ownable.sol நமது ஸ்மார்ட் ஒப்பந்தத்தில் அணுகல் கட்டுப்பாட்டை (opens in a new tab) அமைக்கிறது, எனவே ஸ்மார்ட் ஒப்பந்தத்தின் உரிமையாளர் (நீங்கள்) மட்டுமே NFTகளை உருவாக்க முடியும். (குறிப்பு, அணுகல் கட்டுப்பாட்டைச் சேர்ப்பது முற்றிலும் ஒரு விருப்பமாகும். உங்கள் ஸ்மார்ட் ஒப்பந்தத்தைப் பயன்படுத்தி யார் வேண்டுமானாலும் NFT-ஐ உருவாக்க வேண்டும் என நீங்கள் விரும்பினால், வரி 10-ல் உள்ள Ownable மற்றும் வரி 17-ல் உள்ள onlyOwner என்ற வார்த்தையை அகற்றவும்.)

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

நமது 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: உங்கள் திட்டத்துடன் MetaMask & Alchemy-ஐ இணைக்கவும்

இப்போது நாம் ஒரு MetaMask வாலட், Alchemy கணக்கை உருவாக்கி, நமது ஸ்மார்ட் ஒப்பந்தத்தை எழுதியுள்ளோம், மூன்றையும் இணைக்க வேண்டிய நேரம் இது.

உங்கள் மெய்நிகர் வாலட்டிலிருந்து அனுப்பப்படும் ஒவ்வொரு பரிவர்த்தனைக்கும் உங்கள் தனித்துவமான தனிப்பட்ட திறவுகோலைப் பயன்படுத்தி ஒரு கையொப்பம் தேவை. நமது நிரலுக்கு இந்த அனுமதியை வழங்க, நமது தனிப்பட்ட திறவுகோலை (மற்றும் Alchemy API திறவுகோலை) ஒரு சூழல் கோப்பில் பாதுகாப்பாகச் சேமிக்கலாம்.

பரிவர்த்தனைகளை அனுப்புவது பற்றி மேலும் அறிய, web3-ஐப் பயன்படுத்திப் பரிவர்த்தனைகளை அனுப்புவது குறித்த இந்தப் பயிற்சியைப் பார்க்கவும்.

முதலில், உங்கள் திட்ட டைரக்டரியில் dotenv தொகுப்பை நிறுவவும்:

npm install dotenv --save

பின்னர், நமது திட்டத்தின் ரூட் டைரக்டரியில் ஒரு .env கோப்பை உருவாக்கி, அதில் உங்கள் MetaMask தனிப்பட்ட திறவுகோல் மற்றும் HTTP Alchemy API URL-ஐச் சேர்க்கவும்.

MetaMask-லிருந்து உங்கள் தனிப்பட்ட திறவுகோலை ஏற்றுமதி செய்ய இந்த வழிமுறைகளைப் (opens in a new tab) பின்பற்றவும்
HTTP Alchemy API URL-ஐப் பெற்று அதை உங்கள் கிளிப்போர்டுக்கு நகலெடுக்கக் கீழே பார்க்கவும்

உங்கள் .env இப்போது இதுபோல இருக்க வேண்டும்:

API_URL="https://eth-sepolia.g.alchemy.com/v2/your-api-key (opens in a new tab)" PRIVATE_KEY="your-metamask-private-key"

இவற்றை நமது குறியீட்டுடன் இணைக்க, படி 13-ல் உள்ள நமது hardhat.config.js கோப்பில் இந்த மாறிகளைக் குறிப்பிடுவோம்.

.env கோப்பை கமிட் செய்ய வேண்டாம்! உங்கள் .env கோப்பை யாருடனும் பகிரவோ அல்லது வெளிப்படுத்தவோ வேண்டாம் என்பதை உறுதிப்படுத்திக் கொள்ளுங்கள், அவ்வாறு செய்வதன் மூலம் உங்கள் ரகசியங்களை நீங்கள் சமரசம் செய்கிறீர்கள். நீங்கள் பதிப்புக் கட்டுப்பாட்டைப் பயன்படுத்தினால், உங்கள் .env கோப்பை gitignore கோப்பில் சேர்க்கவும்.

படி 12: Ethers.js-ஐ நிறுவவும்

Ethers.js என்பது நிலையான JSON-RPC முறைகளை மேலும் பயனர் நட்பு முறைகளுடன் இணைப்பதன் மூலம் Ethereum-உடன் தொடர்புகொள்வதையும் கோரிக்கைகளைச் செய்வதையும் எளிதாக்கும் ஒரு லைப்ரரியாகும்.

கூடுதல் கருவிகள் மற்றும் நீட்டிக்கப்பட்ட செயல்பாட்டிற்கான செருகுநிரல்களை (opens in a new tab) ஒருங்கிணைப்பதை Hardhat மிகவும் எளிதாக்குகிறது. ஒப்பந்த வெளியீட்டிற்கான Ethers செருகுநிரலை (opens in a new tab) நாம் பயன்படுத்திக் கொள்வோம் (Ethers.js (opens in a new tab) சில மிகச் சிறந்த ஒப்பந்த வெளியீட்டு முறைகளைக் கொண்டுள்ளது).

உங்கள் திட்ட டைரக்டரியில் தட்டச்சு செய்யவும்:

npm install --save-dev @nomiclabs/hardhat-ethers ethers@^5.0.0

அடுத்த படியில் நமது hardhat.config.js-ல் ethers-ம் தேவைப்படும்.

படி 13: hardhat.config.js-ஐப் புதுப்பிக்கவும்

இதுவரை பல சார்புகளையும் செருகுநிரல்களையும் சேர்த்துள்ளோம், இப்போது நமது திட்டத்திற்கு அவை அனைத்தையும் பற்றித் தெரியப்படுத்த hardhat.config.js-ஐப் புதுப்பிக்க வேண்டும்.

உங்கள் hardhat.config.js-ஐ இதுபோலப் புதுப்பிக்கவும்:

1    /* *
2    * @type import('hardhat/config').HardhatUserConfig */
3    require('dotenv').config();
4    require("@nomiclabs/hardhat-ethers");
5    const { API_URL, PRIVATE_KEY } = process.env;
6    module.exports = {
7       solidity: "0.8.1",
8       defaultNetwork: "sepolia",
9       networks: {
10          hardhat: {},
11          sepolia: {
12             url: API_URL,
13             accounts: [`0x${PRIVATE_KEY}`]
14          }
15       },
16    }

படி 14: நமது ஒப்பந்தத்தைத் தொகுக்கவும்

இதுவரை எல்லாம் சரியாகச் செயல்படுகிறதா என்பதை உறுதிசெய்ய, நமது ஒப்பந்தத்தைத் தொகுப்போம். தொகுக்கும் பணி என்பது உள்ளமைக்கப்பட்ட hardhat பணிகளில் ஒன்றாகும்.

கமாண்ட் லைனிலிருந்து இயக்கவும்:

npx hardhat compile

மூலக் கோப்பில் SPDX உரிம அடையாளங்காட்டி வழங்கப்படவில்லை என்பது பற்றிய எச்சரிக்கையை நீங்கள் பெறலாம், ஆனால் அதைப் பற்றிக் கவலைப்படத் தேவையில்லை — மற்ற அனைத்தும் நன்றாக இருக்கும் என்று நம்புகிறோம்! இல்லையென்றால், நீங்கள் எப்போதும் Alchemy discord (opens in a new tab)-ல் செய்தி அனுப்பலாம்.

படி 15: நமது வெளியீட்டு ஸ்கிரிப்டை எழுதவும்

இப்போது நமது ஒப்பந்தம் எழுதப்பட்டு, நமது உள்ளமைவு கோப்பு தயாராக உள்ளதால், நமது ஒப்பந்த வெளியீட்டு ஸ்கிரிப்டை எழுத வேண்டிய நேரம் இது.

scripts/ கோப்புறைக்குச் சென்று deploy.js என்ற புதிய கோப்பை உருவாக்கி, அதில் பின்வரும் உள்ளடக்கங்களைச் சேர்க்கவும்:

1async function main() {
2  const MyNFT = await ethers.getContractFactory("MyNFT")
3
4  // வரிசைப்படுத்தலைத் தொடங்கவும், இது ஒரு ஒப்பந்தப் பொருளாகத் தீர்க்கப்படும் ஒரு ப்ராமிஸை (promise) வழங்குகிறது
5  const myNFT = await MyNFT.deploy()
6  await myNFT.deployed()
7  console.log("Contract deployed to address:", myNFT.address)
8}
9
10main()
11  .then(() => process.exit(0))
12  .catch((error) => {
13    console.error(error)
14    process.exit(1)
15  })

இந்தக் குறியீட்டின் ஒவ்வொரு வரியும் என்ன செய்கிறது என்பதை Hardhat அவர்களின் ஒப்பந்தங்கள் பயிற்சியில் (opens in a new tab) மிகச் சிறப்பாக விளக்குகிறது, அவர்களின் விளக்கங்களை நாங்கள் இங்கே ஏற்றுக்கொண்டுள்ளோம்.

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

ethers.js-ல் உள்ள ContractFactory என்பது புதிய ஸ்மார்ட் ஒப்பந்தங்களை வெளியிடப் பயன்படும் ஒரு சுருக்கமாகும், எனவே இங்குள்ள MyNFT என்பது நமது NFT ஒப்பந்தத்தின் நிகழ்வுகளுக்கான ஒரு தொழிற்சாலையாகும். hardhat-ethers செருகுநிரலைப் பயன்படுத்தும்போது ContractFactory மற்றும் Contract நிகழ்வுகள் இயல்பாகவே முதல் கையொப்பமிடுபவருடன் இணைக்கப்படும்.

const myNFT = await MyNFT.deploy();

ContractFactory-ல் deploy()-ஐ அழைப்பது வெளியீட்டைத் தொடங்கும், மேலும் Contract-க்குத் தீர்வு காணும் ஒரு Promise-ஐ வழங்கும். இது நமது ஒவ்வொரு ஸ்மார்ட் ஒப்பந்தச் செயல்பாடுகளுக்கும் ஒரு முறையைக் கொண்ட பொருளாகும்.

படி 16: நமது ஒப்பந்தத்தை வெளியிடவும்

இறுதியாக நமது ஸ்மார்ட் ஒப்பந்தத்தை வெளியிடத் தயாராகிவிட்டோம்! உங்கள் திட்ட டைரக்டரியின் ரூட்டிற்குத் திரும்பிச் சென்று, கமாண்ட் லைனில் இயக்கவும்:

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

நீங்கள் இது போன்ற ஒன்றைக் காண வேண்டும்:

Contract deployed to address: 0x4C5266cCc4b3F426965d2f51b6D910325a0E7650

நாம் Sepolia etherscan (opens in a new tab)-க்குச் சென்று நமது ஒப்பந்த முகவரியைத் தேடினால், அது வெற்றிகரமாக வெளியிடப்பட்டிருப்பதைக் காண முடியும். உங்களால் அதை உடனடியாகப் பார்க்க முடியாவிட்டால், சிறிது நேரம் காத்திருக்கவும், ஏனெனில் இதற்குச் சிறிது நேரம் ஆகலாம். பரிவர்த்தனை இதுபோல இருக்கும்:

From முகவரி உங்கள் MetaMask கணக்கு முகவரியுடன் பொருந்த வேண்டும் மற்றும் To முகவரி “Contract Creation” என்று கூறும். நாம் பரிவர்த்தனையைக் கிளிக் செய்தால், To புலத்தில் நமது ஒப்பந்த முகவரியைக் காண்போம்:

ஆஹா! நீங்கள் இப்போதுதான் உங்கள் NFT ஸ்மார்ட் ஒப்பந்தத்தை Ethereum (testnet) செயினில் வெளியிட்டுள்ளீர்கள்!

உள்ளே என்ன நடக்கிறது என்பதைப் புரிந்துகொள்ள, நமது Alchemy டேஷ்போர்டில் (opens in a new tab) உள்ள Explorer தாவலுக்குச் செல்வோம். உங்களிடம் பல Alchemy பயன்பாடுகள் இருந்தால், பயன்பாட்டின் மூலம் வடிகட்டி “MyNFT” என்பதைத் தேர்ந்தெடுப்பதை உறுதிசெய்யவும்.

நாம் .deploy() செயல்பாட்டை அழைத்தபோது Hardhat/Ethers நமக்காக உள்ளே செய்த சில JSON-RPC அழைப்புகளை இங்கே காண்பீர்கள். இங்கே குறிப்பிட வேண்டிய இரண்டு முக்கியமானவை eth_sendRawTransaction, இது நமது ஸ்மார்ட் ஒப்பந்தத்தை Sepolia செயினில் எழுதுவதற்கான கோரிக்கையாகும், மற்றும் eth_getTransactionByHash இது ஹாஷைக் கொண்டு நமது பரிவர்த்தனை பற்றிய தகவல்களைப் படிப்பதற்கான கோரிக்கையாகும் (பரிவர்த்தனைகளை அனுப்பும்போது இது ஒரு பொதுவான முறை). பரிவர்த்தனைகளை அனுப்புவது பற்றி மேலும் அறிய, Web3-ஐப் பயன்படுத்திப் பரிவர்த்தனைகளை அனுப்புவது குறித்த இந்தப் பயிற்சியைப் பார்க்கவும்.

இந்தப் பயிற்சியின் பகுதி 1-க்கு அவ்வளவுதான். பகுதி 2-ல், NFT-ஐ உருவாக்குவதன் மூலம் நமது ஸ்மார்ட் ஒப்பந்தத்துடன் உண்மையில் தொடர்புகொள்வோம், மேலும் பகுதி 3-ல் உங்கள் Ethereum வாலட்டில் உங்கள் NFT-ஐ எவ்வாறு பார்ப்பது என்பதைக் காண்பிப்போம்!

பக்கம் கடைசியாகப் புதுப்பிக்கப்பட்டது: 3 மார்ச், 2026

+15