golang Ethereum-Transfer-Golang-php.cn

Mit der Popularität von Kryptowährungen ist Ethereum neben Bitcoin zu einer der beliebtesten Kryptowährungen geworden. Ethereum ist eine Plattform mit leistungsstarken Smart-Contract-Funktionen, die es Benutzern ermöglicht, ein breiteres Spektrum an Transaktionen und Interaktionen durchzuführen. Golang ist eine schnelle und leistungseffiziente Programmiersprache, was sie zu einer idealen Sprache für die Verarbeitung von Ethereum-Transaktionen macht. In diesem Artikel wird erläutert, wie Sie mit Golang ein Ethereum-Transferprogramm schreiben.

Golang installieren

Bevor Sie mit dem Schreiben von Golang Ethereum-Überweisungen beginnen, müssen Sie sicherstellen, dass Golang auf Ihrem Computer installiert ist. Sie können https://golang.org/dl/ besuchen, um das Golang-Installationsprogramm für Ihr Betriebssystem herunterzuladen.

Installieren Sie die Web3-Bibliothek

Web3 ist eine JavaScript-Bibliothek, die eine Schnittstelle für die Interaktion mit Ethereum-Knoten bereitstellt. Sie können damit Ethereum-Transaktionen senden, den Kontostand von Ethereum überprüfen und vieles mehr.

Um die Web3-Bibliothek in Golang zu verwenden, müssen Sie die Bibliothek golang.org/x/crypto/sha3 verwenden, um Hashes zu berechnen, die mit Ethereum-Transaktionen verbunden sind. Sie können beide Bibliotheken mit dem folgenden Befehl installieren:

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

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

Nach dem Login kopieren

Mit Ethereum-Knoten verbinden

Bevor Sie eine Ethereum-Transaktion senden, müssen Sie eine Verbindung zu einem Ethereum-Knoten herstellen. Ein Ethereum-Knoten ist ein Computer, auf dem die Ethereum-Blockchain läuft, und Sie können mit ihm kommunizieren, indem Sie Anfragen an ihn senden, beispielsweise um Transaktionen zu senden, Blockhöhen abzufragen usw.

Sie können über HTTP oder IPC eine Verbindung zu einem Ethereum-Knoten herstellen, abhängig von den Einstellungen des Ethereum-Knotens und der Umgebung, in der Ihr Code ausgeführt wird.

Im folgenden Beispiel stellen wir eine Verbindung zu einem öffentlichen Ethereum-Knoten her. Sie können den folgenden Code verwenden, um eine Verbindung zu einem Ethereum-Knoten herzustellen:

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...
}

Nach dem Login kopieren

Dieser Code stellt eine Verbindung zum öffentlichen Ethereum-Knoten (https://mainnet.infura.io) her und gibt eine ethclient.Client-Instanz zurück, die Sie mit Ethereum verwenden können Knoten zur Interaktion.

Transaktion erstellen

Bevor Sie eine Transaktion an Ethereum senden, müssen Sie die Transaktionsparameter festlegen. Die wichtigsten sind:

Absenderadresse
Empfängeradresse
Überweisungsbetrag
Gaspreis
Gaslimit

Gas ist eine Einheit zur Messung der Rechenkosten im Ethereum-Netzwerk. Der Preis ist die Menge an Ether, die Sie pro Gaseinheit zu zahlen bereit sind. Das Limit ist die maximale Menge an Benzin, die Sie bereit sind, für eine Transaktion zu zahlen.

Sie können eine Transaktion mit dem folgenden Code erstellen:

// 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

Nach dem Login kopieren

In diesem Code legen wir die Absenderadresse, die Empfängeradresse, den Überweisungsbetrag, den Gaspreis, das Gaslimit und die Nonce (Transaktionssequenznummer) fest.

Wir erstellen außerdem eine neue nicht signierte Transaktion (types.Transaction), die die oben genannten Daten enthält. Allerdings müssen wir die Transaktion auch signieren, damit Ethereum-Knoten überprüfen können, ob sie vom Absender autorisiert wurde.

Signierte Transaktionen

In Ethereum werden Transaktionen mit einem privaten Schlüssel signiert. Der private Schlüssel entspricht der Ethereum-Kontoadresse und wir müssen die Transaktion mit dem privaten Schlüssel des Absenders signieren.

So signieren Sie eine Transaktion mit einem privaten Schlüssel:

// 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
}

Nach dem Login kopieren

In diesem Code verwenden wir die Funktion „types.SignTx“, um die Transaktion zusammen mit dem privaten Schlüssel des Absenders zu signieren. Wir legen auch eine Ketten-ID für diesen spezifischen Vertrag fest (1 steht für das Ethereum-Hauptnetz).

Sie können jetzt signierte Transaktionen mit ethclient.Client senden:

// 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())

Nach dem Login kopieren

Vollständiges Codebeispiel

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())
}

Nach dem Login kopieren

Das Obige zeigt den gesamten Prozess des Schreibens eines Ethereum-Übertragungsprogramms mit Golang. Natürlich gibt es noch weitere Details und Sicherheitsaspekte, die Sie berücksichtigen müssen, wie z. B. die Verwaltung privater Schlüssel und die Transaktionsbestätigung.

Das obige ist der detaillierte Inhalt vongolang Ethereum-Transfer. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!