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

Solidity

Hardhat

Alchemy

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

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

ప్రారంభ

elanh

31 మార్చి, 2021

11 నిమిషం పఠనం

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

ఈ ట్యుటోరియల్ యొక్క భాగం 2 (opens in a new tab)లో మన స్మార్ట్ కాంట్రాక్ట్ ఇక్కడ డిప్లాయ్ అయిన తర్వాత దానితో ఎలా సంకర్షణ చెందవచ్చో చూద్దాం, మరియు భాగం 3 (opens in a new tab)లో దానిని Etherscanలో ఎలా ప్రచురించాలో వివరిస్తాము.

ఏ సమయంలోనైనా మీకు ప్రశ్నలు ఉంటే Alchemy Discord (opens in a new tab)లో సంప్రదించడానికి సంకోచించకండి!

దశ 1: Ethereum నెట్‌వర్క్‌కు కనెక్ట్ అవ్వండి

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

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

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

నావ్ బార్‌లో "ఒక యాప్‌ను ఎంచుకోండి"ని ఎంచుకుని, "కొత్త యాప్‌ను సృష్టించు" క్లిక్ చేయడం ద్వారా మీ Alchemy డ్యాష్‌బోర్డ్‌లోని "కొత్త యాప్‌ను సృష్టించు" పేజీకి నావిగేట్ చేయండి

మీ యాప్‌కు “హలో వరల్డ్” అని పేరు పెట్టండి, ఒక చిన్న వివరణను అందించండి మరియు ఒక వినియోగ సందర్భాన్ని ఎంచుకోండి, ఉదా., "ఇన్‌ఫ్రా & టూలింగ్." తరువాత, "Ethereum" కోసం వెతకండి మరియు నెట్‌వర్క్‌ను ఎంచుకోండి.

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

దశ 3: ఒక Ethereum ఖాతా (చిరునామా) సృష్టించండి

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

మీరు ఇక్కడ (opens in a new tab) MetaMaskని డౌన్‌లోడ్ చేసుకోవచ్చు మరియు ఉచితంగా ఒక Ethereum ఖాతాను సృష్టించుకోవచ్చు. మీరు ఒక ఖాతాను సృష్టిస్తున్నప్పుడు, లేదా మీకు ఇప్పటికే ఒక ఖాతా ఉన్నట్లయితే, నెట్‌వర్క్ డ్రాప్‌డౌన్ మెనూని ఉపయోగించి "Sepolia" టెస్టునెట్‌కు మారారని నిర్ధారించుకోండి (దీనివల్ల మనం నిజమైన డబ్బుతో వ్యవహరించము).

మీకు జాబితాలో Sepolia కనిపించకపోతే, మెనూలోకి వెళ్లి, ఆపై అడ్వాన్స్‌డ్‌కి వెళ్లి "టెస్ట్ నెట్‌వర్క్‌లను చూపించు"ని ఆన్ చేయడానికి క్రిందికి స్క్రోల్ చేయండి. నెట్‌వర్క్ ఎంపిక మెనూలో, టెస్టునెట్‌ల జాబితాను కనుగొనడానికి "కస్టమ్" ట్యాబ్‌ను ఎంచుకుని, "Sepolia"ని ఎంచుకోండి.

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

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

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

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

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

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

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

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

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

mkdir hello-world
cd hello-world

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

npm init

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

ప్యాకేజీ పేరు: (hello-world)
వెర్షన్: (1.0.0)
వివరణ: హలో వరల్డ్ స్మార్ట్ కాంట్రాక్ట్
ప్రవేశ స్థానం: (index.js)
టెస్ట్ కమాండ్:
గిట్ రిపోజిటరీ:
కీలకపదాలు:
రచయిత:
లైసెన్స్: (ISC)
/Users/.../.../.../hello-world/package.json కు వ్రాయబోతున్నారు:

{
  "name": "hello-world",
  "version": "1.0.0",
  "description": "హలో వరల్డ్ స్మార్ట్ కాంట్రాక్ట్",
  "main": "index.js",
  "scripts": {
     "test": "echo \\"లోపం: ఏ పరీక్ష పేర్కొనబడలేదు\\" && exit 1"
  },
  "author": "",
  "license": "ISC"
}

package.jsonని ఆమోదించండి మరియు మనం సిద్ధంగా ఉన్నాము!

దశ 7: Hardhat (opens in a new tab)ను డౌన్‌లోడ్ చేయండి

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

మన hello-world ప్రాజెక్ట్ లోపల రన్ చేయండి:

npm install --save-dev hardhat

ఇన్‌స్టాలేషన్ సూచనల (opens in a new tab)పై మరిన్ని వివరాల కోసం ఈ పేజీని చూడండి.

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

మా ప్రాజెక్ట్ ఫోల్డర్‌లో రన్ చేయండి:

npx hardhat

అప్పుడు మీరు స్వాగత సందేశం మరియు మీరు ఏమి చేయాలనుకుంటున్నారో ఎంచుకోవడానికి ఒక ఎంపికను చూడాలి. “ఖాళీ 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

👷 Hardhat v2.0.11 👷‍కి స్వాగతం?

మీరు ఏమి చేయాలనుకుంటున్నారు? …
నమూనా ప్రాజెక్టును సృష్టించండి
❯ ఖాళీ hardhat.config.jsని సృష్టించండి
నిష్క్రమించు

ఇది మన కోసం ఒక hardhat.config.js ఫైల్‌ను ఉత్పత్తి చేస్తుంది, ఇక్కడ మనం మన ప్రాజెక్ట్ కోసం అన్ని సెటప్‌లను నిర్దేశిస్తాము (దశ 13లో).

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

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

mkdir contracts
mkdir scripts

contracts/ అనేది మనం మన హలో వరల్డ్ స్మార్ట్ కాంట్రాక్ట్ కోడ్ ఫైల్‌ను ఉంచే చోటు
scripts/ అనేది మన కాంట్రాక్టును డిప్లాయ్ చేయడానికి మరియు దానితో ఇంటరాక్ట్ అవ్వడానికి స్క్రిప్ట్‌లను ఉంచే చోటు

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

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

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

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

// సెమాంటిక్ వెర్షనింగ్ ఉపయోగించి, Solidity వెర్షన్‌ను నిర్దేశిస్తుంది.
// మరింత తెలుసుకోండి: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
pragma solidity ^0.7.0;

// `HelloWorld` అనే పేరుతో ఒక కాంట్రాక్టును నిర్వచిస్తుంది.
// కాంట్రాక్ట్ అనేది ఫంక్షన్‌లు మరియు డేటా (దాని స్థితి) యొక్క సమాహారం. ఒకసారి డిప్లాయ్ చేసిన తర్వాత, ఒక కాంట్రాక్ట్ Ethereum బ్లాక్‌చైన్‌లో ఒక నిర్దిష్ట చిరునామాలో ఉంటుంది. మరింత తెలుసుకోండి: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
contract HelloWorld {

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

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

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

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

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

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

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

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

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

మొదట, మీ ప్రాజెక్ట్ డైరెక్టరీలో dotenv ప్యాకేజీని ఇన్‌స్టాల్ చేయండి:

npm install dotenv --save

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

మీ ప్రైవేట్ కీని ఎగుమతి చేయడానికి ఈ సూచనలను (opens in a new tab) అనుసరించండి
HTTP Alchemy API URL పొందడానికి క్రింద చూడండి

Alchemy API URLని కాపీ చేయండి

మీ .env ఈ విధంగా కనిపించాలి:

API_URL = "https://eth-sepolia.g.alchemy.com/v2/మీ-api-కీ"
PRIVATE_KEY = "మీ-మెటామాస్క్-ప్రైవేట్-కీ"

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

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

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

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

Hardhat అదనపు పనిముట్లు మరియు విస్తరించిన కార్యాచరణ కోసం ప్లగిన్‌లను (opens in a new tab) ఏకీకృతం చేయడం చాలా సులభం చేస్తుంది. కాంట్రాక్ట్ డిప్లాయ్‌మెంట్ కోసం మనం 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లో ఈథర్‌లను కూడా రిక్వైర్ చేస్తాము.

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

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

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

require('dotenv').config();

require("@nomiclabs/hardhat-ethers");
const { API_URL, PRIVATE_KEY } = process.env;

/**
* @type import('hardhat/config').HardhatUserConfig
*/
module.exports = {
   solidity: "0.7.3",
   defaultNetwork: "sepolia",
   networks: {
      hardhat: {},
      sepolia: {
         url: API_URL,
         accounts: [`0x${PRIVATE_KEY}`]
      }
   },
}

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

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

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

npx hardhat compile

మీకు SPDX license identifier not provided in source file గురించి హెచ్చరిక రావచ్చు, కానీ దాని గురించి చింతించాల్సిన అవసరం లేదు — ఆశాజనకంగా మిగతావన్నీ బాగానే కనిపిస్తాయి! కాకపోతే, మీరు ఎల్లప్పుడూ ఆల్కెమీ డిస్కార్డ్ (opens in a new tab)లో సందేశం పంపవచ్చు.

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

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

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

async function main() {
   const HelloWorld = await ethers.getContractFactory("HelloWorld");

   // డిప్లాయ్‌మెంట్‌ను ప్రారంభించండి, ఇది కాంట్రాక్ట్ ఆబ్జెక్ట్‌కు పరిష్కరించే ప్రామిస్‌ను అందిస్తుంది
   const hello_world = await HelloWorld.deploy("హలో వరల్డ్!");
   console.log("కాంట్రాక్ట్ ఈ చిరునామాకు డిప్లాయ్ చేయబడింది:", hello_world.address);}

main()
  .then(() => process.exit(0))
  .catch(error => {
    console.error(error);
    process.exit(1);
  });

Hardhat వారి కాంట్రాక్ట్స్ ట్యుటోరియల్ (opens in a new tab)లో ఈ కోడ్ లైన్‌లు ప్రతి ఒక్కటి ఏమి చేస్తుందో అద్భుతంగా వివరిస్తుంది, మేము వారి వివరణలను ఇక్కడ స్వీకరించాము.

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

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

const hello_world = await HelloWorld.deploy();

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

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

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

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

మీరు అప్పుడు ఇలాంటిది చూడాలి:

కాంట్రాక్ట్ ఈ చిరునామాకు డిప్లాయ్ చేయబడింది: 0x6cd7d44516a20882cEa2DE9f205bF401c0d23570

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

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

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

తెర వెనుక ఏమి జరుగుతుందో అర్థం చేసుకోవడానికి, మా ఆల్కెమీ డాష్‌బోర్డ్ (opens in a new tab)లోని ఎక్స్‌ప్లోరర్ ట్యాబ్‌కు నావిగేట్ చేద్దాం. మీకు బహుళ Alchemy యాప్‌లు ఉంటే, యాప్ ద్వారా ఫిల్టర్ చేసి, “హలో వరల్డ్”ను ఎంచుకున్నారని నిర్ధారించుకోండి.

ఇక్కడ మీరు మనం .deploy() ఫంక్షన్‌ను కాల్ చేసినప్పుడు Hardhat/Ethers మన కోసం నేపథ్యంలో చేసిన కొన్ని JSON-RPC కాల్స్‌ను చూస్తారు. ఇక్కడ పేర్కొనవలసిన రెండు ముఖ్యమైనవి eth_sendRawTransaction (opens in a new tab), ఇది మన కాంట్రాక్టును వాస్తవానికి Sepolia చైన్‌పై వ్రాయడానికి చేసే అభ్యర్థన, మరియు eth_getTransactionByHash (opens in a new tab) ఇది హాష్ ఇచ్చినప్పుడు మన లావాదేవీ గురించి సమాచారాన్ని చదవడానికి చేసే అభ్యర్థన (లావాదేవీల సమయంలో ఒక సాధారణ నమూనా). లావాదేవీలను పంపడం గురించి మరింత తెలుసుకోవడానికి, Web3 ఉపయోగించి లావాదేవీలను పంపడంపై ఈ ట్యుటోరియల్‌ను చూడండి

ఈ ట్యుటోరియల్ యొక్క భాగం 1 కోసం అంతే, భాగం 2లో మనం మన ప్రారంభ సందేశాన్ని అప్‌డేట్ చేయడం ద్వారా వాస్తవానికి మన స్మార్ట్ కాంట్రాక్టుతో ఇంటరాక్ట్ అవుతాము (opens in a new tab), మరియు భాగం 3లో మనం మన స్మార్ట్ కాంట్రాక్టును Etherscanకు ప్రచురిస్తాము (opens in a new tab) తద్వారా ప్రతి ఒక్కరికీ దానితో ఎలా ఇంటరాక్ట్ అవ్వాలో తెలుస్తుంది.

Alchemy గురించి మరింత తెలుసుకోవాలనుకుంటున్నారా? మా వెబ్‌సైట్ (opens in a new tab)ని చూడండి. అప్‌డేట్‌ను ఎప్పుడూ మిస్ అవ్వకూడదనుకుంటున్నారా? ఇక్కడ (opens in a new tab) మా వార్తాలేఖకు సబ్‌స్క్రయిబ్ చేసుకోండి! మా Discord (opens in a new tab)లో కూడా తప్పకుండా చేరండి..

పేజీ చివరి నవీకరణ: 3 మార్చి, 2026

+16