In diesem Artikel konzentrieren wir uns auf die Go-Blockchain-Entwicklung von Grund auf neu. Bevor wir jedoch beginnen, sollten Sie sicher sein, dass Sie mit den grundlegenden Konzepten in Golang vertraut sind. Wenn nicht, dann ist es ratsam, wenn Sie die vorläufigen Konzepte durchgehen und dann zur Blockchain zurückkehren.
Kommen wir also direkt zum Thema.
Beginnend mit einem neuen Verzeichnis
Wir werden zunächst ein neues Verzeichnis erstellen. Nehmen wir an, dieses Verzeichnis hat den Namen „Blockchain“. Wir geben den Code in die Eingabeaufforderung ein (oder wenn Sie macOS oder Linux verwenden, müssen Sie das Terminal verwenden). Also tippen wir:
cd go-arbeitsbereich
mkdir-Blockchain
CD-Blockchain
codieren.
Wenn der VS-Code geöffnet wird, erstellen wir ein Go-Modul in der Eingabeaufforderung. Wie machen wir das? Nun, wir tippen:
Gehen Sie zu mod init github.com/golang-company/blockchain
Codierung in main.go
Als nächstes erstellen wir eine Go-Quelldatei mit dem Namen „main.go“ und geben den Code darin ein. Aber lassen Sie uns zuerst verstehen, was Blockchain ist. EIN Blockchain kann als öffentliche Datenbank definiert werden, die dezentralisiert und auf mehrere Peers verteilt ist. Blockchain ermöglicht es der Datenbank, sich selbst zu korrigieren, selbst wenn ein Knoten ungenaue Daten produziert.
Normalerweise besteht ein Block in einer Blockchain aus Daten, die wir in der Datenbank teilen, einem Hash und dem kryptografischen Hash des vorherigen Blocks.
Also, bist du bereit für Gehen Sie zur Blockchain-Entwicklung? Groß! Lass uns anfangen.
Programmierteil
In diesem Abschnitt werden wir uns die Datei main.go ansehen.
Paket main
importieren (
"Bytes"
„Krypto/sha256“
"Fmt"
)
Typ Cryptoblock-Struktur {
Hash [] Byte
Daten [] Byte
PrevHash [] Byte
}
- Wie Sie sehen können, wurde nur eine Struktur erstellt.
func (c *Kryptoblock) BuildHash() {
Details := bytes.Join([][] byte{c.Data, c.PrevHash}, []byte{})
Hash := sha256.Sum256(Details)
c.Hash = Hash[ : ]
}
- Wir werden nun eine Methode konstruieren, die es uns ermöglicht, einen Hash in Abhängigkeit von den Daten und dem vorherigen Hash zu generieren. Wir werden die „Bytes“-Bibliothek importieren, weil wir sie verwenden werden.
- Der nächste Schritt besteht darin, eine Variable namens Details zu erstellen und den Datentyp Bytes zu verwenden. Wir werden Join() verwenden, um die Byte-Slices zu verbinden.
Details := bytes.Join([][] byte{c.Data, c.PrevHash}, []byte{})
Hier nehmen wir einen 2D-Slice von Bytes, wir übertragen die c.Data und den vorherigen Hash. Dann kombinieren wir das leere Stück Bytes.
- Anschließend erstellen wir den eigentlichen Hash mithilfe der sum256-Hash-Funktion für die Details. Wir können dies verwenden, da wir die sha256-Bibliothek importieren werden.
- Als nächstes schieben wir den erstellten Hash in das Hash-Feld für den Block.
func BuildBlock (Datenstring, prevHash [] Byte) *Cryptoblock {
block := &Cryptoblock{[]byte{}, []byte(data), prevHash}
block.BuildHash()
Rückgabeblock
}
- Wir werden jetzt eine Funktion erstellen, die die Erstellung von Block ermöglicht. Die Funktion akzeptiert eine Datenzeichenfolge als Eingabe, prevHash aus dem vorherigen Block als Eingabe und gibt dann einen Verweis auf Cryptoblock aus. Wir werden den Block mit dem Blockkonstruktor erstellen.
- Der &Cryptoblock fungiert als Referenz auf den Block. Für das Hash-Feld integrieren wir ein leeres Stück Bytes. Für das Datenfeld nehmen wir die Datenzeichenfolge und konvertieren sie in einen Byte-Slice. Und wir integrieren prevHash in das PrevHash-Feld.
- Zuletzt rufen wir BuildHash() für den Block auf und geben den Block zurück.
Typ BlockChain-Struktur {
blockiert []*Kryptoblock
}
- Ein Typ, der beim Ausdrücken der Blockchain hilft, ist erforderlich. Und wir haben eine Struktur implementiert, um dies zu erreichen. Die Struktur vom Typ BlockChain besteht aus einem Array von Zeigern auf Cryptoblock.
func (Kette *BlockChain) AddBlock(Datenstring) {
prevBlock := chain.blocks[len(chain.blocks)-1]
new := BuildBlock(data, prevBlock.Hash)
chain.blocks = append(chain.blocks, neu)
}
- Hier erstellen wir eine Methode, die es uns ermöglicht, einen Block mit der Kette zu verbinden. Die Methode ruft den Blockchain-Zeiger ab. Anschließend nimmt er einen Datenstring entgegen.
- Durch den Aufruf von chain.blocks gelangen wir zum vorherigen Block in der Blockchain. Als nächstes haben wir die Länge der Blockchain übergeben [len(chain.blocks)-1].
- In der neuen Variablen rufen wir die BuildBlock-Funktion auf und übergeben die Datenzeichenfolge und prevBlock.Hash.
- Indem wir die Append-Funktion verwenden und dies zu den chain.blocks hinzufügen, fügen wir dann den neuen Block an die Blockchain an.
func Inception() *Cryptoblock {
return BuildBlock("Inception", []byte{})
}
- Der nächste Schritt besteht darin, eine Funktion namens Inception zu erstellen, die den ersten Block der Blockchain beschreibt. Und wir werden einen neuen BuildBlock in der Funktion zusammen mit den Daten im ersten Block zurückgeben. Hier. Ich habe „Inception“ und einen Byte-Slice eingebaut, der einen leeren vorherigen Hash darstellt.
func InitBlockChain() *BlockChain {
return &BlockChain{[]*Cryptoblock{Inception()}}
}
- Um die erste Blockchain zu erstellen, habe ich die InitBlockChain-Funktion eingeführt. Hier gebe ich nur den speziellen Verweis auf die Blockchain zurück. Als nächstes erstellen wir ein Array von Cryptoblock, in dem wir die Inception-Funktion aufrufen.
func main () {
Kette := InitBlockChain()
chain.AddBlock ("Erster Block nach Beginn")
chain.AddBlock ("Zweiter Block nach Beginn")
chain.AddBlock ("Dritter Block nach Beginn")
für _, block := range chain.blocks {
fmt.Printf(“Vorheriger Hash: %x\n”, block.PrevHash)
fmt.Printf(“Daten im Block: %s\n”, Block.Daten)
fmt.Printf(“Hash: %x\n”, block.Hash)
}
}
- Endlich sind wir bei der Hauptfunktion angelangt. Wie Sie sehen können, haben wir InitBlockChain() aufgerufen und der Chain-Variablen zugewiesen.
- Als nächstes fügen wir der Kette über chain.AddBlock Blöcke hinzu und übergeben die erforderlichen Daten.
- Anschließend führen wir eine for-Schleife aus, um nach der Blockchain zu suchen. Dann heben wir jeden Block heraus und drucken die Felder innerhalb jedes Blocks. Wir tippen einfach:
fmt.Printf(“Vorheriger Hash: %x\n”, block.PrevHash)
fmt.Printf(“Daten im Block: %s\n”, Block.Daten)
fmt.Printf(“Hash: %x\n”, block.Hash)
Ausgang:
Wir können also sagen, dass das Programm erfolgreich ist. Ich hoffe, Sie konnten die Implementierung des Blockchain-Konzepts in Golang verstehen. Üben Sie einfach weiter und Sie werden in der Lage sein, komplizierte Projekte zu bewältigen.
Ihre Kryptowährung verdient die beste Sicherheit. Holen Sie sich ein Ledger Hardware-Wallet für nur 79 $!
Quelle: https://coinfomania.com/build-a-blockchain-in-golang/