Selles artiklis keskendume Go plokiahela arendamisele nullist. Enne alustamist peaksite siiski olema kindel, et olete Golangi põhimõistetega kursis. Kui ei, siis on mõistlik teha läbi eelkontseptsioonid ja seejärel tulla tagasi plokiahela juurde.
Niisiis, lähme otse teema juurde.
Alustades uuest kataloogist
Alustuseks loome uue kataloogi. Oletame, et selle kataloogi nimi on "blockchain". Tippime koodi käsureale (või kui kasutate macOS-i või Linuxit, peate kasutama terminali). Seega tippime:
cd go-tööruum
mkdir plokiahel
cd plokiahel
kood .
Kui VS-kood avaneb, loome käsureale Go mooduli. Kuidas me seda teeme? Noh, me kirjutame:
minge mod init github.com/golang-company/blockchain
Kodeerimine saidil main.go
Järgmisena loome Go lähtefaili nimega 'main.go' ja sisestame sellesse koodi. Kuid kõigepealt mõistame, mis on plokiahel. A blockchain võib määratleda kui avalikku andmebaasi, mis on detsentraliseeritud ja jaotatud mitme partneri vahel. Blockchain võimaldab andmebaasil end ise parandada, isegi kui sõlm toodab ebatäpseid andmeid.
Tavaliselt koosneb plokiahela plokk andmetest, mida me andmebaasis jagame, räsist ja eelmise ploki krüptograafilisest räsist.
Niisiis, kas olete selleks valmis Mine plokiahela arendamisse? Suurepärane! Alustame.
Programmeerimise osa
Selles jaotises uurime faili main.go.
pakett peamine
import (
"baidid"
"crypto/sha256"
"fmt"
)
tüüp Cryptoblock struct {
Räsi [] bait
Andmebait []
PrevHash [] bait
}
- Nagu näete, on struktuur alles loodud.
func (c *Krüptoblokk) BuildHash() {
üksikasjad := bytes.Join([][] bait{c.Data, c.PrevHash}, []bait{})
räsi := sha256.Sum256(üksikasjad)
c.Räsi = räsi[ : ]
}
- Nüüd loome meetodi, mis võimaldab meil sõltuvalt andmetest ja eelmisest räsist genereerida räsi. Impordime "baitide" teegi, sest me kasutame seda.
- Järgmine samm on luua muutuja nimega Detailid ja kasutada andmetüübi baite. Kasutame baitide lõikude ühendamiseks funktsiooni Join().
üksikasjad := bytes.Join([][] bait{c.Data, c.PrevHash}, []bait{})
Siin võtame 2D-lõigu baitidest, edastame c.Data ja eelmise räsi. Seejärel ühendame tühja baitide osa.
- Pärast seda loome tegeliku räsi, kasutades üksikasjade räsifunktsiooni sum256. Saame seda kasutada sha256 teegi importimisel.
- Järgmisena lükkame loodud räsi ploki räsiväljale.
func BuildBlock (andmedring, prevHash [] bait) *Cryptoblock {
block := &Krüptoplokk{[]bait{}, []bait(andmed), eelmine hash}
block.BuildHash()
tagastusplokk
}
- Nüüd loome funktsiooni, mis võimaldab luua ploki. Funktsioon aktsepteerib sisendiks andmejada, sisendiks eelmise ploki prevHash ja seejärel väljastab viite krüptoplokile. Ehitame ploki kasutades plokkkonstruktorit.
- &Krüptoplokk toimib ploki viitena. Räsivälja jaoks lisame tühja baitide osa. Andmevälja jaoks võtame andmestringi ja teisendame selle baitide osaks. Ja me lisame prevHashi väljale PrevHash.
- Lõpuks kutsume plokis välja BuildHash() ja tagastame ploki.
tüüp BlockChain struct {
plokid []*Krüptoblokk
}
- Nõutav on tüüp, mis aitab plokiahelat väljendada. Ja me rakendasime selle saavutamiseks struktuuri. Tüüpi BlockChain struktuur koosneb Cryptoblocki viidete massiivist.
func (ahel *BlockChain) AddBlock(andmesring) {
prevBlock := kett.plokid[len(chain.blocks)-1]
uus := BuildBlock(andmed, prevBlock.Hash)
chain.blocks = append(chain.blocks, new)
}
- Siin loome meetodi, mis võimaldab meil ploki ahelaga ühendada. Meetod otsib plokiahela osuti. Pärast seda aktsepteerib see andmestringi.
- Kutsudes chain.blocks, jõuame plokiahelas eelmise ploki juurde. Järgmisena läbisime plokiahela pikkuse [len(chain.blocks)-1].
- Uues muutujas kutsume funktsiooni BuildBlock ja edastame andmestringi ja prevBlock.Hash.
- Kasutades lisamisfunktsiooni, lisades selle ahelasse chain.blocks, kinnitame uue ploki plokiahela külge.
func Inception() *Crypblock {
tagasta BuildBlock ("Algus", []bait{})
}
- Järgmine samm on luua funktsioon nimega Inception, mis kirjeldab plokiahela esimest plokki. Ja me tagastame funktsioonis uue BuildBlocki koos esimese ploki andmetega. Siin. Olen lisanud "Inception" ja baitide osa, mis tähistab tühja eelmist räsi.
func InitBlockChain() *BlockChain {
tagasta &BlockChain{[]*Crypblock{Algus()}}
}
- Esimese plokiahela loomiseks olen kasutusele võtnud funktsiooni InitBlockChain. Siin ma lihtsalt tagastan konkreetse viite BlockChainile. Järgmisena koostame Cryptoblocki massiivi, kus kutsume esile funktsiooni Inception.
func main() {
kett := InitBlockChain()
chain.AddBlock ("Esimene plokk pärast algust")
chain.AddBlock ("Teine plokk pärast algust")
chain.AddBlock ("Kolmas plokk pärast algust")
for _, block := range chain.blocks {
fmt.Printf(“Eelmine räsi: %x\n”, block.PrevHash)
fmt.Printf("Andmed plokis: %s\n", block.Data)
fmt.Printf(“Räsi: %x\n”, block.Räsi)
}
}
- Lõpuks oleme jõudnud põhifunktsiooni juurde. Nagu näete, oleme kutsunud InitBlockChain() ja oleme määranud selle ahela muutujale.
- Järgmisena lisame ahelasse plokke ahela.AddBlock kaudu ja edastame vajalikud andmed.
- Pärast seda käivitame plokiahela kontrollimiseks for-tsükli. Seejärel eraldame iga ploki eraldi ja prindime väljad iga ploki sees. Me lihtsalt kirjutame:
fmt.Printf(“Eelmine räsi: %x\n”, block.PrevHash)
fmt.Printf("Andmed plokis: %s\n", block.Data)
fmt.Printf(“Räsi: %x\n”, block.Räsi)
Väljund:
Seega võime öelda, et programm on edukas. Loodan, et saite aru plokiahela kontseptsiooni rakendamisest Golangis. Lihtsalt jätkake harjutamist ja saate hakkama keeruliste projektidega.
Teie krüpto väärib parimat turvalisust. Saa Ledgeri riistvarakott vaid 79 dollari eest!
Allikas: https://coinfomania.com/build-a-blockchain-in-golang/