feat: don't emit EVM logs into cosmos-sdk events (#576)

* feat: don't emit EVM logs into cosmos-sdk events

* add doc

* no need parse for old event

* less diff

* cleanup

* test

* test

* Update CHANGELOG.md

* Apply suggestions from code review

* Apply suggestions from code review

---------

Co-authored-by: Alex | Interchain Labs <[email protected]>

Author: mmsqe

CHANGELOG.md

@@ -22,6 +22,7 @@
 - [\#496](https://github.com/cosmos/evm/pull/496) Simplify mempool instantiation by using configs instead of objects.
 - [\#568](https://github.com/cosmos/evm/pull/568) Avoid unnecessary block notifications when the event bus is already set up.
 - [\#511](https://github.com/cosmos/evm/pull/511) Minor code cleanup for `AddPrecompileFn`.
+- [\#544](https://github.com/cosmos/evm/pull/544) Parse logs from the txResult.Data and avoid emitting EVM events to cosmos-sdk events.
 
 ### FEATURES
 

rpc/backend/blocks.go

@@ -610,10 +610,18 @@ func (b *Backend) formatTxReceipt(
 	if err != nil {
 		return nil, err
 	}
+	height, err := cosmosevmtypes.SafeUint64(blockRes.Height)
+	if err != nil {
+		return nil, err
+	}
 
 	// parse tx logs from events
 	msgIndex := int(txResult.MsgIndex) // #nosec G115 -- checked for int overflow already
-	logs, err := evmtypes.TxLogsFromEvents(blockRes.TxsResults[txResult.TxIndex].Events, msgIndex)
+	logs, err := evmtypes.DecodeMsgLogs(
+		blockRes.TxsResults[txResult.TxIndex].Data,
+		msgIndex,
+		height,
+	)
 	if err != nil {
 		b.Logger.Debug("failed to parse logs", "hash", ethMsg.Hash().String(), "error", err.Error())
 	}

rpc/backend/tx_info.go

@@ -214,10 +214,22 @@ func (b *Backend) GetTransactionLogs(hash common.Hash) ([]*ethtypes.Log, error)
 		b.Logger.Debug("block result not found", "number", res.Height, "error", err.Error())
 		return nil, nil
 	}
-
+	height, err := types.SafeUint64(resBlockResult.Height)
+	if err != nil {
+		return nil, err
+	}
 	// parse tx logs from events
 	index := int(res.MsgIndex) // #nosec G701
-	return evmtypes.TxLogsFromEvents(resBlockResult.TxsResults[res.TxIndex].Events, index)
+	logs, err := evmtypes.DecodeMsgLogs(
+		resBlockResult.TxsResults[res.TxIndex].Data,
+		index,
+		height,
+	)
+	if err != nil {
+		b.Logger.Debug("failed to parse tx logs", "error", err.Error())
+	}
+
+	return logs, nil
 }
 
 // GetTransactionByBlockHashAndIndex returns the transaction identified by hash and index.

rpc/backend/utils.go

@@ -266,7 +266,7 @@ func GetLogsFromBlockResults(blockRes *cmtrpctypes.ResultBlockResults) ([][]*eth
 	}
 	blockLogs := [][]*ethtypes.Log{}
 	for _, txResult := range blockRes.TxsResults {
-		logs, err := evmtypes.DecodeTxLogsFromEvents(txResult.Data, txResult.Events, height)
+		logs, err := evmtypes.DecodeTxLogs(txResult.Data, height)
 		if err != nil {
 			return nil, err
 		}

rpc/stream/rpc.go

@@ -187,7 +187,7 @@ func (s *RPCStream) start(
 			if err != nil {
 				continue
 			}
-			txLogs, err := evmtypes.DecodeTxLogsFromEvents(dataTx.Result.Data, dataTx.Result.Events, height)
+			txLogs, err := evmtypes.DecodeTxLogs(dataTx.Result.Data, height)
 			if err != nil {
 				s.logger.Error("fail to decode evm tx response", "error", err.Error())
 				continue

rpc/types/events_test.go

@@ -58,7 +58,6 @@ func TestParseTxResult(t *testing.T) {
 						{Key: "recipient", Value: "0x775b87ef5D82ca211811C1a02CE0fE0CA3a455d7"},
 						{Key: "ethereumTxFailed", Value: "contract everted"},
 					}},
-					{Type: evmtypes.EventTypeTxLog, Attributes: []abci.EventAttribute{}},
 				},
 			},
 			[]*ParsedTx{
@@ -143,7 +142,6 @@ func TestParseTxResult(t *testing.T) {
 						{Key: "recipient", Value: "0x775b87ef5D82ca211811C1a02CE0fE0CA3a455d7"},
 						{Key: "ethereumTxFailed", Value: "contract everted"},
 					}},
-					{Type: evmtypes.EventTypeTxLog, Attributes: []abci.EventAttribute{}},
 				},
 			},
 			nil,

tests/integration/rpc/backend/test_client.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/gogo/protobuf/proto"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 
@@ -23,6 +24,7 @@ import (
 
 	"github.com/cosmos/cosmos-sdk/client"
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
 	errortypes "github.com/cosmos/cosmos-sdk/types/errors"
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 )
@@ -199,19 +201,23 @@ func TestRegisterConsensusParams(t *testing.T) {
 }
 
 // BlockResults
-
 func RegisterBlockResultsWithEventLog(client *mocks.Client, height int64) (*cmtrpctypes.ResultBlockResults, error) {
+	anyValue, err := codectypes.NewAnyWithValue(&evmtypes.MsgEthereumTxResponse{
+		Logs: []*evmtypes.Log{
+			{Data: []byte("data")},
+		},
+	})
+	if err != nil {
+		return nil, err
+	}
+	data, err := proto.Marshal(&sdk.TxMsgData{MsgResponses: []*codectypes.Any{anyValue}})
+	if err != nil {
+		return nil, err
+	}
 	res := &cmtrpctypes.ResultBlockResults{
 		Height: height,
 		TxsResults: []*abci.ExecTxResult{
-			{Code: 0, GasUsed: 0, Events: []abci.Event{{
-				Type: evmtypes.EventTypeTxLog,
-				Attributes: []abci.EventAttribute{{
-					Key:   evmtypes.AttributeKeyTxLog,
-					Value: "{\"test\": \"hello\"}", // TODO refactor the value to unmarshall to a evmtypes.Log struct successfully
-					Index: true,
-				}},
-			}}},
+			{Code: 0, GasUsed: 0, Data: data},
 		},
 	}
 	client.On("BlockResults", rpc.ContextWithHeight(height), mock.AnythingOfType("*int64")).

tests/integration/rpc/backend/test_filters.go

@@ -1,8 +1,6 @@
 package backend
 
 import (
-	"encoding/json"
-
 	"github.com/ethereum/go-ethereum/common"
 	ethtypes "github.com/ethereum/go-ethereum/core/types"
 
@@ -16,12 +14,12 @@ import (
 func (s *TestSuite) TestGetLogs() {
 	_, bz := s.buildEthereumTx()
 	block := cmttypes.MakeBlock(1, []cmttypes.Tx{bz}, nil, nil)
-	logs := make([]*evmtypes.Log, 0, 1)
-	var log evmtypes.Log
-	err := json.Unmarshal([]byte("{\"test\": \"hello\"}"), &log) // TODO refactor this to unmarshall to a log struct successfully
-	s.Require().NoError(err)
-
-	logs = append(logs, &log)
+	logs := []*evmtypes.Log{
+		{
+			Data:        []byte("data"),
+			BlockNumber: 1,
+		},
+	}
 
 	testCases := []struct {
 		name         string

tests/integration/x/vm/test_msg_server.go

@@ -63,7 +63,6 @@ func (s *KeeperTestSuite) TestEthereumTx() {
 				// check expected events were emitted
 				s.Require().NotEmpty(events)
 				s.Require().True(utils.ContainsEventType(events.ToABCIEvents(), types.EventTypeEthereumTx))
-				s.Require().True(utils.ContainsEventType(events.ToABCIEvents(), types.EventTypeTxLog))
 				s.Require().True(utils.ContainsEventType(events.ToABCIEvents(), sdktypes.EventTypeMessage))
 			}
 

x/vm/keeper/msg_server.go

@@ -3,7 +3,6 @@ package keeper
 import (
 	"context"
 	"encoding/hex"
-	"encoding/json"
 	"fmt"
 	"strconv"
 
@@ -99,25 +98,12 @@ func (k *Keeper) EthereumTx(goCtx context.Context, msg *types.MsgEthereumTx) (*t
 		attrs = append(attrs, sdk.NewAttribute(types.AttributeKeyEthereumTxFailed, response.VmError))
 	}
 
-	txLogAttrs := make([]sdk.Attribute, len(response.Logs))
-	for i, log := range response.Logs {
-		value, err := json.Marshal(log)
-		if err != nil {
-			return nil, errorsmod.Wrap(err, "failed to encode log")
-		}
-		txLogAttrs[i] = sdk.NewAttribute(types.AttributeKeyTxLog, string(value))
-	}
-
 	// emit events
 	ctx.EventManager().EmitEvents(sdk.Events{
 		sdk.NewEvent(
 			types.EventTypeEthereumTx,
 			attrs...,
 		),
-		sdk.NewEvent(
-			types.EventTypeTxLog,
-			txLogAttrs...,
-		),
 		sdk.NewEvent(
 			sdk.EventTypeMessage,
 			sdk.NewAttribute(sdk.AttributeKeyModule, types.AttributeValueCategory),