முந்தைய சில ஆண்டுகளின் போக்குகளைப் பார்த்தால், பிளாக்செயின் பற்றி எல்லா நேரத்திலும் கேள்விப்பட்டிருக்கிறோம், ஆனால் பிரத்தியேகங்களைப் பற்றி அதிகம் இல்லை.
Bitcoin, Ethereum, Dogecoin, Matic மற்றும் பிற கிரிப்டோகரன்சிகள் பிளாக்செயின் தொழில்நுட்பத்தை நம்பியுள்ளன என்பதை நாம் அனைவரும் அறிவோம். 2021 இல் பல தொழில்களில் புரட்சியை ஏற்படுத்திய மற்றும் புதிய சாதனைகளுக்கு வழி வகுத்த குறிப்பிடத்தக்க நிகழ்வுகளுக்கு Blockchain தலைமை தாங்கியது.
Blockchain என்பது கடினமான அல்லது சாத்தியமில்லாத வகையில் தரவைச் சேமிப்பதற்கான ஒரு வழிமுறையாகும், இது திருத்த, ஹேக் அல்லது மோசடி. இது பணப் பரிவர்த்தனைகளின் டிஜிட்டல் லெட்ஜர் ஆகும், இது பிளாக்செயினின் கணினி அமைப்புகளின் முழு நெட்வொர்க்கிலும் நகலெடுக்கப்பட்டு பரவுகிறது.
இது நடைமுறையில் அனைத்து கிரிப்டோகரன்சிகளுக்கும் சக்தியளிக்கும் அடிப்படை தரவுத்தள தொழில்நுட்பமாகும். Blockchain ஆனது ஒரு தரவுத்தளத்தின் ஒரே மாதிரியான நகல்களை ஒரு முழு நெட்வொர்க்கிலும் பரப்புவதன் மூலம் கணினியை ஹேக் செய்வது அல்லது ஏமாற்றுவது நம்பமுடியாத அளவிற்கு கடினமாக்குகிறது.
Bitcoin இப்போது பிளாக்செயினுக்கு மிகவும் முக்கியமான பயன்பாடாகும், தொழில்நுட்பம் மிகவும் பரந்த பல்வேறு பயன்பாடுகளுக்கு சேவை செய்ய முடியும்.
கிரிப்டோகரன்சிகள் மற்றும் பிளாக்செயின்கள் சமீபத்திய ஆண்டுகளில் பிரபலமடைந்து வருகின்றன, மேலும் இந்த போக்கு தொடரும் என்று எதிர்பார்க்கப்படுகிறது.
இந்த டுடோரியலில் ஜாவாஸ்கிரிப்ட் மூலம் எளிய பிளாக்செயினை உருவாக்குவோம். பிளாக்செயின் எவ்வாறு செயல்படுகிறது என்பதைப் பற்றிய அடிப்படை புரிதலை இது உங்களுக்கு வழங்கும்.
அதை MelodyCoin என்று அழைப்போம் மற்றும் செயலில் இறங்குவோம்!
ஒரு தொகுதியை உருவாக்குதல்
தொடங்குவதற்கு, புதிய ஜாவாஸ்கிரிப்ட் கோப்பை உருவாக்குவோம், அதில் எங்கள் குறியீடு அனைத்தையும் வைப்போம்.
அதை main.js என்று அழைப்போம் மற்றும் பிளாக்செயின் மற்றும் தொகுதிகள் எப்படி இருக்க வேண்டும் என்பதற்கான விளக்கத்துடன் ஆரம்பிக்கலாம்.
ஒரு பிளாக் கிளாஸை உருவாக்கி, அதற்கு ஆப்ஜெக்ட்() { [நேட்டிவ் குறியீடு] } என்ற செயல்பாட்டைக் கொடுக்கவும்.
புதிய தொகுதியை உருவாக்கும் போது, நீங்கள் ஒரு தேதி மற்றும் முந்தைய தொகுதியின் ஹாஷ் கொடுக்க வேண்டும்:
ஒவ்வொரு சொத்துக்கான வரையறைகள் இங்கே:
- பிளாக் எப்போது செய்யப்பட்டது என்பதை நேரமுத்திரை குறிப்பிடுகிறது. நீங்கள் தேர்வு செய்யும் எந்த வடிவமைப்பையும் பயன்படுத்தலாம் (இந்த விஷயத்தில், UNIX நேர முத்திரை).
- இந்தத் தொகுதியுடன் இணைக்க விரும்பும் எந்த வகையான தரவையும் தரவு அளவுருவில் சேர்க்கலாம். நீங்கள் ஒரு கிரிப்டோகரன்சியை உருவாக்க விரும்பினால், அனுப்புபவர்/பெறுபவர் மற்றும் இங்கு நகர்த்திய பணத்தின் அளவு போன்ற பரிவர்த்தனைத் தரவை நீங்கள் வைத்திருக்கலாம்.
- முந்தைய ஹாஷ் என்பது முந்தைய பிளாக்கின் ஹாஷை வைத்திருக்கும் சரம். இதுவே தொகுதிகளின் சங்கிலியை உருவாக்கும், இது எங்கள் பிளாக்செயினின் ஒருமைப்பாட்டை பின்னர் வழங்குவதில் முக்கியமானதாக இருக்கும்.
ஹாஷ்களை உருவாக்குதல்
ஒவ்வொரு தொகுதியும் முந்தைய தொகுதியுடன் இணைக்கிறது (இதனால் முந்தைய ஹாஷ் சொத்து). அதாவது, ஒவ்வொரு தொகுதிக்கும் ஒரு ஹாஷ் தேவை. ஹாஷ் என்பது கைரேகையைப் போன்றது. இது ஒவ்வொரு தொகுதிக்கும் தனித்தனியாக உள்ளது.
ஒரு தொகுதியின் ஹாஷ் அதன் அனைத்து உள்ளடக்கங்களையும் ஹாஷ் செயல்பாட்டின் மூலம் அனுப்புவதன் மூலம் கணக்கிடப்படும்.
எனவே, தற்போதைய தொகுதியின் ஹாஷைக் கணக்கிடும் செயல்பாட்டைச் செயல்படுத்துவதன் மூலம் தொடங்குவோம்.
எனவே, பிளாக் வகுப்பின் கீழ், நாம் கணக்கிடும் ஹாஷ் செயல்பாட்டை வரையறுக்கிறோம்:
இருப்பினும், SHA256 ஹாஷ் JavaScript ஆல் ஆதரிக்கப்படவில்லை மற்றும் வெளிப்புற நூலகத்திலிருந்து பெறப்பட வேண்டும்.
Crypto-js என்பது பல ஹாஷ் அல்காரிதம்களின் பாதுகாப்பான செயலாக்கங்களை உள்ளடக்கிய ஒரு அருமையான தொகுப்பாகும்.
பின்னர் அதை நமது main.js குறியீட்டில் இறக்குமதி செய்யலாம்.
இப்போது நம்மிடம் கணக்கிடுதல்ஹாஷ்() செயல்பாடு உள்ளது, அதை நமது பிளாக்கின் செயல்பாட்டில் பயன்படுத்துவோம்:
ஒரு பிளாக் எப்படி இருக்கும் என்பதை விவரித்த பிறகு, பிளாக்செயின் எப்படி இருக்க வேண்டும் என்பதை வரையறுக்கலாம். எனவே ஒரு புதிய வகுப்பை உருவாக்குவோம்.
இந்தச் சூழ்நிலையில், பிளாக்செயின் என்பது சொத்துச் சங்கிலியைக் கொண்ட மிக எளிமையான பொருளாகும். இது சங்கிலியில் உள்ள அனைத்து தொகுதிகளையும் வைத்திருக்கும் ஒரு வரிசை.
நாம் தொகுதிகளைச் சேர்க்கும் முன், முதலில் "ஜெனிசிஸ் பிளாக்" என்று அழைக்கப்படுவதை உருவாக்க வேண்டும். இது சங்கிலியின் முதல் தொகுதியாகும், மேலும் இது ஒரு முந்தைய தொகுதியை சுட்டிக்காட்ட முடியாதது (இது முதல்!).
எனவே, ஜெனிசிஸ் பிளாக்கை உருவாக்க, எங்கள் வகுப்பில் createGenesisBlock () என்ற செயல்பாட்டைச் சேர்ப்பேன். எங்கள் பிளாக்செயின் வகுப்பின் ஆப்ஜெக்ட்() { [நேட்டிவ் குறியீடு] } செயல்பாட்டில் மீண்டும்.
புதிய பிளாக்செயின் நிகழ்வை உருவாக்கும் எந்த நேரத்திலும் நாம் இப்போது ஜெனிசிஸ் பிளாக்கைச் சேர்க்கலாம்:
பிளாக்செயின் முறைகள்
இப்போது, புதிய தொகுதிகளைச் சேர்ப்பது மற்றும் சமீபத்திய பிளாக்கைப் பெறுவது போன்றவற்றைச் செய்ய அனுமதிக்கும் எங்கள் பிளாக்செயின் வகுப்பில் முறைகளைச் சேர்ப்போம்.
getLatestBlock செயல்பாடு மிகவும் அடிப்படையானது. இது சங்கிலி வரிசையின் இறுதி உறுப்பினரை வெறுமனே வழங்குகிறது:
addBlock நுட்பம் இன்னும் கொஞ்சம் சம்பந்தப்பட்டது.
நமது சங்கிலியில் ஒரு புதிய தொகுதியைச் சேர்ப்பதற்கு முன், முதலில் அந்தத் தொகுதியின் முந்தைய ஹாஷ் புலத்தை சரியாக அமைக்க வேண்டும்.
இது எங்கள் சங்கிலியில் மிக சமீபத்தில் சேர்க்கப்பட்ட பிளாக்கின் ஹாஷுக்கு அமைக்கப்பட வேண்டும். புதிய தொகுதியின் ஹாஷையும் நாம் கணக்கிட வேண்டும்:
சோதனை
நமது MelodyCoin எப்படி வெளிவந்துள்ளது என்று பார்ப்போம்.
இதை நிறைவேற்ற ஒரு பிளாக்செயின் நிகழ்வை உருவாக்கவும். இன்னும் இரண்டு தொகுதிகளைச் சேர்ப்போம்:
அங்கு இரண்டு புதிய தொகுதிகளை உருவாக்கியுள்ளோம். தற்போது நமது பிளாக்செயின் எப்படி இருக்கிறது என்று பார்க்கலாம்.
MelodyCoin நான்கு இடைவெளிகளுடன் இறுக்கப்பட்டு வடிவமைக்கப்படும்:
பிளாக்செயினின் நேர்மையை சரிபார்க்கவும்
பிளாக்செயின்கள் அற்புதமானவை, ஏனெனில் ஒரு தொகுதி சேர்க்கப்பட்டவுடன், மீதமுள்ள சங்கிலியை செல்லாததாக்காமல் அதை மாற்ற முடியாது.
இருப்பினும், இந்தச் செயலாக்கத்தின் மூலம் எங்கள் பிளாக்செயினின் ஒருமைப்பாட்டைச் சரிபார்க்க எனக்கு எந்த முறையும் இல்லை.
நமது பிளாக்செயினுக்கு isChainValid செயல்பாட்டை அறிமுகப்படுத்துவோம். சங்கிலி முறையானதாக இருந்தால், அது உண்மையாகிவிடும்; இல்லையெனில், அது தவறானதாக இருக்கும்:
நேர்மையை சோதிக்கிறது
நாம் இப்போது நமது பிளாக்செயினின் நேர்மையை சோதனைக்கு உட்படுத்தலாம். இப்போது அதை செயல்படுத்தினால், நமது சங்கிலி உண்மையானது என்பதை உறுதிப்படுத்தும்.
இப்போது நமது பிளாக்செயினைக் கெடுக்க முயற்சிப்போம். தொகுதி 2 ஐ மாற்றி அதன் உள்ளடக்கங்களை மேலெழுதலாம் (நான்கிற்கு பதிலாக 100 நாணயங்களை மாற்றியுள்ளோம் என்று வைத்துக்கொள்வோம்).
இதை இயக்கும்போது, சங்கிலியை சேதப்படுத்தும் நமது முயற்சியை மென்பொருள் அங்கீகரிப்பதைக் காணலாம்.
இருப்பினும், இதில் நான் தலையிட வேறு வழி இருப்பதாக நீங்கள் நம்பலாம். நான் பிளாக்கில் உள்ள உள்ளடக்கங்களை மாற்றினேன் ஆனால் ஹாஷை மீண்டும் கணக்கிடவில்லை. எனவே நீங்கள் புத்திசாலியாக இருக்க முயற்சி செய்யலாம் மற்றும் அதே தொகுதியின் ஹாஷை மீண்டும் கணக்கிடலாம்.
எங்கள் சிறிய பிளாக்செயின் அமைப்பில் அவ்வளவுதான்! புதிய தொகுதிகளைச் சேர்ப்பதற்கும், சங்கிலியில் உள்ள தரவுகளை சேதப்படுத்துவதைக் கண்டறியவும் இது உதவுகிறது.
எங்கள் சிறிய பிளாக்செயினில் இரண்டு சிக்கல்கள் உள்ளன, அதை நாம் தீர்க்க வேண்டும்:
- நவீன கணினிகள் மிகவும் வேகமானவை மற்றும் நொடிகளில் நமது சங்கிலியில் ஆயிரக்கணக்கான தொகுதிகளை சேர்க்க முடியும். எங்கள் பிளாக்செயினை யாரும் ஸ்பேம் செய்வதை நாங்கள் விரும்பவில்லை.
- எங்கள் பிளாக்செயின் இன்னும் சேதப்படுத்துதலால் பாதிக்கப்படக்கூடியது. நீங்கள் ஒரு பிளாக்கின் உள்ளடக்கங்களைப் புதுப்பித்து, பின்வரும் எல்லாத் தொகுதிகளுக்கும் ஹாஷ்களை (மற்றும் முந்தைய ஹாஷ்கள்) மீண்டும் கணக்கிடலாம். நீங்கள் அதை குழப்பினாலும், நீங்கள் ஒரு முறையான சங்கிலியுடன் முடிவடையும்.
இந்த கவலைகளை நிவர்த்தி செய்ய, பிளாக்செயின்கள் "வேலைக்கான சான்று" எனப்படும் நுட்பத்தைப் பயன்படுத்துகின்றன. இந்த அணுகுமுறையைப் பயன்படுத்தி ஒரு தொகுதியை உருவாக்க, நீங்கள் கணிசமான அளவு கணக்கீட்டு ஆதாரங்களைப் பயன்படுத்தியுள்ளீர்கள் என்பதை நிரூபிக்க வேண்டும். இதுவும் அழைக்கப்படுகிறது சுரங்க.
ஒரு பிளாக்கின் ஹாஷ் ஒரு குறிப்பிட்ட அளவு பூஜ்ஜியங்களுடன் தொடங்கும் வேலைக்கான சான்று தேவைப்படுகிறது. ஆனால் உங்கள் ஹாஷ் இந்த விதிக்கு பொருந்துகிறதா என்பதை எப்படி அறிந்து கொள்வது?
ஒரு தொகுதியின் உள்ளடக்கங்கள் அதன் ஹாஷை தீர்மானிக்கிறது. எனவே உள்ளடக்கங்களை மாற்றாமல் இருந்தால், எப்போதும் ஒரே ஹாஷைப் பெறுவோம்.
ஒவ்வொரு தொகுதிக்கும் ஒரு தீர்வாக ஒரு மதிப்பு சேர்க்கப்பட வேண்டும். இது அடிப்படையில் சில சீரற்ற தரவு ஆகும், எங்கள் தொகுதியின் ஹாஷ் போதுமான பூஜ்ஜியங்களுடன் தொடங்கும் வரை நாம் புதுப்பிக்க முடியும். ஹாஷ் செயல்பாட்டின் வெளியீட்டை உங்களால் மாற்ற முடியாது என்பதால், நீங்கள் பலவிதமான சேர்க்கைகளைச் சோதித்து சிறந்ததை எதிர்பார்க்க வேண்டும்.
பிளாக்செயினுக்கு சுரங்கத்தை அறிமுகப்படுத்துங்கள்
எங்கள் பிளாக் வகுப்பில் ஒரு நோன்ஸைச் சேர்ப்பதன் மூலம் தொடங்குவோம். நோன்ஸ் என்பது நமது தொகுதிக்குள் இருக்கும் ஒற்றை மதிப்பாகும், இது பிளாக்கின் ஹாஷை பாதிக்கும் வகையில் மாற்றலாம்.
நேரமுத்திரை அல்லது தரவை எங்களால் மாற்ற முடியவில்லை.
அடுத்து, ஒரு தொகுதியின் உண்மையான சுரங்கத்தைச் செய்யும் mineBlock() செயல்பாட்டை எழுதுவோம். இந்த செயல்பாடு தேவையான சிரமத்தை ஒரு அளவுருவாக அனுப்பப்படும் மற்றும் எங்கள் தொகுதியின் ஹாஷ் போதுமான பூஜ்ஜியங்களுடன் தொடங்கும் வரை தொடர்ந்து செயல்படுத்தப்படும்.
எங்கள் ஹாஷ் போதுமான பூஜ்ஜியங்களுடன் தொடங்கும் வரை இயங்கும் ஒரு அடிப்படை லூப்பை நான் உருவாக்கினேன். எத்தனை பூஜ்ஜியங்கள் தேவை என்பதை தீர்மானிக்க சிரமத்தைப் பயன்படுத்துகிறோம். 5 சிரமத்துடன், எங்கள் ஹாஷ் 5 பூஜ்ஜியங்களுடன் தொடங்க வேண்டும்.
நமது ஹாஷில் போதிய பூஜ்ஜியங்கள் இல்லாதபோது, நான்ஸை ஒன்றால் உயர்த்தி, ஹாஷை மீண்டும் கணக்கிடுவோம். சிரமத்திற்கு ஏற்ற ஹாஷை நாம் கண்டால், அதை கன்சோலில் பதிவு செய்கிறோம்.
நாம் செய்ய வேண்டிய இன்னொரு விஷயம் இருக்கிறது. எங்களின் கௌல்ட்ஹாஷ் முறையில் நாம் உண்மையில் nonce மாறியை கணக்கில் எடுத்துக்கொள்வதில்லை, எனவே இதோ:
பிளாக்செயின் வகுப்பு
இந்த புதிய அணுகுமுறையை எங்கள் பிளாக்செயின் வகுப்பில் சோதனை செய்து, அது எவ்வாறு செல்கிறது என்பதைப் பார்ப்போம்.
தொடங்குவதற்கு, ஆப்ஜெக்ட்() செயல்பாட்டில் நமது பிளாக்செயினின் சிரமத்தை வரையறுக்கிறேன். பின்னர் எங்காவது பயன்படுத்தலாம் என்பதால் அதை இங்கே வரையறுக்கிறோம்.
addBlock செயல்பாடு மாற்றியமைக்கப்பட வேண்டும், அது எங்கள் சங்கிலியில் சேர்ப்பதற்கு முன் தொகுதியை சுரங்கமாக்குகிறது.
பிளாக்செயினைப் பயன்படுத்தவும்
இப்போது, ப்ரூஃப்-ஆஃப்-வொர்க் அல்காரிதத்துடன் நமது புதிய பிளாக்செயினைப் பயன்படுத்துவோம். இங்கே, இரண்டு console.log அறிக்கைகளைச் சேர்க்கவும்.
இந்த குறியீட்டை இயக்கும்போது, சுரங்க செயல்முறை குறிப்பாக வேகமாக இல்லை என்பதை நாம் கவனிக்கலாம்.
மூன்று பூஜ்ஜியங்களுடன் (சிரமத்தால் கட்டமைக்கப்பட்டது) தொடங்கும் ஹாஷ்களுடன் தொகுதிகளை உருவாக்க அல்காரிதத்திற்கு சிறிது நேரம் ஆகும்.
அதனால் எங்கள் அடிப்படை பிளாக்செயின் அமைப்பின் முடிவாகும்.
ப்ரூஃப்-ஆஃப்-வொர்க் பொறிமுறையின் மூலம் எங்கள் பிளாக்செயினில் எவ்வளவு விரைவாக புதிய தொகுதிகள் சேர்க்கப்படுகின்றன என்பதை நாம் கட்டுப்படுத்தலாம்.
இது பிளாக்செயின்களில் மிக முக்கியமான பாதுகாப்பு அம்சமாகும். இப்போது அது எவ்வாறு செயல்படுகிறது என்பதை நீங்கள் புரிந்து கொண்டீர்கள், நீங்களே உருவாக்குங்கள்!
ஒரு பதில் விடவும்