Golang melaksanakan kontrak pintar

Kata Pengantar

Dengan perkembangan teknologi blockchain, kontrak pintar telah menjadi salah satu topik hangat. Sebagai bahasa pengaturcaraan yang cekap, Golang secara beransur-ansur telah digunakan secara meluas dalam pembangunan kontrak pintar. Artikel ini akan memperkenalkan cara menggunakan bahasa Golang untuk melaksanakan kontrak pintar.

Apakah kontrak pintar?

Kontrak pintar ialah program komputer yang boleh melaksanakan, mengurus dan mengesahkan syarat kontrak secara automatik. Peraturan kontrak program kontrak pintar dan merealisasikan pengurusan automatik pelaksanaan kontrak melalui teknologi blockchain. Kontrak pintar bukan sahaja dapat meningkatkan kecekapan dan ketepatan pelaksanaan kontrak, tetapi juga melindungi hak dan kepentingan semua pihak dalam kontrak.

Golang melaksanakan kontrak pintar

Sebagai bahasa pengaturcaraan yang cekap, Golang mempunyai ciri penyelarasan, ringan, pemeriksaan jenis statik, dsb., dan sangat sesuai untuk melaksanakan kontrak pintar. Berikut adalah langkah-langkah untuk melaksanakan kontrak pintar di Golang:

1. Pasang persekitaran Golang

Mula-mula anda perlu memasang persekitaran Golang, anda boleh pergi ke laman web rasmi (https://golang.org/) Muat turun versi pakej pemasangan Golang yang sepadan dan pasangkannya mengikut arahan rasmi. Selepas pemasangan selesai, anda boleh menyemak versi Golang melalui alat baris arahan, contohnya:

$ go version
go version go1.16.5 darwin/amd64

2. Bina persekitaran pembangunan kontrak pintar

Sebelum melaksanakan pintar kontrak, anda perlu menyediakan persekitaran persekitaran pembangunan yang sepadan. Pertama, anda perlu memasang pengkompil Solidity, yang digunakan untuk menyusun kod Solidity ke dalam kod bait EVM (Mesin Maya Ethereum). Pengkompil Solidity boleh dipasang melalui alat baris arahan, seperti:

$ npm install -g solc

Pada masa yang sama, anda perlu memuat turun dan memasang klien Geth untuk menyambung ke rangkaian Ethereum. Pelanggan Geth boleh dimuat turun dari tapak web rasmi (https://geth.ethereum.org/downloads/).

3. Reka Bentuk Kontrak Pintar

Sebelum membangunkan kontrak pintar, anda perlu mereka bentuk fungsi dan peraturan kontrak. Di sini kami mengambil kontrak pintar token asas sebagai contoh untuk memperkenalkan proses pelaksanaan kontrak pintar.

Kontrak pintar token terutamanya melaksanakan fungsi berikut:

• Pengeluaran token
• Pemindahan token
• Pertanyaan baki token

Kod kontrak adalah seperti berikut:

pragma solidity ^0.8.0;

contract Token {
    mapping(address => uint256) private balances;
    uint256 private totalSupply;

    constructor(uint256 _totalSupply) {
        balances[msg.sender] = _totalSupply;
        totalSupply = _totalSupply;
    }

    function transfer(address _to, uint256 _value) public returns (bool success) {
        require(balances[msg.sender] >= _value, "Not enough balance");
        balances[msg.sender] -= _value;
        balances[_to] += _value;
        return true;
    }

    function balanceOf(address _owner) public view returns (uint256 balance) {
        return balances[_owner];
    }
}

4. Menulis klien Golang

Kontrak pintar hanyalah program, yang perlu digunakan dan dipanggil melalui pelanggan itu. Golang boleh menyambung ke rangkaian Ethereum dan menghubungi kontrak pintar melalui perpustakaan Web3.

Mula-mula anda perlu memasang perpustakaan Web3, yang boleh dipasang menggunakan arahan berikut:

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

Kemudian, anda boleh menulis klien Golang mengikut langkah berikut:

1. Sambung pertama ke Rangkaian Ethernet Fang:

client, err := ethclient.Dial("http://localhost:8545")
if err != nil {
    log.Fatal(err)
}

2. Baca kontrak pintar ABI (Antara Muka Binari Aplikasi) dan bytecode:

abi, err := abi.JSON(strings.NewReader(tokenABI))
if err != nil {
    log.Fatal(err)
}
bytecode, err := hexutil.Decode(tokenBytecode)
if err != nil {
    log.Fatal(err)
}

3. Construct contoh kontrak:

address := common.HexToAddress(contractAddress)
tokenInstance, err := NewToken(address, client)
if err != nil {
    log.Fatal(err)
}

4. Kaedah untuk memanggil kontrak pintar:

balance, err := tokenInstance.BalanceOf(nil, sender)
if err != nil {
    log.Fatal(err)
}

Kod pelanggan Golang yang lengkap adalah seperti berikut:

package main

import (
    "context"
    "encoding/hex"
    "fmt"
    "log"
    "math/big"
    "strings"

    "github.com/ethereum/go-ethereum/accounts/abi"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/common/hexutil"
    "github.com/ethereum/go-ethereum/crypto"
    "github.com/ethereum/go-ethereum/ethclient"

    "github.com/username/repo/abi"
)

func main() {
    // Set up client
    client, err := ethclient.Dial("http://localhost:8545")
    if err != nil {
        log.Fatal(err)
    }

    // Set up sender address
    privateKey, err := crypto.HexToECDSA("PRIVATE_KEY")
    if err != nil {
        log.Fatal(err)
    }
    publicKey := privateKey.Public()
    publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey)
    if !ok {
        log.Fatal("error casting public key to ECDSA")
    }
    sender := crypto.PubkeyToAddress(*publicKeyECDSA)

    // Set up contract instance
    address := common.HexToAddress(contractAddress)
    tokenInstance, err := NewToken(address, client)
    if err != nil {
        log.Fatal(err)
    }

    // Call balanceOf method
    balance, err := tokenInstance.BalanceOf(nil, sender)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(balance)
}

Nota : Anda perlu menggantikan kunci peribadi akaun di sini dan kontrak pintar ABI dan bytecode.

5. Menggunakan kontrak pintar

Selepas menulis kod kontrak pintar dan pelanggan Golang, kontrak pintar perlu digunakan ke rangkaian Ethereum. Anda boleh menggunakan IDE dalam talian seperti Remix (https://remix.ethereum.org/) untuk menyusun kod Solidity ke dalam ABI dan bytecode dan menggunakan ia ke rangkaian Ethereum.

Selepas penggunaan berjaya, alamat kontrak pintar perlu dikemas kini kepada pelanggan Golang, jika tidak kaedah kontrak tidak boleh dipanggil.

Ringkasan

Artikel ini memperkenalkan cara menggunakan bahasa Golang untuk melaksanakan kontrak pintar. Mula-mula, anda perlu menyediakan pengkompil Solidity dan persekitaran klien Geth, kemudian reka fungsi dan peraturan kontrak pintar, tulis klien Golang dan sambung ke rangkaian Ethereum, dan akhirnya gunakan kontrak pintar dan kemas kini alamat kontrak untuk merealisasikan penggunaan kontrak pintar.

Atas ialah kandungan terperinci Golang melaksanakan kontrak pintar. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!