Bygg en blokkjede i Golang fra bunnen av

I denne artikkelen vil vi fokusere på Go blockchain-utvikling fra bunnen av. Men før vi setter i gang, bør du være sikker på at du er kjent med de grunnleggende konseptene i Golang. Hvis ikke, så er det lurt om du går gjennom de foreløpige konseptene og deretter kommer tilbake til blockchain. 

Så la oss gå rett til temaet. 

Starter med en ny katalog 

Vi vil bygge en ny katalog til å begynne med. La oss anta at denne katalogen har navnet "blockchain." Vi skriver inn koden i ledeteksten (eller hvis du bruker macOS eller Linux, må du bruke terminalen). Derfor skriver vi:

cd gå-arbeidsområde 

mkdir blokkjede 

cd blokkjede 

kode.

Når VS-koden åpnes, vil vi lage en Go-modul i ledeteksten. Hvordan gjør vi det? Vel, vi skriver:

go mod init github.com/golang-company/blockchain

Koding i main.go 

Deretter vil vi lage en Go-kildefil med navnet 'main.go' og vi skriver inn koden i den. Men la oss først forstå hva blockchain er. EN blockchain kan defineres som en offentlig database som er desentralisert og distribuert mellom flere likemenn. Blockchain lar databasen selvkorrigere, selv om en node produserer unøyaktige data. 

Vanligvis består en blokk på en blokkjede av data vi deler i databasen, en hash og forrige blokks kryptografiske hash. 

 Så, er du klar for Gå til blockchain-utvikling? Flott! La oss komme i gang. 

Programmeringsdel 

I denne delen skal vi se på main.go-filen. 

pakke hoved

importere (

"bytes"

"crypto/sha256" 

"fmt" 

)

type Cryptoblock struct {

Hash [] byte 

Data [] byte 

PrevHash [] byte 

}

• Som du kan se, er det bare opprettet en struktur. 

func (c *Cryptoblock) BuildHash() {

detaljer := bytes.Join([][] byte{c.Data, c.PrevHash}, []byte{}) 

hash := sha256.Sum256(detaljer)

c.Hash = hash[ : ]

}

• Vi skal nå konstruere en metode som vil gjøre oss i stand til å generere en hash avhengig av dataene og den forrige hashen. Vi skal importere "bytes"-biblioteket fordi vi skal bruke det.
• Det neste trinnet er å lage en variabel kalt detaljer og bruke datatypen bytes. Vi vil bruke Join() for å koble sammen bitene av byte.

detaljer := bytes.Join([][] byte{c.Data, c.PrevHash}, []byte{}) 

Her tar vi et 2D-stykke med byte, vi overfører c.Data og forrige hash. Deretter vil vi kombinere den tomme delen av byte. 

• Etter dette lager vi selve hashen ved å bruke sum256-hash-funksjonen på detaljene. Vi kan bruke dette ettersom vi vil importere sha256-biblioteket. 
• Deretter skyver vi den opprettede hashen inn i Hash-feltet for blokken. 

func BuildBlock (datastreng, prevHash [] byte) *Cryptoblock {

blokk := &Cryptoblock{[]byte{}, []byte(data), prevHash}

block.BuildHash()

returblokk

} 

• Vi skal nå bygge en funksjon som gjør det mulig å lage Block. Funksjonen aksepterer en streng med data som input, prevHash fra forrige blokk som input, og sender deretter ut en referanse til Cryptoblock. Vi vil bygge blokken ved å bruke blokkkonstruktøren. 
• &Cryptoblokken fungerer som referansen til blokken. For Hash-feltet inkorporerer vi et tomt stykke byte. For datafelt tar vi datastrengen og konverterer den til bit av byte. Og vi innlemmer prevHash i PrevHash-feltet. 
• Til slutt kaller vi BuildHash() på blokken og vi returnerer blokken. 

type BlockChain struct {

blokkerer []*Kryptoblokk

}

• En type som vil hjelpe med å uttrykke blokkjeden er nødvendig. Og vi implementerte en struktur for å oppnå dette. Type BlockChain-struktur består av en rekke pekere til Cryptoblock.

func (kjede *BlockChain) AddBlock(datastreng) {

prevBlock := kjede.blokker[len(kjede.blokker)-1]

new := BuildBlock(data, prevBlock.Hash)

chain.blocks = append(chain.blocks, new)

}

• Her lager vi en metode som gjør oss i stand til å knytte en blokk til kjeden. Metoden henter blokkjedepekeren. Etter dette godtar den en datastreng. 
• Ved å kalle chain.blocks kommer vi til forrige blokk i blokkjeden. Deretter passerte vi lengden på blokkjeden [len(kjede.blokker)-1].
• I den nye variabelen kaller vi BuildBlock-funksjonen, og vi sender datastreng og prevBlock.Hash.
• Ved å bruke append-funksjonen, legge denne til chain.blocks, knytter vi så den nye blokken til blockchain.

func Inception() *Cryptoblock {

return BuildBlock(“Inception”, []byte{})

}

• Neste steg er å lage en funksjon kalt Inception som skal beskrive blokkjedens første blokk. Og vi vil returnere en ny BuildBlock i funksjonen, sammen med dataene i den første blokken. Her. Jeg har inkorporert "Inception" og et stykke byte som representerer en tom tidligere hash. 

func InitBlockChain() *BlockChain {

returner &BlockChain{[]*Cryptoblock{Inception()}}

}

• For å lage den første blokkjeden har jeg introdusert InitBlockChain-funksjonen. Her returnerer jeg bare den spesielle referansen til BlockChain. Deretter bygger vi en rekke Cryptoblock, hvor vi ringer til Inception-funksjonen. 

func main () {

kjede := InitBlockChain()

chain.AddBlock(“Første blokk etter oppstart”)

chain.AddBlock(“Andre blokk etter oppstart”)

chain.AddBlock(“Tredje blokk etter oppstart”)

for _, blokk := range chain.blocks {

fmt.Printf(“Forrige Hash: %x\n”, block.PrevHash)

fmt.Printf(“Data i blokk: %s\n”, blokk.Data)

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

}

}

• Endelig har vi kommet til hovedfunksjonen. Som du kan se har vi kalt InitBlockChain() og vi har tilordnet den til kjedevariabelen. 
• Deretter legger vi til blokker til kjeden via chain.AddBlock, og vi sender de nødvendige dataene. 
• Etter dette kjører vi en for-løkke for å se etter blokkjeden. Så skiller vi ut hver blokk og skriver ut feltene inne i hver blokk. Vi skriver bare:

fmt.Printf(“Forrige Hash: %x\n”, block.PrevHash)

fmt.Printf(“Data i blokk: %s\n”, blokk.Data)

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

Utgang: 

Så vi kan si at programmet er vellykket. Jeg håper du var i stand til å forstå implementeringen av konseptet blokkjede i Golang. Bare fortsett å øve og du vil være i stand til å håndtere intrikate prosjekter. 

Din krypto fortjener den beste sikkerheten. Få en Ledger hardware lommebok for bare $79!