ప్రారంభకుల కోసం హలో వరల్డ్ స్మార్ట్ కాంట్రాక్ట్

Solidity

Hardhat

Alchemy

స్మార్ట్ కాంట్రాక్ట్‌లు

డిప్లాయ్ చేయడం

ప్రారంభ స్థాయి

elanh

31 మార్చి, 2021

11 నిమిషాల పఠనం

మీరు బ్లాక్‌చైన్ డెవలప్‌మెంట్‌కు కొత్త అయితే మరియు ఎక్కడ ప్రారంభించాలో తెలియకపోతే, లేదా స్మార్ట్ కాంట్రాక్ట్‌లను ఎలా డిప్లాయ్ చేయాలో మరియు వాటితో ఎలా ఇంటరాక్ట్ అవ్వాలో అర్థం చేసుకోవాలనుకుంటే, ఈ గైడ్ మీ కోసమే. వర్చువల్ వాలెట్ మెటామాస్క్ (కొత్త ట్యాబ్‌లో తెరవబడుతుంది), Solidity (కొత్త ట్యాబ్‌లో తెరవబడుతుంది), Hardhat (కొత్త ట్యాబ్‌లో తెరవబడుతుంది), మరియు Alchemy (కొత్త ట్యాబ్‌లో తెరవబడుతుంది) ఉపయోగించి Sepolia టెస్ట్ నెట్‌వర్క్‌లో ఒక సాధారణ స్మార్ట్ కాంట్రాక్ట్‌ను సృష్టించడం మరియు డిప్లాయ్ చేయడం ద్వారా మేము మీకు మార్గనిర్దేశం చేస్తాము (వీటి అర్థం మీకు ఇంకా తెలియకపోతే చింతించకండి, మేము దానిని వివరిస్తాము).

మీ కాంట్రాక్ట్ డిప్లాయ్ అయిన తర్వాత, మీరు దాని కోసం యూజర్ ఇంటర్‌ఫేస్‌ను నిర్మించవచ్చు.

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

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

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

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

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

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

మీ యాప్‌కు “Hello World” అని పేరు పెట్టండి, చిన్న వివరణను అందించండి మరియు ఒక యూజ్ కేస్‌ను ఎంచుకోండి, ఉదాహరణకు, "Infra & Tooling." తర్వాత, "Ethereum" కోసం వెతికి నెట్‌వర్క్‌ను ఎంచుకోండి.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

mkdir hello-world
cd hello-world

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

npm init

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

package name: (hello-world)
version: (1.0.0)
description: hello world smart contract
entry point: (index.js)
test command:
git repository:
keywords:
author:
license: (ISC)
About to write to /Users/.../.../.../hello-world/package.json:

{
  "name": "hello-world",
  "version": "1.0.0",
  "description": "hello world smart contract",
  "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 లేదా ఆ తర్వాతి వెర్షన్ అవసరం. మన hello-world ప్రాజెక్ట్ లోపల దీన్ని రన్ చేయండి:

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/ అనేది మన హలో వరల్డ్ స్మార్ట్ కాంట్రాక్ట్ కోడ్ ఫైల్‌ను ఉంచే ప్రదేశం
scripts/ అనేది మన కాంట్రాక్ట్‌ను డిప్లాయ్ చేయడానికి మరియు దానితో ఇంటరాక్ట్ అవ్వడానికి స్క్రిప్ట్‌లను ఉంచే ప్రదేశం

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

మనం కోడ్ ఎప్పుడు రాస్తామా అని మీరు ఆశ్చర్యపోతుండవచ్చు?? సరే, మనం ఇక్కడ 10వ దశలో ఉన్నాము.

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

“contracts” ఫోల్డర్‌కు వెళ్లి HelloWorld.sol అనే కొత్త ఫైల్‌ను సృష్టించండి
ఈ ట్యుటోరియల్ కోసం మనం ఉపయోగించబోయే ఎథీరియం ఫౌండేషన్ నుండి ఒక నమూనా Hello World స్మార్ట్ కాంట్రాక్ట్ కింద ఉంది. కింది కంటెంట్‌లను కాపీ చేసి మీ HelloWorld.sol ఫైల్‌లో పేస్ట్ చేయండి మరియు ఈ కాంట్రాక్ట్ ఏమి చేస్తుందో అర్థం చేసుకోవడానికి కామెంట్‌లను తప్పకుండా చదవండి:

// SPDX-License-Identifier: MIT
// సెమాంటిక్ వెర్షనింగ్‌ని ఉపయోగించి, Solidity యొక్క వెర్షన్‌ను నిర్దేశిస్తుంది.
// మరింత తెలుసుకోండి: https://docs.soliditylang.org/en/latest/layout-of-source-files.html#pragma
pragma solidity ^0.8.24;

// `HelloWorld` పేరుతో ఒక కాంట్రాక్ట్‌ను నిర్వచిస్తుంది.
// కాంట్రాక్ట్ అనేది ఫంక్షన్లు మరియు డేటా (దాని స్థితి) యొక్క సమూహం. ఒకసారి డిప్లాయ్ చేసిన తర్వాత, కాంట్రాక్ట్ ఎథీరియం బ్లాక్‌చైన్‌లోని ఒక నిర్దిష్ట చిరునామా వద్ద ఉంటుంది. మరింత తెలుసుకోండి: https://docs.soliditylang.org/en/latest/structure-of-a-contract.html
contract HelloWorld {

   // `string` రకానికి చెందిన `message` అనే స్టేట్ వేరియబుల్‌ను ప్రకటిస్తుంది.
   // స్టేట్ వేరియబుల్స్ అంటే వాటి విలువలు కాంట్రాక్ట్ స్టోరేజ్‌లో శాశ్వతంగా నిల్వ చేయబడే వేరియబుల్స్. `public` కీవర్డ్ వేరియబుల్స్‌ను కాంట్రాక్ట్ వెలుపల నుండి యాక్సెస్ చేయడానికి వీలు కల్పిస్తుంది మరియు విలువను యాక్సెస్ చేయడానికి ఇతర కాంట్రాక్ట్‌లు లేదా క్లయింట్‌లు కాల్ చేయగల ఫంక్షన్‌ను సృష్టిస్తుంది.
   string public message;

   // అనేక క్లాస్-ఆధారిత ఆబ్జెక్ట్-ఓరియెంటెడ్ భాషల మాదిరిగానే, కన్‌స్ట్రక్టర్ అనేది కాంట్రాక్ట్ సృష్టి సమయంలో మాత్రమే అమలు చేయబడే ఒక ప్రత్యేక ఫంక్షన్.
   // కాంట్రాక్ట్ యొక్క డేటాను ప్రారంభించడానికి కన్‌స్ట్రక్టర్‌లు ఉపయోగించబడతాయి. మరింత తెలుసుకోండి: https://docs.soliditylang.org/en/latest/contracts.html#constructors
   constructor(string memory initMessage) {

      // `initMessage` అనే స్ట్రింగ్ ఆర్గ్యుమెంట్‌ను అంగీకరిస్తుంది మరియు ఆ విలువను కాంట్రాక్ట్ యొక్క `message` స్టోరేజ్ వేరియబుల్‌లో సెట్ చేస్తుంది).
      message = initMessage;
   }

   // స్ట్రింగ్ ఆర్గ్యుమెంట్‌ను అంగీకరించి, `message` స్టోరేజ్ వేరియబుల్‌ను అప్‌డేట్ చేసే పబ్లిక్ ఫంక్షన్.
   function update(string memory newMessage) public {
      message = newMessage;
   }
}

ఇది చాలా సులభమైన స్మార్ట్ కాంట్రాక్ట్, ఇది సృష్టించబడినప్పుడు ఒక సందేశాన్ని నిల్వ చేస్తుంది మరియు update ఫంక్షన్‌ను కాల్ చేయడం ద్వారా అప్‌డేట్ చేయబడుతుంది.

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

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

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

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

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

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

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: మన కాంట్రాక్ట్‌ను కంపైల్ చేయండి

ఇప్పటివరకు అంతా సరిగ్గా పని చేస్తుందో లేదో నిర్ధారించుకోవడానికి, మన కాంట్రాక్ట్‌ను కంపైల్ చేద్దాం. compile టాస్క్ అనేది అంతర్నిర్మిత 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 HelloWorld = await ethers.getContractFactory("HelloWorld")

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

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

const { ethers } = await network.create()

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

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

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

const hello_world = await HelloWorld.deploy("Hello World!")

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

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

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

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

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

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

Contract deployed to address: 0x6cd7d44516a20882cEa2DE9f205bF401c0d23570

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

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

అభినందనలు! మీరు ఇప్పుడే ఎథీరియం చైన్‌కు ఒక స్మార్ట్ కాంట్రాక్ట్‌ను డిప్లాయ్ చేసారు 🎉

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

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

ఈ ట్యుటోరియల్‌కి అంతే. తర్వాత, మీరు మీ కాంట్రాక్ట్ కోసం యూజర్ ఇంటర్‌ఫేస్‌ను నిర్మించవచ్చు.