pemindahan Ethereum golang

Dengan populariti mata wang kripto, Ethereum telah menjadi salah satu mata wang kripto paling popular selain Bitcoin. Ethereum ialah platform dengan keupayaan kontrak pintar yang berkuasa yang membolehkan pengguna menjalankan rangkaian transaksi dan interaksi yang lebih luas. Golang ialah bahasa pengaturcaraan yang pantas dan cekap prestasi, yang menjadikannya bahasa yang ideal untuk memproses transaksi Ethereum. Artikel ini akan memperkenalkan cara menggunakan Golang untuk menulis program pemindahan Ethereum.

1. Pasang Golang

Sebelum anda mula menulis pemindahan Golang Ethereum, anda perlu memastikan bahawa Golang dipasang pada komputer anda. Anda boleh melawati https://golang.org/dl/ untuk memuat turun pemasang Golang untuk sistem pengendalian anda.

2. Pasang perpustakaan Web3

Web3 ialah perpustakaan JavaScript yang menyediakan antara muka untuk berinteraksi dengan nod Ethereum. Anda boleh menggunakannya untuk menghantar transaksi Ethereum, menyemak baki akaun Ethereum dan banyak lagi.

Untuk menggunakan perpustakaan Web3 di Golang, anda perlu menggunakan perpustakaan golang.org/x/crypto/sha3 untuk mengira cincangan yang dikaitkan dengan transaksi Ethereum. Anda boleh memasang kedua-dua perpustakaan menggunakan arahan berikut:

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

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

3. Sambung ke Nod Ethereum

Sebelum menghantar transaksi Ethereum, anda perlu menyambung ke nod Ethereum. Nod Ethereum ialah komputer yang menjalankan blockchain Ethereum dan anda boleh berkomunikasi dengannya dengan menghantar permintaan kepadanya, contohnya, untuk menghantar transaksi, ketinggian blok pertanyaan, dsb.

Anda boleh menyambung ke nod Ethereum melalui HTTP atau IPC, bergantung pada tetapan nod Ethereum dan persekitaran berjalan kod anda.

Dalam contoh berikut, kami akan menyambung ke nod awam Ethereum. Anda boleh menggunakan kod berikut untuk menyambung ke nod 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...
}

Kod ini akan bersambung ke nod awam Ethereum (https://mainnet.infura.io) dan mengembalikan contoh ethclient.Client yang anda boleh gunakan Berinteraksi dengan nod Ethereum.

4. Buat Transaksi

Sebelum menghantar transaksi ke Ethereum, anda perlu menetapkan parameter transaksi. Yang paling penting ialah:

• Alamat pengirim
• Alamat penerima
• Jumlah pemindahan
• Harga gas
• Had Gas

Gas ialah unit ukuran untuk kos pengiraan dalam rangkaian Ethereum. Harga ialah jumlah Eter yang anda sanggup bayar setiap unit Gas. Had ialah jumlah maksimum gas yang anda sanggup bayar untuk transaksi.

Anda boleh membuat transaksi menggunakan kod berikut:

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

Dalam kod ini, kami menetapkan alamat pengirim, alamat penerima, jumlah pemindahan, Harga Gas, Had Gas dan Nonce (nombor urutan transaksi ).

Kami juga membuat transaksi baru yang belum ditandatangani (jenis.Jenis transaksi) yang mengandungi data di atas. Walau bagaimanapun, kami juga perlu menandatangani transaksi, yang membolehkan nod Ethereum mengesahkan bahawa ia telah dibenarkan oleh pengirim.

5. Transaksi yang Ditandatangani

Dalam Ethereum, urus niaga ditandatangani menggunakan kunci peribadi. Kunci persendirian sepadan dengan alamat akaun Ethereum dan kami perlu menandatangani transaksi menggunakan kunci persendirian pengirim.

Begini cara untuk menandatangani transaksi menggunakan kunci persendirian:

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

Dalam kod ini, kami menggunakan fungsi jenis.SignTx untuk menandatangani transaksi bersama-sama dengan kunci persendirian penghantar. Kami juga menetapkan ID Rantaian untuk kontrak khusus ini (1 mewakili mainnet Ethereum).

Anda kini boleh menghantar transaksi yang ditandatangani menggunakan ethclient.Pelanggan:

// 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. Contoh kod penuh

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

Di atas menggunakan Golang untuk menulis pemindahan Ethereum keseluruhan proses program. Sudah tentu, terdapat lebih banyak butiran dan isu keselamatan yang perlu anda pertimbangkan, seperti pengurusan kunci persendirian dan pengesahan transaksi.

Atas ialah kandungan terperinci pemindahan Ethereum golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!