Wie sendet man den RPC-Aufruf korrekt mit Golang, um den Smart-Contract-Eigentümer zu erhalten?

Aktualisierung 12.11.2018

Jemand teilte eine sehr nahe Lösung zu dem, wonach ich hier suchte .

Aktualisierung 10. November 2018

Da ich dies mit dem Ansatz in dieser Frage nicht erreichen kann, habe ich meine eigene Bibliothek erstellt, um dasselbe zu tun ( Link ). Es ist nicht auf das go-ethereum-Paket angewiesen, sondern verwendet das normale net/httpPaket, um JSON-RPC-Anforderungen auszuführen.

Ich würde immer noch gerne wissen, was ich bei meinem Ansatz unten falsch gemacht habe.

Definitionen :

  • Eigentümer = publicVariable im Vertrag mit addressTyp
  • Vertrag = Smart-Vertrag, der einen Eigentümer hat

Dies ist die Curl-Anforderung, um den Eigentümer eines Vertrags zu erhalten. Ich habe es geschafft, den Besitzer zu bekommen.

curl localhost:8545 -X POST \
--header 'Content-type: application/json' \
--data '{"jsonrpc":"2.0", "method":"eth_call", "params":[{"to": "0x_MY_CONTRACT_ADDRESS", "data": "0x8da5cb5b"}, "latest"], "id":1}'

{"jsonrpc":"2.0","id":1,"result":"0x000000000000000000000000_OWNER"}

Aber wenn ich versuche, es in Golang zu replizieren (Code unten), bekomme ich json: Zeichenfolge kann nicht in den Go-Wert des Typs main.response entpackt werden .

package main

import (
    "fmt"
    "log"
    "os"

    "github.com/ethereum/go-ethereum/rpc"
)

func main() {
    client, err := rpc.DialHTTP(os.Getenv("RPC_SERVER"))
    if err != nil {
        log.Fatal(err)
    }
    defer client.Close()

    type request struct {
        To   string `json:"to"`
        Data string `json:"data"`
    }

    type response struct {
        Result string
    }

    req := request{"0x_MY_CONTRACT_ADDRESS", "0x8da5cb5b"}
    var resp response
    if err := client.Call(&resp, "eth_call", req, "latest"); err != nil {
        log.Fatal(err)
    }

    fmt.Printf("%v\n", resp)
}

Was habe ich hier verpasst?

Erwartetes Ergebnis:

Adresse im Zeichenfolgenformat. Z.B0x3ab17372b25154400738C04B04f755321bB5a94b

P/S — Ich kenne abigen und ich weiß, dass es besser und einfacher ist, dies mit abigen zu tun. Aber ich versuche, dieses spezielle Problem zu lösen, ohne die abigen-Methode zu verwenden.

Antworten (1)

Anstatt

type response struct {
    Result string
}

Übergeben Sie einfach die Ergebniszeichenfolge

var result string
if err := client.Call(&result, "eth_call", req, "latest")

und analysieren Sie die Adresse

owner := common.HexToAddress(result)
fmt.Printf("%s\n", owner.Hex())

Vollständiger Code

package main

import (
    "fmt"
    "log"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/rpc"
)

func main() {
    client, err := rpc.DialHTTP("https://mainnet.infura.io")
    if err != nil {
        log.Fatal(err)
    }
    defer client.Close()

    type request struct {
        To   string `json:"to"`
        Data string `json:"data"`
    }

    var result string

    req := request{"0xcc13fc627effd6e35d2d2706ea3c4d7396c610ea", "0x8da5cb5b"}
    if err := client.Call(&result, "eth_call", req, "latest"); err != nil {
        log.Fatal(err)
    }

    owner := common.HexToAddress(result)
    fmt.Printf("%s\n", owner.Hex()) // 0x281017b4E914b79371d62518b17693B36c7a221e
}
Wie sendet man den RPC-Aufruf korrekt mit Golang, um den Smart-Contract-Eigentümer zu erhalten?
AntwortenHierDatenschutz-Bestimmungen1y, 0v