Golang Ethereum

Golang Ethereum : Comment utiliser Go pour rédiger des contrats intelligents

La popularité de la technologie blockchain a apporté de grands changements dans la vie et l'économie, parmi lesquels Ethereum est l'une des plates-formes blockchain publiques distribuées open source qui permet aux développeurs d'utiliser des contrats intelligents pour mettre en œuvre des actifs numériques programmables. Contrairement à d'autres langages de programmation courants, Golang rend le développement de contrats intelligents plus simple et plus sûr, tout en offrant une efficacité d'exécution et une concurrence plus élevées. Dans cet article, nous explorerons comment rédiger des contrats intelligents à l'aide de Golang.

Introduction à Ethereum

Ethereum est une plate-forme de blockchain publique décentralisée, open source, dotée de capacités de contrat intelligent et d'applications distribuées (DApp). Les contrats intelligents sont des contrats auto-exécutables qui sont écrits sur la base du code et peuvent être déployés et exécutés sur le réseau Ethereum. En même temps, ils peuvent réaliser le transfert, le stockage de données et les opérations logiques complexes d'Ethereum, faisant d'Ethereum un leader de la blockchain. développement.

Golang est un langage de programmation très populaire également connu sous le nom de Go. Développé en 2009 par Robert Griesemer, Rob Pike et Ken Thompson chez Google, il s'agit d'un langage de programmation utilisé pour créer des réseaux et des systèmes distribués hautes performances. Par rapport aux langages de programmation traditionnels, Go offre une simplicité, une sécurité et des performances supérieures, et prend en charge la concurrence, il est donc également largement utilisé dans le domaine de la blockchain.

Installer et configurer Golang

Avant de commencer, nous devons installer et configurer l'environnement Golang. Vous pouvez télécharger la dernière version du programme d'installation de Golang sur le site officiel et suivre les instructions pour l'installer. Une fois terminé, vous pouvez vérifier si l'installation a réussi dans le terminal :

go version

Si l'installation est réussie, la version Go s'affichera.

Rédaction de contrats intelligents

Prenons maintenant un simple contrat intelligent comme exemple pour illustrer comment utiliser Golang pour rédiger des contrats intelligents.

Tout d'abord, nous créons un projet go-ethereum et pouvons exécuter la commande suivante dans le terminal :

mkdir go-ethereum
cd go-ethereum

Ensuite, nous initialisons le projet à l'aide du module go :

go mod init go-ethereum

Ensuite, nous devons ajouter des dépendances pour prendre en charge le développement des contrats intelligents d'Ethereum. . Nous utilisons ici le package go-ethereum, qui est une implémentation du langage Go développée par l'équipe Ethereum et fournit un support API riche pour le développement de contrats intelligents.

go get github.com/ethereum/go-ethereum

Dans le répertoire du projet, nous créons un contrat intelligent Solidity (MyContract.sol) comme indiqué ci-dessous :

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract MyContract {
    uint256 value;

    function setValue(uint256 _value) public {
        value = _value;
    }

    function getValue() public view returns (uint256) {
        return value;
    }
}

En haut, nous ajoutons l'annotation SPDX-License-Identifier au contrat pour spécifier la licence. Ensuite, nous déclarons le contrat MyContract et ajoutons une variable d'état appelée valeur. Nous définissons deux fonctions publiques, setValue et getValue. La première définit la valeur de value sur _value et la seconde renvoie la valeur de la valeur actuelle.

Ensuite, nous utilisons la commande suivante pour générer la liaison Go pour le contrat intelligent Solidity dans le répertoire du projet :

abigen --sol MyContract.sol --pkg bindings --out MyContract.go

L'option --pkg spécifie le nom du package du code Go généré, --out spécifie le fichier de sortie de le nom de code Go généré. La commande abigen utilise le fichier source MyContract.sol du contrat intelligent Solidity pour générer le code de liaison Go MyContract.go.

Maintenant, nous créons un fichier Go (main.go) à l'aide de la commande suivante et y ajoutons le contenu suivant :

package main

import (
    "context"
    "fmt"
    "math/big"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/ethclient"

    "./bindings"
)

func main() {
    client, err := ethclient.Dial("https://mainnet.infura.io")
    if err != nil {
        panic(err)
    }

    contractAddress := common.HexToAddress("0x06857768a9b56c860c89effbeb8ce6c6a46940ef")
    instance, err := bindings.NewMyContract(contractAddress, client)
    if err != nil {
        panic(err)
    }

    value, err := instance.GetValue(&bind.CallOpts{})
    if err != nil {
        panic(err)
    }
    fmt.Println("Value:", value)

    tx, err := instance.SetValue(&bind.TransactOpts{
        From:     common.HexToAddress("0x8c51b77048b5A9A1bcc30158b4859Af247bAd2b0"),
        GasLimit: uint64(200000),
        GasPrice: big.NewInt(20000000000),
    }, big.NewInt(10))
    if err != nil {
        panic(err)
    }
    fmt.Println("Tx Hash:", tx.Hash().Hex())
}

En haut, nous avons importé quelques dépendances dont le package go-ethereum et celui que nous avons généré en utilisant l'outil abigen Le package MyContract, ainsi que plusieurs packages de bibliothèques standards. Nous créons une fonction principale pour démarrer notre application.

Dans la fonction principale, nous utilisons la méthode ethclient.Dial pour nous connecter au réseau Ethereum, en spécifiant le nœud https://mainnet.infura.io fourni par Infura. Instanciez MyContract et spécifiez l’adresse du contrat et le client. Nous appelons la fonction GetValue pour obtenir la valeur actuelle et imprimer le résultat sur la console.

Ensuite, nous appelons la fonction SetValue pour définir la valeur sur 10 et spécifier la limite de gaz et le prix du gaz. Enfin, nous imprimons le hachage de la transaction.

Maintenant, nous pouvons compiler et exécuter notre programme à l'aide de la commande suivante :

go build
./go-ethereum

L'application se connectera au réseau Ethereum et utilisera les méthodes setValue et getValue du contrat MyContract pour définir et obtenir la valeur de value.

Résumé

Dans cet article, nous avons appris à rédiger des contrats intelligents Ethereum à l'aide de Golang et avons démontré comment utiliser l'outil abigen pour générer du code de liaison Go pour les contrats intelligents Solidity. Nous utilisons également le package go-ethereum, qui fournit un support API riche pour faciliter la rédaction de contrats intelligents. La combinaison de Golang et Ethereum apporte de nouvelles possibilités au développement d'applications distribuées, permettant aux développeurs de créer plus facilement des applications décentralisées et de mettre en œuvre des actifs numériques programmables sur le réseau Ethereum.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!