Problem: no parsed log from old event (#480)

* Problem: no parsed log from old event

* cleanup

* fix log from blk

CHANGELOG.md

@@ -57,6 +57,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
 * (evm) [#466](https://github.com/crypto-org-chain/ethermint/pull/466) Fix evm response patching.
 * (rpc) [#473](https://github.com/crypto-org-chain/ethermint/pull/473) Avoid panic on invalid elasticity_multiplier.
 * (rpc) [#474](https://github.com/crypto-org-chain/ethermint/pull/474), [#476](https://github.com/crypto-org-chain/ethermint/pull/441) Align genesis related cmd.
+* (rpc) [#480](https://github.com/crypto-org-chain/ethermint/pull/480) Fix parsed logs from old events.
 
 ### Improvements
 

rpc/backend/tx_info.go

@@ -195,7 +195,12 @@ func (b *Backend) GetTransactionReceipt(hash common.Hash) (map[string]interface{
 	}
 
 	// parse tx logs from events
-	logs, err := evmtypes.DecodeMsgLogsFromEvents(blockRes.TxsResults[res.TxIndex].Data, int(res.MsgIndex), uint64(blockRes.Height))
+	logs, err := evmtypes.DecodeMsgLogsFromEvents(
+		blockRes.TxsResults[res.TxIndex].Data,
+		blockRes.TxsResults[res.TxIndex].Events,
+		int(res.MsgIndex),
+		uint64(blockRes.Height),
+	)
 	if err != nil {
 		b.logger.Debug("failed to parse logs", "hash", hash, "error", err.Error())
 	}

rpc/backend/utils.go

@@ -292,7 +292,7 @@ func ShouldIgnoreGasUsed(res *abci.ExecTxResult) bool {
 func GetLogsFromBlockResults(blockRes *tmrpctypes.ResultBlockResults) ([][]*ethtypes.Log, error) {
 	blockLogs := [][]*ethtypes.Log{}
 	for _, txResult := range blockRes.TxsResults {
-		logs, err := evmtypes.DecodeTxLogsFromEvents(txResult.Data, uint64(blockRes.Height))
+		logs, err := evmtypes.DecodeTxLogsFromEvents(txResult.Data, txResult.Events, uint64(blockRes.Height))
 		if err != nil {
 			return nil, err
 		}

rpc/namespaces/ethereum/eth/api.go

@@ -450,7 +450,12 @@ func (e *PublicAPI) GetTransactionLogs(txHash common.Hash) ([]*ethtypes.Log, err
 	}
 
 	// parse tx logs from events
-	logs, err := evmtypes.DecodeMsgLogsFromEvents(resBlockResult.TxsResults[res.TxIndex].Data, int(res.MsgIndex), uint64(resBlockResult.Height))
+	logs, err := evmtypes.DecodeMsgLogsFromEvents(
+		resBlockResult.TxsResults[res.TxIndex].Data,
+		resBlockResult.TxsResults[res.TxIndex].Events,
+		int(res.MsgIndex),
+		uint64(resBlockResult.Height),
+	)
 	if err != nil {
 		e.logger.Debug("failed to parse tx logs", "error", err.Error())
 		return nil, nil

rpc/stream/rpc.go

@@ -192,7 +192,7 @@ func (s *RPCStream) start(
 				s.logger.Error("event data type mismatch", "type", fmt.Sprintf("%T", ev.Data))
 				continue
 			}
-			txLogs, err := evmtypes.DecodeTxLogsFromEvents(dataTx.TxResult.Result.Data, uint64(dataTx.TxResult.Height))
+			txLogs, err := evmtypes.DecodeTxLogsFromEvents(dataTx.TxResult.Result.Data, dataTx.TxResult.Result.Events, uint64(dataTx.TxResult.Height))
 			if err != nil {
 				s.logger.Error("fail to decode evm tx response", "error", err.Error())
 				continue

x/evm/types/events.go

@@ -19,6 +19,7 @@ package types
 const (
 	EventTypeEthereumTx = TypeMsgEthereumTx
 	EventTypeBlockBloom = "block_bloom"
+	EventTypeTxLog      = "tx_log"
 
 	AttributeKeyContractAddress = "contract"
 	AttributeKeyRecipient       = "recipient"

x/evm/types/utils.go

@@ -17,9 +17,11 @@ package types
 
 import (
 	"encoding/hex"
+	"encoding/json"
 	"fmt"
 	"math/big"
 
+	abci "github.com/cometbft/cometbft/abci/types"
 	"github.com/cosmos/gogoproto/proto"
 	feemarkettypes "github.com/evmos/ethermint/x/feemarket/types"
 
@@ -97,7 +99,7 @@ func logsFromTxResponse(dst []*ethtypes.Log, rsp *MsgEthereumTxResponse, blockNu
 }
 
 // DecodeMsgLogsFromEvents decodes a protobuf-encoded byte slice into ethereum logs, for a single message.
-func DecodeMsgLogsFromEvents(in []byte, msgIndex int, blockNumber uint64) ([]*ethtypes.Log, error) {
+func DecodeMsgLogsFromEvents(in []byte, events []abci.Event, msgIndex int, blockNumber uint64) ([]*ethtypes.Log, error) {
 	txResponses, err := DecodeTxResponses(in)
 	if err != nil {
 		return nil, err
@@ -107,11 +109,55 @@ func DecodeMsgLogsFromEvents(in []byte, msgIndex int, blockNumber uint64) ([]*et
 		return nil, fmt.Errorf("invalid message index: %d", msgIndex)
 	}
 
-	return logsFromTxResponse(nil, txResponses[msgIndex], blockNumber), nil
+	logs, err := logsFromTxResponse(nil, txResponses[msgIndex], blockNumber), nil
+	if err != nil {
+		return nil, err
+	}
+
+	if len(logs) == 0 {
+		logs, err = TxLogsFromEvents(events, msgIndex)
+	}
+	return logs, err
+}
+
+// TxLogsFromEvents parses ethereum logs from cosmos events for specific msg index
+func TxLogsFromEvents(events []abci.Event, msgIndex int) ([]*ethtypes.Log, error) {
+	for _, event := range events {
+		if event.Type != EventTypeTxLog {
+			continue
+		}
+
+		if msgIndex > 0 {
+			// not the eth tx we want
+			msgIndex--
+			continue
+		}
+
+		return ParseTxLogsFromEvent(event)
+	}
+	return nil, fmt.Errorf("eth tx logs not found for message index %d", msgIndex)
+}
+
+// ParseTxLogsFromEvent parse tx logs from one event
+func ParseTxLogsFromEvent(event abci.Event) ([]*ethtypes.Log, error) {
+	logs := make([]*Log, 0, len(event.Attributes))
+	for _, attr := range event.Attributes {
+		if attr.Key != AttributeKeyTxLog {
+			continue
+		}
+
+		var log Log
+		if err := json.Unmarshal([]byte(attr.Value), &log); err != nil {
+			return nil, err
+		}
+
+		logs = append(logs, &log)
+	}
+	return LogsToEthereum(logs), nil
 }
 
 // DecodeTxLogsFromEvents decodes a protobuf-encoded byte slice into ethereum logs
-func DecodeTxLogsFromEvents(in []byte, blockNumber uint64) ([]*ethtypes.Log, error) {
+func DecodeTxLogsFromEvents(in []byte, events []abci.Event, blockNumber uint64) ([]*ethtypes.Log, error) {
 	txResponses, err := DecodeTxResponses(in)
 	if err != nil {
 		return nil, err
@@ -120,6 +166,18 @@ func DecodeTxLogsFromEvents(in []byte, blockNumber uint64) ([]*ethtypes.Log, err
 	for _, response := range txResponses {
 		logs = logsFromTxResponse(logs, response, blockNumber)
 	}
+	if len(logs) == 0 {
+		for _, event := range events {
+			if event.Type != EventTypeTxLog {
+				continue
+			}
+			txLogs, err := ParseTxLogsFromEvent(event)
+			if err != nil {
+				return nil, err
+			}
+			logs = append(logs, txLogs...)
+		}
+	}
 	return logs, nil
 }