ORIHINAL NA THREAD ni webtricks
Ito ay pagsasalin lamang. Ang orihinal na thead ay makikita sa pamamagitan ng pag-click sa link na nasa itaas.
Ang header ay dinesenyo ni: HBKMusiK
Maaaring nabasa mo ang maraming mga teoretikal na post sa kung paano gumagana ang mga cryptocurrencies, kung paano gumagana ang blockchain at maraming iba pang mga kaugnay na konsepto tulad ng Proof of Work, sha256. at iba pa. Ngunit ang gayong mga theoretical posts ay maaring magbigay sa iyo ng pangunahing ideya tungkol sa pagtatrabaho at maraming mga bagay ay mananatiling misteryo sa iyo. Kaya, ang layunin ng thread na ito ay upang mabigyan ka ng unang karanasan tungkol sa kung paano gumagana ang Blockchain gamit ang tunay na coding.
Bago ko simulan ang gabay, nais kong linawin ang ilang mga bagay:
Una, ang thread na ito ay para sa layunin ng pag-aaral lamang. Ang code sa ibaba ay hindi pa production ready at may ilang mga kahinaan. Kung plano mong gamitin ito para sa produksyon, tiyaking makipag-ugnay muna sa akin at sasabihin ko sa iyo ang mga kinakailangang idagdag na dapat mong gawin upang maging handa ito sa paggawa.
Pangalawa, ang gabay na ito ay gagamit ng Javascript / Node.JS kaya kung mayroon kang pangunahing ideya tungkol sa kung paano gumagana ang Javascript ang gabay na ito ay cake-walk na lamang para sa iyo. Kung hindi, kahit na ikaw ay maaaring matuto nang labis hangga't sinubukan kong manatili bilang descriptive hangga't maaari. Ngunit kung natigil ka sa isang lugar, PM mo lang ako o mag-post dito at lulutasin ko ang bawat pangamba na natanggap ko. Sapat na ang sinabi, simulan natin:
PART 1: BLOCK
Part 1(a): Constructor Class
Ok! block tulad ng alam nating lahat ay pangunahing yunit ng Blockchain. Ang series ng magkakaugnay na mga blocks ay bumubuo ng blockchain. Hayaan mo akong bigyan ka ng isang halimbawa: Ipagpalagay na 10 bata ang naglalaro sa isang parke. Ang bawat isa sa kanila ay nakahawak sa kamay ng isang bata kaya nabubuo ang istraktura ng human chain, ang mga bata sa parehong magkabilang dulo ay magkahawak ng kamay ng isa pang bata habang ang natitirang 8 ay nakahawak sa mga kamay ng 2 bata, isa sa magkabilang gilid. Gumagana ang blockchain sa parehong konsepto. Ang unang block ng chain (kilala bilang genesis block) ay hahawak sa kamay ng pangalawang block habang ang pinakahuling block ay nakahawak lamang sa kamay ng huling pangalawang block. Ang lahat ng iba pang mga blocks ay nakahawak sa kamay ng mga block dati at sa tabi nito.
Ang isang maliit na larawan na representasyon ng sinabi ko:
Ok! ngayon isang bagay na ang malinaw na ang bawat block ay dapat hawakan ang kamay ng iba pang mga block upang mabuo ang chain. Upang matiyak na ginagamit ng blockchain ang konsepto ng hash at previous hash (gusto ko itong tawaging last hash). Ang bawat block ay may natatanging hash na nabuo sa pamamagitan ng SHA256 algorithm (ipapaliwanag ang mga detalye mamaya). Ang hash na ito ay kumilos bilang kamay ng bawat block. Ang pangalawang block ay ise-save ang hash ng genesis block, ang ikatlong block ay ise-save ang hash ng pangalawang bloke at iba pa ... ito ay magdadala sa atin sa pangunahing disenyo ng block, ang block ay dapat magkaroon ng hash, lastHash (hash ng previous block), data (isang natatanging bagay na nakalagay sa block), timestamp (ang timing ng paglikha ng block) at nonce (ipapaliwanag kung ano'ng nonce ang kasama ng PoW). Bago magsimula sa code, siguraduhing mayroon ka ng mga sumusunod:
(i) I-install Node.js sa inyong system
(ii) I-download ang kahit anong code editor (Gusto ko isuggest ang Visual Studio Code)
(iii) Gumawa ng isang bagong file na may kahit anong pangalan ngunit may .js extension, Halimbawa: app.js or index.js
(iv) Buksan ang file sa visual studio code
Narito ang unang snippet ng code:
Code:
class Block {
constructor(timestamp, lastHash, hash, data, nonce) {
this.timestamp = timestamp;
this.lastHash = lastHash;
this.hash = hash;
this.data = data;
this.nonce = nonce;
}
}
Boom! Narito ang code para sa Part: 1 (a). Ngayon hayaan mo akong ipaliwanag kung ano ang ginawa namin. Simula sa salitang 'class'. Ang Class ay talagang isang skeleton. Ginawa namin ang skeleton na may pangalan na 'Block'. Tulad ng bawat tao ay may parehong balangkas ngunit iba't-ibang mga laman at organs. Katulad nito, ang bawat block sa chain ay magkakaroon ng Block skeleton. Timestamp, lastHash, hash, data at nonce ang mga buto. Ang bawat block ay dapat magkaroon ng mga buto upang makabuo ng isang skeleton. Sa pagpapatuloy, ang salitang 'constructor' ay tumutukoy sa function na kukuha ng mga buto bilang input at lilikha ng skeleton mula roon. Kaya't talagang pinapasok natin ang value ng timestamp, lastHash, hash, data at nonce sa constructor function na kung saan ay ang pagtatakda ng value ng timestamp, lastHash, hash, data at nonce of Block's instance na katumbas nito.
Great? Tayo na't magpatuloy sa Part: 1(b).
Part 1(b): Genesis Block
Here goes the code for Part: 1(b), this code will come after constructor function :
Code:
static createGenesis() {
return new this("17/01/2020", "dummy-last-hash", "dummy-hash", "data in genesis block", 0)
}
Great! hayaan mo akong sabihin sa iyo kung ano ang ginawa natin, gumawa tayo ng isang static function sa klase ng Block na lilikha ng isang genesis block para sa atin. Maaari napansin mo na gumawa tayo ng isang hard-coded value para sa block na ito (ang anumang nasa loob ng '' "ay string o hard-coded na value, hindi code). Ginagawa natin ito sa ganitong paraan dahil ang genesis block ay hindi maaaring magkaroon ng lastHash, kaya hindi ito mabubuhay na lumikha ng hash para dito, na kung saan ay delikado na maglagay ng anumang data sa genesis block.Kaya, mas mabuti kung tukuyin natin ang mga katangian ng genesis block sa ating sarili at huwag gamitin ito para sa anumang storage.
Sa pagpapatuloy, hayaan mong ipaliwanag ko kung ano ang ginagawa ng nasa itaas na code. Simula sa salitang 'static'. Maaari tayong lumikha ng dalawang uri ng functions sa class, normal function at static function. Maaaring magamit ang mga normal function sa bawat instance ng class (halimbawa, ang bawat block na ginawa gamit ang Block class ay pwedeng gumamit ng normal function) ngunit hindi posible na gumamit ng static function sa bawat pagkakataon. Sa ating chain, nais lamang natin ang isang genesis block kaya hindi maganda kung gumawaa tayo ng normal function para dito. Samakatuwid, ang static function ay sisiguraduhin na ang createGenesis() function ay maaaring tawagi ng isang beses lamang sa blockchain.
Maaari mong mapansin ang 'return' sa code sa itaas. Ang return ay nangangahulugang bumalik (smart, ehh). Tinitiyak nito na tuwing tinawag ang function na ito, ibabalik ng function ang value ng genesis block. ang 'new' ay tumutukoy sa halimbawa ng class block. Sa tuwing, lumilikha tayo ng instance ng anumang class, kailangan nating gumamit ng bagong keyword. 'this' ay tumutukoy sa block class's constructor. Kung gumagamit tayo ng constructor sa loob ng class, kailangan nating lagyan natin ng 'ito'.
Sapat na ang sinabi, tayo na't magpatuloy at gumawa ng pinakaimportanteng function i.e. createBlock.
Part 1(c): Paggawa ng Block function at Proof of Work
Code will go after createGenesis() function:Code:
static createBlock(previousBlock, data) {
let hash, timestamp, nonce=0;
const lastHash = previousBlock.hash;
do {
timestamp = Date.now();
nonce++;
hash = hashGenerator(timestamp, lastHash, data, nonce);
} while (hash.substr(0,4) !== ‘0’.repeat(4));
return new this(timestamp, lastHash, hash, data, nonce);
}
Neat! Ngayon oras upang maunawaan kung ano ang ginawa natin sa itaas. Ang function ay gumagamit ng dalawang input: previousBlock na kung saan ang block bago ang isa sa ating ginawa at data i.e. ang aktwal na data na nais nating i-save sa block. Pagkatapos, hinahayaan natin ang unang value ng hash = wala, timestamp = wala at nonce = 0. Sa Javascript 'let' at 'const' ay dalawang paraan ng pagtukoy ng mga variables. Tinutukoy natin ang mga variable na hindi nagbabago ng kanilang value sa 'const' at sa mga nagbabago ng kanilang value sa pamamagitan ng 'let'. Susunod, kinuha natin ang value ng lastHash mula sa previous Block na katumbas ng hash ng previousBlock.
Cool!Susunod ang mighty concept ng Proof of Work. Sinubukan nating makamit ito sa pamamagitan ng do/while loop. 'While' na bahagi ng do/while loop ay gumagamit ng kondisyon at ang loop ay nagpapatuloy ng code sa 'do' hanggang sa ang kondisyon sa while statement ay nakukuha. Kaya't ang kundisyon sa nabanggit nating while statement ay: hash.substr (0, 4)! == '0'.repeat (4). Ngayon ibreak natin ang statement na ito. hash.substr (0,4) ay nangangahulugang unang 4 na character ng hash na nagsisimula mula sa 0 i.e. unang character tapos yung pangalawa, pangatlo at ikaapat. Ang '0' . repeat(4) ay nangangahulugang apat na zero o '0000'. Kaya talagang sinasabi natin na patuloy na tumatakbo ang loop hanggang sa ang unang apat na mga character ng hash ay hindi 0. Sa sandaling ang unang 4 na character ng hash ay 0, magbe-break ang loop at ang resulta ng halaga ay magiging hash ng block. Hindi ito eksakto kung paano gumagana ang proof of system ngunit pareho ang pangunahing ideya. Naghahanap tayo ng hash na may apat na zero sa simula tulad ng 0000vddvd5vd4dv5dvdXXXXXXXXXX. Kung nais mong madagdagan ang difficulty ng Proof of Work system, dagdagan ang bilang ng mga zero sa 5 o higit pa at ang mga blocks ay babagal sa paghahanap. Kung nais mong babaan ang difficulty bawasan ang bilang ng mga zero sa 3 o mas mababa at ang mga block ay mas bibilis ang paghahanap.
Ngayon papunta ng code sa loob ng 'do' statement. Una ay ang timestamp na kinuha nating katumbas sa Data.now () na kung saan function ng javascript upang makabuo ng kasalukuyang petsa. Susunod ay nonce. Ang Nonce ay ang number na patuloy sa pagdaragdag ng 1 sa bawat loop upang ang value ng hash ay patuloy na nagbabago, kung mananatiling stagnant si nonce hindi posible na makabuo ng bagong hash sa bawat loop. Ang pangwakas na bagay sa code ay hashGenerator na nais ang value ng timestamp, lastHash, data at nonce at makabuo ng hash sa pamamagitan ng pagsasama ng lahat ng 4 na value bilang isang single string gamit ang sha256 algorithm. Isusulat natin ang function ng hashGenerator sa susunod na bahagi. Tayo na't magpatuloy.
Part 1(d): SHA256
Let’s write the code first, this will go at the top of the file before Block class:Code:
const crypto = require(‘crypto’);
const hashGenerator = (...inputs) => {
const hash = crypto.createHash(‘sha256’);
hash.update(inputs.map(item => JSON.stringify(item)).join(‘’));
return hash.digest(‘hex’);
}
Lovely! Oras na para sa paliwanag. Ang Crypto ay in-built library ng Node.js. Kaya, tinawag natin ito sa ating file sa pagrequire nito. Susunod ay hashGenerator function. Una, kumukuha tayo ng mga inputs sa i.e. kung naalala mo mula sa Part: 1 (c) ang timestamp, lastHash, data at nonce. Susunod dapat mong mapansin ang tatlong tuldok sa harap ng mga input. Ang mga tuldok na iyon ay hindi mali, kino-convert ng mga tuldok na ito ang lahat ng 4 na mga input sa Array na tulad nito: [timestamp, lastHash, data, nonce]. Bingo! Ngayon ay pumunta tayo sa hashGenerator function. Sa unang linya ay tinukoy namin ang value ng hash katumbas ng createHash ('sha256') function ng crypto library. Pagkatapos ay mag-i-input tayo ng bawat item ng mga input Array sa pamamagitan ng paraan ng pag-update. Una natin ang pagma-map over ng mga inputs array na nangangahulugan looping over item ng array, pag-convert ng bawat item sa string sa pamamagitan ng JSON.stringify na pamamaraan at pagkatapos ay pagsasama ng lahat ng single string. Panghuli, binabalik natin ang value ng function sa pamamagitan ng digest method ngunit unang nagko-convert ang nabuo na value mula sa line two hanggang hex.
Kung nahihirapan kang maunawaan ang function ng hashGenerator huwag kang mag-alala, dahil ito ay ginamit natin ang native syntax ng crypto library na kung saan ay naiiba sa mga generic na Javascript syntaxes.
Dito na nagtatapos ang unang part ng ating two parts guide sa paggawa ng Blockchain. Matagumpay nating nagawa ang Block class. Susunod ay gagawa tayo ng Blockchain class at magdagdag ng mga blocks sa ating blockchain.