In dit artikel zullen we ons vanaf het begin concentreren op de ontwikkeling van de Go-blockchain. Voordat we echter aan de slag gaan, moet u er zeker van zijn dat u bekend bent met de basisconcepten in Golang. Zo niet, dan is het verstandig als je de voorlopige concepten doorloopt en dan terugkomt op blockchain.
Dus laten we meteen naar het onderwerp gaan.
Beginnen met een nieuwe directory
We zullen om te beginnen een nieuwe directory bouwen. Laten we aannemen dat deze map de naam "blockchain" heeft. We typen de code in de opdrachtprompt (of als je macOS of Linux gebruikt, moet je de terminal gebruiken). Zo typen we:
cd go-werkruimte
mkdir-blockchain
cd-blockchain
code.
Terwijl de VS-code wordt geopend, maken we een Go-module in de opdrachtprompt. Hoe doen we dat? Nou, we typen:
ga mod init github.com/golang-company/blockchain
Coderen in main.go
Vervolgens maken we een Go-bronbestand met de naam 'main.go' en typen we de code erin. Maar laten we eerst begrijpen wat blockchain is. EEN blockchain kan worden gedefinieerd als een openbare database die is gedecentraliseerd en verspreid over verschillende peers. Blockchain stelt de database in staat zichzelf te corrigeren, zelfs als een knooppunt onnauwkeurige gegevens produceert.
Gewoonlijk bestaat een blok op een blockchain uit gegevens die we delen in de database, een hash en de cryptografische hash van het vorige blok.
Dus, ben je er klaar voor Ga voor blockchain-ontwikkeling? Super goed! Laten we beginnen.
Programmeeronderdeel
In deze sectie zullen we het bestand main.go bekijken.
pakket belangrijkste
importeren (
"bytes"
"crypto/sha256"
"fmt"
)
typ Cryptoblock-structuur {
Hash[]-byte
Gegevens [] byte
VorigeHash [] byte
}
- Zoals je kunt zien, is er alleen een structuur gemaakt.
func (c *Cryptoblock) BuildHash() {
details := bytes.Join([][] byte{c.Data, c.PrevHash}, []byte{})
hasj := sha256.Sum256(details)
c.Hash = hash[: ]
}
- We zullen nu een methode construeren waarmee we een hash kunnen genereren, afhankelijk van de gegevens en de vorige hash. We zullen de "bytes" -bibliotheek importeren omdat we deze gaan gebruiken.
- De volgende stap is om een variabele met de naam details te maken en het gegevenstype bytes te gebruiken. We zullen Join() gebruiken om de segmenten van bytes te verbinden.
details := bytes.Join([][] byte{c.Data, c.PrevHash}, []byte{})
Hier nemen we een 2D-stukje bytes, we verzenden de c.Data en de vorige hash. Vervolgens combineren we het lege stuk bytes.
- Hierna creëren we de eigenlijke hash met behulp van de sum256 hashing-functie op de details. We kunnen dit gebruiken omdat we de sha256-bibliotheek zullen importeren.
- Vervolgens duwen we de gemaakte hash in het hash-veld voor het blok.
func BuildBlock (gegevensreeks, prevHash [] byte) *Cryptoblock {
block := &Cryptoblock{[]byte{}, []byte(data), prevHash}
blok.BuildHash()
retourblok
}
- We zullen nu een functie bouwen die het maken van Block mogelijk maakt. De functie accepteert een reeks gegevens als invoer, prevHash van het vorige blok als invoer en voert vervolgens een verwijzing naar Cryptoblock uit. We zullen het blok bouwen met behulp van de blokconstructor.
- Het &Cryptoblok fungeert als referentie naar het blok. Voor het hash-veld nemen we een leeg stukje bytes op. Voor het gegevensveld nemen we de gegevensreeks en zetten deze om in bytes. En we nemen prevHash op in het PrevHash-veld.
- Ten slotte noemen we de BuildHash() op het blok en geven we het blok terug.
type BlockChain-structuur {
blokken []*Cryptoblok
}
- Een type dat helpt bij het uitdrukken van de blockchain is vereist. En we hebben een structuur geïmplementeerd om dit te bereiken. Het type BlockChain-struct bestaat uit een reeks verwijzingen naar Cryptoblock.
func (keten *BlockChain) AddBlock(gegevensreeks) {
prevBlock := chain.blocks[len(chain.blocks)-1]
nieuw := BuildBlock(data, prevBlock.Hash)
chain.blocks = append(chain.blocks, nieuw)
}
- Hier creëren we een methode waarmee we een blok aan de keten kunnen koppelen. De methode haalt de blockchain-pointer op. Hierna accepteert het een gegevensreeks.
- Door chain.blocks aan te roepen, komen we bij het vorige blok in de blockchain. Vervolgens passeerden we de lengte van de blockchain [len(chain.blocks)-1].
- In de nieuwe variabele roepen we de BuildBlock-functie aan en geven we datastring en prevBlock.Hash door.
- Door de append-functie te gebruiken en deze toe te voegen aan de chain.blocks, koppelen we het nieuwe blok aan de blockchain.
func Inception() *Cryptoblok {
return BuildBlock(“Begin”, []byte{})
}
- De volgende stap is het creëren van een functie genaamd Inception die het eerste blok van de blockchain beschrijft. En we zullen een nieuw BuildBlock in de functie retourneren, samen met de gegevens in het eerste blok. Hier. Ik heb "Inception" en een stukje bytes opgenomen dat een lege vorige hash vertegenwoordigt.
func InitBlockChain() *BlockChain {
return &BlockChain{[]*Cryptoblock{Inception()}}
}
- Om de eerste blockchain te maken, heb ik de InitBlockChain-functie geïntroduceerd. Hier stuur ik alleen de specifieke verwijzing naar de BlockChain terug. Vervolgens bouwen we een array van Cryptoblock, waar we een aanroep doen naar de Inception-functie.
fun hoofd() {
keten := InitBlockChain()
chain.AddBlock ("Eerste blok na aanvang")
chain.AddBlock ("Tweede blok na aanvang")
chain.AddBlock ("Derde blok na aanvang")
voor _, blok := bereik chain.blocks {
fmt.Printf(“Vorige hash: %x\n”, block.PrevHash)
fmt.Printf ("Gegevens in blok: %s\n", blok.Data)
fmt.Printf(“Hash: %x\n”, blok.Hash)
}
}
- Eindelijk zijn we bij de hoofdfunctie aangekomen. Zoals je kunt zien, hebben we de InitBlockChain() aangeroepen en hebben we deze toegewezen aan de chain-variabele.
- Vervolgens voegen we blokken toe aan de keten via chain.AddBlock, en we geven de benodigde gegevens door.
- Hierna voeren we een for-lus uit om te controleren op de blockchain. Vervolgens selecteren we elk blok en drukken we de velden in elk blok af. We typen gewoon:
fmt.Printf(“Vorige hash: %x\n”, block.PrevHash)
fmt.Printf ("Gegevens in blok: %s\n", blok.Data)
fmt.Printf(“Hash: %x\n”, blok.Hash)
Output:
We kunnen dus zeggen dat het programma succesvol is. Ik hoop dat je de implementatie van het concept van blockchain in Golang hebt kunnen begrijpen. Blijf gewoon oefenen en je zult in staat zijn om ingewikkelde projecten aan te pakken.
Uw crypto verdient de beste beveiliging. Krijg een Ledger hardware wallet voor slechts $79!
Bron: https://coinfomania.com/build-a-blockchain-in-golang/