ఒక Python డెవలపర్‌కి ఎథీరియం పరిచయం, భాగం 1

కాబట్టి, మీరు ఈ ఎథీరియం గురించి విన్నారు మరియు దీని గురించి లోతుగా తెలుసుకోవడానికి సిద్ధంగా ఉన్నారా? ఈ పోస్ట్ కొన్ని బ్లాక్‌చైన్ ప్రాథమికాలను త్వరగా కవర్ చేస్తుంది, ఆపై మిమ్మల్ని అనుకరణ చేయబడిన ఎథీరియం నోడ్‌తో ఇంటరాక్ట్ అయ్యేలా చేస్తుంది – బ్లాక్ డేటాను చదవడం, ఖాతా బ్యాలెన్స్‌లను తనిఖీ చేయడం మరియు లావాదేవీలను పంపడం. ఈ క్రమంలో, యాప్‌లను నిర్మించే సాంప్రదాయ పద్ధతులకు మరియు ఈ కొత్త వికేంద్రీకృత విధానానికి మధ్య ఉన్న తేడాలను మేము హైలైట్ చేస్తాము.

(తేలికపాటి) ముందస్తు అవసరాలు

ఈ పోస్ట్ విస్తృత శ్రేణి డెవలపర్‌లకు అందుబాటులో ఉండాలని ఆశిస్తోంది. Python సాధనాలు ఇందులో ఉంటాయి, కానీ అవి కేవలం ఆలోచనలను తెలియజేయడానికి ఒక మాధ్యమం మాత్రమే – మీరు Python డెవలపర్ కాకపోయినా ఎలాంటి సమస్య లేదు. అయితే, మీకు ఇప్పటికే ఏమి తెలుసు అనే దాని గురించి నేను కొన్ని ఊహలను మాత్రమే చేస్తాను, తద్వారా మనం ఎథీరియం-సంబంధిత విషయాలకు త్వరగా వెళ్లవచ్చు.

ఊహలు:

• మీరు టెర్మినల్‌ను ఉపయోగించగలరు,
• మీరు కొన్ని పంక్తుల Python కోడ్‌ను రాశారు,
• మీ మెషీన్‌లో Python వెర్షన్ 3.6 లేదా అంతకంటే ఎక్కువ ఇన్‌స్టాల్ చేయబడి ఉండాలి (ఒక వర్చువల్ ఎన్విరాన్‌మెంట్ (opens in a new tab) వాడకం గట్టిగా ప్రోత్సహించబడుతుంది), మరియు
• మీరు Python ప్యాకేజీ ఇన్‌స్టాలర్ అయిన pip ని ఉపయోగించారు. మళ్ళీ చెబుతున్నాను, వీటిలో ఏవైనా నిజం కాకపోయినా, లేదా ఈ కథనంలోని కోడ్‌ను మీరు అమలు చేయాలని అనుకోకపోయినా, మీరు దీన్ని సులభంగా అర్థం చేసుకోగలరు.

బ్లాక్‌చైన్‌లు, క్లుప్తంగా

ఎథీరియంను వివరించడానికి అనేక మార్గాలు ఉన్నాయి, కానీ దాని మూలంలో ఒక బ్లాక్‌చైన్ ఉంది. బ్లాక్‌చైన్‌లు వరుస బ్లాక్‌లతో రూపొందించబడ్డాయి, కాబట్టి మనం అక్కడి నుండే ప్రారంభిద్దాం. సరళమైన పదాలలో చెప్పాలంటే, ఎథీరియం బ్లాక్‌చైన్‌లోని ప్రతి బ్లాక్ కేవలం కొంత మెటాడేటా మరియు లావాదేవీల జాబితా మాత్రమే. JSON ఫార్మాట్‌లో, అది ఈ విధంగా కనిపిస్తుంది:

{
   "number": 1234567,
   "hash": "0xabc123...",
   "parentHash": "0xdef456...",
   ...,
   "transactions": [...]
}

ప్రతి బ్లాక్ దానికి ముందు వచ్చిన బ్లాక్‌కి సూచనను కలిగి ఉంటుంది; parentHash అనేది కేవలం మునుపటి బ్లాక్ యొక్క హాష్.

బ్లాక్‌చైన్ అనేది ప్రాథమికంగా ఒక లింక్డ్ లిస్ట్; ప్రతి బ్లాక్ మునుపటి బ్లాక్‌కి సూచనను కలిగి ఉంటుంది.

ఈ డేటా స్ట్రక్చర్ కొత్తదేమీ కాదు, కానీ నెట్‌వర్క్‌ను నియంత్రించే నియమాలు (అంటే, పీర్-టు-పీర్ ప్రోటోకాల్‌లు) కొత్తవి. ఇక్కడ ఎటువంటి కేంద్ర అధికారం లేదు; నెట్‌వర్క్‌ను నిలబెట్టడానికి పీర్‌ల నెట్‌వర్క్ తప్పనిసరిగా సహకరించుకోవాలి మరియు తదుపరి బ్లాక్‌లో ఏ లావాదేవీలను చేర్చాలో నిర్ణయించడానికి పోటీపడాలి. కాబట్టి, మీరు స్నేహితుడికి కొంత డబ్బు పంపాలనుకున్నప్పుడు, మీరు ఆ లావాదేవీని నెట్‌వర్క్‌కు ప్రసారం చేయాలి, ఆపై అది రాబోయే బ్లాక్‌లో చేర్చబడే వరకు వేచి ఉండాలి.

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

ఒక కొత్త విధానం

ఈ కొత్త వికేంద్రీకృత టెక్ స్టాక్ కొత్త డెవలపర్ సాధనాలను పుట్టించింది. ఇటువంటి సాధనాలు అనేక ప్రోగ్రామింగ్ భాషలలో ఉన్నాయి, కానీ మనం Python కోణం నుండి చూస్తాము. మళ్ళీ చెబుతున్నాను: Python మీకు ఇష్టమైన భాష కాకపోయినా, దీన్ని అర్థం చేసుకోవడంలో పెద్దగా ఇబ్బంది ఉండకూడదు.

ఎథీరియంతో ఇంటరాక్ట్ అవ్వాలనుకునే Python డెవలపర్‌లు Web3.py (opens in a new tab) ని ఎంచుకునే అవకాశం ఉంది. Web3.py అనేది మీరు ఎథీరియం నోడ్‌కి కనెక్ట్ అయ్యే విధానాన్ని, ఆపై దాని నుండి డేటాను పంపడం మరియు స్వీకరించడాన్ని చాలా సులభతరం చేసే ఒక లైబ్రరీ.

ఎథీరియం క్లయింట్‌లను IPC (opens in a new tab), HTTP లేదా Websockets ద్వారా చేరుకునేలా కాన్ఫిగర్ చేయవచ్చు, కాబట్టి Web3.py ఈ కాన్ఫిగరేషన్‌ను ప్రతిబింబించాల్సి ఉంటుంది. Web3.py ఈ కనెక్షన్ ఎంపికలను ప్రొవైడర్లు (providers) అని పిలుస్తుంది. Web3.py ఇన్‌స్టాన్స్‌ను మీ నోడ్‌తో లింక్ చేయడానికి మీరు ఈ మూడు ప్రొవైడర్లలో ఒకదాన్ని ఎంచుకోవాలి.

ఒకే ప్రోటోకాల్ ద్వారా కమ్యూనికేట్ చేయడానికి ఎథీరియం నోడ్ మరియు Web3.py ని కాన్ఫిగర్ చేయండి, ఉదాహరణకు, ఈ రేఖాచిత్రంలో IPC.

Web3.py సరిగ్గా కాన్ఫిగర్ చేయబడిన తర్వాత, మీరు బ్లాక్‌చైన్‌తో ఇంటరాక్ట్ అవ్వడం ప్రారంభించవచ్చు. రాబోయే వాటికి ప్రివ్యూగా ఇక్కడ కొన్ని Web3.py వినియోగ ఉదాహరణలు ఉన్నాయి:

# బ్లాక్ డేటాను చదవండి:
w3.eth.get_block('latest')

# ఒక లావాదేవీని పంపండి:
w3.eth.send_transaction({'from': ..., 'to': ..., 'value': ...})

ఇన్‌స్టాలేషన్

ఈ వాక్‌త్రూలో, మనం కేవలం Python ఇంటర్‌ప్రెటర్‌లో మాత్రమే పని చేస్తాము. మనం ఎలాంటి డైరెక్టరీలు, ఫైల్‌లు, క్లాస్‌లు లేదా ఫంక్షన్‌లను సృష్టించము.

ముందుగా, అన్వేషించడానికి యూజర్ ఫ్రెండ్లీ వాతావరణం కోసం IPython (opens in a new tab) ని ఇన్‌స్టాల్ చేయండి. IPython ఇతర ఫీచర్లతో పాటు ట్యాబ్ కంప్లీషన్‌ను అందిస్తుంది, దీని వలన Web3.py లో ఏమి సాధ్యమో చూడటం చాలా సులభం అవుతుంది.

pip install ipython

Web3.py అనేది web3 పేరుతో ప్రచురించబడింది. దీన్ని ఈ విధంగా ఇన్‌స్టాల్ చేయండి:

pip install web3

ఇంకొక విషయం – మనం తర్వాత ఒక బ్లాక్‌చైన్‌ను అనుకరించబోతున్నాము, దీనికి మరికొన్ని డిపెండెన్సీలు అవసరం. మీరు వాటిని దీని ద్వారా ఇన్‌స్టాల్ చేయవచ్చు:

pip install 'web3[tester]'

మీరు ప్రారంభించడానికి అంతా సిద్ధంగా ఉంది!

గమనిక: web3[tester] ప్యాకేజీ Python 3.10.xx వరకు పని చేస్తుంది

శాండ్‌బాక్స్‌ను ప్రారంభించండి

మీ టెర్మినల్‌లో ipython ని రన్ చేయడం ద్వారా కొత్త Python ఎన్విరాన్‌మెంట్‌ను తెరవండి. ఇది python ని రన్ చేయడంతో సమానం, కానీ మరిన్ని అదనపు ఫీచర్లతో వస్తుంది.

ipython

ఇది మీరు రన్ చేస్తున్న Python మరియు IPython వెర్షన్‌ల గురించి కొంత సమాచారాన్ని ప్రింట్ చేస్తుంది, ఆపై ఇన్‌పుట్ కోసం వేచి ఉన్న ప్రాంప్ట్‌ను మీరు చూడాలి:

In [1]:

మీరు ఇప్పుడు ఇంటరాక్టివ్ Python షెల్‌ను చూస్తున్నారు. ప్రాథమికంగా, ఇది ఆడుకోవడానికి ఒక శాండ్‌బాక్స్. మీరు ఇక్కడి వరకు వచ్చినట్లయితే, Web3.py ని దిగుమతి (import) చేసుకోవడానికి ఇది సమయం:

In [1]: from web3 import Web3

Web3 మాడ్యూల్ పరిచయం

ఎథీరియంకు గేట్‌వేగా ఉండటమే కాకుండా, Web3 (opens in a new tab) మాడ్యూల్ కొన్ని అనుకూలమైన ఫంక్షన్‌లను అందిస్తుంది. మనం కొన్నింటిని అన్వేషిద్దాం.

ఎథీరియం అప్లికేషన్‌లో, మీరు సాధారణంగా కరెన్సీ డినామినేషన్‌లను మార్చాల్సి ఉంటుంది. దీని కోసమే Web3 మాడ్యూల్ కొన్ని హెల్పర్ పద్ధతులను అందిస్తుంది: from_wei (opens in a new tab) మరియు to_wei (opens in a new tab).

కొన్ని విలువలను Wei కి మరియు Wei నుండి మార్చడానికి ప్రయత్నించండి. ఈథర్ మరియు Wei మధ్య అనేక డినామినేషన్‌లకు పేర్లు ఉన్నాయని (opens in a new tab) గమనించండి. వాటిలో బాగా తెలిసిన వాటిలో ఒకటి Gwei, ఎందుకంటే లావాదేవీ రుసుములను తరచుగా ఇలాగే సూచిస్తారు.

In [2]: Web3.to_wei(1, 'ether')
Out[2]: 1000000000000000000

In [3]: Web3.from_wei(500000000, 'gwei')
Out[3]: Decimal('0.5')

Web3 మాడ్యూల్‌లోని ఇతర యుటిలిటీ పద్ధతులలో డేటా ఫార్మాట్ కన్వర్టర్‌లు (ఉదా., toHex (opens in a new tab)), చిరునామా హెల్పర్‌లు (ఉదా., isAddress (opens in a new tab)) మరియు హాష్ ఫంక్షన్‌లు (ఉదా., keccak (opens in a new tab)) ఉన్నాయి. వీటిలో చాలా వరకు సిరీస్‌లో తర్వాత కవర్ చేయబడతాయి. అందుబాటులో ఉన్న అన్ని పద్ధతులు మరియు లక్షణాలను (properties) వీక్షించడానికి, Web3. అని టైప్ చేసి, చుక్క (period) తర్వాత ట్యాబ్ కీని రెండుసార్లు నొక్కడం ద్వారా IPython యొక్క ఆటో-కంప్లీట్‌ను ఉపయోగించండి.

చైన్‌తో మాట్లాడండి

కన్వీనియన్స్ పద్ధతులు బాగున్నాయి, కానీ మనం బ్లాక్‌చైన్‌కి వెళ్దాం. తదుపరి దశ ఎథీరియం నోడ్‌తో కమ్యూనికేట్ చేయడానికి Web3.py ని కాన్ఫిగర్ చేయడం. ఇక్కడ మనం IPC, HTTP లేదా Websocket ప్రొవైడర్‌లను ఉపయోగించే ఎంపికను కలిగి ఉన్నాము.

మనం ఈ మార్గంలో వెళ్లము, కానీ HTTP ప్రొవైడర్‌ను ఉపయోగించే పూర్తి వర్క్‌ఫ్లో ఉదాహరణ ఈ విధంగా ఉండవచ్చు:

• ఎథీరియం నోడ్‌ను డౌన్‌లోడ్ చేయండి, ఉదా., Geth (opens in a new tab).
• ఒక టెర్మినల్ విండోలో Geth ని ప్రారంభించండి మరియు అది నెట్‌వర్క్‌ను సమకాలీకరణ చేసే వరకు వేచి ఉండండి. డిఫాల్ట్ HTTP పోర్ట్ 8545, కానీ దీనిని కాన్ఫిగర్ చేయవచ్చు.
• localhost:8545 లో HTTP ద్వారా నోడ్‌కి కనెక్ట్ అవ్వమని Web3.py కి చెప్పండి. w3 = Web3(Web3.HTTPProvider('http://127.0.0.1:8545'))
• నోడ్‌తో ఇంటరాక్ట్ అవ్వడానికి w3 ఇన్‌స్టాన్స్‌ను ఉపయోగించండి.

దీన్ని చేయడానికి ఇది ఒక "నిజమైన" మార్గం అయినప్పటికీ, సమకాలీకరణ ప్రక్రియకు గంటల సమయం పడుతుంది మరియు మీకు కేవలం డెవలప్‌మెంట్ ఎన్విరాన్‌మెంట్ మాత్రమే కావాలంటే ఇది అనవసరం. Web3.py ఈ ప్రయోజనం కోసం నాల్గవ ప్రొవైడర్‌ను అందిస్తుంది, అదే EthereumTesterProvider. ఈ టెస్టర్ ప్రొవైడర్ సడలించిన అనుమతులు మరియు ఆడుకోవడానికి నకిలీ కరెన్సీతో అనుకరణ చేయబడిన ఎథీరియం నోడ్‌కి లింక్ చేస్తుంది.

EthereumTesterProvider అనుకరణ చేయబడిన నోడ్‌కి కనెక్ట్ అవుతుంది మరియు శీఘ్ర డెవలప్‌మెంట్ ఎన్విరాన్‌మెంట్‌ల కోసం ఉపయోగకరంగా ఉంటుంది.

ఆ అనుకరణ చేయబడిన నోడ్‌ను eth-tester (opens in a new tab) అని పిలుస్తారు మరియు మనం దానిని pip install web3[tester] కమాండ్‌లో భాగంగా ఇన్‌స్టాల్ చేసాము. ఈ టెస్టర్ ప్రొవైడర్‌ను ఉపయోగించడానికి Web3.py ని కాన్ఫిగర్ చేయడం చాలా సులభం:

In [4]: w3 = Web3(Web3.EthereumTesterProvider())

ఇప్పుడు మీరు చైన్‌లో సర్ఫ్ చేయడానికి సిద్ధంగా ఉన్నారు! ప్రజలు అలా అనరు. నేను ఇప్పుడే దాన్ని కల్పించాను. మనం ఒక చిన్న టూర్ చేద్దాం.

చిన్న టూర్

ముందుగా చేయాల్సింది, ఒక శానిటీ చెక్:

In [5]: w3.is_connected()
Out[5]: True

మనం టెస్టర్ ప్రొవైడర్‌ను ఉపయోగిస్తున్నందున, ఇది చాలా విలువైన పరీక్ష కాదు, కానీ అది విఫలమైతే, w3 వేరియబుల్‌ను ఇన్‌స్టాన్షియేట్ చేసేటప్పుడు మీరు ఏదైనా తప్పుగా టైప్ చేసి ఉండే అవకాశం ఉంది. మీరు లోపలి కుండలీకరణాలను (parentheses) చేర్చారో లేదో ఒకటికి రెండుసార్లు తనిఖీ చేయండి, అంటే, Web3.EthereumTesterProvider().

టూర్ స్టాప్ #1: ఖాతాలు

సౌలభ్యం కోసం, టెస్టర్ ప్రొవైడర్ కొన్ని ఖాతాలను సృష్టించింది మరియు వాటిలో టెస్ట్ ఈథర్‌ను ముందుగానే లోడ్ చేసింది.

ముందుగా, ఆ ఖాతాల జాబితాను చూద్దాం:

In [6]: w3.eth.accounts
Out[6]: ['0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf',
 '0x2B5AD5c4795c026514f8317c7a215E218DcCD6cF',
 '0x6813Eb9362372EEF6200f3b1dbC3f819671cBA69', ...]

మీరు ఈ కమాండ్‌ను రన్ చేస్తే, 0x తో ప్రారంభమయ్యే పది స్ట్రింగ్‌ల జాబితాను మీరు చూడాలి. ప్రతిదీ ఒక పబ్లిక్ చిరునామా మరియు ఇది కొన్ని విధాలుగా చెకింగ్ ఖాతాలోని ఖాతా నంబర్‌ను పోలి ఉంటుంది. మీకు ఈథర్ పంపాలనుకునే ఎవరికైనా మీరు ఈ చిరునామాను అందిస్తారు.

చెప్పినట్లుగా, టెస్టర్ ప్రొవైడర్ ఈ ప్రతి ఖాతాలో కొంత టెస్ట్ ఈథర్‌ను ముందుగానే లోడ్ చేసింది. మొదటి ఖాతాలో ఎంత ఉందో తెలుసుకుందాం:

In [7]: w3.eth.get_balance(w3.eth.accounts[0])
Out[7]: 1000000000000000000000000

అవి చాలా సున్నాలు! మీరు నకిలీ బ్యాంకుకు వెళ్లి నవ్వుకునే ముందు, కరెన్సీ డినామినేషన్‌ల గురించి ఇంతకు ముందు నేర్చుకున్న పాఠాన్ని గుర్తుచేసుకోండి. ఈథర్ విలువలు అతిచిన్న డినామినేషన్ అయిన Wei లో సూచించబడతాయి. దానిని ఈథర్‌గా మార్చండి:

In [8]: w3.from_wei(1000000000000000000000000, 'ether')
Out[8]: Decimal('1000000')

ఒక మిలియన్ టెస్ట్ ఈథర్ — ఇది కూడా తక్కువేమీ కాదు.

టూర్ స్టాప్ #2: బ్లాక్ డేటా

ఈ అనుకరణ చేయబడిన బ్లాక్‌చైన్ స్థితిని ఒకసారి చూద్దాం:

In [9]: w3.eth.get_block('latest')
Out[9]: AttributeDict({
   'number': 0,
   'hash': HexBytes('0x9469878...'),
   'parentHash': HexBytes('0x0000000...'),
   ...
   'transactions': []
})

బ్లాక్ గురించి చాలా సమాచారం తిరిగి వస్తుంది, కానీ ఇక్కడ ఎత్తి చూపాల్సిన కొన్ని విషయాలు:

• బ్లాక్ నంబర్ సున్నా — మీరు టెస్టర్ ప్రొవైడర్‌ను ఎంత కాలం క్రితం కాన్ఫిగర్ చేసినా సరే. ప్రతి 12 సెకన్లకు కొత్త బ్లాక్‌ను జోడించే నిజమైన ఎథీరియం నెట్‌వర్క్ వలె కాకుండా, ఈ అనుకరణ మీరు దానికి కొంత పని ఇచ్చే వరకు వేచి ఉంటుంది.
• transactions అనేది ఖాళీ జాబితా, అదే కారణంతో: మనం ఇంకా ఏమీ చేయలేదు. ఈ మొదటి బ్లాక్ చైన్‌ను ప్రారంభించడానికి మాత్రమే ఉపయోగపడే ఒక ఖాళీ బ్లాక్.
• parentHash అనేది కేవలం ఖాళీ బైట్‌ల సమూహం అని గమనించండి. ఇది చైన్‌లోని మొదటి బ్లాక్ అని సూచిస్తుంది, దీనిని ప్రారంభ బ్లాక్ అని కూడా పిలుస్తారు.

టూర్ స్టాప్ #3: లావాదేవీలు

పెండింగ్ లావాదేవీ ఉండే వరకు మనం బ్లాక్ సున్నా వద్దే ఆగిపోతాము, కాబట్టి దానికి ఒక లావాదేవీని ఇద్దాం. ఒక ఖాతా నుండి మరొక ఖాతాకు కొన్ని టెస్ట్ ఈథర్‌లను పంపండి:

In [10]: tx_hash = w3.eth.send_transaction({
   'from': w3.eth.accounts[0],
   'to': w3.eth.accounts[1],
   'value': w3.to_wei(3, 'ether'),
   'gas': 21000
})

సాధారణంగా మీ లావాదేవీ కొత్త బ్లాక్‌లో చేర్చబడటానికి మీరు కొన్ని సెకన్ల పాటు వేచి ఉండే సమయం ఇది. పూర్తి ప్రక్రియ ఈ విధంగా ఉంటుంది:

1. లావాదేవీని సమర్పించండి మరియు లావాదేవీ హాష్‌ను పట్టుకోండి. లావాదేవీని కలిగి ఉన్న బ్లాక్ సృష్టించబడి మరియు ప్రసారం చేయబడే వరకు, లావాదేవీ "పెండింగ్" లో ఉంటుంది. tx_hash = w3.eth.send_transaction({ … })
2. లావాదేవీ బ్లాక్‌లో చేర్చబడే వరకు వేచి ఉండండి: w3.eth.wait_for_transaction_receipt(tx_hash)
3. అప్లికేషన్ లాజిక్‌ను కొనసాగించండి. విజయవంతమైన లావాదేవీని వీక్షించడానికి: w3.eth.get_transaction(tx_hash)

మన అనుకరణ చేయబడిన ఎన్విరాన్‌మెంట్ లావాదేవీని తక్షణమే కొత్త బ్లాక్‌లో జోడిస్తుంది, కాబట్టి మనం వెంటనే లావాదేవీని వీక్షించవచ్చు:

In [11]: w3.eth.get_transaction(tx_hash)
Out[11]: AttributeDict({
   'hash': HexBytes('0x15e9fb95dc39...'),
   'blockNumber': 1,
   'transactionIndex': 0,
   'from': '0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf',
   'to': '0x2B5AD5c4795c026514f8317c7a215E218DcCD6cF',
   'value': 3000000000000000000,
   ...
})

మీరు ఇక్కడ కొన్ని తెలిసిన వివరాలను చూస్తారు: from, to మరియు value ఫీల్డ్‌లు మన send_transaction కాల్ యొక్క ఇన్‌పుట్‌లతో సరిపోలాలి. మరో భరోసా ఇచ్చే విషయం ఏమిటంటే, ఈ లావాదేవీ బ్లాక్ నంబర్ 1 లో మొదటి లావాదేవీగా ('transactionIndex': 0) చేర్చబడింది.

ఇందులో పాల్గొన్న రెండు ఖాతాల బ్యాలెన్స్‌లను తనిఖీ చేయడం ద్వారా మనం ఈ లావాదేవీ విజయాన్ని సులభంగా ధృవీకరించవచ్చు. మూడు ఈథర్‌లు ఒకరి నుండి మరొకరికి బదిలీ చేయబడి ఉండాలి.

In [12]: w3.eth.get_balance(w3.eth.accounts[0])
Out[12]: 999996999979000000000000

In [13]: w3.eth.get_balance(w3.eth.accounts[1])
Out[13]: 1000003000000000000000000

రెండవది బాగానే ఉంది! బ్యాలెన్స్ 1,000,000 నుండి 1,000,003 ఈథర్‌కు పెరిగింది. కానీ మొదటి ఖాతాకు ఏమైంది? ఇది మూడు ఈథర్‌ల కంటే కొంచెం ఎక్కువగా కోల్పోయినట్లు కనిపిస్తోంది. అయ్యో, జీవితంలో ఏదీ ఉచితం కాదు, మరియు ఎథీరియం పబ్లిక్ నెట్‌వర్క్‌ను ఉపయోగించడానికి మీరు మీ పీర్‌లకు వారి సహాయక పాత్ర కోసం పరిహారం చెల్లించాల్సి ఉంటుంది. లావాదేవీని సమర్పించిన ఖాతా నుండి ఒక చిన్న లావాదేవీ రుసుము తీసివేయబడింది - ఈ రుసుము అనేది బర్న్ చేయబడిన గ్యాస్ మొత్తం (ఒక ETH బదిలీకి 21000 యూనిట్ల గ్యాస్) గుణించబడిన ప్రాథమిక రుసుము (ఇది నెట్‌వర్క్ కార్యాచరణను బట్టి మారుతుంది) మరియు లావాదేవీని బ్లాక్‌లో చేర్చే ధృవీకర్తకు వెళ్లే టిప్.

గ్యాస్ గురించి మరింత

మరియు ఊపిరి పీల్చుకోండి

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