បង្កើត Blockchain នៅ Golang ពី Scratch

នៅក្នុងអត្ថបទនេះ យើងនឹងផ្តោតលើការអភិវឌ្ឍន៍ Go blockchain ពីដំបូង។ ទោះជាយ៉ាងណាក៏ដោយ មុនពេលយើងចាប់ផ្តើម អ្នកគួរតែប្រាកដថាអ្នកធ្លាប់ស្គាល់គោលគំនិតជាមូលដ្ឋាននៅក្នុង Golang ។ បើមិនដូច្នេះទេ វាជាការល្អប្រសិនបើអ្នកឆ្លងកាត់គំនិតបឋម ហើយបន្ទាប់មកត្រលប់ទៅ blockchain វិញ។ 

ដូច្នេះសូមឱ្យយើងទៅត្រង់ប្រធានបទ។ 

ចាប់ផ្តើមជាមួយថតថ្មី។ 

យើងនឹងបង្កើតថតថ្មីមួយដើម្បីចាប់ផ្តើមជាមួយ។ អនុញ្ញាតឱ្យយើងសន្មត់ថាថតនេះមានឈ្មោះថា "blockchain" ។ យើងនឹងវាយលេខកូដនៅក្នុង Command Prompt (ឬប្រសិនបើអ្នកកំពុងប្រើ macOS ឬ Linux អ្នកត្រូវតែប្រើ Terminal)។ ដូច្នេះយើងវាយ:

cd go-workspace 

mkdir blockchain 

ស៊ីឌី blockchain 

កូដ។

នៅពេលដែល VS Code បើក យើងនឹងបង្កើតម៉ូឌុល Go នៅក្នុង Command Prompt ។ តើ​យើង​ធ្វើ​ដូច្នេះ​ដោយ​របៀប​ណា? ជាការប្រសើរណាស់, យើងវាយ:

ចូលទៅ mod init github.com/golang-company/blockchain

ការសរសេរកូដនៅក្នុង main.go 

បន្ទាប់មក យើងនឹងបង្កើតឯកសារប្រភព Go ដែលមានឈ្មោះថា 'main.go' ហើយយើងនឹងវាយបញ្ចូលកូដទៅក្នុងនោះ។ ប៉ុន្តែដំបូងអនុញ្ញាតឱ្យយើងយល់ពីអ្វីដែល blockchain គឺជាអ្វី។ ក blockchain អាច​ត្រូវ​បាន​កំណត់​ថា​ជា​មូលដ្ឋាន​ទិន្នន័យ​សាធារណៈ​ដែល​ត្រូវ​បាន​ធ្វើ​វិមជ្ឈការ​និង​ចែកចាយ​ក្នុង​ចំណោម​មិត្តភ័ក្តិ​មួយ​ចំនួន។ Blockchain អនុញ្ញាតឱ្យមូលដ្ឋានទិន្នន័យកែតម្រូវដោយខ្លួនឯង ទោះបីជាថ្នាំងមួយកំពុងផលិតទិន្នន័យមិនត្រឹមត្រូវក៏ដោយ។ 

ជាធម្មតា ប្លុកនៅលើ blockchain មានទិន្នន័យដែលយើងចែករំលែកនៅក្នុង database, hash, និង cryptographic hash របស់ block ពីមុន។ 

 ដូច្នេះ តើអ្នកត្រៀមខ្លួនហើយឬនៅ? ទៅការអភិវឌ្ឍន៍ blockchain? អស្ចារ្យ! តោះ​ចាប់ផ្តើម។ 

ផ្នែកសរសេរកម្មវិធី 

នៅក្នុងផ្នែកនេះយើងនឹងពិនិត្យមើលឯកសារ main.go ។ 

កញ្ចប់ចម្បង

នាំចូល (

“បៃ”

“crypto/sha256” 

"fmt" 

)

ប្រភេទ Cryptoblock struct {

ហាស [] បៃ 

ទិន្នន័យ [] បៃ 

PrevHash [] បៃ 

}

• ដូចដែលអ្នកអាចឃើញរចនាសម្ព័ន្ធមួយត្រូវបានបង្កើតឡើងតែប៉ុណ្ណោះ។ 

func (c *Cryptoblock) BuildHash() {

ព័ត៌មានលម្អិត := bytes.Join([][] byte{c.Data, c.PrevHash}, []byte{}) 

hash :=sha256.Sum256(លម្អិត)

c.Hash = hash[ : ]

}

• ឥឡូវនេះ យើងនឹងបង្កើតវិធីសាស្រ្តមួយ ដែលអាចឱ្យយើងបង្កើត hash អាស្រ័យលើទិន្នន័យ និង hash ពីមុន។ យើងនឹងនាំចូលបណ្ណាល័យ "បៃ" ពីព្រោះយើងនឹងប្រើវា។
• ជំហានបន្ទាប់គឺបង្កើតអថេរដែលហៅថាព័ត៌មានលម្អិត ហើយប្រើប្រភេទទិន្នន័យបៃ។ យើងនឹងប្រើ Join() ដើម្បីភ្ជាប់ចំណិតនៃបៃ។

ព័ត៌មានលម្អិត := bytes.Join([][] byte{c.Data, c.PrevHash}, []byte{}) 

នៅទីនេះ យើងកំពុងយកបំណែក 2D នៃបៃ យើងបញ្ជូន c.Data និង hash ពីមុន។ បន្ទាប់​មក​យើង​នឹង​រួម​បញ្ចូល​ចំណែក​ទទេ​នៃ​បៃ។ 

• បន្ទាប់ពីនេះ យើងកំពុងបង្កើត hash ពិតប្រាកដដែលទទួលយកជំនួយនៃមុខងារ sum256 hashing លើព័ត៌មានលម្អិត។ យើង​អាច​ប្រើ​វា​បាន ព្រោះ​យើង​នឹង​នាំចូល​បណ្ណាល័យ sha256។ 
• បន្ទាប់យើងរុញ hash ដែលបានបង្កើតទៅក្នុងវាល Hash សម្រាប់ប្លុក។ 

func BuildBlock (ខ្សែទិន្នន័យ prevHash [] byte) *Cryptoblock {

ប្លុក := &Cryptoblock{[]byte{}, []byte(data), prevHash}

block.BuildHash()

ប្លុកត្រឡប់មកវិញ

} 

• ឥឡូវនេះ យើងនឹងបង្កើតមុខងារមួយ ដែលអនុញ្ញាតឱ្យបង្កើត Block ។ មុខងារទទួលយកខ្សែទិន្នន័យជាការបញ្ចូល prevHash ពីប្លុកមុនជាការបញ្ចូល ហើយបន្ទាប់មកបញ្ចេញសេចក្តីយោងទៅ Cryptoblock ។ យើងនឹងសាងសង់ប្លុកដោយប្រើអ្នកបង្កើតប្លុក។ 
• &Cryptoblock ដើរតួជាឯកសារយោងទៅប្លុក។ សម្រាប់វាល Hash យើងបញ្ចូលផ្នែកទទេនៃបៃ។ សម្រាប់វាលទិន្នន័យ យើងយកខ្សែទិន្នន័យ ហើយបម្លែងវាទៅជាចំណិតនៃបៃ។ ហើយយើងបញ្ចូល prevHash ទៅក្នុងវាល PrevHash ។ 
• ចុងក្រោយ យើងហៅ BuildHash() នៅលើប្លុក ហើយយើងត្រឡប់ប្លុកវិញ។ 

ប្រភេទ BlockChain struct {

ប្លុក []* Cryptoblock

}

• ប្រភេទដែលនឹងជួយក្នុងការបញ្ចេញមតិ blockchain ត្រូវបានទាមទារ។ ហើយ​យើង​បាន​អនុវត្ត​រចនាសម្ព័ន្ធ​មួយ​ដើម្បី​សម្រេច​កិច្ចការ​នេះ។ ប្រភេទ BlockChain struct ត្រូវបានបង្កើតឡើងដោយអារេនៃចង្អុលទៅ Cryptoblock ។

func (ខ្សែសង្វាក់ * BlockChain) AddBlock (ខ្សែទិន្នន័យ) {

prevBlock := chain.blocks[len(chain.blocks)-1]

ថ្មី := BuildBlock(ទិន្នន័យ prevBlock.Hash)

chain.blocks = append(chain.blocks, ថ្មី)

}

• នៅទីនេះ យើងកំពុងបង្កើតវិធីសាស្រ្តមួយដែលអនុញ្ញាតឱ្យយើងចូលរួមប្លុកមួយទៅកាន់ខ្សែសង្វាក់។ វិធីសាស្រ្តទាញយកទ្រនិច blockchain ។ បន្ទាប់ពីនេះ វាទទួលយកខ្សែទិន្នន័យ។ 
• ការហៅទៅកាន់ chain.blocks យើងទៅដល់ប្លុកមុននៅក្នុង blockchain ។ បន្ទាប់មកយើងឆ្លងកាត់ប្រវែងនៃ blockchain [len(chain.blocks)-1] ។
• នៅក្នុងអថេរថ្មី យើងកំពុងហៅមុខងារ BuildBlock ហើយយើងកំពុងឆ្លងកាត់ខ្សែទិន្នន័យ និង prevBlock.Hash ។
• ដោយប្រើមុខងារបន្ថែមដោយបន្ថែមវាទៅ chain.blocks បន្ទាប់មកយើងភ្ជាប់ប្លុកថ្មីទៅ blockchain ។

func Inception() *Cryptoblock {

ត្រឡប់ BuildBlock (“ការចាប់ផ្តើម”, []បៃ{})

}

• ជំហានបន្ទាប់គឺបង្កើតមុខងារមួយហៅថា Inception ដែលនឹងពិពណ៌នាអំពីប្លុកដំបូងរបស់ blockchain ។ ហើយយើងនឹងត្រឡប់ BuildBlock ថ្មីមួយនៅក្នុងមុខងាររួមជាមួយនឹងទិន្នន័យនៅក្នុងប្លុកទីមួយ។ នៅទីនេះ។ ខ្ញុំបានដាក់បញ្ចូល "ការចាប់ផ្តើម" និងចំណែកនៃបៃដែលតំណាងឱ្យសញ្ញាដកពីមុនទទេ។ 

func InitBlockChain() *BlockChain {

ត្រឡប់ &BlockChain{[]*Cryptoblock{Inception()}}

}

• ដើម្បីបង្កើត blockchain ដំបូងខ្ញុំបានណែនាំមុខងារ InitBlockChain ។ នៅទីនេះ ខ្ញុំគ្រាន់តែត្រលប់មកវិញនូវឯកសារយោងជាក់លាក់ចំពោះ BlockChain ។ បន្ទាប់មកយើងបង្កើតអារេនៃ Cryptoblock ដែលយើងធ្វើការហៅទៅកាន់មុខងារ Inception ។ 

មុខងារចម្បង () {

ខ្សែសង្វាក់ := InitBlockChain()

chain.AddBlock("ប្លុកដំបូងបន្ទាប់ពីការចាប់ផ្តើម")

chain.AddBlock("ប្លុកទីពីរបន្ទាប់ពីការចាប់ផ្តើម")

chain.AddBlock("ប្លុកទីបីបន្ទាប់ពីការចាប់ផ្តើម")

សម្រាប់ _, ប្លុក := range chain.blocks {

fmt.Printf(“Hash មុន៖ %x\n”, block.PrevHash)

fmt.Printf(“ទិន្នន័យក្នុងប្លុក៖ %s\n”, block.Data)

fmt.Printf("Hash: %x\n", block.Hash)

}

}

• ទីបំផុតយើងបានមកដល់មុខងារសំខាន់។ ដូចដែលអ្នកអាចឃើញយើងបានហៅ InitBlockChain () ហើយយើងបានកំណត់វាទៅអថេរខ្សែសង្វាក់។ 
• បន្ទាប់មក យើងកំពុងបន្ថែមប្លុកទៅខ្សែសង្វាក់តាមរយៈ chain.AddBlock ហើយយើងបញ្ជូនទិន្នន័យចាំបាច់។ 
• អនុវត្តតាមនេះ យើងដំណើរការសម្រាប់រង្វិលជុំដើម្បីពិនិត្យមើល blockchain ។ បន្ទាប់មក យើងដាក់ប្លុកនីមួយៗ ហើយបោះពុម្ពវាលនៅខាងក្នុងប្លុកនីមួយៗ។ យើងគ្រាន់តែវាយ:

fmt.Printf(“Hash មុន៖ %x\n”, block.PrevHash)

fmt.Printf(“ទិន្នន័យក្នុងប្លុក៖ %s\n”, block.Data)

fmt.Printf("Hash: %x\n", block.Hash)

លទ្ធផល: 

ដូច្នេះយើងអាចនិយាយបានថាកម្មវិធីទទួលបានជោគជ័យ។ ខ្ញុំសង្ឃឹមថាអ្នកអាចយល់ពីការអនុវត្តគំនិតនៃ blockchain នៅក្នុង Golang ។ គ្រាន់តែបន្តអនុវត្ត នោះអ្នកនឹងអាចគ្រប់គ្រងគម្រោងស្មុគស្មាញបាន។ 

crypto របស់អ្នកសមនឹងទទួលបានសុវត្ថិភាពល្អបំផុត។ ទទួលបានមួយ។ Ledger hardware wallet តម្លៃត្រឹមតែ $79 ប៉ុណ្ណោះ!