refactor!: Using the MsgEthereumTx interface in the rpc module

ante/evm/11_emit_event.go

@@ -15,7 +15,7 @@ func EmitTxHashEvent(ctx sdk.Context, msg *evmtypes.MsgEthereumTx, blockTxIndex
 	ctx.EventManager().EmitEvent(
 		sdk.NewEvent(
 			evmtypes.EventTypeEthereumTx,
-			sdk.NewAttribute(evmtypes.AttributeKeyEthereumTxHash, msg.Hash().String()),
+			sdk.NewAttribute(evmtypes.AttributeKeyEthereumTxHash, msg.AsTransaction().Hash().String()),
 			sdk.NewAttribute(evmtypes.AttributeKeyTxIndex, strconv.FormatUint(blockTxIndex, 10)), // #nosec G115
 		),
 	)

ante/tx_listener.go

@@ -27,7 +27,7 @@ func (d TxListenerDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate boo
 	if ctx.IsCheckTx() && !simulate && d.pendingTxListener != nil {
 		for _, msg := range tx.GetMsgs() {
 			if ethTx, ok := msg.(*evmtypes.MsgEthereumTx); ok {
-				d.pendingTxListener(ethTx.Hash())
+				d.pendingTxListener(ethTx.AsTransaction().Hash())
 			}
 		}
 	}

indexer/kv_indexer.go

@@ -82,7 +82,7 @@ func (kv *KVIndexer) IndexBlock(block *cmttypes.Block, txResults []*abci.ExecTxR
 		var cumulativeGasUsed uint64
 		for msgIndex, msg := range tx.GetMsgs() {
 			ethMsg := msg.(*evmtypes.MsgEthereumTx)
-			txHash := ethMsg.Hash()
+			txHash := ethMsg.AsTransaction().Hash()
 
 			txResult := servertypes.TxResult{
 				Height:     height,

mempool/mempool.go

@@ -409,7 +409,7 @@ func (m *Mempool) removeCosmosTx(tx sdk.Tx, reason sdkmempool.RemoveReason) erro
 func (m *Mempool) removeEVMTx(tx sdk.Tx, msgEthereumTx *evmtypes.MsgEthereumTx, reason sdkmempool.RemoveReason) error {
 	m.logger.Debug("Removing EVM transaction")
 
-	hash := msgEthereumTx.Hash()
+	hash := msgEthereumTx.AsTransaction().Hash()
 	if reason.Caller == sdkmempool.CallerRunTxFinalize {
 		_ = m.txTracker.IncludedInBlock(hash)
 		m.recordNonceAdvances(tx)

rpc/backend/backend.go

@@ -76,7 +76,7 @@ type EVMBackend interface {
 	CometBlockByHash(ctx context.Context, blockHash common.Hash) (*tmrpctypes.ResultBlock, error)
 	BlockNumberFromComet(ctx context.Context, blockNrOrHash types.BlockNumberOrHash) (types.BlockNumber, error)
 	BlockNumberFromCometByHash(ctx context.Context, blockHash common.Hash) (*big.Int, error)
-	EthMsgsFromCometBlock(ctx context.Context, block *tmrpctypes.ResultBlock, blockRes *tmrpctypes.ResultBlockResults) []*evmtypes.MsgEthereumTx
+	EthMsgsFromCometBlock(ctx context.Context, block *tmrpctypes.ResultBlock, blockRes *tmrpctypes.ResultBlockResults) []evmtypes.RPCMsgEthereumTxI
 	BlockBloomFromCometBlock(ctx context.Context, blockRes *tmrpctypes.ResultBlockResults) (ethtypes.Bloom, error)
 	HeaderByNumber(ctx context.Context, blockNum types.BlockNumber) (*ethtypes.Header, error)
 	HeaderByHash(ctx context.Context, blockHash common.Hash) (*ethtypes.Header, error)

rpc/backend/comet_to_eth.go

@@ -106,10 +106,10 @@ func (b *Backend) EthMsgsFromCometBlock(
 	ctx context.Context,
 	resBlock *cmtrpctypes.ResultBlock,
 	blockRes *cmtrpctypes.ResultBlockResults,
-) []*evmtypes.MsgEthereumTx {
+) []evmtypes.RPCMsgEthereumTxI {
 	_, span := tracer.Start(ctx, "EthMsgsFromCometBlock")
 	defer span.End()
-	var result []*evmtypes.MsgEthereumTx
+	var result []evmtypes.RPCMsgEthereumTxI
 	block := resBlock.Block
 
 	txResults := blockRes.TxsResults
@@ -130,7 +130,7 @@ func (b *Backend) EthMsgsFromCometBlock(
 		}
 
 		for _, msg := range tx.GetMsgs() {
-			ethMsg, ok := msg.(*evmtypes.MsgEthereumTx)
+			ethMsg, ok := msg.(evmtypes.RPCMsgEthereumTxI)
 			if !ok {
 				continue
 			}
@@ -254,7 +254,7 @@ func (b *Backend) ReceiptsFromCometBlock(
 	ctx context.Context,
 	resBlock *cmtrpctypes.ResultBlock,
 	blockRes *cmtrpctypes.ResultBlockResults,
-	msgs []*evmtypes.MsgEthereumTx,
+	msgs []evmtypes.RPCMsgEthereumTxI,
 ) (result []*ethtypes.Receipt, err error) {
 	ctx, span := tracer.Start(ctx, "ReceiptsFromCometBlock")
 	defer func() { evmtrace.EndSpanErr(span, err) }()
@@ -269,9 +269,10 @@ func (b *Backend) ReceiptsFromCometBlock(
 	receipts := make([]*ethtypes.Receipt, len(msgs))
 	cumulatedGasUsed := uint64(0)
 	for i, ethMsg := range msgs {
-		txResult, err := b.GetTxByEthHash(ctx, ethMsg.Hash())
+		tx := ethMsg.AsTransaction()
+		txResult, err := b.GetTxByEthHash(ctx, tx.Hash())
 		if err != nil {
-			return nil, fmt.Errorf("tx not found: hash=%s, error=%s", ethMsg.Hash(), err.Error())
+			return nil, fmt.Errorf("tx not found: hash=%s, error=%s", tx.Hash().Hex(), err.Error())
 		}
 
 		// Resolve -1 sentinel: indexer hasn't assigned EthTxIndex yet.
@@ -285,9 +286,9 @@ func (b *Backend) ReceiptsFromCometBlock(
 
 		var effectiveGasPrice *big.Int
 		if baseFee != nil {
-			effectiveGasPrice = rpctypes.EffectiveGasPrice(ethMsg.Raw.Transaction, baseFee)
+			effectiveGasPrice = rpctypes.EffectiveGasPrice(tx, baseFee)
 		} else {
-			effectiveGasPrice = ethMsg.Raw.GasFeeCap()
+			effectiveGasPrice = tx.GasFeeCap()
 		}
 
 		var status uint64
@@ -298,8 +299,8 @@ func (b *Backend) ReceiptsFromCometBlock(
 		}
 
 		contractAddress := common.Address{}
-		if ethMsg.Raw.To() == nil {
-			contractAddress = crypto.CreateAddress(ethMsg.GetSender(), ethMsg.Raw.Nonce())
+		if tx.To() == nil {
+			contractAddress = crypto.CreateAddress(common.BytesToAddress(ethMsg.GetFrom().Bytes()), tx.Nonce())
 		}
 
 		msgIndex := int(txResult.MsgIndex) // #nosec G115 -- checked for int overflow already
@@ -315,7 +316,7 @@ func (b *Backend) ReceiptsFromCometBlock(
 		if txResult.EthTxIndex == -1 {
 			var err error
 			// Fallback to find tx index by iterating all valid eth transactions
-			txResult.EthTxIndex, err = b.FindEthTxIndexByHash(ctx, ethMsg.Hash(), resBlock, blockRes)
+			txResult.EthTxIndex, err = b.FindEthTxIndexByHash(ctx, ethMsg.AsTransaction().Hash(), resBlock, blockRes)
 			if err != nil {
 				return nil, err
 			}
@@ -325,15 +326,15 @@ func (b *Backend) ReceiptsFromCometBlock(
 
 		receipt := &ethtypes.Receipt{
 			// Consensus fields: These fields are defined by the Yellow Paper
-			Type:              ethMsg.Raw.Type(),
+			Type:              tx.Type(),
 			PostState:         nil,
 			Status:            status, // convert to 1=success, 0=failure
 			CumulativeGasUsed: cumulatedGasUsed,
 			Bloom:             bloom,
 			Logs:              logs,
 
 			// Implementation fields: These fields are added by geth when processing a transaction.
-			TxHash:            ethMsg.Hash(),
+			TxHash:            tx.Hash(),
 			ContractAddress:   contractAddress,
 			GasUsed:           txResult.GasUsed,
 			EffectiveGasPrice: effectiveGasPrice,

rpc/backend/tx_info.go

@@ -53,7 +53,7 @@ func (b *Backend) GetTransactionByHash(ctx context.Context, txHash common.Hash)
 	}
 
 	// the `res.MsgIndex` is inferred from tx index, should be within the bound.
-	msg, ok := tx.GetMsgs()[res.MsgIndex].(*evmtypes.MsgEthereumTx)
+	msg, ok := tx.GetMsgs()[res.MsgIndex].(evmtypes.RPCMsgEthereumTxI)
 	if !ok {
 		return nil, errors.New("invalid ethereum tx")
 	}
@@ -113,7 +113,7 @@ func (b *Backend) GetTransactionByHashPending(ctx context.Context, txHash common
 			continue
 		}
 
-		if msg.Hash() == txHash {
+		if msg.AsTransaction().Hash() == txHash {
 			// use zero block values since it's not included in a block yet
 			return rpctypes.NewTransactionFromMsg(
 				msg,
@@ -194,8 +194,8 @@ func (b *Backend) GetTransactionReceipt(ctx context.Context, hash common.Hash) (
 		return nil, fmt.Errorf("block result not found at height %d: %w", res.Height, err)
 	}
 
-	ethMsg := tx.GetMsgs()[res.MsgIndex].(*evmtypes.MsgEthereumTx)
-	receipts, err := b.ReceiptsFromCometBlock(ctx, resBlock, blockRes, []*evmtypes.MsgEthereumTx{ethMsg})
+	ethMsg := tx.GetMsgs()[res.MsgIndex].(evmtypes.RPCMsgEthereumTxI)
+	receipts, err := b.ReceiptsFromCometBlock(ctx, resBlock, blockRes, []evmtypes.RPCMsgEthereumTxI{ethMsg})
 	if err != nil {
 		return nil, fmt.Errorf("failed to get receipts from comet block")
 	}
@@ -391,7 +391,7 @@ func (b *Backend) GetTransactionByBlockAndIndex(ctx context.Context, block *cmtr
 		return nil, nil
 	}
 
-	var msg *evmtypes.MsgEthereumTx
+	var msg evmtypes.RPCMsgEthereumTxI
 	// find in tx indexer
 	res, err := b.GetTxByTxIndex(ctx, block.Block.Height, uint(idx))
 	if err == nil {
@@ -403,7 +403,7 @@ func (b *Backend) GetTransactionByBlockAndIndex(ctx context.Context, block *cmtr
 
 		var ok bool
 		// msgIndex is inferred from tx events, should be within bound.
-		msg, ok = tx.GetMsgs()[res.MsgIndex].(*evmtypes.MsgEthereumTx)
+		msg, ok = tx.GetMsgs()[res.MsgIndex].(evmtypes.RPCMsgEthereumTxI)
 		if !ok {
 			b.Logger.Debug("invalid ethereum tx", "height", block.Block.Header, "index", idx)
 			return nil, nil

rpc/backend/tx_info_test.go

@@ -498,7 +498,7 @@ func TestReceiptsFromCometBlock(t *testing.T) {
 	}
 	for _, tc := range tcs {
 		t.Run(tc.name, func(t *testing.T) {
-			msgs := []*evmtypes.MsgEthereumTx{
+			msgs := []evmtypes.RPCMsgEthereumTxI{
 				buildMsgEthereumTx(t),
 			}
 			expectedTxResult := &servertypes.TxResult{
@@ -509,7 +509,7 @@ func TestReceiptsFromCometBlock(t *testing.T) {
 			}
 			mockIndexer := &MockIndexer{
 				txResults: map[common.Hash]*servertypes.TxResult{
-					msgs[0].Hash(): expectedTxResult,
+					msgs[0].AsTransaction().Hash(): expectedTxResult,
 				},
 			}
 			backend.Indexer = mockIndexer
@@ -519,7 +519,7 @@ func TestReceiptsFromCometBlock(t *testing.T) {
 			require.NoError(t, err)
 			require.Len(t, receipts, 1)
 			require.Equal(t, tc.expectedTxIndex, receipts[0].TransactionIndex)
-			require.Equal(t, msgs[0].Hash(), receipts[0].TxHash)
+			require.Equal(t, msgs[0].AsTransaction().Hash(), receipts[0].TxHash)
 			require.Equal(t, big.NewInt(height), receipts[0].BlockNumber)
 			require.Equal(t, ethtypes.ReceiptStatusSuccessful, receipts[0].Status)
 		})
@@ -560,8 +560,8 @@ func TestReceiptsLogIndexBlockGlobal(t *testing.T) {
 		return data
 	}
 
-	tx0Data := encodeTxResult(makeTxResponse(msg0.Hash().Hex(), 0))
-	tx1Data := encodeTxResult(makeTxResponse(msg1.Hash().Hex(), 1))
+	tx0Data := encodeTxResult(makeTxResponse(msg0.AsTransaction().Hash().Hex(), 0))
+	tx1Data := encodeTxResult(makeTxResponse(msg1.AsTransaction().Hash().Hex(), 1))
 
 	resBlock := &tmrpctypes.ResultBlock{
 		Block: &tmtypes.Block{Header: tmtypes.Header{Height: height}},
@@ -580,16 +580,16 @@ func TestReceiptsLogIndexBlockGlobal(t *testing.T) {
 
 	mockIndexer := &MockIndexer{
 		txResults: map[common.Hash]*servertypes.TxResult{
-			msg0.Hash(): {Height: height, TxIndex: 0, EthTxIndex: 0, MsgIndex: 0},
-			msg1.Hash(): {Height: height, TxIndex: 1, EthTxIndex: 1, MsgIndex: 0},
+			msg0.AsTransaction().Hash(): {Height: height, TxIndex: 0, EthTxIndex: 0, MsgIndex: 0},
+			msg1.AsTransaction().Hash(): {Height: height, TxIndex: 1, EthTxIndex: 1, MsgIndex: 0},
 		},
 	}
 	backend.Indexer = mockIndexer
 
 	mockEVMQueryClient := backend.QueryClient.QueryClient.(*mocks.EVMQueryClient)
 	mockEVMQueryClient.On("BaseFee", mock.Anything, mock.Anything).Return(&evmtypes.QueryBaseFeeResponse{}, nil)
 
-	msgs := []*evmtypes.MsgEthereumTx{msg0, msg1}
+	msgs := []evmtypes.RPCMsgEthereumTxI{msg0, msg1}
 	receipts, err := backend.ReceiptsFromCometBlock(rpctypes.NewContextWithHeight(1), resBlock, blockRes, msgs)
 	require.NoError(t, err)
 	require.Len(t, receipts, 2)

rpc/backend/utils.go

@@ -95,7 +95,7 @@ func (b *Backend) getAccountNonce(ctx context.Context, accAddr common.Address, p
 	// only supports `MsgEthereumTx` style tx
 	for _, tx := range pendingTxs {
 		for _, msg := range (*tx).GetMsgs() {
-			ethMsg, ok := msg.(*evmtypes.MsgEthereumTx)
+			ethMsg, ok := msg.(evmtypes.RPCMsgEthereumTxI)
 			if !ok {
 				// not ethereum tx
 				break
@@ -255,7 +255,7 @@ func (b *Backend) ProcessBlock(
 		}
 		txGasUsed := uint64(cometTxResult.GasUsed) // #nosec G115
 		for _, msg := range tx.GetMsgs() {
-			ethMsg, ok := msg.(*evmtypes.MsgEthereumTx)
+			ethMsg, ok := msg.(evmtypes.RPCMsgEthereumTxI)
 			if !ok {
 				continue
 			}
@@ -362,7 +362,7 @@ func unwrapBlockNOrHash(blockNOrHash types.BlockNumberOrHash) string {
 func (b *Backend) FindEthTxIndexByHash(ctx context.Context, txHash common.Hash, block *cmtrpctypes.ResultBlock, blockRes *cmtrpctypes.ResultBlockResults) (int32, error) {
 	msgs := b.EthMsgsFromCometBlock(ctx, block, blockRes)
 	for i := range msgs {
-		if msgs[i].Hash() == txHash {
+		if msgs[i].AsTransaction().Hash() == txHash {
 			if i > math.MaxInt32 {
 				return -1, fmt.Errorf("tx index overflow")
 			}

rpc/types/events.go

@@ -133,7 +133,7 @@ func ParseTxResult(result *abci.ExecTxResult, tx sdk.Tx) (*ParsedTxs, error) {
 			p.Txs[i].Failed = true
 
 			// replace gasUsed with gasLimit because that's what's actually deducted.
-			gasLimit := tx.GetMsgs()[i].(*evmtypes.MsgEthereumTx).GetGas()
+			gasLimit := tx.GetMsgs()[i].(evmtypes.RPCMsgEthereumTxI).GetGas()
 			p.Txs[i].GasUsed = gasLimit
 		}
 	}

rpc/types/utils.go

@@ -30,15 +30,15 @@ import (
 )
 
 // RawTxToEthTx returns a evm MsgEthereum transaction from raw tx bytes.
-func RawTxToEthTx(clientCtx client.Context, txBz cmttypes.Tx) ([]*evmtypes.MsgEthereumTx, error) {
+func RawTxToEthTx(clientCtx client.Context, txBz cmttypes.Tx) ([]evmtypes.RPCMsgEthereumTxI, error) {
 	tx, err := clientCtx.TxConfig.TxDecoder()(txBz)
 	if err != nil {
 		return nil, errorsmod.Wrap(errortypes.ErrJSONUnmarshal, err.Error())
 	}
 
-	ethTxs := make([]*evmtypes.MsgEthereumTx, len(tx.GetMsgs()))
+	ethTxs := make([]evmtypes.RPCMsgEthereumTxI, len(tx.GetMsgs()))
 	for i, msg := range tx.GetMsgs() {
-		ethTx, ok := msg.(*evmtypes.MsgEthereumTx)
+		ethTx, ok := msg.(evmtypes.RPCMsgEthereumTxI)
 		if !ok {
 			return nil, fmt.Errorf("invalid message type %T, expected %T", msg, &evmtypes.MsgEthereumTx{})
 		}
@@ -152,7 +152,7 @@ func MakeHeader(
 // NewTransactionFromMsg returns a transaction that will serialize to the RPC
 // representation, with the given location metadata set (if available).
 func NewTransactionFromMsg(
-	msg *evmtypes.MsgEthereumTx,
+	msg evmtypes.RPCMsgEthereumTxI,
 	blockHash common.Hash,
 	blockNumber, blockTime, index uint64,
 	baseFee *big.Int,
@@ -410,7 +410,7 @@ func RPCMarshalHeader(head *ethtypes.Header, blockHash []byte) map[string]interf
 //
 // This method refers to go-ethereum v1.16.3 internal package method - RPCMarshalBlock
 // (https://github.com/ethereum/go-ethereum/blob/d818a9af7bd5919808df78f31580f59382c53150/internal/ethapi/api.go#L929-L962)
-func RPCMarshalBlock(block *ethtypes.Block, cmtBlock *cmtrpccore.ResultBlock, msgs []*evmtypes.MsgEthereumTx, inclTx bool, fullTx bool, config *ethparams.ChainConfig) (map[string]interface{}, error) {
+func RPCMarshalBlock(block *ethtypes.Block, cmtBlock *cmtrpccore.ResultBlock, msgs []evmtypes.RPCMsgEthereumTxI, inclTx bool, fullTx bool, config *ethparams.ChainConfig) (map[string]interface{}, error) {
 	blockHash := cmtBlock.BlockID.Hash.Bytes()
 	fields := RPCMarshalHeader(block.Header(), blockHash)
 	fields["size"] = hexutil.Uint64(block.Size())

tests/integration/rpc/backend/test_backend_suite.go

@@ -181,9 +181,9 @@ func (s *TestSuite) buildFormattedBlock(
 	validator sdk.AccAddress,
 	baseFee *big.Int,
 ) map[string]interface{} {
-	var msgs []*evmtypes.MsgEthereumTx
+	var msgs []evmtypes.RPCMsgEthereumTxI
 	if tx != nil {
-		msgs = []*evmtypes.MsgEthereumTx{tx}
+		msgs = []evmtypes.RPCMsgEthereumTxI{tx}
 	}
 	ethBlock := s.buildEthBlock(blockRes, resBlock, msgs, validator, baseFee)
 	res, err := rpctypes.RPCMarshalBlock(ethBlock, resBlock, msgs, true, fullTx, s.backend.ChainConfig())
@@ -195,7 +195,7 @@ func (s *TestSuite) buildFormattedBlock(
 func (s *TestSuite) buildEthBlock(
 	blockRes *cmtrpctypes.ResultBlockResults,
 	resBlock *cmtrpctypes.ResultBlock,
-	msgs []*evmtypes.MsgEthereumTx,
+	msgs []evmtypes.RPCMsgEthereumTxI,
 	validator sdk.AccAddress,
 	baseFee *big.Int,
 ) *ethtypes.Block {

tests/integration/rpc/backend/test_call_tx.go

@@ -362,7 +362,7 @@ func (s *TestSuite) TestSendRawTransaction() {
 				bytes, _ := rlp.EncodeToBytes(ethTx.AsTransaction())
 				return bytes
 			},
-			expHash:  ethTx.Hash(),
+			expHash:  ethTx.AsTransaction().Hash(),
 			expError: "queue is full",
 		},
 		{
@@ -374,7 +374,7 @@ func (s *TestSuite) TestSendRawTransaction() {
 				RegisterMempoolInsert(s.T(), s.Mempool(), cosmosTx, nil)
 			},
 			rawTx:   func() []byte { return rlpEncodedBz },
-			expHash: ethTx.Hash(),
+			expHash: ethTx.AsTransaction().Hash(),
 			expPass: true,
 		},
 	}