golang Ethereum

Golang Ethereum: Cara menggunakan Pergi untuk menulis kontrak pintar

Kepopularan teknologi blockchain telah membawa perubahan besar kepada kehidupan dan ekonomi, antaranya Ethereum adalah salah satu platform blockchain awam yang diedarkan sumber terbuka, membolehkan pemaju untuk melaksanakan aset digital boleh diprogramkan melalui kontrak pintar. Tidak seperti bahasa pengaturcaraan biasa yang lain, Golang menjadikan pembangunan kontrak pintar lebih mudah dan lebih selamat, sambil menyediakan kecekapan pelaksanaan dan keselarasan yang lebih tinggi. Dalam artikel ini, kami akan meneroka cara menulis kontrak pintar menggunakan Golang.

Pengenalan kepada Ethereum

Ethereum ialah platform blockchain awam yang terdesentralisasi, sumber terbuka, dengan keupayaan kontrak pintar dan aplikasi teragih (DApps). Kontrak pintar ialah kontrak pelaksanaan sendiri yang ditulis berdasarkan kod dan boleh digunakan dan dijalankan pada rangkaian Ethereum Pada masa yang sama, mereka boleh merealisasikan pemindahan, penyimpanan data dan operasi logik Ethereum yang kompleks, menjadikan Ethereum sebagai peneraju dalam rantaian blok. pembangunan platform yang penting.

Golang ialah bahasa pengaturcaraan yang sangat popular yang juga dikenali sebagai Go. Dibangunkan pada tahun 2009 oleh Robert Griesemer, Rob Pike, dan Ken Thompson di Google, ia adalah bahasa pengaturcaraan yang digunakan untuk membina rangkaian berprestasi tinggi dan sistem teragih. Berbanding dengan bahasa pengaturcaraan tradisional, Go mempunyai kesederhanaan, keselamatan dan prestasi yang lebih tinggi, serta menyokong konkurensi, jadi ia juga digunakan secara meluas dalam bidang blockchain.

Pasang dan konfigurasikan Golang

Sebelum kita bermula, kita perlu memasang dan mengkonfigurasi persekitaran Golang. Anda boleh memuat turun versi terkini pemasang Golang dari tapak web rasmi dan ikut arahan untuk memasangnya. Selepas selesai, anda boleh menyemak sama ada pemasangan berjaya di terminal:

go version

Jika pemasangan berjaya, versi Go akan dipaparkan.

Menulis kontrak pintar

Kini kami mengambil kontrak pintar ringkas sebagai contoh untuk menggambarkan cara menggunakan Golang untuk menulis kontrak pintar.

Pertama, kami mencipta projek go-ethereum dan boleh melaksanakan arahan berikut dalam terminal:

mkdir go-ethereum
cd go-ethereum

Kemudian, kami menggunakan modul go untuk memulakan projek:

go mod init go-ethereum

Seterusnya, Kami perlu menambah kebergantungan untuk menyokong pembangunan kontrak pintar pada Ethereum. Kami menggunakan pakej go-ethereum di sini, yang merupakan pelaksanaan bahasa Go yang dibangunkan oleh pasukan Ethereum dan menyediakan sokongan API yang kaya untuk membangunkan kontrak pintar.

go get github.com/ethereum/go-ethereum

Dalam direktori projek, kami mencipta kontrak pintar Solidity (MyContract.sol) seperti yang ditunjukkan di bawah:

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

Di bahagian atas, kami menambah anotasi SPDX-License-Identifier pada kontrak untuk menentukan lesen. Seterusnya, kami mengisytiharkan kontrak MyContract dan menambah pembolehubah keadaan yang dipanggil nilai. Kami mentakrifkan dua fungsi awam, setValue dan getValue yang pertama menetapkan nilai nilai kepada _value, dan yang kedua mengembalikan nilai nilai semasa.

Seterusnya, kami menggunakan arahan berikut untuk menjana Go binding untuk kontrak pintar Solidity dalam direktori projek:

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

Pilihan --pkg menentukan nama pakej kod Go yang akan dijana, --out Menentukan nama fail output kod Go yang dijana. Perintah abigen menggunakan fail sumber MyContract.sol kontrak pintar Solidity untuk menjana kod mengikat Go MyContract.go.

Kini, kami mencipta fail Go (main.go) menggunakan arahan berikut dan menambah kandungan berikut di dalamnya:

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

Di bahagian atas, kami telah mengimport beberapa kebergantungan termasuk go- The pakej ethereum dan pakej MyContract yang kami hasilkan menggunakan alat abigen, serta beberapa pakej perpustakaan standard. Kami mencipta fungsi utama untuk memulakan aplikasi kami.

Dalam fungsi utama, kami menggunakan kaedah ethclient.Dial untuk menyambung ke rangkaian Ethereum, menyatakan nod https://mainnet.infura.io yang disediakan oleh Infura. Segerakan MyContract dan nyatakan alamat kontrak dan pelanggan. Kami memanggil fungsi GetValue untuk mendapatkan nilai nilai semasa dan mencetak hasilnya ke konsol.

Seterusnya, kami memanggil fungsi SetValue untuk menetapkan nilai kepada 10 dan menentukan had gas dan harga gas. Akhir sekali, kami mencetak cincang transaksi.

Kini, kami boleh menyusun dan menjalankan program kami menggunakan arahan berikut:

go build
./go-ethereum

Aplikasi akan menyambung ke rangkaian Ethereum dan menggunakan kaedah kontrak MyContract setValue dan getValue untuk menetapkan dan mendapatkan nilai daripada nilai.

Ringkasan

Dalam artikel ini, kami mempelajari cara menulis kontrak pintar Ethereum menggunakan Golang dan menunjukkan cara menggunakan alat abigen untuk menjana kod pengikat Go untuk kontrak pintar Solidity. Kami juga menggunakan pakej go-ethereum, yang menyediakan sokongan API yang kaya untuk memudahkan penulisan kontrak pintar. Gabungan Golang dan Ethereum membawa kemungkinan baharu kepada pembangunan aplikasi yang diedarkan, menjadikannya lebih mudah bagi pembangun untuk membina aplikasi terdesentralisasi dan melaksanakan aset digital boleh atur cara pada rangkaian Ethereum.

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