update development branch

CHANGELOG.md

@@ -44,6 +44,8 @@ Ref: https://keepachangelog.com/en/1.0.0/
 
 ### Bug Fixes
 
+* (evm) [\#747](https://github.com/cosmos/ethermint/issues/747) Fix format errors in String() of QueryETHLogs
+* (evm) [\#742](https://github.com/cosmos/ethermint/issues/742) Add parameter check for evm query func. 
 * (evm) [\#687](https://github.com/cosmos/ethermint/issues/687) Fix nonce check to explicitly check for the correct nonce, rather than a simple 'greater than' comparison. 
 * (api) [\#687](https://github.com/cosmos/ethermint/issues/687) Returns error for a transaction with an incorrect nonce. 
 * (evm) [\#674](https://github.com/cosmos/ethermint/issues/674) Reset all cache after account data has been committed in `EndBlock` to make sure every node state consistent.

x/evm/keeper/querier.go

@@ -19,6 +19,11 @@ import (
 // NewQuerier is the module level router for state queries
 func NewQuerier(keeper Keeper) sdk.Querier {
 	return func(ctx sdk.Context, path []string, _ abci.RequestQuery) ([]byte, error) {
+		if len(path) < 1 {
+			return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest,
+				"Insufficient parameters, at least 1 parameter is required")
+		}
+
 		switch path[0] {
 		case types.QueryBalance:
 			return queryBalance(ctx, path, keeper)
@@ -45,6 +50,11 @@ func NewQuerier(keeper Keeper) sdk.Querier {
 }
 
 func queryBalance(ctx sdk.Context, path []string, keeper Keeper) ([]byte, error) {
+	if len(path) < 2 {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest,
+			"Insufficient parameters, at least 2 parameters is required")
+	}
+
 	addr := ethcmn.HexToAddress(path[1])
 	balance := keeper.GetBalance(ctx, addr)
 	balanceStr, err := utils.MarshalBigInt(balance)
@@ -73,6 +83,11 @@ func queryBlockNumber(ctx sdk.Context, keeper Keeper) ([]byte, error) {
 }
 
 func queryStorage(ctx sdk.Context, path []string, keeper Keeper) ([]byte, error) {
+	if len(path) < 3 {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest,
+			"Insufficient parameters, at least 3 parameters is required")
+	}
+
 	addr := ethcmn.HexToAddress(path[1])
 	key := ethcmn.HexToHash(path[2])
 	val := keeper.GetState(ctx, addr, key)
@@ -85,6 +100,11 @@ func queryStorage(ctx sdk.Context, path []string, keeper Keeper) ([]byte, error)
 }
 
 func queryCode(ctx sdk.Context, path []string, keeper Keeper) ([]byte, error) {
+	if len(path) < 2 {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest,
+			"Insufficient parameters, at least 2 parameters is required")
+	}
+
 	addr := ethcmn.HexToAddress(path[1])
 	code := keeper.GetCode(ctx, addr)
 	res := types.QueryResCode{Code: code}
@@ -97,6 +117,11 @@ func queryCode(ctx sdk.Context, path []string, keeper Keeper) ([]byte, error) {
 }
 
 func queryHashToHeight(ctx sdk.Context, path []string, keeper Keeper) ([]byte, error) {
+	if len(path) < 2 {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest,
+			"Insufficient parameters, at least 2 parameters is required")
+	}
+
 	blockHash := ethcmn.FromHex(path[1])
 	blockNumber, found := keeper.GetBlockHash(ctx, blockHash)
 	if !found {
@@ -113,6 +138,11 @@ func queryHashToHeight(ctx sdk.Context, path []string, keeper Keeper) ([]byte, e
 }
 
 func queryBlockBloom(ctx sdk.Context, path []string, keeper Keeper) ([]byte, error) {
+	if len(path) < 2 {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest,
+			"Insufficient parameters, at least 2 parameters is required")
+	}
+
 	num, err := strconv.ParseInt(path[1], 10, 64)
 	if err != nil {
 		return nil, fmt.Errorf("could not unmarshal block height: %w", err)
@@ -133,6 +163,11 @@ func queryBlockBloom(ctx sdk.Context, path []string, keeper Keeper) ([]byte, err
 }
 
 func queryTransactionLogs(ctx sdk.Context, path []string, keeper Keeper) ([]byte, error) {
+	if len(path) < 2 {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest,
+			"Insufficient parameters, at least 2 parameters is required")
+	}
+
 	txHash := ethcmn.HexToHash(path[1])
 
 	logs, err := keeper.GetLogs(ctx, txHash)
@@ -161,6 +196,11 @@ func queryLogs(ctx sdk.Context, keeper Keeper) ([]byte, error) {
 }
 
 func queryAccount(ctx sdk.Context, path []string, keeper Keeper) ([]byte, error) {
+	if len(path) < 2 {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest,
+			"Insufficient parameters, at least 2 parameters is required")
+	}
+
 	addr := ethcmn.HexToAddress(path[1])
 	so := keeper.GetOrNewStateObject(ctx, addr)
 

x/evm/types/querier.go

@@ -71,7 +71,13 @@ type QueryETHLogs struct {
 }
 
 func (q QueryETHLogs) String() string {
-	return fmt.Sprintf("%+v", q.Logs)
+	var logsStr string
+	logsLen := len(q.Logs)
+	for i := 0; i < logsLen; i++ {
+		logsStr = fmt.Sprintf("%s%v\n", logsStr, *q.Logs[i])
+	}
+
+	return logsStr
 }
 
 // QueryBloomFilter is response type for tx logs query

x/evm/types/querier_test.go

@@ -0,0 +1,26 @@
+package types
+
+import (
+	ethtypes "github.com/ethereum/go-ethereum/core/types"
+	"github.com/stretchr/testify/require"
+	"strings"
+	"testing"
+)
+
+func TestQueryETHLogs_String(t *testing.T) {
+	const expectedQueryETHLogsStr = `{0x0000000000000000000000000000000000000000 [] [1 2 3 4] 9 0x0000000000000000000000000000000000000000000000000000000000000000 0 0x0000000000000000000000000000000000000000000000000000000000000000 0 false}
+{0x0000000000000000000000000000000000000000 [] [5 6 7 8] 10 0x0000000000000000000000000000000000000000000000000000000000000000 0 0x0000000000000000000000000000000000000000000000000000000000000000 0 false}
+`
+	logs := []*ethtypes.Log{
+		{
+			Data:        []byte{1, 2, 3, 4},
+			BlockNumber: 9,
+		},
+		{
+			Data:        []byte{5, 6, 7, 8},
+			BlockNumber: 10,
+		},
+	}
+
+	require.True(t, strings.EqualFold(expectedQueryETHLogsStr, QueryETHLogs{logs}.String()))
+}

x/evm/types/utils.go

@@ -68,13 +68,19 @@ type ResultData struct {
 
 // String implements fmt.Stringer interface.
 func (rd ResultData) String() string {
+	var logsStr string
+	logsLen := len(rd.Logs)
+	for i := 0; i < logsLen; i++ {
+		logsStr = fmt.Sprintf("%s\t\t%v\n ", logsStr, *rd.Logs[i])
+	}
+
 	return strings.TrimSpace(fmt.Sprintf(`ResultData:
 	ContractAddress: %s
 	Bloom: %s
-	Logs: %v
 	Ret: %v
-	TxHash: %s
-`, rd.ContractAddress.String(), rd.Bloom.Big().String(), rd.Logs, rd.Ret, rd.TxHash.String()))
+	TxHash: %s	
+	Logs: 
+%s`, rd.ContractAddress.String(), rd.Bloom.Big().String(), rd.Ret, rd.TxHash.String(), logsStr))
 }
 
 // EncodeResultData takes all of the necessary data from the EVM execution

x/evm/types/utils_test.go

@@ -1,6 +1,7 @@
 package types
 
 import (
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -34,3 +35,34 @@ func TestEvmDataEncoding(t *testing.T) {
 	require.Equal(t, data.Logs, res.Logs)
 	require.Equal(t, ret, res.Ret)
 }
+
+func TestResultData_String(t *testing.T) {
+	const expectedResultDataStr = `ResultData:
+	ContractAddress: 0x5dE8a020088a2D6d0a23c204FFbeD02790466B49
+	Bloom: 259
+	Ret: [5 8]
+	TxHash: 0x0000000000000000000000000000000000000000000000000000000000000000	
+	Logs: 
+		{0x0000000000000000000000000000000000000000 [] [1 2 3 4] 17 0x0000000000000000000000000000000000000000000000000000000000000000 0 0x0000000000000000000000000000000000000000000000000000000000000000 0 false}
+ 		{0x0000000000000000000000000000000000000000 [] [5 6 7 8] 18 0x0000000000000000000000000000000000000000000000000000000000000000 0 0x0000000000000000000000000000000000000000000000000000000000000000 0 false}`
+	addr := ethcmn.HexToAddress("0x5dE8a020088a2D6d0a23c204FFbeD02790466B49")
+	bloom := ethtypes.BytesToBloom([]byte{0x1, 0x3})
+	ret := []byte{0x5, 0x8}
+
+	data := ResultData{
+		ContractAddress: addr,
+		Bloom:           bloom,
+		Logs: []*ethtypes.Log{
+			{
+				Data:        []byte{1, 2, 3, 4},
+				BlockNumber: 17,
+			},
+			{
+				Data:        []byte{5, 6, 7, 8},
+				BlockNumber: 18,
+			}},
+		Ret: ret,
+	}
+
+	require.True(t, strings.EqualFold(expectedResultDataStr, data.String()))
+}