I denne artikel vil vi fokusere på Go blockchain-udvikling fra bunden. Inden vi går i gang, skal du dog være sikker på, at du er fortrolig med de grundlæggende begreber i Golang. Hvis ikke, så er det klogt, hvis du gennemgår de foreløbige koncepter og derefter vender tilbage til blockchain.
Så lad os komme direkte til emnet.
Starter med en ny mappe
Vi vil bygge en ny mappe til at begynde med. Lad os antage, at denne mappe har navnet "blockchain." Vi skriver koden i kommandoprompten (eller hvis du bruger macOS eller Linux, skal du bruge terminalen). Derfor skriver vi:
cd go-workspace
mkdir blockchain
cd blockchain
kode.
Når VS-koden åbner, vil vi oprette et Go-modul i kommandoprompten. Hvordan gør vi det? Nå, vi skriver:
go mod init github.com/golang-company/blockchain
Kodning i main.go
Dernæst vil vi oprette en Go-kildefil med navnet 'main.go', og vi skriver koden i den. Men lad os først forstå, hvad blockchain er. EN blockchain kan defineres som en offentlig database, der er decentraliseret og fordelt på flere peers. Blockchain tillader databasen at selvkorrigere, selvom en node producerer unøjagtige data.
Normalt består en blok på en blockchain af data, vi deler i databasen, en hash og den foregående bloks kryptografiske hash.
Så er du klar til Gå til blockchain-udvikling? Store! Lad os komme igang.
Programmeringsdel
I dette afsnit vil vi se på main.go-filen.
pakke vigtigste
import (
"bytes"
"crypto/sha256"
"fmt"
)
type Cryptoblock struct {
Hash [] byte
Data [] byte
PrevHash [] byte
}
- Som du kan se, er der kun oprettet en struktur.
func (c *Cryptoblock) BuildHash() {
detaljer := bytes.Join([][] byte{c.Data, c.PrevHash}, []byte{})
hash := sha256.Sum256(detaljer)
c.Hash = hash[ : ]
}
- Vi vil nu konstruere en metode, der gør os i stand til at generere en hash afhængig af dataene og den tidligere hash. Vi importerer "bytes"-biblioteket, fordi vi vil bruge det.
- Det næste trin er at oprette en variabel kaldet detaljer og bruge datatypen bytes. Vi vil bruge Join() til at forbinde skiverne af bytes.
detaljer := bytes.Join([][] byte{c.Data, c.PrevHash}, []byte{})
Her tager vi et 2D-stykke af bytes, vi transmitterer c.Data og den forrige hash. Så vil vi kombinere det tomme stykke bytes.
- Efter dette opretter vi den faktiske hash ved hjælp af sum256-hash-funktionen på detaljerne. Vi kan bruge dette, da vi importerer sha256-biblioteket.
- Dernæst skubber vi den oprettede hash ind i Hash-feltet for blokken.
func BuildBlock (datastreng, prevHash [] byte) *Cryptoblock {
blok := &Cryptoblok{[]byte{}, []byte(data), prevHash}
block.BuildHash()
returblok
}
- Vi vil nu bygge en funktion, der muliggør oprettelsen af Block. Funktionen accepterer en streng af data som input, prevHash fra den forrige blok som input og udsender derefter en reference til Cryptoblock. Vi bygger blokken ved hjælp af blokkonstruktøren.
- &Cryptoblokken fungerer som reference til blokken. For Hash-feltet inkorporerer vi et tomt stykke bytes. For datafelt tager vi datastrengen og konverterer den til udsnit af bytes. Og vi inkorporerer prevHash i PrevHash-feltet.
- Til sidst kalder vi BuildHash() på blokken, og vi returnerer blokken.
type BlockChain struct {
blokerer []*Kryptoblok
}
- En type, der vil hjælpe med at udtrykke blockchain, er påkrævet. Og vi implementerede en struktur for at opnå dette. Typen BlockChain struct består af en række pointere til Cryptoblock.
func (kæde *BlockChain) AddBlock(datastreng) {
prevBlock := chain.blocks[len(chain.blocks)-1]
new := BuildBlock(data, prevBlock.Hash)
chain.blocks = append(chain.blocks, new)
}
- Her skaber vi en metode, der gør os i stand til at forbinde en blok til kæden. Metoden henter blockchain-pointeren. Efter dette accepterer den en datastreng.
- Ved at kalde chain.blocks kommer vi til den forrige blok i blockchainen. Dernæst passerede vi længden af blockchain [len(chain.blocks)-1].
- I den nye variabel kalder vi BuildBlock-funktionen, og vi sender datastreng og prevBlock.Hash.
- Ved at bruge append-funktionen, tilføje denne til chain.blocks, vedhæfter vi så den nye blok til blockchain.
func Inception() *Cryptoblock {
returner BuildBlock(“Inception”, []byte{})
}
- Næste trin er at lave en funktion kaldet Inception, der vil beskrive blockchains første blok. Og vi vil returnere en ny BuildBlock i funktionen sammen med dataene i den første blok. Her. Jeg har inkorporeret "Inception" og et udsnit af bytes, som repræsenterer en tom tidligere hash.
func InitBlockChain() *BlockChain {
returner &BlockChain{[]*Cryptoblock{Inception()}}
}
- For at skabe den første blockchain har jeg introduceret InitBlockChain-funktionen. Her returnerer jeg bare den særlige reference til BlockChain. Dernæst bygger vi et array af Cryptoblock, hvor vi foretager et opkald til Inception-funktionen.
func main () {
kæde := InitBlockChain()
chain.AddBlock(“Første blok efter start”)
chain.AddBlock(“Anden blok efter start”)
chain.AddBlock(“Tredje blok efter start”)
for _, blok := range chain.blocks {
fmt.Printf(“Forrige Hash: %x\n”, blok.PrevHash)
fmt.Printf(“Data i blok: %s\n”, blok.Data)
fmt.Printf(“Hash: %x\n”, blok.Hash)
}
}
- Endelig er vi nået frem til hovedfunktionen. Som du kan se, har vi kaldt InitBlockChain(), og vi har tildelt den til kædevariablen.
- Dernæst tilføjer vi blokke til kæden via chain.AddBlock, og vi videregiver de nødvendige data.
- Efter dette kører vi en for-løkke for at tjekke for blockchain. Derefter udskiller vi hver blok og udskriver felterne inde i hver blok. Vi skriver bare:
fmt.Printf(“Forrige Hash: %x\n”, blok.PrevHash)
fmt.Printf(“Data i blok: %s\n”, blok.Data)
fmt.Printf(“Hash: %x\n”, blok.Hash)
Output:
Så vi kan sige, at programmet er vellykket. Jeg håber, du var i stand til at forstå implementeringen af begrebet blockchain i Golang. Bare fortsæt med at øve dig, og du vil være i stand til at håndtere indviklede projekter.
Din krypto fortjener den bedste sikkerhed. Få en Ledger hardware pung for kun $79!
Kilde: https://coinfomania.com/build-a-blockchain-in-golang/