పైథాన్ అభివృద్ధి చేసేవారికి ఇతీరియము పరిచయం, భాగం 1

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

(సాఫ్ట్) ముందస్తు అవసరాలు

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

అంచనాలు:

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

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

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

1{
2   "number": 1234567,
3   "hash": "0xabc123...",
4   "parentHash": "0xdef456...",
5   ...,
6   "transactions": [...]
7}
కాపీ

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

బ్లాక్ చైను తప్పనిసరిగా ఒక లింక్డ్ జాబితా; ప్రతి బ్లాక్ మునుపటి బ్లాక్‌కు ఒక రిఫరెన్స్ కలిగి ఉంటుంది.

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

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

ఒక కొత్త నమూనా

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

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

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

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

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

1# బ్లాక్ డేటాను చదవండి:
2w3.eth.get_block('latest')
3
4# లావాదేవీని పంపండి:
5w3.eth.send_transaction({'from': ..., 'to': ..., 'value': ...})
కాపీ

సంస్థాపన

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

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

pip install ipython

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

pip install web3

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

pip install 'web3[tester]'

మీరు వెళ్ళడానికి సిద్ధంగా ఉన్నారు!

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

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

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

ipython

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

1In [1]:
కాపీ

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

1In [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, ఎందుకంటె లావాదేవీ రుసుములు తరచుగా అలానే సూచించబడతాయి.

1In [2]: Web3.to_wei(1, 'ether')
2Out[2]: 1000000000000000000
3
4In [3]: Web3.from_wei(500000000, 'gwei')
5Out[3]: Decimal('0.5')
కాపీ

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

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

సౌకర్యవంతమైన పద్ధతులు బాగున్నాయి, కానీ బ్లాక్‌చైన్‌కు వెళ్దాం. తదుపరి దశ 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ని కాన్ఫిగర్ చేయడం చాలా సులభం:

1In [4]: w3 = Web3(Web3.EthereumTesterProvider())
కాపీ

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

శీఘ్ర పర్యటన

అన్నింటికంటే ముందు, ఒక శానిటీ చెక్:

1In [5]: w3.is_connected()
2Out[5]: True
కాపీ

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

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

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

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

1In [6]: w3.eth.accounts
2Out[6]: ['0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf',
3 '0x2B5AD5c4795c026514f8317c7a215E218DcCD6cF',
4 '0x6813Eb9362372EEF6200f3b1dbC3f819671cBA69', ...]
కాపీ

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

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

1In [7]: w3.eth.get_balance(w3.eth.accounts[0])
2Out[7]: 1000000000000000000000000
కాపీ

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

1In [8]: w3.from_wei(1000000000000000000000000, 'ether')
2Out[8]: Decimal('1000000')
కాపీ

ఒక మిలియన్ టెస్ట్ ఈథర్ — ఇప్పటికీ చాలా బాగుంది.

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

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

1In [9]: w3.eth.get_block('latest')
2Out[9]: AttributeDict({
3   'number': 0,
4   'hash': HexBytes('0x9469878...'),
5   'parentHash': HexBytes('0x0000000...'),
6   ...
7   'transactions': []
8})
కాపీ

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

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

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

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

1In [10]: tx_hash = w3.eth.send_transaction({
2   'from': w3.eth.accounts[0],
3   'to': w3.eth.accounts[1],
4   'value': w3.to_wei(3, 'ether'),
5   'gas': 21000
6})
కాపీ

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

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

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

1In [11]: w3.eth.get_transaction(tx_hash)
2Out[11]: AttributeDict({
3   'hash': HexBytes('0x15e9fb95dc39...'),
4   'blockNumber': 1,
5   'transactionIndex': 0,
6   'from': '0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf',
7   'to': '0x2B5AD5c4795c026514f8317c7a215E218DcCD6cF',
8   'value': 3000000000000000000,
9   ...
10})
అన్నీ చూపించు
కాపీ

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

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

1In [12]: w3.eth.get_balance(w3.eth.accounts[0])
2Out[12]: 999996999979000000000000
3
4In [13]: w3.eth.get_balance(w3.eth.accounts[1])
5Out[13]: 1000003000000000000000000
కాపీ

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

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

మరియు శ్వాస తీసుకోండి

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

పేజీ చివరి అప్‌డేట్: 6 ఫిబ్రవరి, 2025

b (opens in a new tab)

n (opens in a new tab)

c (opens in a new tab)

+14

సహకారులను చూడండి