Golang Ethereum transfert

Avec la popularité des crypto-monnaies, Ethereum est devenu l’une des crypto-monnaies les plus populaires avec Bitcoin. Ethereum est une plate-forme dotée de puissantes capacités de contrats intelligents qui permettent aux utilisateurs d'effectuer un plus large éventail de transactions et d'interactions. Golang est un langage de programmation rapide et efficace, ce qui en fait un langage idéal pour traiter les transactions Ethereum. Cet article explique comment utiliser Golang pour écrire un programme de transfert Ethereum.

1. Installer Golang

Avant de commencer à écrire des transferts Golang Ethereum, vous devez vous assurer que Golang est installé sur votre ordinateur. Vous pouvez visiter https://golang.org/dl/ pour télécharger le programme d'installation Golang pour votre système d'exploitation.

2. Installer la bibliothèque Web3

Web3 est une bibliothèque JavaScript qui fournit une interface pour interagir avec les nœuds Ethereum. Vous pouvez l’utiliser pour envoyer des transactions Ethereum, vérifier les soldes des comptes Ethereum, et bien plus encore.

Pour utiliser la bibliothèque Web3 dans Golang, vous devez utiliser la bibliothèque golang.org/x/crypto/sha3 pour calculer les hachages associés aux transactions Ethereum. Vous pouvez installer les deux bibliothèques à l'aide des commandes suivantes :

go get -u github.com/ethereum/go-ethereum

go get -u golang.org/x/crypto/sha3

3. Connectez-vous au nœud Ethereum

Avant d'envoyer une transaction Ethereum, vous devez vous connecter à un nœud Ethereum. Un nœud Ethereum est un ordinateur exécutant la blockchain Ethereum et vous pouvez communiquer avec lui en lui envoyant des requêtes, par exemple pour envoyer des transactions, interroger la hauteur des blocs, etc.

Vous pouvez vous connecter à un nœud Ethereum via HTTP ou IPC, en fonction des paramètres du nœud Ethereum et de l'environnement dans lequel votre code s'exécute.

Dans l'exemple suivant, nous nous connecterons à un nœud public Ethereum. Vous pouvez utiliser le code suivant pour vous connecter à un nœud Ethereum :

package main

import (
    "context"
    "fmt"

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

func main() {
    client, err := ethclient.Dial("https://mainnet.infura.io")
    if err != nil {
        fmt.Println("Failed to connect to the Ethereum network: ", err)
        return
    }

    // Do something with the client...
}

Ce code se connectera au nœud public Ethereum (https://mainnet.infura.io) et renverra une instance ethclient.Client que vous pourrez utiliser avec Ethereum nœud pour interagir.

4. Créer une transaction

Avant d'envoyer une transaction à Ethereum, vous devez définir les paramètres de la transaction. Les plus importants sont :

• Adresse de l'expéditeur
• Adresse du destinataire
• Montant du transfert
• Prix du gaz
• Limite de gaz

Le gaz est une unité permettant de mesurer les coûts de calcul dans le réseau Ethereum. Le prix est le montant d’Ether que vous êtes prêt à payer par unité de Gaz. La limite est le montant maximum d’essence que vous êtes prêt à payer pour une transaction.

Vous pouvez créer une transaction en utilisant le code suivant :

// Sender and recipient addresses
fromAddress := common.HexToAddress("0xA97c32E990157aEbe7b14dD062a45C454a035B64")
toAddress := common.HexToAddress("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2")

// Amount to transfer
amount := big.NewInt(1000000000000000000) // 1 ETH

// Gas price and gas limit
gasPrice, err := client.SuggestGasPrice(context.Background())
if err != nil {
    fmt.Println("Failed to get gas price: ", err)
    return
}
gasLimit := uint64(21000)

// Nonce
nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
if err != nil {
    fmt.Println("Failed to get nonce: ", err)
    return
}

// Create transaction
tx := types.NewTransaction(
    nonce,
    toAddress,
    amount,
    gasLimit,
    gasPrice,
    nil,
)

//TODO: Sign transaction

Dans ce code, nous définissons l'adresse de l'expéditeur, l'adresse du destinataire, le montant du transfert, le prix du gaz, la limite de gaz et le Nonce (numéro de séquence de transaction).

Nous créons également une nouvelle transaction non signée (types.Transaction) qui contient les données ci-dessus. Cependant, nous devons également signer la transaction, ce qui permet aux nœuds Ethereum de vérifier qu'elle a été autorisée par l'expéditeur.

5. Transactions signées

Dans Ethereum, les transactions sont signées à l'aide d'une clé privée. La clé privée correspond à l'adresse du compte Ethereum et nous devons utiliser la clé privée de l'expéditeur pour signer la transaction.

Voici comment signer une transaction à l'aide d'une clé privée :

// Private key (32 byte slice)
privateKey := []byte{...}

// Sign transaction
signer := types.NewEIP155Signer(big.NewInt(1)) // Chain ID: 1 (Mainnet)
signedTx, err := types.SignTx(tx, signer, privateKey)
if err != nil {
    fmt.Println("Failed to sign transaction: ", err)
    return
}

Dans ce code, nous utilisons la fonction types.SignTx pour signer la transaction avec la clé privée de l'expéditeur. Nous définissons également un ID de chaîne pour ce contrat spécifique (1 représente le réseau principal Ethereum).

Vous pouvez désormais envoyer des transactions signées à l'aide de ethclient.Client :

// Send signed transaction
err = client.SendTransaction(context.Background(), signedTx)
if err != nil {
    fmt.Println("Failed to send transaction: ", err)
    return
}

fmt.Printf("Transaction sent: %s
", signedTx.Hash().Hex())

6. Exemple de code complet

package main

import (
    "context"
    "crypto/ecdsa"
    "fmt"
    "log"
    "math/big"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/crypto"
    "github.com/ethereum/go-ethereum/ethclient"
    "github.com/ethereum/go-ethereum/core/types"
)

func main() {
    client, err := ethclient.Dial("https://mainnet.infura.io")
    if err != nil {
        log.Fatalf("Failed to connect to the Ethereum network: %v", err)
    }

    // Sender and recipient addresses
    fromAddress := common.HexToAddress("0xA97c32E990157aEbe7b14dD062a45C454a035B64")
    toAddress := common.HexToAddress("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2")

    // Amount to transfer
    amount := big.NewInt(1000000000000000000) // 1 ETH

    // Gas price and gas limit
    gasPrice, err := client.SuggestGasPrice(context.Background())
    if err != nil {
        log.Fatalf("Failed to get gas price: %v", err)
    }
    gasLimit := uint64(21000)

    // Nonce
    nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
    if err != nil {
        log.Fatalf("Failed to get nonce: %v", err)
    }

    // Create transaction
    tx := types.NewTransaction(
        nonce,
        toAddress,
        amount,
        gasLimit,
        gasPrice,
        nil,
    )

    // Private key (32 byte slice)
    privateKey, err := crypto.HexToECDSA("YOUR_PRIVATE_KEY_HERE")
    if err != nil {
        log.Fatalf("Failed to get private key: %v", err)
    }

    // Sign transaction
    chainID, err := client.NetworkID(context.Background())
    if err != nil {
        log.Fatalf("Failed to get chain ID: %v", err)
    }
    signer := types.NewEIP155Signer(chainID)
    signedTx, err := types.SignTx(tx, signer, privateKey)
    if err != nil {
        log.Fatalf("Failed to sign transaction: %v", err)
    }

    // Send signed transaction
    err = client.SendTransaction(context.Background(), signedTx)
    if err != nil {
        log.Fatalf("Failed to send transaction: %v", err)
    }

    fmt.Printf("Transaction sent: %s
", signedTx.Hash().Hex())
}

Ce qui précède est l'ensemble du processus d'écriture d'un programme de transfert Ethereum à l'aide de Golang. Bien entendu, vous devez prendre en compte davantage de détails et de problèmes de sécurité, tels que la gestion des clés privées et la confirmation des transactions.

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!