Šajā rakstā mēs koncentrēsimies uz Go blokķēdes attīstību no nulles. Tomēr, pirms sākam darbu, jums ir jāpārliecinās, ka esat iepazinies ar Golangas pamatjēdzieniem. Ja nē, tad ir prātīgi, ja iziet cauri sākotnējiem jēdzieniem un pēc tam atgriezīsities pie blokķēdes.
Tātad, ķersimies pie tēmas.
Sākot ar jaunu direktoriju
Sākumā mēs izveidosim jaunu direktoriju. Pieņemsim, ka šī direktorija nosaukums ir “blockchain”. Mēs ierakstīsim kodu komandu uzvednē (vai, ja izmantojat macOS vai Linux, jums ir jāizmanto terminālis). Tādējādi mēs ierakstām:
cd go-workspace
mkdir blokķēde
CD blokķēde
kods .
Kad tiek atvērts VS kods, komandu uzvednē mēs izveidosim Go moduli. Kā mēs to darām? Nu, mēs ierakstām:
dodieties uz mod init github.com/golang-company/blockchain
Kodēšana vietnē main.go
Pēc tam mēs izveidosim Go avota failu ar nosaukumu "main.go" un ierakstīsim tajā kodu. Bet vispirms ļaujiet mums saprast, kas ir blokķēde. A blockchain var definēt kā publisku datubāzi, kas ir decentralizēta un izplatīta starp vairākiem vienādrangiem. Blockchain ļauj datu bāzei pašam veikt labojumus, pat ja mezgls rada neprecīzus datus.
Parasti bloku ķēdes bloks sastāv no datiem, ko mēs kopīgojam datu bāzē, jaucējkodu un iepriekšējā bloka kriptogrāfiskā jaucēja.
Tātad, vai esat gatavs Dodieties uz blokķēdes attīstību? Lieliski! Sāksim.
Programmēšanas daļa
Šajā sadaļā mēs apskatīsim failu main.go.
galvenā pakete
importēt (
"baiti"
“crypto/sha256”
"Fmt"
)
tips Kriptobloks struct {
Hash [] baits
Datu [] baits
PrevHash [] baits
}
- Kā redzat, struktūra ir tikai izveidota.
func (c *Kriptobloks) BuildHash() {
informācija := baiti.Pievienoties([][] baits{c.Dati, c.PrevHash}, []baits{})
hash := sha256.Sum256(detalizēta informācija)
c.Hash = hash[ : ]
}
- Tagad mēs izveidosim metodi, kas ļaus mums ģenerēt jaucējkodu atkarībā no datiem un iepriekšējās jaukšanas. Mēs importēsim “baitu” bibliotēku, jo mēs to izmantosim.
- Nākamais solis ir izveidot mainīgo ar nosaukumu Details un izmantot datu tipa baitus. Mēs izmantosim Join (), lai savienotu baitu šķēles.
informācija := baiti.Pievienoties([][] baits{c.Dati, c.PrevHash}, []baits{})
Šeit mēs ņemam 2D baitu daļu, pārsūtām c.Data un iepriekšējo jaucējkodu. Tad mēs apvienosim tukšo baitu daļu.
- Pēc tam mēs izveidojam faktisko jaucējfunkciju, izmantojot detaļu jaukšanas funkciju sum256. Mēs to varam izmantot, importējot sha256 bibliotēku.
- Tālāk mēs iespiežam izveidoto hash bloka laukā Hash.
func BuildBlock (datu virkne, prevHash [] baits) *Cryptoblock {
bloks := &Kriptobloks{[]baits{}, []baits(dati), prevHash}
block.BuildHash()
atgriešanas bloks
}
- Tagad mēs izveidosim funkciju, kas ļauj izveidot bloku. Funkcija pieņem datu virkni kā ievadi, prevHash no iepriekšējā bloka kā ievadi un pēc tam izvada atsauci uz Cryptoblock. Mēs veidosim bloku, izmantojot bloku konstruktoru.
- &Kriptobloks darbojas kā atsauce uz bloku. Laukā Hash mēs iekļaujam tukšu baitu daļu. Datu laukam mēs ņemam datu virkni un pārvēršam to baitu daļā. Un mēs iekļaujam prevHash laukā PrevHash.
- Visbeidzot, mēs blokā izsaucam BuildHash () un atgriežam bloku.
ierakstiet BlockChain struct {
bloki []*Kriptobloks
}
- Ir nepieciešams veids, kas palīdzēs izteikt blokķēdi. Un mēs ieviesām struktūru, lai to paveiktu. Tipa BlockChain struktūru veido norādes uz Cryptoblock.
func (ķēde *BlockChain) AddBlock(datu virkne) {
prevBlock := chain.blocks[len(chain.blocks)-1]
jauns := BuildBlock(dati, prevBlock.Hash)
ķēde.bloki = pievienot(ķēde.bloki, jauns)
}
- Šeit mēs izveidojam metodi, kas ļauj pievienot bloku ķēdei. Metode izgūst blokķēdes rādītāju. Pēc tam tas pieņem datu virkni.
- Izsaucot ķēdi.blokus, tiekam pie iepriekšējā bloka blokķēdē. Tālāk mēs izturējām blokķēdes garumu [len(chain.blocks)-1].
- Jaunajā mainīgajā mēs izsaucam funkciju BuildBlock un nododam datu virkni un prevBlock.Hash.
- Izmantojot pievienošanas funkciju, pievienojot to ķēdei. bloki, mēs pievienojam jauno bloku blokķēdei.
func Inception() *Kriptobloks {
atgriezt BuildBlock ("Iesākums", []baits{})
}
- Nākamais solis ir izveidot funkciju ar nosaukumu Inception, kas aprakstīs blokķēdes pirmo bloku. Un mēs funkcijā atgriezīsim jaunu BuildBlock kopā ar datiem pirmajā blokā. Šeit. Esmu iekļāvis “Inception” un baitu daļu, kas apzīmē tukšu iepriekšējo jaucējkodu.
func InitBlockChain() *BlockChain {
atgriezt &BlockChain{[]*Kriptobloks{Iesākums()}}
}
- Lai izveidotu pirmo blokķēdi, esmu ieviesis InitBlockChain funkciju. Šeit es tikai atgriežu konkrēto atsauci uz BlockChain. Tālāk mēs izveidojam Cryptoblock masīvu, kurā izsaucam funkciju Inception.
func main() {
ķēde := InitBlockChain()
ķēde.AddBlock (“Pirmais bloks pēc sākuma”)
ķēde.AddBlock (“Otrais bloks pēc sākuma”)
ķēde.AddBlock (“trešais bloks pēc sākuma”)
for _, block := range chain.blocks {
fmt.Printf (“Iepriekšējais jaucējkrāns: %x\n”, block.PrevHash)
fmt.Printf (“Dati blokā: %s\n”, block.Data)
fmt.Printf(“Jaukts: %x\n”, block.Hash)
}
}
- Beidzot esam nonākuši pie galvenās funkcijas. Kā redzat, mēs esam izsaukuši InitBlockChain () un esam to piešķīruši ķēdes mainīgajam.
- Tālāk mēs pievienojam ķēdei blokus, izmantojot ķēdi.AddBlock, un mēs nododam nepieciešamos datus.
- Pēc tam mēs izpildām for cilpu, lai pārbaudītu blokķēdi. Pēc tam mēs izdalām katru bloku un izdrukājam laukus katrā blokā. Mēs vienkārši ierakstām:
fmt.Printf (“Iepriekšējais jaucējkrāns: %x\n”, block.PrevHash)
fmt.Printf (“Dati blokā: %s\n”, block.Data)
fmt.Printf(“Jaukts: %x\n”, block.Hash)
Output:
Tātad, mēs varam teikt, ka programma ir veiksmīga. Es ceru, ka jums izdevās saprast blokķēdes koncepcijas ieviešanu Golangā. Vienkārši turpiniet praktizēt, un jūs varēsit tikt galā ar sarežģītiem projektiem.
Jūsu kriptovalūta ir pelnījusi vislabāko drošību. Dabūt Ledger aparatūras maks tikai par 79 USD!
Avots: https://coinfomania.com/build-a-blockchain-in-golang/