Dans cet article, nous nous concentrerons sur le développement de la blockchain Go à partir de zéro. Cependant, avant de commencer, vous devez vous assurer que vous connaissez les concepts de base de Golang. Si ce n'est pas le cas, il est sage de passer par les concepts préliminaires et de revenir ensuite à la blockchain.
Alors, passons directement au sujet.
Commencer avec un nouveau répertoire
Nous allons créer un nouveau répertoire pour commencer. Supposons que ce répertoire porte le nom de "blockchain". Nous allons taper le code dans l'invite de commande (ou si vous utilisez macOS ou Linux, vous devez utiliser le terminal). Ainsi, on tape :
cd go-espace de travail
blockchain mkdir
chaîne de blocs cd
code.
Au fur et à mesure que le code VS s'ouvre, nous allons créer un module Go dans l'invite de commande. Comment procédons-nous ? Eh bien, nous tapons:
aller mod init github.com/golang-company/blockchain
Codage dans main.go
Ensuite, nous allons créer un fichier source Go nommé 'main.go' et nous y saisirons le code. Mais d'abord, comprenons ce qu'est la blockchain. UN blockchain peut être défini comme une base de données publique décentralisée et distribuée entre plusieurs pairs. La blockchain permet à la base de données de s'auto-corriger, même si un nœud produit des données inexactes.
Habituellement, un bloc sur une blockchain se compose de données que nous partageons dans la base de données, d'un hachage et du hachage cryptographique du bloc précédent.
Alors, êtes-vous prêt pour Allez au développement de la blockchain? Super! Commençons.
Partie programmation
Dans cette section, nous examinerons le fichier main.go.
paquet principal
importer (
"octets"
"crypto/sha256"
"Fmt"
)
type Structure de bloc de chiffrement {
Hachage [] octet
Données [] octet
PrécHash [] octet
}
- Comme vous pouvez le voir, une structure a seulement été créée.
func (c *Cryptoblock) ConstruireHash() {
détails := bytes.Join([][] byte{c.Data, c.PrevHash}, []byte{})
hachage := sha256.Sum256(détails)
c.Hachage = hachage[ : ]
}
- Nous allons maintenant construire une méthode qui va nous permettre de générer un hash en fonction des données et du hash précédent. Nous allons importer la bibliothèque "bytes" car nous allons l'utiliser.
- L'étape suivante consiste à créer une variable appelée details et à utiliser le type de données bytes. Nous utiliserons Join() pour connecter les tranches d'octets.
détails := bytes.Join([][] byte{c.Data, c.PrevHash}, []byte{})
Ici, nous prenons une tranche 2D d'octets, nous transmettons le c.Data et le hash précédent. Ensuite, nous combinerons la tranche vide d'octets.
- Suite à cela, nous créons le hachage réel en nous aidant de la fonction de hachage sum256 sur les détails. Nous pouvons l'utiliser car nous allons importer la bibliothèque sha256.
- Ensuite, nous poussons le hachage créé dans le champ Hash du bloc.
func BuildBlock (chaîne de données, prevHash [] octet) *Cryptoblock {
block := &Cryptoblock{[]octet{}, []octet(données), prevHash}
bloc.BuildHash()
bloc de retour
}
- Nous allons maintenant construire une fonction qui permet la création de Block. La fonction accepte une chaîne de données en entrée, prevHash du bloc précédent en entrée, puis génère une référence à Cryptoblock. Nous allons construire le bloc en utilisant le constructeur de bloc.
- Le &Cryptoblock agit comme la référence au bloc. Pour le champ Hash, nous incorporons une tranche vide d'octets. Pour le champ Données, nous prenons la chaîne de données et la convertissons en tranche d'octets. Et nous incorporons prevHash dans le champ PrevHash.
- Enfin, nous appelons le BuildHash () sur le bloc et nous renvoyons le bloc.
tapez la structure BlockChain {
blocs []*Cryptobloc
}
- Un type qui aidera à exprimer la blockchain est requis. Et nous avons implémenté une structure pour y parvenir. La structure de type BlockChain est composée d'un tableau de pointeurs vers Cryptoblock.
func (chaîne *BlockChain) AddBlock(chaîne de données) {
prevBlock := chain.blocks[len(chain.blocks)-1]
new := BuildBlock(données, prevBlock.Hash)
chain.blocks = ajouter(chain.blocks, nouveau)
}
- Ici, nous créons une méthode permettant de joindre un bloc à la chaîne. La méthode récupère le pointeur blockchain. Ensuite, il accepte une chaîne de données.
- En appelant chain.blocks, nous arrivons au bloc précédent dans la blockchain. Ensuite, nous avons passé la longueur de la blockchain [len(chain.blocks)-1].
- Dans la nouvelle variable, nous appelons la fonction BuildBlock et nous transmettons la chaîne de données et prevBlock.Hash.
- En utilisant la fonction append, en l'ajoutant à chain.blocks, nous attachons ensuite le nouveau bloc à la blockchain.
func Inception() *Cryptobloc {
return BuildBlock("Inception", []byte{})
}
- L'étape suivante consiste à créer une fonction appelée Inception qui décrira le premier bloc de la blockchain. Et nous renverrons un nouveau BuildBlock dans la fonction, ainsi que les données du premier bloc. Ici. J'ai incorporé "Inception" et une tranche d'octets qui représente un hachage précédent vide.
func InitBlockChain() *BlockChain {
retourner &BlockChain{[]*Cryptoblock{Inception()}}
}
- Afin de créer la première blockchain, j'ai introduit la fonction InitBlockChain. Ici, je ne fais que renvoyer la référence particulière à la BlockChain. Ensuite, nous construisons un tableau de Cryptoblock, où nous appelons la fonction Inception.
func main () {
chaine := InitBlockChain()
chain.AddBlock("Premier bloc après la création")
chain.AddBlock("Deuxième bloc après la création")
chain.AddBlock("Troisième bloc après la création")
pour _, block := range chain.blocks {
fmt.Printf("Hash précédent : %x\n", block.PrevHash)
fmt.Printf("Données dans le bloc : %s\n", bloc.Données)
fmt.Printf("Hash : %x\n", block.Hash)
}
}
- Enfin, nous sommes arrivés à la fonction principale. Comme vous pouvez le voir, nous avons appelé InitBlockChain() et nous l'avons affecté à la variable de chaîne.
- Ensuite, nous ajoutons des blocs à la chaîne via chain.AddBlock, et nous transmettons les données nécessaires.
- Ensuite, nous exécutons une boucle for pour vérifier la blockchain. Ensuite, nous distinguons chaque bloc et imprimons les champs à l'intérieur de chaque bloc. On tape juste :
fmt.Printf("Hash précédent : %x\n", block.PrevHash)
fmt.Printf("Données dans le bloc : %s\n", bloc.Données)
fmt.Printf("Hash : %x\n", block.Hash)
Sortie :
Donc, on peut dire que le programme est un succès. J'espère que vous avez pu comprendre la mise en œuvre du concept de blockchain dans Golang. Continuez simplement à vous entraîner et vous serez en mesure de gérer des projets complexes.
Votre crypto mérite la meilleure sécurité. Obtenir un Portefeuille matériel Ledger pour seulement 79 $!
Source : https://coinfomania.com/build-a-blockchain-in-golang/