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

Python

web3.py

தொடக்கநிலையாளர்

மார்க் கரோ

8 செப்டம்பர், 2020

10 நிமிட வாசிப்பு

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

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

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

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

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

பிளாக்செயின்கள், சுருக்கமாக

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

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

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

குறிப்பு: நிலையான அளவிலான மதிப்புகளை (“ஹாஷ்கள்”) உருவாக்க எத்தேரியம் தொடர்ந்து ஹாஷ் செயல்பாடுகளைப் (hash functions) பயன்படுத்துகிறது. எத்தேரியத்தில் ஹாஷ்கள் முக்கியப் பங்கு வகிக்கின்றன, ஆனால் இப்போதைக்கு அவற்றை தனித்துவமான ஐடிகள் (unique IDs) என்று நீங்கள் நினைத்துக் கொள்ளலாம்.

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

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

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

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

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

எத்தேரியத்துடன் தொடர்பு கொள்ள விரும்பும் பைதான் டெவலப்பர்கள் 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': ...})

நிறுவல்

இந்த வழிகாட்டியில், நாம் ஒரு பைதான் இன்டர்ப்ரெட்டருக்குள் (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] பேக்கேஜ் பைதான் 3.10.xx வரை வேலை செய்யும்

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

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

ipython

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

In [1]:

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

In [1]: from web3 import Web3

Web3 தொகுதியை அறிமுகப்படுத்துதல்

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

ஒரு எத்தேரியம் பயன்பாட்டில், நீங்கள் பொதுவாக நாணய மதிப்புகளை மாற்ற வேண்டியிருக்கும். இதற்காகவே Web3 தொகுதி சில உதவி முறைகளை (helper methods) வழங்குகிறது: from_wei (opens in a new tab) மற்றும் to_wei (opens in a new tab).

குறிப்பு: தசம கணிதத்தைக் கையாள்வதில் கணினிகள் மிகவும் மோசமானவை. இதைத் தவிர்க்க, டெவலப்பர்கள் பெரும்பாலும் டாலர் தொகைகளை சென்ட்களில் சேமிக்கிறார்கள். எடுத்துக்காட்டாக, $5.99 விலையுள்ள ஒரு பொருள் தரவுத்தளத்தில் 599 ஆகச் சேமிக்கப்படலாம்.

ஈதரில் (ether) பரிவர்த்தனைகளைக் கையாளும்போதும் இதே போன்ற முறை பயன்படுத்தப்படுகிறது. இருப்பினும், இரண்டு தசம புள்ளிகளுக்குப் பதிலாக, ஈதரில் 18 உள்ளன! ஈதரின் மிகச்சிறிய மதிப்பு வேய் (wei) என்று அழைக்கப்படுகிறது, எனவே பரிவர்த்தனைகளை அனுப்பும்போது அந்த மதிப்புதான் குறிப்பிடப்படுகிறது.

1 ஈதர் = 1000000000000000000 வேய்

1 வேய் = 0.000000000000000001 ஈதர்

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

ஒரு எத்தேரியம் நோடைப் பதிவிறக்கவும், எ.கா., 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 இன்ஸ்டன்ஸைப் பயன்படுத்தவும்.

இதைச் செய்வதற்கான ஒரு “உண்மையான” வழி இதுவாக இருந்தாலும், ஒத்திசைவு செயல்முறைக்கு பல மணிநேரம் ஆகும், மேலும் நீங்கள் ஒரு மேம்பாட்டுச் சூழலை (development environment) மட்டுமே விரும்பினால் இது தேவையற்றது. இதற்காக Web3.py நான்காவது புரொவைடரான EthereumTesterProvider-ஐ வழங்குகிறது. இந்த டெஸ்டர் புரொவைடர், தளர்த்தப்பட்ட அனுமதிகள் மற்றும் விளையாடுவதற்கான போலி நாணயத்துடன் கூடிய உருவகப்படுத்தப்பட்ட எத்தேரியம் நோடுடன் இணைகிறது.

EthereumTesterProvider ஒரு உருவகப்படுத்தப்பட்ட நோடுடன் இணைகிறது மற்றும் விரைவான மேம்பாட்டுச் சூழல்களுக்கு இது மிகவும் வசதியானது.

அந்த உருவகப்படுத்தப்பட்ட நோடு eth-tester (opens in a new tab) என்று அழைக்கப்படுகிறது, மேலும் அதை pip install web3[tester] கட்டளையின் ஒரு பகுதியாக நிறுவினோம். இந்த டெஸ்டர் புரொவைடரைப் பயன்படுத்த Web3.py-ஐ உள்ளமைப்பது மிகவும் எளிதானது:

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

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

விரைவான சுற்றுப்பயணம்

முதலில், ஒரு அடிப்படைச் சரிபார்ப்பு (sanity check):

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

நாம் டெஸ்டர் புரொவைடரைப் பயன்படுத்துவதால், இது மிகவும் மதிப்புமிக்க சோதனை அல்ல, ஆனால் இது தோல்வியுற்றால், w3 மாறியை (variable) உருவாக்கும்போது நீங்கள் ஏதேனும் தவறாகத் தட்டச்சு செய்திருக்க வாய்ப்புள்ளது. நீங்கள் உள் அடைப்புக்குறிகளைச் சேர்த்துள்ளீர்களா என்பதை இருமுறை சரிபார்க்கவும், அதாவது Web3.EthereumTesterProvider().

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

வசதிக்காக, டெஸ்டர் புரொவைடர் சில கணக்குகளை உருவாக்கி, அவற்றில் சோதனை ஈதரை (test ether) முன்கூட்டியே ஏற்றியுள்ளது.

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

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

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

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

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

அது நிறைய பூஜ்ஜியங்கள்! போலி வங்கிக்குச் சென்று சிரிப்பதற்கு முன், நாணய மதிப்புகள் பற்றிய முந்தைய பாடத்தை நினைவுகூருங்கள். ஈதர் மதிப்புகள் மிகச்சிறிய மதிப்பான வேய்யில் குறிப்பிடப்படுகின்றன. அதை ஈதராக மாற்றவும்:

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

ஒரு மில்லியன் சோதனை ஈதர் — இதுவும் மோசமானதல்ல.

சுற்றுப்பயண நிறுத்தம் #2: பிளாக் தரவு

இந்த உருவகப்படுத்தப்பட்ட பிளாக்செயினின் நிலையை (state) ஒருமுறை பார்ப்போம்:

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

ஒரு பிளாக்கைப் பற்றி நிறைய தகவல்கள் வழங்கப்படுகின்றன, ஆனால் இங்கே சுட்டிக்காட்ட வேண்டிய சில விஷயங்கள்:

பிளாக் எண் பூஜ்ஜியம் — நீங்கள் டெஸ்டர் புரொவைடரை எவ்வளவு காலத்திற்கு முன்பு உள்ளமைத்திருந்தாலும் சரி. ஒவ்வொரு 12 வினாடிகளுக்கும் ஒரு புதிய பிளாக்கைச் சேர்க்கும் உண்மையான எத்தேரியம் நெட்வொர்க்கைப் போலல்லாமல், இந்த உருவகப்படுத்துதல் நீங்கள் அதற்குச் சில வேலைகளைக் கொடுக்கும் வரை காத்திருக்கும்.
transactions என்பது ஒரு வெற்றுப் பட்டியல், அதே காரணத்திற்காகத்தான்: நாம் இன்னும் எதுவும் செய்யவில்லை. இந்த முதல் பிளாக் ஒரு வெற்று பிளாக் (empty block) ஆகும், இது செயினைத் தொடங்குவதற்காக மட்டுமே.
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
})

பொதுவாக உங்கள் பரிவர்த்தனை ஒரு புதிய பிளாக்கில் சேர்க்கப்படுவதற்கு நீங்கள் பல வினாடிகள் காத்திருக்கும் புள்ளி இதுவாகும். முழு செயல்முறையும் இப்படித்தான் நடக்கும்:

ஒரு பரிவர்த்தனையைச் சமர்ப்பித்து, பரிவர்த்தனை ஹாஷை (transaction hash) வைத்திருக்கவும். பரிவர்த்தனையைக் கொண்ட பிளாக் உருவாக்கப்பட்டு ஒளிபரப்பப்படும் வரை, பரிவர்த்தனை "நிலுவையில் (pending)" இருக்கும். tx_hash = w3.eth.send_transaction({ … })
பரிவர்த்தனை ஒரு பிளாக்கில் சேர்க்கப்படும் வரை காத்திருக்கவும்: w3.eth.wait_for_transaction_receipt(tx_hash)
பயன்பாட்டு லாஜிக்கைத் தொடரவும். வெற்றிகரமான பரிவர்த்தனையைப் பார்க்க: 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 யூனிட் கேஸ்) நெட்வொர்க் செயல்பாட்டிற்கு ஏற்ப மாறுபடும் அடிப்படைக் கட்டணத்தால் பெருக்கப்பட்டு, அதனுடன் பரிவர்த்தனையை ஒரு பிளாக்கில் சேர்க்கும் வேலிடேட்டருக்குச் (validator) செல்லும் டிப் (tip) ஆகியவற்றை உள்ளடக்கியதாகும்.

கேஸ் (gas) பற்றி மேலும் அறிய

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

மூச்சு விடுங்கள்

நாம் சிறிது நேரமாக இதைச் செய்து வருகிறோம், எனவே ஓய்வு எடுக்க இது ஒரு நல்ல இடமாகத் தெரிகிறது. இந்த ஆழமான பயணம் தொடர்கிறது, மேலும் இந்தத் தொடரின் இரண்டாம் பகுதியில் நாம் தொடர்ந்து ஆராய்வோம். வரவிருக்கும் சில கருத்துகள்: உண்மையான நோடுடன் இணைத்தல், ஸ்மார்ட் ஒப்பந்தங்கள் (smart contracts) மற்றும் டோக்கன்கள் (tokens). ஏதேனும் கேள்விகள் உள்ளதா? எனக்குத் தெரியப்படுத்துங்கள்! உங்கள் கருத்துகள் இங்கிருந்து நாம் எங்கு செல்கிறோம் என்பதைத் தீர்மானிக்கும். Twitter (opens in a new tab) வழியாகக் கோரிக்கைகள் வரவேற்கப்படுகின்றன.

பக்கம் கடைசியாகப் புதுப்பிக்கப்பட்டது: 3 மார்ச், 2026

+14