From ca02d3ca52ecaf80bad6507c0adcc86c9a5c3afb Mon Sep 17 00:00:00 2001 From: Jun Kimura Date: Mon, 16 Sep 2019 22:49:29 +0900 Subject: [PATCH] fix event print format --- pkg/client/cmd/contract/event.go | 45 ++++++++++++++++++----------- pkg/contract/event/event.go | 49 ++++++++++++++++++++++++-------- 2 files changed, 65 insertions(+), 29 deletions(-) diff --git a/pkg/client/cmd/contract/event.go b/pkg/client/cmd/contract/event.go index 6af9bf4..c23a7ac 100644 --- a/pkg/client/cmd/contract/event.go +++ b/pkg/client/cmd/contract/event.go @@ -4,14 +4,16 @@ import ( "context" "fmt" + "github.com/bluele/hypermint/pkg/abci/types" "github.com/bluele/hypermint/pkg/client" "github.com/bluele/hypermint/pkg/contract/event" "github.com/bluele/hypermint/pkg/util" + ethcmn "github.com/ethereum/go-ethereum/common" "github.com/spf13/cobra" "github.com/spf13/viper" "github.com/tendermint/tendermint/libs/common" - "github.com/tendermint/tendermint/types" + tmtypes "github.com/tendermint/tendermint/types" ) func init() { @@ -56,25 +58,13 @@ func EventCMD() *cobra.Command { return err } for ev := range out { - etx := ev.Data.(types.EventDataTx) + etx := ev.Data.(tmtypes.EventDataTx) fmt.Printf("TxID=0x%x\n", etx.Tx.Hash()) for _, ev := range etx.Result.Events { if ev.Type != "contract" { continue } - for _, tag := range ev.Attributes { - if k := string(tag.GetKey()); k == "event.data" { - e, err := event.ParseEntry(tag.GetValue()) - if err != nil { - return err - } - fmt.Println(e.String()) - } else if k == "event.name" || k == "address" { - // skip - } else { - fmt.Printf("unknown event: %v\n", tag) - } - } + printEvents([]types.Event{types.Event(ev)}) } } return nil @@ -134,13 +124,21 @@ func EventCMD() *cobra.Command { if err != nil { return err } - count += len(events) + if len(events) == 0 { + continue + } + count++ } fmt.Print(count) return nil } else { for _, tx := range res.Txs { - fmt.Println(tx.TxResult.String()) + fmt.Printf("Tx=0x%x\n", tx.Tx.Hash()) + events, err := event.GetContractEventsFromResultTx(contractAddr, tx) + if err != nil { + return err + } + printEvents(events) } } return nil @@ -156,3 +154,16 @@ func EventCMD() *cobra.Command { return eventCmd } + +func printEvents(events []types.Event) { + for _, ev := range events { + fmt.Printf("event type=%v\n", ev.Type) + es, err := event.GetEntryFromEvent(ev) + if err != nil { + panic(err) + } + for _, entry := range es { + fmt.Printf("\tname=%v value=%v\n", string(entry.Name), string(entry.Value)) + } + } +} diff --git a/pkg/contract/event/event.go b/pkg/contract/event/event.go index bda9247..f5b6496 100644 --- a/pkg/contract/event/event.go +++ b/pkg/contract/event/event.go @@ -13,6 +13,18 @@ import ( ctypes "github.com/tendermint/tendermint/rpc/core/types" ) +const ( + EventKey = "event" + EventDataKey = EventKey + ".data" + EventNameKey = EventKey + ".name" + + AddressKey = "address" + ContractKey = "contract" + ContractAddressKey = ContractKey + "." + AddressKey + ContractEventDataKey = ContractKey + "." + EventDataKey + ContractEventNameKey = ContractKey + "." + EventNameKey +) + type Event struct { address common.Address entries []*Entry @@ -84,10 +96,10 @@ func MakeTMEvent(contractAddr common.Address, es []*Entry) (*types.Event, error) return nil, err } pairs = append(pairs, tmcmn.KVPair{ - Key: []byte("address"), + Key: []byte(AddressKey), Value: []byte(contractAddr.Hex()), }) - e := types.Event{Type: "contract"} + e := types.Event{Type: ContractKey} e.Attributes = pairs return &e, nil } @@ -98,10 +110,8 @@ func eventsToPairs(es []*Entry) (tmcmn.KVPairs, error) { if err := e.Validate(); err != nil { return nil, err } - key := []byte("event.name") - pairs = append(pairs, tmcmn.KVPair{Key: key, Value: e.Name}) - dataKey := []byte("event.data") - pairs = append(pairs, tmcmn.KVPair{Key: dataKey, Value: e.Bytes()}) + pairs = append(pairs, tmcmn.KVPair{Key: []byte(EventNameKey), Value: e.Name}) + pairs = append(pairs, tmcmn.KVPair{Key: []byte(EventDataKey), Value: e.Bytes()}) } return pairs, nil } @@ -147,14 +157,14 @@ func MakeEntryBytes(name, value string) ([]byte, error) { // eventValue: value corresponding to event name. NOTE: if value has a prefix "0x", value will be decoded into []byte func MakeEventSearchQuery(contractAddr common.Address, eventName, eventValue string) (string, error) { var parts []string - parts = append(parts, fmt.Sprintf("contract.address='%v'", contractAddr.Hex())) - parts = append(parts, fmt.Sprintf("contract.event.name='%v'", eventName)) + parts = append(parts, fmt.Sprintf("%v='%v'", ContractAddressKey, contractAddr.Hex())) + parts = append(parts, fmt.Sprintf("%v='%v'", ContractEventNameKey, eventName)) if len(eventValue) > 0 { ev, err := MakeEntryBytes(eventName, eventValue) if err != nil { return "", err } - parts = append(parts, fmt.Sprintf("contract.event.data='%v'", string(ev))) + parts = append(parts, fmt.Sprintf("%v='%v'", ContractEventDataKey, string(ev))) } return strings.Join(parts, " AND "), nil } @@ -169,7 +179,7 @@ func GetContractEventsFromResultTx(contractAddr common.Address, result *ctypes.R L: for _, ev := range result.TxResult.GetEvents() { for _, attr := range ev.GetAttributes() { - if bytes.Equal([]byte("address"), attr.GetKey()) { + if bytes.Equal([]byte(AddressKey), attr.GetKey()) { if bytes.Equal([]byte(contractAddr.Hex()), attr.GetValue()) { events = append(events, types.Event(ev)) } @@ -199,13 +209,13 @@ func FilterContractEvents(events []types.Event, eventName, eventValue string) ([ for _, ev := range events { for _, attr := range ev.Attributes { if !checkValue { - if bytes.Equal([]byte("event.name"), attr.GetKey()) { + if bytes.Equal([]byte(EventNameKey), attr.GetKey()) { if bytes.Equal([]byte(eventName), attr.GetValue()) { rets = append(rets, ev) } } } else { - if bytes.Equal([]byte("event.data"), attr.GetKey()) { + if bytes.Equal([]byte(EventDataKey), attr.GetKey()) { if bytes.Equal(value, attr.GetValue()) { rets = append(rets, ev) } @@ -215,3 +225,18 @@ func FilterContractEvents(events []types.Event, eventName, eventValue string) ([ } return rets, nil } + +func GetEntryFromEvent(ev types.Event) ([]*Entry, error) { + var es []*Entry + for _, attr := range ev.Attributes { + if !bytes.Equal([]byte(EventDataKey), attr.GetKey()) { + continue + } + e, err := ParseEntry(attr.GetValue()) + if err != nil { + return nil, err + } + es = append(es, e) + } + return es, nil +}