കഴിഞ്ഞ കുറച്ച് വർഷങ്ങളിലെ ട്രെൻഡുകൾ നോക്കുകയാണെങ്കിൽ, ബ്ലോക്ക്ചെയിനിനെക്കുറിച്ച് നമ്മൾ എല്ലായ്പ്പോഴും കേട്ടിട്ടുണ്ട്, പക്ഷേ പ്രത്യേകതകളെക്കുറിച്ച് കൂടുതലല്ല.
Bitcoin, Ethereum, Dogecoin, Matic, തുടങ്ങിയ ക്രിപ്റ്റോകറൻസികൾ ബ്ലോക്ക്ചെയിൻ സാങ്കേതികവിദ്യയെ ആശ്രയിക്കുന്നുവെന്ന് ഞങ്ങൾക്കെല്ലാം അറിയാം. 2021 ൽ നിരവധി വ്യവസായങ്ങളിൽ വിപ്ലവം സൃഷ്ടിക്കുകയും പുതിയ നേട്ടങ്ങൾക്ക് വഴിയൊരുക്കുകയും ചെയ്ത സുപ്രധാന സംഭവങ്ങൾക്ക് ബ്ലോക്ക്ചെയിൻ നേതൃത്വം നൽകി.
എഡിറ്റ് ചെയ്യാനോ ഹാക്ക് ചെയ്യാനോ വഞ്ചിക്കാനോ ബുദ്ധിമുട്ടുള്ളതോ അസാധ്യമോ ആയ രീതിയിൽ ഡാറ്റ സംഭരിക്കുന്നതിനുള്ള ഒരു മാർഗമാണ് ബ്ലോക്ക്ചെയിൻ. ഇത് ഡ്യൂപ്ലിക്കേറ്റ് ചെയ്ത ഇടപാടുകളുടെ ഒരു ഡിജിറ്റൽ ലെഡ്ജറാണ്, അത് ബ്ലോക്ക്ചെയിനിന്റെ കമ്പ്യൂട്ടർ സിസ്റ്റങ്ങളുടെ മുഴുവൻ ശൃംഖലയിലും വ്യാപിക്കുന്നു.
പ്രായോഗികമായി എല്ലാ ക്രിപ്റ്റോകറൻസികൾക്കും ശക്തി പകരുന്നത് തകർപ്പൻ ഡാറ്റാബേസ് സാങ്കേതികവിദ്യയാണ്. ഒരു നെറ്റ്വർക്കിലുടനീളം ഒരു ഡാറ്റാബേസിന്റെ സമാന പകർപ്പുകൾ പ്രചരിപ്പിച്ച് സിസ്റ്റം ഹാക്ക് ചെയ്യുകയോ വഞ്ചിക്കുകയോ ചെയ്യുന്നത് ബ്ലോക്ക്ചെയിൻ അവിശ്വസനീയമാംവിധം ബുദ്ധിമുട്ടാക്കുന്നു.
ബ്ലോക്ക്ചെയിനിനുള്ള ഏറ്റവും പ്രധാനപ്പെട്ട ഉപയോഗമാണ് ബിറ്റ്കോയിൻ എന്നിരിക്കെ, ഈ സാങ്കേതികവിദ്യയ്ക്ക് വൈവിധ്യമാർന്ന ആപ്ലിക്കേഷനുകൾ നൽകാൻ കഴിയും.
സമീപ വർഷങ്ങളിൽ ക്രിപ്റ്റോകറൻസികളും ബ്ലോക്ക്ചെയിനുകളും കൂടുതൽ പ്രചാരത്തിലുണ്ട്, ഈ പ്രവണത തുടരുമെന്ന് പ്രതീക്ഷിക്കുന്നു.
ഈ ട്യൂട്ടോറിയലിൽ ഞങ്ങൾ JavaScript ഉപയോഗിച്ച് ഒരു ലളിതമായ ബ്ലോക്ക്ചെയിൻ ഉണ്ടാക്കും. ഒരു ബ്ലോക്ക്ചെയിൻ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിനെക്കുറിച്ചുള്ള അടിസ്ഥാന ധാരണ ഇത് നിങ്ങൾക്ക് നൽകും.
നമുക്ക് ഇതിനെ MelodyCoin എന്ന് വിളിക്കാം, തുടർന്ന് പ്രവർത്തനത്തിലേക്ക് പ്രവേശിക്കാം!
ഒരു ബ്ലോക്ക് ഉണ്ടാക്കുന്നു
ആരംഭിക്കുന്നതിന്, ഞങ്ങൾ ഒരു പുതിയ JavaScript ഫയൽ സൃഷ്ടിക്കും, അതിൽ ഞങ്ങളുടെ എല്ലാ കോഡുകളും സ്ഥാപിക്കും.
നമുക്ക് അതിനെ main.js എന്ന് വിളിക്കാം, ഒരു ബ്ലോക്ക്ചെയിനും ബ്ലോക്കുകളും എങ്ങനെയായിരിക്കണം എന്നതിന്റെ വിവരണത്തോടെ ആരംഭിക്കാം.
ഒരു ബ്ലോക്ക് ക്ലാസ് സൃഷ്ടിച്ച് അതിന് ഒബ്ജക്റ്റ്() { [നേറ്റീവ് കോഡ്] } എന്ന ഫംഗ്ഷൻ നൽകുക.
ഒരു പുതിയ ബ്ലോക്ക് സൃഷ്ടിക്കുമ്പോൾ നിങ്ങൾ ഒരു തീയതിയും മുമ്പത്തെ ബ്ലോക്കിന്റെ ഹാഷും നൽകണം:
ഓരോ വസ്തുവിന്റെയും നിർവചനങ്ങൾ ഇതാ:
- ബ്ലോക്ക് എപ്പോഴാണ് നിർമ്മിച്ചതെന്ന് ടൈംസ്റ്റാമ്പ് സൂചിപ്പിക്കുന്നു. നിങ്ങൾ തിരഞ്ഞെടുക്കുന്ന ഏത് ഫോർമാറ്റും നിങ്ങൾക്ക് ഉപയോഗിക്കാം (ഈ സാഹചര്യത്തിൽ, ഒരു UNIX ടൈംസ്റ്റാമ്പ്).
- ഈ ബ്ലോക്കിലേക്ക് നിങ്ങൾ ബന്ധിപ്പിക്കാൻ ആഗ്രഹിക്കുന്ന ഏത് രൂപത്തിലുള്ള ഡാറ്റയും ഡാറ്റാ പാരാമീറ്ററിൽ ഉൾപ്പെടുത്താവുന്നതാണ്. നിങ്ങൾക്ക് ഒരു ക്രിപ്റ്റോകറൻസി സൃഷ്ടിക്കാൻ താൽപ്പര്യമുണ്ടെങ്കിൽ, അയച്ചയാൾ/സ്വീകർത്താവ്, ഇങ്ങോട്ട് നീക്കിയ പണത്തിന്റെ അളവ് എന്നിവ പോലുള്ള ഇടപാട് ഡാറ്റ നിങ്ങൾക്ക് സൂക്ഷിക്കാം.
- മുമ്പത്തെ ബ്ലോക്കിന്റെ ഹാഷ് ഉൾക്കൊള്ളുന്ന ഒരു സ്ട്രിംഗ് ആണ് മുൻ ഹാഷ്. ഇതാണ് ബ്ലോക്കുകളുടെ ശൃംഖല സൃഷ്ടിക്കുന്നത്, ഇത് പിന്നീട് ഞങ്ങളുടെ ബ്ലോക്ക്ചെയിനിന്റെ സമഗ്രത നൽകുന്നതിൽ നിർണായകമാകും.
ഹാഷുകൾ സൃഷ്ടിക്കുന്നു
ഓരോ ബ്ലോക്കും മുമ്പത്തെ ബ്ലോക്കിലേക്ക് ലിങ്ക് ചെയ്യുന്നു (അങ്ങനെ മുൻ ഹാഷ് പ്രോപ്പർട്ടി). അതായത്, ഓരോ ബ്ലോക്കിനും ഒരു ഹാഷ് ആവശ്യമാണ്. ഒരു ഹാഷ് ഒരു വിരലടയാളത്തിന് സമാനമാണ്. ഓരോ ബ്ലോക്കിനും ഇത് വ്യത്യസ്തമാണ്.
ഒരു ബ്ലോക്കിന്റെ ഹാഷ് അതിന്റെ എല്ലാ ഉള്ളടക്കങ്ങളും ഒരു ഹാഷ് ഫംഗ്ഷനിലൂടെ കടത്തിവിട്ട് കണക്കാക്കാം.
അതിനാൽ, നിലവിലെ ബ്ലോക്കിന്റെ ഹാഷ് കണക്കാക്കുന്ന ഒരു ഫംഗ്ഷൻ നടപ്പിലാക്കിക്കൊണ്ട് നമുക്ക് ആരംഭിക്കാം.
അതിനാൽ, ബ്ലോക്ക് ക്ലാസിന് കീഴിൽ, ഞങ്ങൾ കണക്കുകൂട്ടൽ ഹാഷ് ഫംഗ്ഷൻ നിർവചിക്കുന്നു:
എന്നിരുന്നാലും, SHA256 ഹാഷിനെ JavaScript പിന്തുണയ്ക്കുന്നില്ല, അത് ഒരു ബാഹ്യ ലൈബ്രറിയിൽ നിന്ന് ലഭിച്ചിരിക്കണം.
നിരവധി ഹാഷ് അൽഗോരിതങ്ങളുടെ സുരക്ഷിതമായ നിർവ്വഹണങ്ങൾ ഉൾപ്പെടുന്ന ഒരു മികച്ച പാക്കേജാണ് Crypto-js.
അപ്പോൾ നമുക്ക് അത് നമ്മുടെ main.js കോഡിലേക്ക് ഇറക്കുമതി ചെയ്യാം.
ഇപ്പോൾ നമുക്ക് കണക്കുകൂട്ടൽ ഹാഷ്() ഫംഗ്ഷൻ ഉണ്ട്, അത് നമ്മുടെ ബ്ലോക്കിന്റെ ഫംഗ്ഷനിൽ ഉപയോഗിക്കാൻ നോക്കാം:
ഒരു ബ്ലോക്ക് എങ്ങനെയായിരിക്കുമെന്ന് വിവരിച്ച ശേഷം, ഒരു ബ്ലോക്ക്ചെയിൻ എങ്ങനെയായിരിക്കണമെന്ന് നമുക്ക് നിർവചിക്കാം. അതുകൊണ്ട് നമുക്ക് ഒരു പുതിയ ക്ലാസ് ഉണ്ടാക്കാം.
ഈ സാഹചര്യത്തിൽ, ഒരു പ്രോപ്പർട്ടി ചെയിൻ ഉള്ള വളരെ ലളിതമായ ഒരു വസ്തുവാണ് ബ്ലോക്ക്ചെയിൻ. ചെയിനിലെ എല്ലാ ബ്ലോക്കുകളും ഉൾക്കൊള്ളുന്ന ഒരു അറേയാണിത്.
നമുക്ക് ബ്ലോക്കുകൾ ചേർക്കുന്നതിന് മുമ്പ്, നമ്മൾ ആദ്യം "ജെനിസിസ് ബ്ലോക്ക്" എന്നറിയപ്പെടുന്നത് സൃഷ്ടിക്കണം. ഇത് ശൃംഖലയിലെ ആദ്യത്തെ ബ്ലോക്കാണ്, ഇതിന് മുമ്പുള്ള ഒരു ബ്ലോക്കിലേക്ക് ചൂണ്ടിക്കാണിക്കാൻ കഴിയാത്തതിനാൽ ഇത് സവിശേഷമാണ് (ഇത് ആദ്യത്തേതാണ്!).
അതിനാൽ, ജെനസിസ് ബ്ലോക്ക് നിർമ്മിക്കുന്നതിന്, ഞാൻ ഞങ്ങളുടെ ക്ലാസിലേക്ക് createGenesisBlock () എന്ന പേരിൽ ഒരു ഫംഗ്ഷൻ ചേർക്കും. ഞങ്ങളുടെ ബ്ലോക്ക്ചെയിൻ ക്ലാസിലെ ഒബ്ജക്റ്റ്() { [നേറ്റീവ് കോഡ്] } എന്ന ഫംഗ്ഷനിലേക്ക് മടങ്ങുക.
ഞങ്ങൾ ഒരു പുതിയ ബ്ലോക്ക്ചെയിൻ ഉദാഹരണം നിർമ്മിക്കുമ്പോൾ എപ്പോൾ വേണമെങ്കിലും നമുക്ക് ഇപ്പോൾ ജെനസിസ് ബ്ലോക്ക് ഉൾപ്പെടുത്താം:
ബ്ലോക്ക്ചെയിൻ രീതികൾ
ഇപ്പോൾ, പുതിയ ബ്ലോക്കുകൾ ചേർക്കുന്നതും ഏറ്റവും പുതിയ ബ്ലോക്ക് ലഭ്യമാക്കുന്നതും പോലുള്ള കാര്യങ്ങൾ ചെയ്യാൻ ഞങ്ങളെ അനുവദിക്കുന്ന ഞങ്ങളുടെ ബ്ലോക്ക്ചെയിൻ ക്ലാസിലേക്ക് രീതികൾ ചേർക്കാം.
getLatestBlock ഫംഗ്ഷൻ ഏറ്റവും അടിസ്ഥാനപരമാണ്. ഇത് ചെയിൻ അറേയിലെ അവസാന അംഗത്തെ തിരികെ നൽകുന്നു:
ആഡ്ബ്ലോക്ക് ടെക്നിക് കുറച്ചുകൂടി ഉൾപ്പെട്ടിരിക്കുന്നു.
ഞങ്ങളുടെ ശൃംഖലയിലേക്ക് ഒരു പുതിയ ബ്ലോക്ക് ചേർക്കുന്നതിന് മുമ്പ്, ആദ്യം ആ ബ്ലോക്കിന്റെ മുൻ ഹാഷ് ഫീൽഡ് ഉചിതമായി സജ്ജീകരിക്കണം.
നമ്മുടെ ശൃംഖലയിലേക്ക് അടുത്തിടെ ചേർത്ത ബ്ലോക്കിന്റെ ഹാഷിലേക്ക് ഇത് സജ്ജീകരിച്ചിരിക്കണം. പുതിയ ബ്ലോക്കിന്റെ ഹാഷും നമുക്ക് കണക്കാക്കേണ്ടതുണ്ട്:
ടെസ്റ്റിംഗ്
നമ്മുടെ MelodyCoin എങ്ങനെയാണ് പുറത്തുവന്നതെന്ന് നോക്കാം.
ഇത് പൂർത്തീകരിക്കുന്നതിന് ഒരു ബ്ലോക്ക്ചെയിൻ ഉദാഹരണം സൃഷ്ടിക്കുക. നമുക്ക് കുറച്ച് ബ്ലോക്കുകൾ കൂടി ചേർക്കാം:
ഞങ്ങൾ അവിടെ രണ്ട് പുതിയ ബ്ലോക്കുകൾ ഉണ്ടാക്കി. നമ്മുടെ ബ്ലോക്ക്ചെയിൻ നിലവിൽ എങ്ങനെയുണ്ടെന്ന് നോക്കാം.
MelodyCoin നാല് സ്പെയ്സുകൾ ഉപയോഗിച്ച് സ്ട്രിംഗൈസ് ചെയ്യുകയും ഫോർമാറ്റ് ചെയ്യുകയും ചെയ്യും:
ബ്ലോക്ക്ചെയിനിന്റെ സമഗ്രത പരിശോധിക്കുക
ബ്ലോക്ക്ചെയിനുകൾ അതിശയകരമാണ്, കാരണം ഒരു ബ്ലോക്ക് ചേർത്തുകഴിഞ്ഞാൽ, ശൃംഖലയുടെ ശേഷിക്കുന്ന ഭാഗം അസാധുവാക്കാതെ അത് പരിഷ്ക്കരിക്കാൻ കഴിയില്ല.
എന്നിരുന്നാലും, ഈ നടപ്പാക്കലിലൂടെ ഞങ്ങളുടെ ബ്ലോക്ക്ചെയിനിന്റെ സമഗ്രത പരിശോധിക്കാൻ എനിക്ക് ഒരു രീതിയുമില്ല.
നമ്മുടെ ബ്ലോക്ക്ചെയിനിലേക്ക് ഒരു isChainValid ഫംഗ്ഷൻ അവതരിപ്പിക്കാം. ചെയിൻ നിയമാനുസൃതമാണെങ്കിൽ, അത് ശരിയാകും; അല്ലെങ്കിൽ, അത് തെറ്റായി നൽകും:
സമഗ്രത പരിശോധിക്കുന്നു
നമുക്ക് ഇപ്പോൾ നമ്മുടെ ബ്ലോക്ക്ചെയിനിന്റെ സമഗ്രത പരീക്ഷിക്കാം. നമ്മൾ ഇപ്പോൾ അത് എക്സിക്യൂട്ട് ചെയ്താൽ, അത് നമ്മുടെ ചെയിൻ യഥാർത്ഥമാണെന്ന് സ്ഥിരീകരിക്കും.
ഇനി നമുക്ക് നമ്മുടെ ബ്ലോക്ക് ചെയിനിൽ കൃത്രിമം കാണിക്കാൻ ശ്രമിക്കാം. നമുക്ക് ബ്ലോക്ക് 2 മാറ്റി അതിലെ ഉള്ളടക്കങ്ങൾ പുനരാലേഖനം ചെയ്യാം (നാല് നാണയത്തിന് പകരം 100 നാണയങ്ങൾ കൈമാറിയെന്ന് കരുതുക).
ഇത് എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ, ശൃംഖലയിൽ കൃത്രിമം കാണിക്കാനുള്ള നമ്മുടെ ശ്രമത്തെ സോഫ്റ്റ്വെയർ തിരിച്ചറിയുന്നതായി നമുക്ക് കാണാൻ കഴിയും.
എന്നിരുന്നാലും, ഇതിൽ ഇടപെടാൻ എനിക്ക് മറ്റൊരു രീതിയുണ്ടെന്ന് നിങ്ങൾക്ക് വിശ്വസിക്കാം. ഞാൻ ബ്ലോക്കിലെ ഉള്ളടക്കങ്ങൾ മാറ്റി, പക്ഷേ ഹാഷ് വീണ്ടും കണക്കാക്കിയില്ല. അതിനാൽ നിങ്ങൾക്ക് സമർത്ഥനാകാനും അതേ ബ്ലോക്കിന്റെ ഹാഷ് വീണ്ടും കണക്കാക്കാനും ശ്രമിക്കാം.
ഞങ്ങളുടെ ചെറിയ ബ്ലോക്ക്ചെയിൻ സജ്ജീകരണത്തിൽ അത്രയേയുള്ളൂ! പുതിയ ബ്ലോക്കുകൾ ചേർക്കാനും ചെയിനിനുള്ളിലെ ഡാറ്റയിൽ കൃത്രിമം കണ്ടെത്താനും ഇത് ഞങ്ങളെ പ്രാപ്തരാക്കുന്നു.
ഞങ്ങളുടെ ചെറിയ ബ്ലോക്ക്ചെയിനിൽ രണ്ട് പ്രശ്നങ്ങളുണ്ട്, അവ പരിഹരിക്കേണ്ടതുണ്ട്:
- ആധുനിക കമ്പ്യൂട്ടറുകൾ വളരെ വേഗമേറിയതും സെക്കൻഡുകൾക്കുള്ളിൽ ആയിരക്കണക്കിന് ബ്ലോക്കുകൾ നമ്മുടെ ശൃംഖലയിലേക്ക് ചേർക്കാനും കഴിയും. ഞങ്ങളുടെ ബ്ലോക്ക്ചെയിൻ ആരും സ്പാം ചെയ്യരുതെന്ന് ഞങ്ങൾ ആഗ്രഹിക്കുന്നു.
- ഞങ്ങളുടെ ബ്ലോക്ക്ചെയിൻ ഇപ്പോഴും കൃത്രിമത്വത്തിന് ഇരയാകുന്നു. നിങ്ങൾക്ക് ഒരു ബ്ലോക്കിന്റെ ഉള്ളടക്കം അപ്ഡേറ്റ് ചെയ്യാം, തുടർന്ന് ഇനിപ്പറയുന്ന എല്ലാ ബ്ലോക്കുകൾക്കുമായി ഹാഷുകൾ (മുൻപുള്ള ഹാഷുകൾ) വീണ്ടും കണക്കാക്കാം. നിങ്ങൾ അതിൽ കുഴപ്പമുണ്ടാക്കിയാലും, നിയമാനുസൃതമായ ഒരു ശൃംഖലയിൽ നിങ്ങൾ അവസാനിക്കും.
ഈ ആശങ്കകൾ പരിഹരിക്കുന്നതിന്, ബ്ലോക്ക്ചെയിനുകൾ "ജോലിയുടെ തെളിവ്" എന്നറിയപ്പെടുന്ന ഒരു സാങ്കേതികത ഉപയോഗിക്കുന്നു. ഈ സമീപനം ഉപയോഗിച്ച് ഒരു ബ്ലോക്ക് സൃഷ്ടിക്കാൻ നിങ്ങൾ ഗണ്യമായ അളവിലുള്ള കമ്പ്യൂട്ടേഷണൽ ഉറവിടങ്ങൾ ഉപയോഗിച്ചുവെന്ന് നിങ്ങൾ തെളിയിക്കണം. ഇതിനെയും വിളിക്കുന്നു ഖനനം.
പ്രൂഫ്-ഓഫ്-വർക്ക് ഒരു ബ്ലോക്കിന്റെ ഹാഷ് ഒരു നിശ്ചിത തുക പൂജ്യങ്ങളിൽ ആരംഭിക്കേണ്ടതുണ്ട്. എന്നാൽ നിങ്ങളുടെ ഹാഷ് ഈ നിയമത്തിന് അനുയോജ്യമാണോ എന്ന് നിങ്ങൾക്ക് എങ്ങനെ അറിയാനാകും?
ഒരു ബ്ലോക്കിന്റെ ഉള്ളടക്കം അതിന്റെ ഹാഷ് നിർണ്ണയിക്കുന്നു. ഉള്ളടക്കം പരിഷ്ക്കരിക്കാത്ത പക്ഷം, ഞങ്ങൾക്ക് എല്ലായ്പ്പോഴും ഒരേ ഹാഷ് ലഭിക്കും.
ഒരു പരിഹാരമായി ഓരോ ബ്ലോക്കിലും ഒരു നോൺസ് മൂല്യം ചേർത്തിരിക്കണം. നമ്മുടെ ബ്ലോക്കിന്റെ ഹാഷ് മതിയായ പൂജ്യങ്ങളോടെ ആരംഭിക്കുന്നത് വരെ നമുക്ക് അപ്ഡേറ്റ് ചെയ്യാൻ കഴിയുന്ന ചില ക്രമരഹിതമായ ഡാറ്റയാണിത്. നിങ്ങൾക്ക് ഒരു ഹാഷ് ഫംഗ്ഷന്റെ ഔട്ട്പുട്ട് മാറ്റാൻ കഴിയാത്തതിനാൽ, നിങ്ങൾ നിരവധി വ്യത്യസ്ത കോമ്പിനേഷനുകൾ പരീക്ഷിക്കുകയും മികച്ചത് പ്രതീക്ഷിക്കുകയും വേണം.
ബ്ലോക്ക്ചെയിനിലേക്ക് മൈനിംഗ് അവതരിപ്പിക്കുക
നമ്മുടെ ബ്ലോക്ക് ക്ലാസ്സിൽ ഒരു നോൺസ് ഉൾപ്പെടുത്തിക്കൊണ്ട് നമുക്ക് ആരംഭിക്കാം. ബ്ലോക്കിന്റെ ഹാഷിനെ സ്വാധീനിക്കുന്നതിനായി നമുക്ക് പരിഷ്ക്കരിക്കാവുന്ന ഞങ്ങളുടെ ബ്ലോക്കിനുള്ളിലെ ഏക മൂല്യമാണ് നോൺസ്.
ടൈംസ്റ്റാമ്പോ ഡാറ്റയോ മാറ്റാൻ ഞങ്ങൾക്ക് കഴിയുന്നില്ല.
അടുത്തതായി, ഒരു ബ്ലോക്കിന്റെ യഥാർത്ഥ ഖനനം ചെയ്യുന്ന ഒരു mineBlock() ഫംഗ്ഷൻ എഴുതാം. ഈ ഫംഗ്ഷൻ ആവശ്യമായ ബുദ്ധിമുട്ട് ഒരു പാരാമീറ്ററായി അയയ്ക്കുകയും ഞങ്ങളുടെ ബ്ലോക്കിന്റെ ഹാഷ് മതിയായ പൂജ്യങ്ങളോടെ ആരംഭിക്കുന്നത് വരെ എക്സിക്യൂട്ട് ചെയ്യുന്നത് തുടരുകയും ചെയ്യും.
മതിയായ പൂജ്യങ്ങളിൽ ഞങ്ങളുടെ ഹാഷ് ആരംഭിക്കുന്നത് വരെ പ്രവർത്തിക്കുന്ന ഒരു അടിസ്ഥാന ലൂപ്പ് ഞാൻ ഉണ്ടാക്കി. എത്ര പൂജ്യങ്ങൾ ആവശ്യമാണെന്ന് നിർണ്ണയിക്കാൻ ഞങ്ങൾ ബുദ്ധിമുട്ട് ഉപയോഗിക്കുന്നു. 5 ന്റെ ബുദ്ധിമുട്ട് കൊണ്ട്, നമ്മുടെ ഹാഷ് 5 പൂജ്യങ്ങളിൽ തുടങ്ങണം.
നമ്മുടെ ഹാഷിൽ മതിയായ പൂജ്യങ്ങൾ ഇല്ലെങ്കിൽ, ഞങ്ങൾ നോൺസ് ഒന്നായി ഉയർത്തുകയും ഹാഷ് വീണ്ടും കണക്കാക്കുകയും ചെയ്യുന്നു. ബുദ്ധിമുട്ടിന് അനുയോജ്യമായ ഒരു ഹാഷ് ഞങ്ങൾ കണ്ടെത്തിയാൽ, ഞങ്ങൾ അത് കൺസോളിലേക്ക് ലോഗ് ചെയ്യുന്നു.
നമ്മൾ ചെയ്യേണ്ട മറ്റൊരു കാര്യം കൂടിയുണ്ട്. ഞങ്ങളുടെ കണക്കുകൂട്ടൽ ഹാഷ് രീതിയിൽ ഞങ്ങൾ നോൺസ് വേരിയബിൾ കണക്കിലെടുക്കുന്നില്ല, അതിനാൽ ഇതാ:
ബ്ലോക്ക്ചെയിൻ ക്ലാസ്
ഈ പുതിയ സമീപനം നമ്മുടെ ബ്ലോക്ക്ചെയിൻ ക്ലാസ്സിൽ പരീക്ഷിച്ച് നോക്കാം.
ആരംഭിക്കുന്നതിന്, ഒബ്ജക്റ്റ്() എന്ന ഫംഗ്ഷനിൽ ഞങ്ങളുടെ ബ്ലോക്ക്ചെയിനിന്റെ ബുദ്ധിമുട്ട് ഞാൻ നിർവ്വചിക്കും. പിന്നീട് എവിടെയെങ്കിലും ഉപയോഗിക്കാമെന്നതിനാൽ ഞങ്ങൾ അത് ഇവിടെ നിർവ്വചിക്കുന്നു.
addBlock ഫംഗ്ഷൻ പിന്നീട് നമ്മുടെ ശൃംഖലയിലേക്ക് ചേർക്കുന്നതിന് മുമ്പ് ബ്ലോക്ക് മൈനിംഗ് ചെയ്യുന്ന തരത്തിൽ പരിഷ്ക്കരിക്കണം.
ബ്ലോക്ക്ചെയിൻ ഉപയോഗിക്കുക
ഇപ്പോൾ, പ്രൂഫ്-ഓഫ്-വർക്ക് അൽഗോരിതം ഉപയോഗിച്ച് നമുക്ക് നമ്മുടെ പുതിയ ബ്ലോക്ക്ചെയിൻ ഉപയോഗിക്കാം. ഇവിടെ, രണ്ട് console.log പ്രസ്താവനകൾ ചേർക്കുക.
ഞങ്ങൾ ഈ കോഡ് എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ, ഖനന പ്രക്രിയ ഇനി പ്രത്യേകിച്ച് വേഗത്തിലല്ലെന്ന് നമുക്ക് നിരീക്ഷിക്കാൻ കഴിയും.
മൂന്ന് പൂജ്യങ്ങളിൽ (ബുദ്ധിമുട്ട് കൊണ്ട് ക്രമീകരിച്ചത് പോലെ) ആരംഭിക്കുന്ന ഹാഷുകളുള്ള ബ്ലോക്കുകൾ സൃഷ്ടിക്കാൻ അൽഗോരിതത്തിന് കുറച്ച് സമയമെടുക്കും.
അങ്ങനെ ഞങ്ങളുടെ അടിസ്ഥാന ബ്ലോക്ക്ചെയിൻ സജ്ജീകരണത്തിന്റെ അവസാനമായിരുന്നു.
പ്രൂഫ്-ഓഫ്-വർക്ക് മെക്കാനിസത്തിന് നന്ദി, ഞങ്ങളുടെ ബ്ലോക്ക്ചെയിനിലേക്ക് എത്ര വേഗത്തിൽ പുതിയ ബ്ലോക്കുകൾ ചേർക്കുന്നുവെന്ന് നമുക്ക് നിയന്ത്രിക്കാനാകും.
ബ്ലോക്ക്ചെയിനുകളിലെ ഏറ്റവും പ്രധാനപ്പെട്ട സുരക്ഷാ സവിശേഷതയാണിത്. ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് ഇപ്പോൾ നിങ്ങൾ മനസ്സിലാക്കുന്നു, നിങ്ങളുടേതായ സൃഷ്ടിയിൽ ഏർപ്പെടൂ!
നിങ്ങളുടെ അഭിപ്രായങ്ങൾ രേഖപ്പെടുത്തുക