Python டெவலப்பர்களுக்கான எத்திரியம் அறிமுகம், பகுதி 1

எனவே, நீங்கள் இந்த எத்திரியம் பற்றி கேள்விப்பட்டிருக்கிறீர்கள், மேலும் இதைப்பற்றி ஆழமாகத் தெரிந்துகொள்ளத் தயாராக இருக்கிறீர்களா? இந்த பதிவு சில தொகுதிச்சங்கிலி (blockchain) அடிப்படைகளை விரைவாக உள்ளடக்கும், பின்னர் உருவகப்படுத்தப்பட்ட எத்திரியம் கணுவுடன் (node) உங்களை தொடர்பு கொள்ளச் செய்யும் – தொகுதித் தரவைப் படித்தல், கணக்கு நிலுவைகளைச் சரிபார்த்தல் மற்றும் பரிவர்த்தனைகளை அனுப்புதல். இதற்கிடையில், பயன்பாடுகளை உருவாக்கும் பாரம்பரிய வழிகளுக்கும் இந்தப் புதிய பரவலாக்கப்பட்ட (decentralized) முறைக்கும் உள்ள வேறுபாடுகளை நாங்கள் முன்னிலைப்படுத்துவோம்.

(எளிய) முன்நிபந்தனைகள்

இந்த பதிவு பரந்த அளவிலான டெவலப்பர்களுக்கு அணுகக்கூடியதாக இருக்க விரும்புகிறது. இதில் Python கருவிகள் ஈடுபடுத்தப்படும், ஆனால் அவை யோசனைகளுக்கான ஒரு கருவி மட்டுமே – நீங்கள் ஒரு Python டெவலப்பராக இல்லாவிட்டாலும் எந்தப் பிரச்சனையும் இல்லை. இருப்பினும், உங்களுக்கு ஏற்கனவே தெரிந்தவற்றைப் பற்றி நான் சில அனுமானங்களைச் செய்வேன், எனவே நாம் விரைவாக எத்திரியம் சார்ந்த பகுதிகளுக்குச் செல்லலாம்.

அனுமானங்கள்:

• நீங்கள் டெர்மினலில் (terminal) வேலை செய்யத் தெரிந்தவர்,
• நீங்கள் சில வரிகள் Python குறியீட்டை எழுதியுள்ளீர்கள்,
• உங்கள் கணினியில் Python பதிப்பு 3.6 அல்லது அதற்கு மேற்பட்டவை நிறுவப்பட்டுள்ளது (ஒரு மெய்நிகர் சூழலை (virtual environment) (opens in a new tab) பயன்படுத்துவது கடுமையாக ஊக்குவிக்கப்படுகிறது), மற்றும்
• நீங்கள் Python-இன் தொகுப்பு நிறுவியான pip-ஐப் பயன்படுத்தியுள்ளீர்கள். மீண்டும், இவற்றில் ஏதேனும் உண்மையாக இல்லாவிட்டாலோ அல்லது இந்தக் கட்டுரையில் உள்ள குறியீட்டை மீண்டும் உருவாக்க நீங்கள் திட்டமிடவில்லை என்றாலோ, நீங்கள் தொடர்ந்து இதைப் படித்துப் புரிந்து கொள்ள முடியும்.

தொகுதிச்சங்கிலிகள், சுருக்கமாக

எத்திரியத்தை விவரிக்க பல வழிகள் உள்ளன, ஆனால் அதன் மையத்தில் இருப்பது ஒரு தொகுதிச்சங்கிலி ஆகும். தொகுதிச்சங்கிலிகள் தொடர்ச்சியான தொகுதிகளால் ஆனவை, எனவே அங்கிருந்து தொடங்குவோம். எளிமையான வார்த்தைகளில் கூறுவதானால், எத்திரியம் தொகுதிச்சங்கிலியில் உள்ள ஒவ்வொரு தொகுதியும் சில மீத்தரவு (metadata) மற்றும் பரிவர்த்தனைகளின் பட்டியல் மட்டுமே. JSON வடிவத்தில், அது இதுபோன்று இருக்கும்:

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

ஒவ்வொரு தொகுதியும் அதற்கு முன் வந்த தொகுதிக்கான குறிப்பைக் கொண்டுள்ளது; parentHash என்பது முந்தைய தொகுதியின் ஹாஷ் மட்டுமே.

ஒரு தொகுதிச்சங்கிலி என்பது அடிப்படையில் இணைக்கப்பட்ட பட்டியல் (linked list) ஆகும்; ஒவ்வொரு தொகுதியும் முந்தைய தொகுதிக்கான குறிப்பைக் கொண்டுள்ளது.

இந்த தரவுக் கட்டமைப்பு புதிதல்ல, ஆனால் பிணையத்தை நிர்வகிக்கும் விதிகள் (அதாவது, சக-முனைய நெறிமுறைகள்) புதியவை. இதில் மைய அதிகாரம் எதுவும் இல்லை; பிணையத்தைத் தக்கவைக்க சக-முனையங்களின் பிணையம் ஒத்துழைக்க வேண்டும், மேலும் அடுத்த தொகுதியில் எந்தப் பரிவர்த்தனைகளைச் சேர்க்க வேண்டும் என்பதைத் தீர்மானிக்கப் போட்டியிட வேண்டும். எனவே, நீங்கள் ஒரு நண்பருக்குப் பணம் அனுப்ப விரும்பினால், அந்தப் பரிவர்த்தனையைப் பிணையத்தில் ஒளிபரப்ப வேண்டும், பின்னர் அது வரவிருக்கும் தொகுதியில் சேர்க்கப்படும் வரை காத்திருக்க வேண்டும்.

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

ஒரு புதிய முன்னுதாரணம்

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

எத்திரியத்துடன் தொடர்பு கொள்ள விரும்பும் Python டெவலப்பர்கள் Web3.py (opens in a new tab)-ஐப் பயன்படுத்த வாய்ப்புள்ளது. Web3.py என்பது ஒரு நிரலகம் (library), இது நீங்கள் எத்திரியம் கணுவுடன் இணைக்கும் வழியைப் பெரிதும் எளிதாக்குகிறது, பின்னர் அதிலிருந்து தரவை அனுப்பவும் பெறவும் உதவுகிறது.

எத்திரியம் கிளையண்டுகளை 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 இன்டர்ப்ரெட்டருக்குள் (interpreter) மட்டுமே வேலை செய்வோம். நாங்கள் எந்த கோப்பகங்கள், கோப்புகள், வகுப்புகள் அல்லது செயல்பாடுகளை உருவாக்க மாட்டோம்.

முதலில், ஆராய்வதற்குப் பயனர் நட்பு சூழலுக்காக IPython (opens in a new tab)-ஐ நிறுவவும். IPython மற்ற அம்சங்களுடன் டேப் நிறைவு (tab completion) வசதியை வழங்குகிறது, இது Web3.py-க்குள் என்ன சாத்தியம் என்பதைப் பார்ப்பதை மிகவும் எளிதாக்குகிறது.

pip install ipython

Web3.py ஆனது web3 என்ற பெயரில் வெளியிடப்பட்டுள்ளது. இதை இவ்வாறு நிறுவவும்:

pip install web3

இன்னொரு விஷயம் – நாங்கள் பின்னர் ஒரு தொகுதிச்சங்கிலியை உருவகப்படுத்தப் போகிறோம், இதற்கு இன்னும் சில சார்புகள் (dependencies) தேவை. நீங்கள் அவற்றை இதன் மூலம் நிறுவலாம்:

pip install 'web3[tester]'

நீங்கள் தொடங்குவதற்குத் தயாராகிவிட்டீர்கள்!

குறிப்பு: web3[tester] தொகுப்பு Python 3.10.xx வரை வேலை செய்யும்

ஒரு சாண்ட்பாக்ஸை (sandbox) உருவாக்குதல்

உங்கள் டெர்மினலில் ipython-ஐ இயக்குவதன் மூலம் புதிய Python சூழலைத் திறக்கவும். இது python-ஐ இயக்குவதற்கு ஒப்பானது, ஆனால் கூடுதல் அம்சங்களுடன் வருகிறது.

ipython

இது நீங்கள் இயக்கும் Python மற்றும் IPython பதிப்புகளைப் பற்றிய சில தகவல்களை அச்சிடும், பின்னர் உள்ளீட்டிற்காகக் காத்திருக்கும் ஒரு வரியை நீங்கள் காண வேண்டும்:

In [1]:

நீங்கள் இப்போது ஒரு ஊடாடும் Python ஷெல்லைப் (shell) பார்க்கிறீர்கள். அடிப்படையில், இது விளையாடுவதற்கான ஒரு சாண்ட்பாக்ஸ் ஆகும். நீங்கள் இதுவரை வந்திருந்தால், Web3.py-ஐ இறக்குமதி செய்ய வேண்டிய நேரம் இது:

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-க்கும் இடையில் பல மதிப்புகளுக்குப் பெயர்கள் உள்ளன (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)) ஆகியவை அடங்கும். இவற்றில் பல இந்தத் தொடரில் பின்னர் விவாதிக்கப்படும். கிடைக்கக்கூடிய அனைத்து முறைகள் மற்றும் பண்புகளைப் பார்க்க, Web3. எனத் தட்டச்சு செய்து, புள்ளிக்குப் பிறகு இரண்டு முறை டேப் (tab) விசையை அழுத்துவதன் மூலம் IPython-இன் தானியங்கு-நிறைவு (auto-complete) வசதியைப் பயன்படுத்தவும்.

சங்கிலியுடன் பேசுங்கள்

வசதியான முறைகள் அருமையாக உள்ளன, ஆனால் தொகுதிச்சங்கிலிக்குச் செல்வோம். அடுத்த கட்டமாக எத்திரியம் கணுவுடன் தொடர்பு கொள்ள Web3.py-ஐ உள்ளமைக்க வேண்டும். இங்கே நாம் IPC, HTTP அல்லது Websocket வழங்குநர்களைப் பயன்படுத்துவதற்கான விருப்பம் உள்ளது.

நாங்கள் இந்த வழியில் செல்ல மாட்டோம், ஆனால் HTTP வழங்குநரைப் பயன்படுத்தும் முழுமையான பணிப்பாய்வுக்கான எடுத்துக்காட்டு இதுபோன்று இருக்கலாம்:

• ஒரு எத்திரியம் கணுவைப் பதிவிறக்கவும், எ.கா., Geth (opens in a new tab).
• ஒரு டெர்மினல் சாளரத்தில் Geth-ஐத் தொடங்கி, அது பிணையத்தை ஒத்திசைக்கும் (sync) வரை காத்திருக்கவும். இயல்புநிலை 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 மாறியை உருவாக்கும்போது நீங்கள் ஏதேனும் தவறாகத் தட்டச்சு செய்திருக்க வாய்ப்புள்ளது. நீங்கள் உள் அடைப்புக்குறிகளைச் சேர்த்துள்ளீர்களா என்பதை இருமுறை சரிபார்க்கவும், அதாவது Web3.EthereumTesterProvider().

சுற்றுப்பயண நிறுத்தம் #1: கணக்குகள்

ஒரு வசதிக்காக, சோதனையாளர் வழங்குநர் சில கணக்குகளை உருவாக்கி, அவற்றில் சோதனை ஈதரை முன்பே ஏற்றியுள்ளார்.

முதலில், அந்தக் கணக்குகளின் பட்டியலைப் பார்ப்போம்:

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

இந்தக் கட்டளையை நீங்கள் இயக்கினால், 0x உடன் தொடங்கும் பத்து சரங்களின் (strings) பட்டியலைக் காண வேண்டும். ஒவ்வொன்றும் ஒரு பொது முகவரி ஆகும், மேலும் இது சில வழிகளில் சரிபார்ப்புக் கணக்கில் உள்ள கணக்கு எண்ணுக்கு ஒத்ததாகும். உங்களுக்கு ஈதரை அனுப்ப விரும்பும் ஒருவருக்கு இந்த முகவரியை நீங்கள் வழங்குவீர்கள்.

குறிப்பிட்டுள்ளபடி, சோதனையாளர் வழங்குநர் இந்தக் கணக்குகள் ஒவ்வொன்றிலும் சில சோதனை ஈதரை முன்பே ஏற்றியுள்ளார். முதல் கணக்கில் எவ்வளவு இருக்கிறது என்பதைக் கண்டுபிடிப்போம்:

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 என்பது வெறும் வெற்று பைட்டுகளின் தொகுப்பு என்பதைக் கவனியுங்கள். இது சங்கிலியின் முதல் தொகுதி என்பதைக் குறிக்கிறது, இது தொடக்கத் தொகுதி (genesis block) என்றும் அழைக்கப்படுகிறது.

சுற்றுப்பயண நிறுத்தம் #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) வழியாகக் கோரிக்கைகள் வரவேற்கப்படுகின்றன.