మేము గత కొన్ని సంవత్సరాల ట్రెండ్లను పరిశీలిస్తే, మేము బ్లాక్చెయిన్ గురించి ఎప్పటికప్పుడు విన్నాము, కానీ ప్రత్యేకతల గురించి పెద్దగా చెప్పలేదు.
Bitcoin, Ethereum, Dogecoin, Matic మరియు ఇతర క్రిప్టోకరెన్సీలు బ్లాక్చెయిన్ టెక్నాలజీపై ఆధారపడతాయని మనందరికీ తెలుసు. బ్లాక్చెయిన్ 2021లో అనేక పరిశ్రమలను విప్లవాత్మకంగా మార్చిన ముఖ్యమైన సంఘటనలకు నాయకత్వం వహించింది మరియు కొత్త విజయాలకు మార్గం సుగమం చేసింది.
బ్లాక్చెయిన్ అనేది డేటాను ఎడిట్ చేయడం, హ్యాక్ చేయడం లేదా మోసం చేయడం కష్టతరమైన లేదా అసాధ్యమైన రీతిలో నిల్వ చేసే సాధనం. ఇది బ్లాక్చెయిన్ యొక్క కంప్యూటర్ సిస్టమ్ల మొత్తం నెట్వర్క్లో నకిలీ మరియు వ్యాపించిన లావాదేవీల డిజిటల్ లెడ్జర్.
ఇది ఆచరణాత్మకంగా అన్ని క్రిప్టోకరెన్సీలకు శక్తినిచ్చే గ్రౌండ్ బ్రేకింగ్ డేటాబేస్ టెక్నాలజీ. బ్లాక్చెయిన్ మొత్తం నెట్వర్క్లో డేటాబేస్ యొక్క ఒకే విధమైన కాపీలను వ్యాప్తి చేయడం ద్వారా సిస్టమ్ను హ్యాక్ చేయడం లేదా మోసం చేయడం చాలా కష్టతరం చేస్తుంది.
Bitcoin ఇప్పుడు బ్లాక్చెయిన్కు అత్యంత ప్రముఖమైన ఉపయోగం అయితే, సాంకేతికత చాలా విస్తృతమైన అప్లికేషన్లకు ఉపయోగపడుతుంది.
ఇటీవలి సంవత్సరాలలో క్రిప్టోకరెన్సీలు మరియు బ్లాక్చెయిన్లు బాగా ప్రాచుర్యం పొందాయి మరియు ఈ ధోరణి కొనసాగుతుందని భావిస్తున్నారు.
మేము ఈ ట్యుటోరియల్లో జావాస్క్రిప్ట్తో ఒక సాధారణ బ్లాక్చెయిన్ను తయారు చేస్తాము. ఇది బ్లాక్చెయిన్ ఎలా పనిచేస్తుందనే దానిపై మీకు ప్రాథమిక అవగాహనను అందిస్తుంది.
దీన్ని MelodyCoin అని పిలుద్దాం మరియు చర్యలో పాల్గొనండి!
ఒక బ్లాక్ని సృష్టిస్తోంది
ప్రారంభించడానికి, మేము కొత్త JavaScript ఫైల్ని సృష్టిస్తాము, దీనిలో మేము మా కోడ్ మొత్తాన్ని ఉంచుతాము.
దీన్ని main.js అని పిలుద్దాం మరియు బ్లాక్చెయిన్ మరియు బ్లాక్లు ఎలా కనిపించాలి అనే వివరణతో ప్రారంభిద్దాం.
బ్లాక్ క్లాస్ని సృష్టించి, ప్రారంభించడానికి ఆబ్జెక్ట్() { [స్థానిక కోడ్] } అనే ఫంక్షన్ను ఇవ్వండి.
కొత్త బ్లాక్ను సృష్టించేటప్పుడు మీరు తప్పనిసరిగా తేదీని మరియు మునుపటి బ్లాక్ యొక్క హాష్ను తప్పక ఇవ్వాలి:
ప్రతి ఆస్తికి నిర్వచనాలు ఇక్కడ ఉన్నాయి:
- బ్లాక్ ఎప్పుడు చేయబడిందో టైమ్స్టాంప్ సూచిస్తుంది. మీరు ఎంచుకున్న ఫార్మాట్ను ఉపయోగించవచ్చు (ఈ సందర్భంలో, UNIX టైమ్స్టాంప్).
- మీరు ఈ బ్లాక్కి కనెక్ట్ చేయాలనుకుంటున్న ఏదైనా డేటా ఫారమ్ డేటా పారామీటర్లో చేర్చబడుతుంది. మీరు క్రిప్టోకరెన్సీని సృష్టించాలనుకుంటే, పంపినవారు/గ్రహీత మరియు తరలించిన డబ్బు వంటి లావాదేవీ డేటాను మీరు ఇక్కడ ఉంచుకోవచ్చు.
- మునుపటి హాష్ అనేది మునుపటి బ్లాక్ యొక్క హాష్ను కలిగి ఉన్న స్ట్రింగ్. ఇది బ్లాక్ల గొలుసును ఉత్పత్తి చేస్తుంది, ఇది తరువాత మా బ్లాక్చెయిన్ యొక్క సమగ్రతను అందించడంలో కీలకం.
హాష్లను సృష్టిస్తోంది
ప్రతి బ్లాక్ మునుపటి బ్లాక్కి లింక్ చేస్తుంది (అందువల్ల మునుపటి హాష్ ప్రాపర్టీ). అంటే, ప్రతి బ్లాక్కి హాష్ అవసరం. హ్యాష్ అనేది వేలిముద్రను పోలి ఉంటుంది. ప్రతి బ్లాక్కి ఇది ప్రత్యేకంగా ఉంటుంది.
ఒక బ్లాక్ యొక్క హాష్ దానిలోని అన్ని విషయాలను హాష్ ఫంక్షన్ ద్వారా పాస్ చేయడం ద్వారా గణించబడుతుంది.
కాబట్టి, ప్రస్తుత బ్లాక్ యొక్క హాష్ను గణించే ఫంక్షన్ను అమలు చేయడం ద్వారా ప్రారంభిద్దాం.
కాబట్టి, బ్లాక్ క్లాస్ కింద, మేము గణన హాష్ ఫంక్షన్ను నిర్వచించాము:
అయినప్పటికీ, SHA256 హాష్కు JavaScript ద్వారా మద్దతు లేదు మరియు తప్పనిసరిగా బాహ్య లైబ్రరీ నుండి పొందాలి.
Crypto-js అనేది అనేక హాష్ అల్గారిథమ్ల యొక్క సురక్షిత అమలులను కలిగి ఉన్న అద్భుతమైన ప్యాకేజీ.
అప్పుడు మనం దానిని మన main.js కోడ్లోకి దిగుమతి చేసుకోవచ్చు.
ఇప్పుడు మన కాలిక్యులేషన్హాష్() ఫంక్షన్ని కలిగి ఉన్నందున, దానిని మన బ్లాక్ ఫంక్షన్లో ఉపయోగించుకుందాం:
బ్లాక్ ఎలా ఉంటుందో వివరించిన తర్వాత, బ్లాక్చెయిన్ ఎలా ఉండాలో మనం నిర్వచించవచ్చు. కాబట్టి కొత్త తరగతిని క్రియేట్ చేద్దాం.
ఈ దృష్టాంతంలో, బ్లాక్చెయిన్ అనేది ఆస్తి గొలుసును కలిగి ఉన్న చాలా సులభమైన వస్తువు. ఇది చైన్లోని అన్ని బ్లాక్లను కలిగి ఉన్న శ్రేణి.
మేము బ్లాక్లను జోడించే ముందు, మనం ముందుగా "జెనిసిస్ బ్లాక్" అని పిలవబడే దానిని సృష్టించాలి. ఇది గొలుసులోని మొదటి బ్లాక్, మరియు ఇది ముందుగా ఉన్న బ్లాక్ను సూచించలేకపోవడం (ఇది మొదటిది!) ప్రత్యేకత.
కాబట్టి, జెనెసిస్ బ్లాక్ను నిర్మించడానికి, నేను మా తరగతికి createGenesisBlock () పేరుతో ఒక ఫంక్షన్ని జోడిస్తాను. మా బ్లాక్చెయిన్ క్లాస్లోని ఆబ్జెక్ట్() { [స్థానిక కోడ్] } ఫంక్షన్కి తిరిగి వెళ్లండి.
మేము ఇప్పుడు కొత్త బ్లాక్చెయిన్ ఉదాహరణను రూపొందించినప్పుడు ఎప్పుడైనా జెనెసిస్ బ్లాక్ను చేర్చవచ్చు:
బ్లాక్చెయిన్ పద్ధతులు
ఇప్పుడు, కొత్త బ్లాక్లను జోడించడం మరియు అత్యంత ఇటీవలి బ్లాక్ను పొందడం వంటి పనులను చేయడానికి మమ్మల్ని అనుమతించే మా Blockchain తరగతికి పద్ధతులను జోడిద్దాం.
getLatestBlock ఫంక్షన్ అత్యంత ప్రాథమికమైనది. ఇది గొలుసు శ్రేణి యొక్క చివరి సభ్యుడిని తిరిగి అందిస్తుంది:
addBlock టెక్నిక్ కొంచెం ఎక్కువగా ఉంటుంది.
మన గొలుసుకు కొత్త బ్లాక్ని జోడించే ముందు, మనం ముందుగా ఆ బ్లాక్ యొక్క మునుపటి హాష్ ఫీల్డ్ను తగిన విధంగా సెట్ చేయాలి.
ఇది తప్పనిసరిగా మా గొలుసుకు ఇటీవల జోడించిన బ్లాక్ యొక్క హాష్కి సెట్ చేయబడాలి. మేము కొత్త బ్లాక్ యొక్క హాష్ను కూడా లెక్కించాలి:
టెస్టింగ్
మరి మన MelodyCoin ఎలా వచ్చిందో చూద్దాం.
దీన్ని సాధించడానికి బ్లాక్చెయిన్ ఉదాహరణను సృష్టించండి. మరికొన్ని బ్లాక్లను జోడిద్దాం:
మేము అక్కడ రెండు కొత్త బ్లాకులను తయారు చేసాము. ప్రస్తుతం మన బ్లాక్చెయిన్ ఎలా ఉందో ఒకసారి చూద్దాం.
MelodyCoin నాలుగు ఖాళీలతో స్ట్రింగ్ చేయబడి మరియు ఫార్మాట్ చేయబడుతుంది:
బ్లాక్చెయిన్ సమగ్రతను ధృవీకరించండి
బ్లాక్చెయిన్లు అద్భుతంగా ఉన్నాయి ఎందుకంటే ఒకసారి బ్లాక్ జోడించబడితే, మిగిలిన గొలుసును చెల్లుబాటు చేయకుండా సవరించడం సాధ్యం కాదు.
అయితే, ఈ అమలుతో మా బ్లాక్చెయిన్ యొక్క సమగ్రతను తనిఖీ చేయడానికి నాకు ఎలాంటి పద్ధతి లేదు.
మన బ్లాక్చెయిన్కి isChainValid ఫంక్షన్ని పరిచయం చేద్దాం. గొలుసు చట్టబద్ధమైనట్లయితే, అది నిజమవుతుంది; లేకపోతే, అది తప్పుగా తిరిగి వస్తుంది:
సమగ్రతను పరీక్షిస్తోంది
మనం ఇప్పుడు మా బ్లాక్చెయిన్ సమగ్రతను పరీక్షించవచ్చు. ఇప్పుడు దాన్ని ఎగ్జిక్యూట్ చేస్తే మన చైన్ అసలైనదే అని నిర్ధారిస్తుంది.
ఇప్పుడు మన బ్లాక్చెయిన్ను ట్యాంపర్ చేయడానికి ప్రయత్నిద్దాం. బ్లాక్ 2ని మార్చండి మరియు దాని కంటెంట్లను ఓవర్రైట్ చేద్దాం (మనం నాలుగు బదులుగా 100 నాణేలను బదిలీ చేసాము అనుకుందాం).
మేము దీన్ని అమలు చేసినప్పుడు, గొలుసును దెబ్బతీసే మన ప్రయత్నాన్ని సాఫ్ట్వేర్ గుర్తిస్తుందని మనం చూడవచ్చు.
అయితే, నేను దీనితో జోక్యం చేసుకోవడానికి మరొక పద్ధతి ఉందని మీరు నమ్మవచ్చు. నేను బ్లాక్లోని కంటెంట్లను మార్చాను కానీ హాష్ని మళ్లీ లెక్కించలేదు. కాబట్టి మీరు తెలివిగా ప్రయత్నించవచ్చు మరియు అదే బ్లాక్ యొక్క హాష్ని మళ్లీ లెక్కించవచ్చు.
మా చిన్న బ్లాక్చెయిన్ సెటప్లో అంతే! ఇది కొత్త బ్లాక్లను జోడించడానికి మరియు గొలుసులోని డేటాతో ట్యాంపరింగ్ను గుర్తించడానికి మాకు వీలు కల్పిస్తుంది.
మా చిన్న బ్లాక్చెయిన్తో మనం పరిష్కరించాల్సిన రెండు సమస్యలు ఉన్నాయి:
- ఆధునిక కంప్యూటర్లు అత్యంత వేగవంతమైనవి మరియు సెకన్లలో మన గొలుసుకు వేలాది బ్లాక్లను జోడించగలవు. మా బ్లాక్చెయిన్ను ఎవరైనా స్పామ్ చేయడం మాకు ఇష్టం లేదు.
- మా బ్లాక్చెయిన్ ఇప్పటికీ ట్యాంపరింగ్కు గురయ్యే అవకాశం ఉంది. మీరు బ్లాక్లోని కంటెంట్లను అప్డేట్ చేసి, ఆపై అన్ని కింది బ్లాక్ల కోసం హ్యాష్లను (మరియు ముందు హ్యాష్లు) మళ్లీ లెక్కించవచ్చు. మీరు దానితో గందరగోళానికి గురైనప్పటికీ, మీరు చట్టబద్ధమైన గొలుసుతో ముగుస్తుంది.
ఈ ఆందోళనలను పరిష్కరించడానికి, బ్లాక్చెయిన్లు "పని యొక్క రుజువు" అని పిలువబడే సాంకేతికతను ఉపయోగిస్తాయి. ఈ విధానాన్ని ఉపయోగించి బ్లాక్ని సృష్టించడానికి మీరు గణనీయమైన మొత్తంలో గణన వనరులను ఉపయోగించారని మీరు తప్పనిసరిగా ప్రదర్శించాలి. దీనిని కూడా అంటారు గనుల తవ్వకం.
ప్రూఫ్-ఆఫ్-వర్క్ కోసం బ్లాక్ యొక్క హాష్ నిర్దిష్ట మొత్తంలో సున్నాలతో ప్రారంభం కావాలి. అయితే మీ హాష్ ఈ నియమానికి సరిపోతుందో లేదో మీరు ఎలా తెలుసుకోవాలి?
బ్లాక్ యొక్క కంటెంట్లు దాని హాష్ని నిర్ణయిస్తాయి. కాబట్టి మేము కంటెంట్లను సవరించనట్లయితే, మేము ఎల్లప్పుడూ ఒకే హాష్ని పొందుతాము.
ప్రతి బ్లాక్కి పరిష్కారంగా నాన్స్ విలువ జోడించబడాలి. ఇది తప్పనిసరిగా కొన్ని యాదృచ్ఛిక డేటా, మా బ్లాక్ యొక్క హాష్ తగినంత సున్నాలతో ప్రారంభమయ్యే వరకు మనం నవీకరించవచ్చు. మీరు హాష్ ఫంక్షన్ యొక్క అవుట్పుట్ను మార్చలేరు కాబట్టి, మీరు చాలా విభిన్న కాంబినేషన్లను పరీక్షించాలి మరియు ఉత్తమమైన వాటి కోసం ఆశించాలి.
బ్లాక్చెయిన్కు మైనింగ్ను పరిచయం చేయండి
మా బ్లాక్ క్లాస్లో నాన్స్ని చేర్చడం ద్వారా ప్రారంభిద్దాం. నాన్స్ అనేది మా బ్లాక్లోని ఒకే విలువ, ఇది బ్లాక్ యొక్క హాష్ను ప్రభావితం చేయడానికి మేము సవరించగలము.
మేము టైమ్స్టాంప్ లేదా డేటాను మార్చలేకపోతున్నాము.
తరువాత, ఒక బ్లాక్ యొక్క అసలు మైనింగ్ చేసే mineBlock() ఫంక్షన్ని వ్రాద్దాం. ఈ ఫంక్షన్ అవసరమైన ఇబ్బందిని పారామీటర్గా పంపబడుతుంది మరియు మా బ్లాక్ యొక్క హాష్ తగినంత సున్నాలతో ప్రారంభమయ్యే వరకు అమలు చేయడం కొనసాగుతుంది.
నేను మా హాష్ తగినంత సున్నాలతో ప్రారంభమయ్యే వరకు అమలు చేసే ఒక ప్రాథమిక అయితే లూప్ను తయారు చేసాను. ఎన్ని సున్నాలు అవసరమో గుర్తించడానికి మేము కష్టాన్ని ఉపయోగిస్తాము. 5 కష్టంతో, మా హాష్ తప్పనిసరిగా 5 సున్నాలతో ప్రారంభమవుతుంది.
మా హాష్లో తగినంత సున్నాలు లేనప్పుడు, మేము నాన్స్ను ఒక్కొక్కటిగా పెంచుతాము మరియు హాష్ను మళ్లీ లెక్కిస్తాము. మరియు కష్టానికి అనుగుణంగా ఉన్న హాష్ను మేము కనుగొంటే, మేము దానిని కన్సోల్కు లాగిన్ చేస్తాము.
మనం చేయవలసింది ఇంకొకటి ఉంది. మేము మా గణన హాష్ పద్ధతిలో నాన్స్ వేరియబుల్ని నిజంగా పరిగణనలోకి తీసుకోము, కాబట్టి ఇది ఇక్కడ ఉంది:
బ్లాక్చెయిన్ క్లాస్
ఈ కొత్త విధానాన్ని మన బ్లాక్చెయిన్ క్లాస్లో పరీక్షించి, అది ఎలా జరుగుతుందో చూద్దాం.
ప్రారంభించడానికి, నేను ఆబ్జెక్ట్() ఫంక్షన్లో మా బ్లాక్చెయిన్ యొక్క కష్టాన్ని నిర్వచిస్తాను. మేము దానిని ఇక్కడ నిర్వచించాము ఎందుకంటే మేము దానిని తర్వాత ఎక్కడైనా ఉపయోగించవచ్చు.
addBlock ఫంక్షన్ తప్పనిసరిగా సవరించబడాలి, అది మా గొలుసులో జోడించే ముందు బ్లాక్ను మైనింగ్ చేస్తుంది.
బ్లాక్చెయిన్ ఉపయోగించండి
ఇప్పుడు, ప్రూఫ్-ఆఫ్-వర్క్ అల్గారిథమ్తో ఉపయోగించడానికి మా కొత్త బ్లాక్చెయిన్ను ఉంచుదాం. ఇక్కడ, ఒక జంట console.log స్టేట్మెంట్లను జోడించండి.
మేము ఈ కోడ్ను అమలు చేసినప్పుడు, మైనింగ్ ప్రక్రియ ఇకపై ముఖ్యంగా వేగంగా ఉండదని మనం గమనించవచ్చు.
అల్గోరిథం మూడు సున్నాలతో ప్రారంభమయ్యే హాష్లతో బ్లాక్లను రూపొందించడానికి కొంత సమయం పడుతుంది (కష్టతతో కాన్ఫిగర్ చేయబడింది).
కాబట్టి అది మా ప్రాథమిక బ్లాక్చెయిన్ సెటప్ ముగింపు.
ప్రూఫ్-ఆఫ్-వర్క్ మెకానిజం ద్వారా మా బ్లాక్చెయిన్కు ఎంత త్వరగా కొత్త బ్లాక్లు జోడించబడతాయో మేము నియంత్రించగలము.
బ్లాక్చెయిన్లలో ఇది అత్యంత ముఖ్యమైన భద్రతా లక్షణం. మరియు ఇప్పుడు ఇది ఎలా పని చేస్తుందో మీరు అర్థం చేసుకున్నారు, మీ స్వంతంగా సృష్టించడం ప్రారంభించండి!
సమాధానం ఇవ్వూ