wie erstelle ich eine dapp in go?

Ich verstehe den Entwicklungsprozess von dapp in Javascript. Die Web3-API wird verwendet, um auf bereitgestellte Verträge zuzugreifen, und Truffle kann für die Bereitstellung verwendet werden. Ich möchte eine API mit Go-Sprache für meine Ethereum-Verträge erstellen, damit ich sie mit dem Rest der in Go erstellten Anwendung verbinden kann. Ist es möglich, alles in go statt in js zu entwickeln? Wenn ja, verweisen Sie mich bitte auf die Ressourcen. Ich konnte auf der Github-Seite von Ethereum kein Äquivalent dazu finden.

Antworten (2)

Das Erstellen einer DApp ist einfach, sobald Sie herausgefunden haben, wie Sie mit den Grundlagen wie dem Zugriff auf Smart Contracts in Go und dem Senden von Transaktionen beginnen.

Hier ist ein Beispiel aus dem Ethereum Development with Go-Buch .

Store.sol

pragma solidity ^0.4.24;

contract Store {
  event ItemSet(bytes32 key, bytes32 value);

  string public version;
  mapping (bytes32 => bytes32) public items;

  constructor(string _version) public {
    version = _version;
  }

  function setItem(bytes32 key, bytes32 value) external {
    items[key] = value;
    emit ItemSet(key, value);
  }
}

Zusammenstellung

solc --abi Store.sol | awk '/JSON ABI/{x=1;next}x' > Store.abi
solc --bin Store.sol | awk '/Binary:/{x=1;next}x' > Store.bin
abigen --bin=Store.bin --abi=Store.abi --pkg=store --out=Store.go

Beispiel.gehen

package main

import (
    "fmt"
    "log"

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

    store "./contracts"
)

func main() {
    client, err := ethclient.Dial("https://rinkeby.infura.io")
    if err != nil {
        log.Fatal(err)
    }

    privateKey, err := crypto.HexToECDSA("fad9c8855b740a0b7ed4c221dbad0f33a83a49cad6b3fe8d5817ac83d38b6a19")
    if err != nil {
        log.Fatal(err)
    }

    publicKey := privateKey.Public()
    publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey)
    if !ok {
        log.Fatal("error casting public key to ECDSA")
    }

    fromAddress := crypto.PubkeyToAddress(*publicKeyECDSA)
    nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
    if err != nil {
        log.Fatal(err)
    }

    gasPrice, err := client.SuggestGasPrice(context.Background())
    if err != nil {
        log.Fatal(err)
    }

    auth := bind.NewKeyedTransactor(privateKey)
    auth.Nonce = big.NewInt(int64(nonce))
    auth.Value = big.NewInt(0)     // in wei
    auth.GasLimit = uint64(300000) // in units
    auth.GasPrice = gasPrice

    address := common.HexToAddress("0x147B8eb97fD247D06C4006D269c90C1908Fb5D54")
    instance, err := store.NewStore(address, client)
    if err != nil {
        log.Fatal(err)
    }

    key := [32]byte{}
    value := [32]byte{}
    copy(key[:], []byte("foo"))
    copy(value[:], []byte("bar"))

    tx, err := instance.SetItem(auth, key, value)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("tx sent: %s", tx.Hash().Hex()) // tx sent: 0x8d490e535678e9a24360e955d75b27ad307bdfb97a1dca51d0f3035dcee3e870

    result, err := instance.Items(nil, key)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(string(result[:])) // "bar"
}

Wenn Sie eine API in Go erstellen möchten, müssen Sie sie nur mit RPC/IPC erstellen. Erstellen Sie einfach eine Bibliothek in Go, die über RPC/IPC mit dem Ethereum-Netzwerk interagiert. Dann können Sie Dapps in Go erstellen, die unabhängig von der Implementierung mit jedem der Ethereum-Clients interagieren.

wie erstelle ich eine dapp in go?
AntwortenHierDatenschutz-Bestimmungen1y, 0v