Schreiben Sie intelligente Verträge in Go und interagieren Sie mit der Blockchain

Mit der kontinuierlichen Weiterentwicklung der Blockchain-Technologie sind Smart Contracts zu einer wichtigen Anwendung der Blockchain geworden. Smart Contracts stellen eine Form von Code auf der Blockchain dar, mit der bestimmte Aufgaben ausgeführt werden können und die sich für verschiedene Szenarien wie elektronische Signaturen, Zahlungen usw. eignen. Intelligente Verträge übernehmen die automatische Ausführung und Selbstregulierung, wodurch Vermittler ersetzt, die Kosten für die Vertragsausführung gesenkt und die Rechtmäßigkeit und Fairness der Vereinbarung sichergestellt werden können.

Derzeit ist Ethereum eine der beliebtesten Smart-Contract-Plattformen. Ethereum stellt die Solidity-Sprache zum Schreiben intelligenter Verträge bereit, aber die Solidity-Sprache ist für Anfänger komplexer, sodass einige Entwickler auf andere Programmiersprachen wie die Go-Sprache zurückgreifen. Die Go-Sprache ist eine von Google entwickelte Open-Source-Programmiersprache, die hohe Parallelität und verteilte Systeme implementiert und sich sehr gut für die Entwicklung von Blockchain-Anwendungen eignet. Daher wird in diesem Artikel erläutert, wie man mithilfe der Go-Sprache intelligente Verträge schreibt und mit der Blockchain interagiert.

Zuerst müssen wir einige Tools installieren, um Smart Contracts zu kompilieren und bereitzustellen. Zu diesen Tools gehören Solc, Abigen, Geth usw. Schauen wir uns als Nächstes ein einfaches Beispiel für einen Smart Contract-Code an:

package main

import (
    "context"
    "fmt"
    "math/big"

    "github.com/ethereum/go-ethereum/accounts/abi/bind"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/ethclient"
)

// 定义智能合约
type SimpleToken struct {
    totalSupply *big.Int
    owner       common.Address
}

// 转账函数
func (s *SimpleToken) Transfer(to common.Address, amount *big.Int) error {
    // TODO 实现转账逻辑
    return nil
}

func main() {
    // 连接以太坊节点
    client, err := ethclient.Dial("https://mainnet.infura.io")
    if err != nil {
        panic(err)
    }

    // 初始化智能合约
    tokenAddress := common.HexToAddress("0x...")
    token, err := NewSimpleToken(tokenAddress, client)
    if err != nil {
        panic(err)
    }

    // 调用智能合约函数
    auth := bind.NewKeyedTransactor(common.HexToAddress("0x..."))
    tx, err := token.Transfer(auth, common.HexToAddress("0x..."), big.NewInt(10))
    if err != nil {
        panic(err)
    }

    fmt.Printf("Transaction hash: %v
", tx.Hash())
}

Der obige Code definiert einen einfachen Smart Contract, der eine Übertragungsfunktion und ein Gesamtangebot umfasst. Der Smart Contract definiert auch eine Hauptfunktion, die zur Verbindung mit dem Ethereum-Knoten und zum Aufrufen der Smart Contract-Funktion verwendet wird.

Im Code verwenden wir die Go-Ethereum-Bibliothek, um mit Ethereum zu interagieren. Zuerst verwenden wir ethclient.Dial, um eine Verbindung zum Ethereum-Knoten herzustellen. Anschließend erstellen wir ein Smart-Contract-Objekt, indem wir die Smart-Contract-Adresse und die Verbindung an die NewSimpleToken-Funktion übergeben. Abschließend nutzen wir die Transfer-Funktion des Smart-Contract-Objekts, um die angegebene Menge an Token an die angegebene Adresse zu übertragen.

Hinweis: Bevor Sie die Übertragungsfunktion verwenden, müssen Sie über NewKeyedTransactor ein Autorisierungsobjekt erstellen, das die Absenderadresse und den privaten Schlüssel der Übertragung enthält.

Um Smart Contracts zu kompilieren und bereitzustellen, müssen wir den Solidity-Compiler und das Abigen-Tool verwenden. Wir können sie mit dem folgenden Befehl installieren:

// 安装 Solidity 编译器
sudo add-apt-repository ppa:ethereum/ethereum
sudo apt-get update
sudo apt-get install solc

// 安装 abigen 工具
go get -u github.com/ethereum/go-ethereum
cd $GOPATH/src/github.com/ethereum/go-ethereum/
make abigen

Als nächstes müssen wir den Solidity-Code des Smart Contracts schreiben, ihn in ein Binärformat kompilieren und den Go-Sprachbindungscode generieren. Hier ist ein einfaches Solidity-Codebeispiel:

pragma solidity ^0.5.0;

contract SimpleToken {
    uint256 totalSupply;
    address owner;

    constructor() public {
        totalSupply = 1000000;
        owner = msg.sender;
    }

    function transfer(address to, uint256 amount) public {
        // TODO 实现转账逻辑
    }
}

Der Code definiert einen Smart Contract namens SimpleToken, der einen Gesamtvorrat und eine Eigentümeradresse enthält. Im Konstruktor initialisieren wir die gesamte Liefer- und Eigentümeradresse. In der Übertragungsfunktion verwenden wir TODO-Platzhalter, um später die Übertragungslogik zu implementieren.

Um Solidity-Code in einen Smart Contract zu kompilieren, können wir den folgenden Befehl verwenden:

solc --abi SimpleToken.sol -o build/
solc --bin SimpleToken.sol -o build/

Dadurch werden abi- bzw. bin-Dateien generiert. Als nächstes müssen wir das Abigen-Tool verwenden, um Go-Sprachbindungscode zu generieren. Wir können den folgenden Befehl verwenden:

abigen --sol SimpleToken.sol --pkg main --out SimpleToken.go --abi build/SimpleToken.abi --bin build/SimpleToken.bin

Dadurch wird eine Datei namens SimpleToken.go generiert, die den Go-Sprachbindungscode für den Smart Contract enthält.

Schließlich können wir den Befehl „go run“ verwenden, um unseren Smart-Contract-Code auszuführen:

go run main.go SimpleToken.go

Kurz gesagt, das Schreiben von Smart Contracts in der Go-Sprache kann dazu führen, dass der Vertragscode leichter zu verstehen, zu warten und zu erweitern ist. Gleichzeitig machen die Parallelität und die verteilten Eigenschaften der Go-Sprache sie auch zu einer idealen Wahl für die Entwicklung von Blockchain-Anwendungen. Im nächsten Schritt können Sie auf dieser Basis mehr erfahren und komplexere und praxistauglichere Smart-Contract-Anwendungen entwickeln.

Das obige ist der detaillierte Inhalt vonSchreiben Sie intelligente Verträge in Go und interagieren Sie mit der Blockchain. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!