golang Ethereum

Golang Ethereum: So verwenden Sie Go zum Schreiben intelligenter Verträge

Die Popularität der Blockchain-Technologie hat große Veränderungen im Leben und in der Wirtschaft mit sich gebracht, wobei Ethereum eine der Open-Source-Plattformen für verteilte öffentliche Blockchains ist, die es Entwicklern ermöglicht, intelligente Verträge zu verwenden Implementierung programmierbarer digitaler Assets. Im Gegensatz zu anderen gängigen Programmiersprachen macht Golang die Entwicklung intelligenter Verträge einfacher und sicherer und bietet gleichzeitig eine höhere Ausführungseffizienz und Parallelität. In diesem Artikel untersuchen wir, wie man mit Golang intelligente Verträge schreibt.

Einführung in Ethereum

Ethereum ist eine dezentrale, öffentliche Open-Source-Blockchain-Plattform mit intelligenten Vertrags- und verteilten Anwendungsfunktionen (DApp). Intelligente Verträge sind selbstausführende Verträge, die auf Codebasis geschrieben werden und im Ethereum-Netzwerk bereitgestellt und ausgeführt werden können. Gleichzeitig können sie die Übertragung, Datenspeicherung und komplexen logischen Operationen von Ethereum realisieren, was Ethereum zu einem führenden Unternehmen in der Blockchain macht Entwicklung.

Golang ist eine sehr beliebte Programmiersprache, auch bekannt als Go. Es handelt sich um eine Programmiersprache, die 2009 von Robert Griesemer, Rob Pike und Ken Thompson bei Google entwickelt wurde und zum Aufbau leistungsstarker Netzwerke und verteilter Systeme verwendet wird. Im Vergleich zu herkömmlichen Programmiersprachen bietet Go eine höhere Einfachheit, Sicherheit und Leistung und unterstützt Parallelität, sodass es auch im Blockchain-Bereich weit verbreitet ist.

Golang installieren und konfigurieren

Bevor wir beginnen, müssen wir die Golang-Umgebung installieren und konfigurieren. Sie können die neueste Version des Golang-Installationsprogramms von der offiziellen Website herunterladen und den Anweisungen zur Installation folgen. Nach Abschluss können Sie im Terminal überprüfen, ob die Installation erfolgreich war:

go version

Wenn die Installation erfolgreich war, wird die Go-Version angezeigt.

Smart Contracts schreiben

Nun nehmen wir einen einfachen Smart Contract als Beispiel, um zu erklären, wie man Golang zum Schreiben von Smart Contracts verwendet.

Zuerst erstellen wir ein Go-Ethereum-Projekt und können den folgenden Befehl im Terminal ausführen:

mkdir go-ethereum
cd go-ethereum

Dann initialisieren wir das Projekt mit dem Go-Modul:

go mod init go-ethereum

Als nächstes müssen wir Abhängigkeiten hinzufügen, um die Entwicklung intelligenter Verträge von Ethereum zu unterstützen . Wir verwenden hier das Paket go-ethereum, eine vom Ethereum-Team entwickelte Go-Sprachimplementierung, die umfassende API-Unterstützung für die Entwicklung intelligenter Verträge bietet.

go get github.com/ethereum/go-ethereum

Im Projektverzeichnis erstellen wir einen Solidity-Smart-Vertrag (MyContract.sol), wie unten gezeigt:

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

Oben fügen wir dem Vertrag die Annotation SPDX-License-Identifier hinzu, um die Lizenz anzugeben. Als nächstes deklarieren wir den MyContract-Vertrag und fügen eine Statusvariable namens value hinzu. Wir definieren zwei öffentliche Funktionen, setValue und getValue. Erstere setzt den Wert von value auf _value und letztere gibt den Wert des aktuellen Werts zurück.

Als nächstes verwenden wir den folgenden Befehl, um die Go-Bindung für den Solidity-Smart-Vertrag im Projektverzeichnis zu generieren:

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

Die Option --pkg gibt den Paketnamen des generierten Go-Codes an, --out gibt die Ausgabedatei von an der generierte Go-Codename. Der abigen-Befehl verwendet die Quelldatei MyContract.sol des Solidity-Smart-Vertrags, um den Go-Bindungscode MyContract.go zu generieren.

Jetzt erstellen wir mit dem folgenden Befehl eine Go-Datei (main.go) und fügen darin den folgenden Inhalt hinzu:

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

Oben haben wir ein paar Abhängigkeiten importiert, darunter das go-ethereum-Paket und das, das wir mit generiert haben das Abigen-Tool Das MyContract-Paket sowie mehrere Standardbibliothekspakete. Wir erstellen eine Hauptfunktion, um unsere Anwendung zu starten.

In der Hauptfunktion verwenden wir die Methode ethclient.Dial, um eine Verbindung zum Ethereum-Netzwerk herzustellen, und geben dabei den von Infura bereitgestellten Knoten https://mainnet.infura.io an. Instanziieren Sie MyContract und geben Sie die Vertragsadresse und den Kunden an. Wir rufen die Funktion GetValue auf, um den Wert des aktuellen Werts abzurufen und das Ergebnis auf der Konsole auszugeben.

Als nächstes rufen wir die SetValue-Funktion auf, um den Wert auf 10 zu setzen und das Gaslimit und den Gaspreis anzugeben. Zum Schluss drucken wir den Transaktions-Hash aus.

Jetzt können wir unser Programm mit dem folgenden Befehl kompilieren und ausführen:

go build
./go-ethereum

Die Anwendung stellt eine Verbindung zum Ethereum-Netzwerk her und verwendet die Methoden setValue und getValue des MyContract-Vertrags, um den Wert von value festzulegen und abzurufen.

Zusammenfassung

In diesem Artikel haben wir gelernt, wie man Ethereum-Smart-Verträge mit Golang schreibt, und gezeigt, wie man mit dem Abigen-Tool Go-Bindungscode für Solidity-Smart-Verträge generiert. Wir verwenden auch das Paket go-ethereum, das umfassende API-Unterstützung bietet, um das Schreiben intelligenter Verträge zu erleichtern. Die Kombination von Golang und Ethereum eröffnet neue Möglichkeiten für die Entwicklung verteilter Anwendungen und erleichtert Entwicklern die Erstellung dezentraler Anwendungen und die Implementierung programmierbarer digitaler Assets im Ethereum-Netzwerk.

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