Ich bin neu bei Go-Ethereum und sogar Golang im Allgemeinen, daher könnte meine Terminologie falsch sein. Ich vermute, die Ereignisbehandlung wird auch als "Abonnement" bezeichnet. Wie auch immer, mein eigentliches Problem ist, dass ich ein Ereignis auf einem Vertrag testen möchte, aber anscheinend keine Rückrufe bekomme.
Hier ist mein Code:
func main() {
client, err := ethclient.Dial("wss://ropsten.infura.io/ws")
if err != nil{
log.Fatal(err)
}
fmt.Println("We have a connection!")
privateKey, err := crypto.HexToECDSA("blablabla")
if(err != nil){
log.Fatal(err)
}
publicKey := privateKey.Public()
publicECDSA := publicKey.(*ecdsa.PublicKey)
fromAddress := crypto.PubkeyToAddress(*publicECDSA)
nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
gasPrice, err := client.SuggestGasPrice(context.Background())
auth := bind.NewKeyedTransactor(privateKey)
auth.Nonce = big.NewInt(int64(nonce))
auth.GasLimit = uint64(300000)
auth.GasPrice = gasPrice
auth.Value = big.NewInt(int64(0))
testAddr := common.HexToAddress("blablablabla")
testEvent, err := TestEvent.NewTestEvent(testAddr, client)
if(err != nil){
log.Fatal(err)
}
resChan := make(chan *TestEvent.TestEventHandleEvent)
if(err != nil){
log.Fatal(err)
}
start := uint64(0)
testEvent.WatchHandleEvent(&bind.WatchOpts{
Context: context.Background(),
Start: &start}, resChan)
if(err != nil){
log.Fatal(err)
}
timer := time.NewTimer(5 * time.Second)
go func(){
<- timer.C
_, err := testEvent.Gotcha(auth)
if(err != nil){
log.Fatal(err)
}
}()
code := <-resChan
fmt.Println(code)
close(resChan)
}
Hier mein Vertrag:
pragma solidity 0.4.25;
Vertrag TestCon {Ereignis HandleEvent (uint64-Code); Adresse öffentlicher Eigentümer;
constructor() public{
owner = msg.sender;
}
function Gotcha() public payable {
if(msg.sender == owner)
{
emit HandleEvent(10); // I've deployed the contract from the same address. So this should match.
return;
}
revert();
}
}
Was mache ich falsch? Oder liegt das an meinem Vertrag?
Hier ist ein voll funktionsfähiges Beispiel zum Abonnieren von Ereignisprotokollen eines Smart Contracts:
package main
import (
"context"
"fmt"
"log"
"github.com/ethereum/go-ethereum"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/ethclient"
)
func main() {
client, err := ethclient.Dial("wss://rinkeby.infura.io/ws")
if err != nil {
log.Fatal(err)
}
contractAddress := common.HexToAddress(" 0x147B8eb97fD247D06C4006D269c90C1908Fb5D54")
query := ethereum.FilterQuery{
Addresses: []common.Address{contractAddress},
}
logs := make(chan types.Log)
sub, err := client.SubscribeFilterLogs(context.Background(), query, logs)
if err != nil {
log.Fatal(err)
}
for {
select {
case err := <-sub.Err():
log.Fatal(err)
case vLog := <-logs:
fmt.Println(vLog) // pointer to event log
}
}
}
Weitere Beispiele finden Sie im Ethereum Development with Go- Leitfaden.
From
und To
sind optional, wenn Sie nur Ereignisprotokolle aus einer Reihe von Blöcken benötigen. Sie sind beim Abonnieren nicht erforderlich, da Sie beim Abonnieren nur die neuesten Blöcke erhalten. Es ist die einzige Methode, die ich kenne, aber ich würde gerne von besseren Ansätzen hören, falls es welche gibt
Nawaz
wss://ropsten.infura.io/ws
ist komplett? Ich hatte erwartet, dass es so istwss://ropsten.infura.io/ws/v3/427bec2fd1ca4870a8fbef8af8132e18