rpc, evm: fix eth_coinbase endpoint to return ethereum address of the validator node (#153)

* fix coinbase rpc endpoint to return ethereum address of the validator

* update changelog

* fix lint

* clean code and simplify logic

* fix changelog

* change request variable name and type

* add test

* fix proto comments

* fix proto comments

* Update x/evm/keeper/grpc_query.go

* Update x/evm/keeper/grpc_query.go

Co-authored-by: Federico Kunze <31522760+fedekunze@users.noreply.github.com>

CHANGELOG.md

@@ -58,6 +58,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
 * (evm) [tharsis#66](https://github.com/tharsis/ethermint/issues/66) Support legacy transaction types for signing.
 * (evm) [tharsis#24](https://github.com/tharsis/ethermint/pull/24) Implement metrics for `MsgEthereumTx`, state transitions, `BeginBlock` and `EndBlock`.
 * (rpc)  [#124](https://github.com/tharsis/ethermint/issues/124) Implement `txpool_content`, `txpool_inspect` and `txpool_status` RPC methods
+* (rpc) [tharsis#112](https://github.com/tharsis/ethermint/pull/153) Fix `eth_coinbase` to return the ethereum address of the validator
 
 ### Bug Fixes
 

docs/basics/json_rpc.md

@@ -57,7 +57,7 @@ Check the JSON-RPC methods and namespaces supported on Ethermint. {synopsis}
 | `eth_compileSerpent`                                                              | Eth       |             |                           |
 | `eth_signTransaction`                                                             | Eth       |             |                           |
 | `eth_mining`                                                                      | Eth       | N/A         | Not relevant to Ethermint |
-| `eth_coinbase`                                                                    | Eth       | N/A         | Not relevant to Ethermint |
+| [`eth_coinbase`](#eth-coinbase)                                                                    | Eth       | ✔           |                           |
 | `eth_hashrate`                                                                    | Eth       | N/A         | Not relevant to Ethermint |
 | `eth_getUncleCountByBlockHash`                                                    | Eth       | N/A         | Not relevant to Ethermint |
 | `eth_getUncleCountByBlockNumber`                                                  | Eth       | N/A         | Not relevant to Ethermint |
@@ -731,6 +731,19 @@ curl -X POST --data '{"jsonrpc":"2.0","method":"txpool_status","params":[],"id":
 {"jsonrpc":"2.0","id":1,"result":{"pending":"0x0","queued":"0x0"}}
 ```        
 
+### eth_coinbase
+
+Returns the account the mining rewards will be send to.
+
+
+```json
+// Request
+curl -X POST --data '{"jsonrpc":"2.0","method":"eth_coinbase","params":[],"id":1}' -H "Content-Type: application/json" http://localhost:8545
+
+// Result
+{"jsonrpc":"2.0","id":1,"result":"0x7cB61D4117AE31a12E393a1Cfa3BaC666481D02E"}
+```
+
 ## WebSocket Methods
 
 Read about websockets in [events](./../quickstart/events.md) {hide}

docs/core/proto-docs.md

@@ -45,6 +45,8 @@
     - [QueryStorageResponse](#ethermint.evm.v1alpha1.QueryStorageResponse)
     - [QueryTxLogsRequest](#ethermint.evm.v1alpha1.QueryTxLogsRequest)
     - [QueryTxLogsResponse](#ethermint.evm.v1alpha1.QueryTxLogsResponse)
+    - [QueryValidatorAccountRequest](#ethermint.evm.v1alpha1.QueryValidatorAccountRequest)
+    - [QueryValidatorAccountResponse](#ethermint.evm.v1alpha1.QueryValidatorAccountResponse)
   
     - [Query](#ethermint.evm.v1alpha1.Query)
   
@@ -704,6 +706,38 @@ QueryTxLogs is the response type for the Query/TxLogs RPC method.
 
 
 
+
+<a name="ethermint.evm.v1alpha1.QueryValidatorAccountRequest"></a>
+
+### QueryValidatorAccountRequest
+QueryValidatorAccountRequest is the request type for the Query/ValidatorAccount RPC method.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `cons_address` | [string](#string) |  | cons_address is the validator cons address to query the account for. |
+
+
+
+
+
+
+<a name="ethermint.evm.v1alpha1.QueryValidatorAccountResponse"></a>
+
+### QueryValidatorAccountResponse
+QueryValidatorAccountResponse is the response type for the Query/ValidatorAccount RPC method.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `account_address` | [string](#string) |  | account_address is the cosmos address of the account in bech32 format. |
+| `sequence` | [uint64](#uint64) |  | sequence is the account's sequence number. |
+| `account_number` | [uint64](#uint64) |  | account_number is the account number |
+
+
+
+
+
  <!-- end messages -->
 
  <!-- end enums -->
@@ -719,7 +753,8 @@ Query defines the gRPC querier service.
 | Method Name | Request Type | Response Type | Description | HTTP Verb | Endpoint |
 | ----------- | ------------ | ------------- | ------------| ------- | -------- |
 | `Account` | [QueryAccountRequest](#ethermint.evm.v1alpha1.QueryAccountRequest) | [QueryAccountResponse](#ethermint.evm.v1alpha1.QueryAccountResponse) | Account queries an Ethereum account. | GET|/ethermint/evm/v1alpha1/account/{address}|
-| `CosmosAccount` | [QueryCosmosAccountRequest](#ethermint.evm.v1alpha1.QueryCosmosAccountRequest) | [QueryCosmosAccountResponse](#ethermint.evm.v1alpha1.QueryCosmosAccountResponse) | Account queries an Ethereum account's Cosmos Address. | GET|/ethermint/evm/v1alpha1/cosmos_account/{address}|
+| `CosmosAccount` | [QueryCosmosAccountRequest](#ethermint.evm.v1alpha1.QueryCosmosAccountRequest) | [QueryCosmosAccountResponse](#ethermint.evm.v1alpha1.QueryCosmosAccountResponse) | CosmosAccount queries an Ethereum account's Cosmos Address. | GET|/ethermint/evm/v1alpha1/cosmos_account/{address}|
+| `ValidatorAccount` | [QueryValidatorAccountRequest](#ethermint.evm.v1alpha1.QueryValidatorAccountRequest) | [QueryValidatorAccountResponse](#ethermint.evm.v1alpha1.QueryValidatorAccountResponse) | ValidatorAccount queries an Ethereum account's from a validator consensus Address. | GET|/ethermint/evm/v1alpha1/validator_account/{cons_address}|
 | `Balance` | [QueryBalanceRequest](#ethermint.evm.v1alpha1.QueryBalanceRequest) | [QueryBalanceResponse](#ethermint.evm.v1alpha1.QueryBalanceResponse) | Balance queries the balance of a the EVM denomination for a single EthAccount. | GET|/ethermint/evm/v1alpha1/balances/{address}|
 | `Storage` | [QueryStorageRequest](#ethermint.evm.v1alpha1.QueryStorageRequest) | [QueryStorageResponse](#ethermint.evm.v1alpha1.QueryStorageResponse) | Storage queries the balance of all coins for a single account. | GET|/ethermint/evm/v1alpha1/storage/{address}/{key}|
 | `Code` | [QueryCodeRequest](#ethermint.evm.v1alpha1.QueryCodeRequest) | [QueryCodeResponse](#ethermint.evm.v1alpha1.QueryCodeResponse) | Code queries the balance of all coins for a single account. | GET|/ethermint/evm/v1alpha1/codes/{address}|

ethereum/rpc/eth_api.go

@@ -129,20 +129,31 @@ func (e *PublicEthAPI) Syncing() (interface{}, error) {
 }
 
 // Coinbase is the address that staking rewards will be send to (alias for Etherbase).
-func (e *PublicEthAPI) Coinbase() (common.Address, error) {
+func (e *PublicEthAPI) Coinbase() (string, error) {
 	e.logger.Debugln("eth_coinbase")
 
 	node, err := e.clientCtx.GetNode()
 	if err != nil {
-		return common.Address{}, err
+		return "", err
 	}
 
 	status, err := node.Status(e.ctx)
 	if err != nil {
-		return common.Address{}, err
+		return "", err
 	}
 
-	return common.BytesToAddress(status.ValidatorInfo.Address.Bytes()), nil
+	req := &evmtypes.QueryValidatorAccountRequest{
+		ConsAddress: sdk.ConsAddress(status.ValidatorInfo.Address).String(),
+	}
+
+	res, err := e.queryClient.ValidatorAccount(e.ctx, req)
+	if err != nil {
+		return "", err
+	}
+
+	toAddr, _ := sdk.AccAddressFromBech32(res.AccountAddress)
+	ethAddr := common.BytesToAddress(toAddr.Bytes())
+	return ethAddr.Hex(), nil
 }
 
 // Mining returns whether or not this node is currently mining. Always false.

proto/ethermint/evm/v1alpha1/query.proto

@@ -15,11 +15,16 @@ service Query {
     option (google.api.http).get = "/ethermint/evm/v1alpha1/account/{address}";
   }
 
-  // Account queries an Ethereum account's Cosmos Address.
+  // CosmosAccount queries an Ethereum account's Cosmos Address.
   rpc CosmosAccount(QueryCosmosAccountRequest) returns (QueryCosmosAccountResponse) {
     option (google.api.http).get = "/ethermint/evm/v1alpha1/cosmos_account/{address}";
   }
 
+  // ValidatorAccount queries an Ethereum account's from a validator consensus Address.
+  rpc ValidatorAccount(QueryValidatorAccountRequest) returns (QueryValidatorAccountResponse) {
+    option (google.api.http).get = "/ethermint/evm/v1alpha1/validator_account/{cons_address}";
+  }
+
   // Balance queries the balance of a the EVM denomination for a single
   // EthAccount.
   rpc Balance(QueryBalanceRequest) returns (QueryBalanceResponse) {
@@ -100,6 +105,25 @@ message QueryCosmosAccountResponse {
   uint64 account_number = 3;
 }
 
+// QueryValidatorAccountRequest is the request type for the Query/ValidatorAccount RPC method.
+message QueryValidatorAccountRequest {
+  option (gogoproto.equal)           = false;
+  option (gogoproto.goproto_getters) = false;
+
+  // cons_address is the validator cons address to query the account for.
+  string cons_address = 1;
+}
+
+// QueryValidatorAccountResponse is the response type for the Query/ValidatorAccount RPC method.
+message QueryValidatorAccountResponse {
+  // account_address is the cosmos address of the account in bech32 format.
+  string account_address = 1;
+  // sequence is the account's sequence number.
+  uint64 sequence = 2;
+  // account_number is the account number
+  uint64 account_number = 3;
+}
+
 // QueryBalanceRequest is the request type for the Query/Balance RPC method.
 message QueryBalanceRequest {
   option (gogoproto.equal)           = false;

x/evm/keeper/grpc_query.go

@@ -72,6 +72,42 @@ func (k Keeper) CosmosAccount(c context.Context, req *types.QueryCosmosAccountRe
 	return &res, nil
 }
 
+func (k Keeper) ValidatorAccount(c context.Context, req *types.QueryValidatorAccountRequest) (*types.QueryValidatorAccountResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "empty request")
+	}
+
+	consAddr, err := sdk.ConsAddressFromBech32(req.ConsAddress)
+	if err != nil {
+		return nil, status.Error(
+			codes.InvalidArgument, err.Error(),
+		)
+	}
+
+	ctx := sdk.UnwrapSDKContext(c)
+	k.WithContext(ctx)
+
+	validator, found := k.stakingKeeper.GetValidatorByConsAddr(ctx, consAddr)
+	if !found {
+		return nil, nil
+	}
+
+	accAddr := sdk.AccAddress(validator.GetOperator())
+
+	res := types.QueryValidatorAccountResponse{
+		AccountAddress: accAddr.String(),
+	}
+
+	account := k.accountKeeper.GetAccount(ctx, accAddr)
+	if account != nil {
+		res.Sequence = account.GetSequence()
+		res.AccountNumber = account.GetAccountNumber()
+	}
+
+	return &res, nil
+
+}
+
 // Balance implements the Query/Balance gRPC method
 func (k Keeper) Balance(c context.Context, req *types.QueryBalanceRequest) (*types.QueryBalanceResponse, error) {
 	if req == nil {

x/evm/keeper/grpc_query_test.go

@@ -585,3 +585,81 @@ func (suite *KeeperTestSuite) TestQueryParams() {
 	suite.Require().NoError(err)
 	suite.Require().Equal(expParams, res.Params)
 }
+
+func (suite *KeeperTestSuite) TestQueryValidatorAccount() {
+	var (
+		req        *types.QueryValidatorAccountRequest
+		expAccount *types.QueryValidatorAccountResponse
+	)
+
+	testCases := []struct {
+		msg      string
+		malleate func()
+		expPass  bool
+	}{
+		{"zero address",
+			func() {
+				suite.app.BankKeeper.SetBalance(suite.ctx, suite.address.Bytes(), ethermint.NewPhotonCoinInt64(0))
+				expAccount = &types.QueryValidatorAccountResponse{
+					AccountAddress: sdk.AccAddress(ethcmn.Address{}.Bytes()).String(),
+				}
+				req = &types.QueryValidatorAccountRequest{
+					ConsAddress: "",
+				}
+			},
+			false,
+		},
+		{
+			"success",
+			func() {
+				expAccount = &types.QueryValidatorAccountResponse{
+					AccountAddress: sdk.AccAddress(suite.address.Bytes()).String(),
+					Sequence:      0,
+					AccountNumber: 0,
+				}
+				req = &types.QueryValidatorAccountRequest{
+					ConsAddress: suite.consAddress.String(),
+				}
+			},
+			true,
+		},
+		{
+			"success with seq and account number",
+			func() {
+				acc := suite.app.AccountKeeper.GetAccount(suite.ctx, suite.address.Bytes())
+				suite.Require().NoError(acc.SetSequence(10))
+				suite.Require().NoError(acc.SetAccountNumber(1))
+				suite.app.AccountKeeper.SetAccount(suite.ctx, acc)
+
+				expAccount = &types.QueryValidatorAccountResponse{
+					AccountAddress: sdk.AccAddress(suite.address.Bytes()).String(),
+					Sequence:      10,
+					AccountNumber: 1,
+				}
+				req = &types.QueryValidatorAccountRequest{
+					ConsAddress: suite.consAddress.String(),
+				}
+			},
+			true,
+		},
+	}
+
+	for _, tc := range testCases {
+		suite.Run(fmt.Sprintf("Case %s", tc.msg), func() {
+			suite.SetupTest() // reset
+
+			tc.malleate()
+			ctx := sdk.WrapSDKContext(suite.ctx)
+			res, err := suite.queryClient.ValidatorAccount(ctx, req)
+
+			if tc.expPass {
+				suite.Require().NoError(err)
+				suite.Require().NotNil(res)
+
+				suite.Require().Equal(expAccount, res)
+			} else {
+				suite.Require().Error(err)
+			}
+		})
+	}
+}

x/evm/keeper/keeper_test.go

@@ -1,6 +1,7 @@
 package keeper_test
 
 import (
+	"github.com/cosmos/ethermint/crypto/ethsecp256k1"
 	"testing"
 	"time"
 
@@ -9,6 +10,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/baseapp"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 
 	"github.com/cosmos/ethermint/app"
 	ethermint "github.com/cosmos/ethermint/types"
@@ -34,6 +36,7 @@ type KeeperTestSuite struct {
 	app         *app.EthermintApp
 	queryClient types.QueryClient
 	address     ethcmn.Address
+	consAddress sdk.ConsAddress
 }
 
 func (suite *KeeperTestSuite) SetupTest() {
@@ -57,6 +60,14 @@ func (suite *KeeperTestSuite) SetupTest() {
 
 	suite.app.AccountKeeper.SetAccount(suite.ctx, acc)
 	suite.app.BankKeeper.SetBalance(suite.ctx, acc.GetAddress(), balance)
+
+	priv, err := ethsecp256k1.GenerateKey()
+	suite.Require().NoError(err)
+	valAddr := sdk.ValAddress(suite.address.Bytes())
+	validator, err := stakingtypes.NewValidator(valAddr, priv.PubKey(), stakingtypes.Description{})
+	suite.app.StakingKeeper.SetValidatorByConsAddr(suite.ctx, validator)
+	suite.app.StakingKeeper.SetValidator(suite.ctx, validator)
+	suite.consAddress = sdk.ConsAddress(priv.PubKey().Address())
 }
 
 func TestKeeperTestSuite(t *testing.T) {

x/evm/types/interfaces.go

@@ -29,4 +29,5 @@ type BankKeeper interface {
 // StakingKeeper returns the historical headers kept in store.
 type StakingKeeper interface {
 	GetHistoricalInfo(ctx sdk.Context, height int64) (stakingtypes.HistoricalInfo, bool)
+	GetValidatorByConsAddr(ctx sdk.Context, consAddr sdk.ConsAddress) (validator stakingtypes.Validator, found bool)
 }

x/evm/types/query.pb.go

@@ -236,6 +236,109 @@ func (m *QueryCosmosAccountResponse) GetAccountNumber() uint64 {
 	return 0
 }
 
+// QueryValidatorAccountRequest is the request type for the Query/ValidatorAccount RPC method.
+type QueryValidatorAccountRequest struct {
+	// cons_address is the validator cons address to query the account for.
+	ConsAddress string `protobuf:"bytes,1,opt,name=cons_address,json=consAddress,proto3" json:"cons_address,omitempty"`
+}
+
+func (m *QueryValidatorAccountRequest) Reset()         { *m = QueryValidatorAccountRequest{} }
+func (m *QueryValidatorAccountRequest) String() string { return proto.CompactTextString(m) }
+func (*QueryValidatorAccountRequest) ProtoMessage()    {}
+func (*QueryValidatorAccountRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_8bbc79ec2b6c5cb2, []int{4}
+}
+func (m *QueryValidatorAccountRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryValidatorAccountRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryValidatorAccountRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *QueryValidatorAccountRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryValidatorAccountRequest.Merge(m, src)
+}
+func (m *QueryValidatorAccountRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryValidatorAccountRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryValidatorAccountRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryValidatorAccountRequest proto.InternalMessageInfo
+
+// QueryValidatorAccountResponse is the response type for the Query/ValidatorAccount RPC method.
+type QueryValidatorAccountResponse struct {
+	// account_address is the cosmos address of the account in bech32 format.
+	AccountAddress string `protobuf:"bytes,1,opt,name=account_address,json=accountAddress,proto3" json:"account_address,omitempty"`
+	// sequence is the account's sequence number.
+	Sequence uint64 `protobuf:"varint,2,opt,name=sequence,proto3" json:"sequence,omitempty"`
+	// account_number is the account number
+	AccountNumber uint64 `protobuf:"varint,3,opt,name=account_number,json=accountNumber,proto3" json:"account_number,omitempty"`
+}
+
+func (m *QueryValidatorAccountResponse) Reset()         { *m = QueryValidatorAccountResponse{} }
+func (m *QueryValidatorAccountResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryValidatorAccountResponse) ProtoMessage()    {}
+func (*QueryValidatorAccountResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_8bbc79ec2b6c5cb2, []int{5}
+}
+func (m *QueryValidatorAccountResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryValidatorAccountResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryValidatorAccountResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *QueryValidatorAccountResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryValidatorAccountResponse.Merge(m, src)
+}
+func (m *QueryValidatorAccountResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryValidatorAccountResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryValidatorAccountResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryValidatorAccountResponse proto.InternalMessageInfo
+
+func (m *QueryValidatorAccountResponse) GetAccountAddress() string {
+	if m != nil {
+		return m.AccountAddress
+	}
+	return ""
+}
+
+func (m *QueryValidatorAccountResponse) GetSequence() uint64 {
+	if m != nil {
+		return m.Sequence
+	}
+	return 0
+}
+
+func (m *QueryValidatorAccountResponse) GetAccountNumber() uint64 {
+	if m != nil {
+		return m.AccountNumber
+	}
+	return 0
+}
+
 // QueryBalanceRequest is the request type for the Query/Balance RPC method.
 type QueryBalanceRequest struct {
 	// address is the ethereum hex address to query the balance for.
@@ -246,7 +349,7 @@ func (m *QueryBalanceRequest) Reset()         { *m = QueryBalanceRequest{} }
 func (m *QueryBalanceRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryBalanceRequest) ProtoMessage()    {}
 func (*QueryBalanceRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bbc79ec2b6c5cb2, []int{4}
+	return fileDescriptor_8bbc79ec2b6c5cb2, []int{6}
 }
 func (m *QueryBalanceRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -285,7 +388,7 @@ func (m *QueryBalanceResponse) Reset()         { *m = QueryBalanceResponse{} }
 func (m *QueryBalanceResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryBalanceResponse) ProtoMessage()    {}
 func (*QueryBalanceResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bbc79ec2b6c5cb2, []int{5}
+	return fileDescriptor_8bbc79ec2b6c5cb2, []int{7}
 }
 func (m *QueryBalanceResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -333,7 +436,7 @@ func (m *QueryStorageRequest) Reset()         { *m = QueryStorageRequest{} }
 func (m *QueryStorageRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryStorageRequest) ProtoMessage()    {}
 func (*QueryStorageRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bbc79ec2b6c5cb2, []int{6}
+	return fileDescriptor_8bbc79ec2b6c5cb2, []int{8}
 }
 func (m *QueryStorageRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -373,7 +476,7 @@ func (m *QueryStorageResponse) Reset()         { *m = QueryStorageResponse{} }
 func (m *QueryStorageResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryStorageResponse) ProtoMessage()    {}
 func (*QueryStorageResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bbc79ec2b6c5cb2, []int{7}
+	return fileDescriptor_8bbc79ec2b6c5cb2, []int{9}
 }
 func (m *QueryStorageResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -419,7 +522,7 @@ func (m *QueryCodeRequest) Reset()         { *m = QueryCodeRequest{} }
 func (m *QueryCodeRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryCodeRequest) ProtoMessage()    {}
 func (*QueryCodeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bbc79ec2b6c5cb2, []int{8}
+	return fileDescriptor_8bbc79ec2b6c5cb2, []int{10}
 }
 func (m *QueryCodeRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -459,7 +562,7 @@ func (m *QueryCodeResponse) Reset()         { *m = QueryCodeResponse{} }
 func (m *QueryCodeResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryCodeResponse) ProtoMessage()    {}
 func (*QueryCodeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bbc79ec2b6c5cb2, []int{9}
+	return fileDescriptor_8bbc79ec2b6c5cb2, []int{11}
 }
 func (m *QueryCodeResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -505,7 +608,7 @@ func (m *QueryTxLogsRequest) Reset()         { *m = QueryTxLogsRequest{} }
 func (m *QueryTxLogsRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryTxLogsRequest) ProtoMessage()    {}
 func (*QueryTxLogsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bbc79ec2b6c5cb2, []int{10}
+	return fileDescriptor_8bbc79ec2b6c5cb2, []int{12}
 }
 func (m *QueryTxLogsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -544,7 +647,7 @@ func (m *QueryTxLogsResponse) Reset()         { *m = QueryTxLogsResponse{} }
 func (m *QueryTxLogsResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryTxLogsResponse) ProtoMessage()    {}
 func (*QueryTxLogsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bbc79ec2b6c5cb2, []int{11}
+	return fileDescriptor_8bbc79ec2b6c5cb2, []int{13}
 }
 func (m *QueryTxLogsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -592,7 +695,7 @@ func (m *QueryBlockLogsRequest) Reset()         { *m = QueryBlockLogsRequest{} }
 func (m *QueryBlockLogsRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryBlockLogsRequest) ProtoMessage()    {}
 func (*QueryBlockLogsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bbc79ec2b6c5cb2, []int{12}
+	return fileDescriptor_8bbc79ec2b6c5cb2, []int{14}
 }
 func (m *QueryBlockLogsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -633,7 +736,7 @@ func (m *QueryBlockLogsResponse) Reset()         { *m = QueryBlockLogsResponse{}
 func (m *QueryBlockLogsResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryBlockLogsResponse) ProtoMessage()    {}
 func (*QueryBlockLogsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bbc79ec2b6c5cb2, []int{13}
+	return fileDescriptor_8bbc79ec2b6c5cb2, []int{15}
 }
 func (m *QueryBlockLogsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -685,7 +788,7 @@ func (m *QueryBlockBloomRequest) Reset()         { *m = QueryBlockBloomRequest{}
 func (m *QueryBlockBloomRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryBlockBloomRequest) ProtoMessage()    {}
 func (*QueryBlockBloomRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bbc79ec2b6c5cb2, []int{14}
+	return fileDescriptor_8bbc79ec2b6c5cb2, []int{16}
 }
 func (m *QueryBlockBloomRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -725,7 +828,7 @@ func (m *QueryBlockBloomResponse) Reset()         { *m = QueryBlockBloomResponse
 func (m *QueryBlockBloomResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryBlockBloomResponse) ProtoMessage()    {}
 func (*QueryBlockBloomResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bbc79ec2b6c5cb2, []int{15}
+	return fileDescriptor_8bbc79ec2b6c5cb2, []int{17}
 }
 func (m *QueryBlockBloomResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -769,7 +872,7 @@ func (m *QueryParamsRequest) Reset()         { *m = QueryParamsRequest{} }
 func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryParamsRequest) ProtoMessage()    {}
 func (*QueryParamsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bbc79ec2b6c5cb2, []int{16}
+	return fileDescriptor_8bbc79ec2b6c5cb2, []int{18}
 }
 func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -808,7 +911,7 @@ func (m *QueryParamsResponse) Reset()         { *m = QueryParamsResponse{} }
 func (m *QueryParamsResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryParamsResponse) ProtoMessage()    {}
 func (*QueryParamsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bbc79ec2b6c5cb2, []int{17}
+	return fileDescriptor_8bbc79ec2b6c5cb2, []int{19}
 }
 func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -856,7 +959,7 @@ func (m *QueryStaticCallRequest) Reset()         { *m = QueryStaticCallRequest{}
 func (m *QueryStaticCallRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryStaticCallRequest) ProtoMessage()    {}
 func (*QueryStaticCallRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bbc79ec2b6c5cb2, []int{18}
+	return fileDescriptor_8bbc79ec2b6c5cb2, []int{20}
 }
 func (m *QueryStaticCallRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -908,7 +1011,7 @@ func (m *QueryStaticCallResponse) Reset()         { *m = QueryStaticCallResponse
 func (m *QueryStaticCallResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryStaticCallResponse) ProtoMessage()    {}
 func (*QueryStaticCallResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bbc79ec2b6c5cb2, []int{19}
+	return fileDescriptor_8bbc79ec2b6c5cb2, []int{21}
 }
 func (m *QueryStaticCallResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -949,6 +1052,8 @@ func init() {
 	proto.RegisterType((*QueryAccountResponse)(nil), "ethermint.evm.v1alpha1.QueryAccountResponse")
 	proto.RegisterType((*QueryCosmosAccountRequest)(nil), "ethermint.evm.v1alpha1.QueryCosmosAccountRequest")
 	proto.RegisterType((*QueryCosmosAccountResponse)(nil), "ethermint.evm.v1alpha1.QueryCosmosAccountResponse")
+	proto.RegisterType((*QueryValidatorAccountRequest)(nil), "ethermint.evm.v1alpha1.QueryValidatorAccountRequest")
+	proto.RegisterType((*QueryValidatorAccountResponse)(nil), "ethermint.evm.v1alpha1.QueryValidatorAccountResponse")
 	proto.RegisterType((*QueryBalanceRequest)(nil), "ethermint.evm.v1alpha1.QueryBalanceRequest")
 	proto.RegisterType((*QueryBalanceResponse)(nil), "ethermint.evm.v1alpha1.QueryBalanceResponse")
 	proto.RegisterType((*QueryStorageRequest)(nil), "ethermint.evm.v1alpha1.QueryStorageRequest")
@@ -972,72 +1077,77 @@ func init() {
 }
 
 var fileDescriptor_8bbc79ec2b6c5cb2 = []byte{
-	// 1026 bytes of a gzipped FileDescriptorProto
+	// 1113 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x96, 0xcf, 0x6f, 0xe3, 0x44,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x97, 0xcf, 0x6f, 0x1b, 0x45,
-	0x14, 0xc7, 0xe3, 0x36, 0x4d, 0xda, 0xd7, 0x16, 0x2d, 0x43, 0x58, 0x8a, 0x17, 0xa5, 0x95, 0xd1,
+	0x14, 0xc7, 0xbd, 0x8d, 0xf3, 0xeb, 0x25, 0x81, 0x30, 0x98, 0x12, 0xb6, 0xc5, 0x09, 0x83, 0x1a,
-	0x36, 0xe9, 0x8f, 0xb5, 0x37, 0x41, 0xe2, 0x97, 0x90, 0x50, 0xbb, 0x52, 0x59, 0x89, 0x15, 0x5a,
+	0x3b, 0x3f, 0xba, 0x5b, 0x9b, 0x5f, 0xa5, 0x42, 0x82, 0xa4, 0x52, 0xa8, 0xd4, 0x0a, 0x15, 0xa7,
-	0xd2, 0x3d, 0x71, 0x89, 0x26, 0xce, 0xc8, 0x89, 0xea, 0x78, 0xb2, 0x19, 0x27, 0x6a, 0x55, 0xf5,
+	0xe2, 0xc0, 0xc5, 0x1a, 0xaf, 0x57, 0x6b, 0x2b, 0xeb, 0x1d, 0xd7, 0xbb, 0xb6, 0x12, 0x45, 0xb9,
-	0xc2, 0x01, 0x81, 0xc4, 0x01, 0xc4, 0x81, 0x15, 0x12, 0xd2, 0x5e, 0xb9, 0xf1, 0x67, 0xec, 0xb1,
+	0x70, 0x40, 0x20, 0x38, 0x80, 0x38, 0x80, 0x90, 0x90, 0x7a, 0xe5, 0xc6, 0xbf, 0xc0, 0xad, 0xc7,
-	0x12, 0x17, 0x4e, 0x08, 0xb5, 0x1c, 0xf8, 0x33, 0xd0, 0xcc, 0x3c, 0x27, 0x76, 0x1b, 0xd7, 0x29,
+	0x4a, 0x5c, 0x38, 0x20, 0x84, 0x12, 0x0e, 0xfc, 0x19, 0x68, 0x66, 0xde, 0xda, 0xbb, 0xb6, 0xd7,
-	0x37, 0xcf, 0xe4, 0xfd, 0xf8, 0xbc, 0xf7, 0x66, 0xbe, 0x13, 0xb0, 0x58, 0xd8, 0x61, 0x83, 0x5e,
+	0xeb, 0x20, 0x6e, 0x33, 0xb3, 0xef, 0xc7, 0xe7, 0xbd, 0x79, 0x9e, 0xaf, 0x0c, 0xd4, 0x0e, 0x1a,
-	0x37, 0x08, 0x1d, 0x36, 0xea, 0x39, 0xa3, 0x1a, 0xf5, 0xfb, 0x1d, 0x5a, 0x73, 0x9e, 0x0f, 0xd9,
+	0x76, 0xa7, 0xd5, 0xf4, 0x02, 0xd3, 0xee, 0xb5, 0xcc, 0x5e, 0x89, 0xb9, 0xed, 0x06, 0x2b, 0x99,
-	0xe0, 0xc4, 0xee, 0x0f, 0x78, 0xc8, 0xc9, 0xdd, 0xb1, 0x8d, 0xcd, 0x46, 0x3d, 0x3b, 0xb2, 0x31,
+	0x8f, 0xbb, 0x76, 0xe7, 0xc4, 0x68, 0x77, 0x78, 0xc0, 0xc9, 0xd5, 0xbe, 0x8d, 0x61, 0xf7, 0x5a,
-	0x4b, 0x1e, 0xf7, 0xb8, 0x32, 0x71, 0xe4, 0x97, 0xb6, 0x36, 0xb7, 0x5d, 0x2e, 0x7a, 0x5c, 0x38,
+	0x46, 0x68, 0xa3, 0xe7, 0x1c, 0xee, 0x70, 0x69, 0x62, 0x8a, 0x95, 0xb2, 0xd6, 0xb7, 0x2d, 0xee,
-	0x2d, 0x2a, 0x98, 0x0e, 0xe3, 0x8c, 0x6a, 0x2d, 0x16, 0xd2, 0x9a, 0xd3, 0xa7, 0x5e, 0x37, 0xa0,
+	0xb7, 0xb8, 0x6f, 0xd6, 0x98, 0x6f, 0xab, 0x30, 0x66, 0xaf, 0x54, 0xb3, 0x03, 0x56, 0x32, 0xdb,
-	0x61, 0x97, 0x07, 0x68, 0xfb, 0x8e, 0xc7, 0xb9, 0xe7, 0x33, 0x87, 0xf6, 0xbb, 0x0e, 0x0d, 0x02,
+	0xcc, 0x69, 0x7a, 0x2c, 0x68, 0x72, 0x0f, 0x6d, 0xaf, 0x3b, 0x9c, 0x3b, 0xae, 0x6d, 0xb2, 0x76,
-	0x1e, 0xaa, 0x1f, 0x05, 0xfe, 0xba, 0x91, 0xc2, 0x26, 0x21, 0x94, 0x85, 0xf5, 0x11, 0xbc, 0xf1,
+	0xd3, 0x64, 0x9e, 0xc7, 0x03, 0xf9, 0xd1, 0xc7, 0xaf, 0x1b, 0x09, 0x6c, 0x02, 0x42, 0x5a, 0xd0,
-	0xa5, 0xcc, 0xb0, 0xe7, 0xba, 0x7c, 0x18, 0x84, 0x0d, 0xf6, 0x7c, 0xc8, 0x44, 0x48, 0xd6, 0xa0,
+	0x77, 0xe1, 0xc5, 0x8f, 0x45, 0x86, 0x3d, 0xcb, 0xe2, 0x5d, 0x2f, 0xa8, 0xd8, 0x8f, 0xbb, 0xb6,
-	0x48, 0xdb, 0xed, 0x01, 0x13, 0x62, 0xcd, 0xd8, 0x30, 0xaa, 0x4b, 0x8d, 0x68, 0xf9, 0xf1, 0xe2,
+	0x1f, 0x90, 0x35, 0x98, 0x67, 0xf5, 0x7a, 0xc7, 0xf6, 0xfd, 0x35, 0x6d, 0x43, 0x2b, 0x2e, 0x56,
-	0xb7, 0x2f, 0xd7, 0x73, 0xff, 0xbe, 0x5c, 0xcf, 0x59, 0x2e, 0x94, 0x92, 0xae, 0xa2, 0xcf, 0x03,
+	0xc2, 0xed, 0x9d, 0x85, 0x2f, 0x9e, 0xac, 0x67, 0xfe, 0x79, 0xb2, 0x9e, 0xa1, 0x16, 0xe4, 0xe2,
-	0xc1, 0xa4, 0x6f, 0x8b, 0xfa, 0x34, 0x70, 0x59, 0xe4, 0x8b, 0x4b, 0x72, 0x0f, 0x96, 0x5c, 0xde,
+	0xae, 0x7e, 0x9b, 0x7b, 0xbe, 0x2d, 0x7c, 0x6b, 0xcc, 0x65, 0x9e, 0x65, 0x87, 0xbe, 0xb8, 0x25,
-	0x66, 0xcd, 0x0e, 0x15, 0x9d, 0xb5, 0x39, 0xf5, 0xdb, 0xa2, 0xdc, 0x78, 0x4c, 0x45, 0x87, 0x94,
+	0xd7, 0x60, 0xd1, 0xe2, 0x75, 0xbb, 0xda, 0x60, 0x7e, 0x63, 0xed, 0x8a, 0xfc, 0xb6, 0x20, 0x0e,
-	0x60, 0x21, 0xe0, 0xd2, 0x69, 0x7e, 0xc3, 0xa8, 0xe6, 0x1b, 0x7a, 0x61, 0x7d, 0x0a, 0x6f, 0xab,
+	0xee, 0x31, 0xbf, 0x41, 0x72, 0x30, 0xeb, 0x71, 0xe1, 0x34, 0xb3, 0xa1, 0x15, 0xb3, 0x15, 0xb5,
-	0x24, 0x8f, 0x54, 0x4b, 0xfe, 0x07, 0xe5, 0x37, 0x06, 0x98, 0xd3, 0x22, 0x20, 0xec, 0x7d, 0x78,
+	0xa1, 0xef, 0xc3, 0x2b, 0x32, 0xc9, 0x5d, 0xd9, 0x92, 0xff, 0x40, 0xf9, 0xb9, 0x06, 0xfa, 0xb8,
-	0x4d, 0x77, 0xbb, 0x99, 0x8c, 0xb4, 0xaa, 0x77, 0xf7, 0xf4, 0x26, 0x31, 0x61, 0x51, 0xc8, 0xa4,
+	0x08, 0x08, 0x7b, 0x03, 0x9e, 0x53, 0xdd, 0xae, 0xc6, 0x23, 0xad, 0xa8, 0xd3, 0x3d, 0x75, 0x48,
-	0x92, 0x6f, 0x4e, 0xf1, 0x8d, 0xd7, 0x32, 0x04, 0xd5, 0x51, 0x9b, 0xc1, 0xb0, 0xd7, 0x62, 0x03,
+	0x74, 0x58, 0xf0, 0x45, 0x52, 0xc1, 0x77, 0x45, 0xf2, 0xf5, 0xf7, 0x22, 0x04, 0x53, 0x51, 0xab,
-	0xac, 0x60, 0x15, 0x77, 0xbf, 0x50, 0x9b, 0xe3, 0x4e, 0xef, 0xeb, 0x66, 0xdc, 0xa6, 0x86, 0x87,
+	0x5e, 0xb7, 0x55, 0xb3, 0x3b, 0x58, 0xc1, 0x0a, 0x9e, 0x7e, 0x24, 0x0f, 0xe9, 0x7d, 0xb8, 0x2e,
-	0xd8, 0xe9, 0xb1, 0x6b, 0x56, 0xa7, 0xad, 0xcf, 0x31, 0xd9, 0x61, 0xc8, 0x07, 0xd4, 0xcb, 0x4e,
+	0x39, 0x3e, 0x61, 0x6e, 0xb3, 0xce, 0x02, 0xde, 0x19, 0x2a, 0xe6, 0x35, 0x58, 0xb6, 0xb8, 0x37,
-	0x46, 0xee, 0xc0, 0xfc, 0x11, 0x3b, 0xc1, 0xa1, 0xc8, 0xcf, 0x58, 0xfa, 0x5d, 0x4c, 0x3f, 0x0e,
+	0xcc, 0xb1, 0x24, 0xce, 0xf6, 0x46, 0xaa, 0xfa, 0x4a, 0x83, 0x57, 0x13, 0xa2, 0x61, 0x61, 0x05,
-	0x86, 0xe9, 0x4b, 0xb0, 0x30, 0xa2, 0xfe, 0x30, 0x4a, 0xae, 0x17, 0xd6, 0xfb, 0x70, 0x07, 0xfb,
+	0x78, 0x3e, 0xa4, 0x8a, 0x47, 0x0c, 0x61, 0xff, 0xc7, 0xd2, 0xc2, 0x21, 0xda, 0x57, 0xf7, 0x7c,
-	0xdd, 0xbe, 0x55, 0x91, 0x15, 0x78, 0x3d, 0xe6, 0x87, 0x29, 0x08, 0xe4, 0xe5, 0x01, 0x51, 0x5e,
+	0x99, 0xeb, 0xb9, 0x85, 0x43, 0xd4, 0x77, 0x4d, 0x1b, 0x22, 0x7a, 0x1f, 0x93, 0x1d, 0x06, 0xbc,
-	0x2b, 0x0d, 0xf5, 0x6d, 0xd5, 0x81, 0x28, 0xc3, 0x67, 0xc7, 0x4f, 0xb8, 0x27, 0xa2, 0x14, 0x04,
+	0xc3, 0x9c, 0xf4, 0x64, 0x64, 0x15, 0x66, 0x8e, 0xec, 0x13, 0x9c, 0x37, 0xb1, 0x8c, 0xa4, 0xdf,
-	0xf2, 0xea, 0x58, 0xe9, 0xf8, 0xea, 0x3b, 0x16, 0xfc, 0x00, 0xfb, 0x11, 0xf9, 0x60, 0x78, 0x07,
+	0xc5, 0xf4, 0xfd, 0x60, 0x98, 0x3e, 0x07, 0xb3, 0x3d, 0xe6, 0x76, 0xc3, 0xe4, 0x6a, 0x43, 0xdf,
-	0xf2, 0x3e, 0xf7, 0x24, 0xd4, 0x7c, 0x75, 0xb9, 0x7e, 0xcf, 0x9e, 0x7e, 0x4d, 0xed, 0x27, 0xdc,
+	0x86, 0x55, 0x1c, 0xa5, 0xfa, 0xa5, 0x8a, 0x2c, 0xc0, 0x0b, 0x11, 0x3f, 0x4c, 0x41, 0x20, 0x2b,
-	0x6b, 0x28, 0x43, 0xeb, 0x0c, 0xde, 0xd4, 0x93, 0xf0, 0xb9, 0x7b, 0x94, 0x91, 0x9e, 0x1c, 0x00,
+	0x66, 0x5f, 0x7a, 0x2d, 0x57, 0xe4, 0x9a, 0x96, 0x81, 0x48, 0xc3, 0x47, 0xc7, 0x0f, 0xb8, 0xe3,
-	0x4c, 0xee, 0xab, 0x6a, 0xed, 0x72, 0x7d, 0xd3, 0xd6, 0x07, 0xcb, 0x96, 0x97, 0xdb, 0xd6, 0x1a,
+	0x87, 0x29, 0x08, 0x64, 0xe5, 0x2f, 0x46, 0xc5, 0x97, 0xeb, 0x48, 0xf0, 0x03, 0xec, 0x47, 0xe8,
-	0x81, 0x97, 0xdb, 0x7e, 0x3a, 0x99, 0x54, 0x23, 0xe6, 0x19, 0x2b, 0xe3, 0x37, 0x03, 0xee, 0x5e,
+	0x83, 0xe1, 0x4d, 0xc8, 0xba, 0xdc, 0x11, 0x50, 0x33, 0xc5, 0xa5, 0xf2, 0x35, 0x63, 0xfc, 0x0b,
-	0xcd, 0x8f, 0xa5, 0x1c, 0x40, 0x31, 0x3c, 0x6e, 0xc6, 0xaa, 0xa9, 0xa4, 0x55, 0xf3, 0x6c, 0x40,
+	0x64, 0x3c, 0xe0, 0x4e, 0x45, 0x1a, 0xd2, 0x33, 0x78, 0x49, 0xdd, 0x84, 0xcb, 0xad, 0xa3, 0x94,
-	0x03, 0x41, 0x5d, 0x19, 0x5a, 0x46, 0xd8, 0xcf, 0xbf, 0xfa, 0x6b, 0x3d, 0xd7, 0x28, 0x84, 0xaa,
+	0xf4, 0xe4, 0x00, 0x60, 0xf0, 0x14, 0xc9, 0xd6, 0x2e, 0x95, 0x37, 0x0d, 0xf5, 0x9b, 0x31, 0xc4,
-	0x35, 0xe4, 0xb3, 0x29, 0xd0, 0x95, 0x4c, 0x68, 0x0d, 0x11, 0xa7, 0xb6, 0xd6, 0xe2, 0xa8, 0xfb,
+	0xbb, 0x65, 0xa8, 0xe7, 0x0f, 0xdf, 0x2d, 0xe3, 0xe1, 0xe0, 0xa6, 0x2a, 0x11, 0xcf, 0x48, 0x19,
-	0x3e, 0xe7, 0x3d, 0xac, 0xcd, 0x72, 0xe0, 0xad, 0x6b, 0xbf, 0x4c, 0x8e, 0x54, 0x4b, 0x6e, 0xe0,
+	0x3f, 0x6b, 0x70, 0x75, 0x38, 0x3f, 0x96, 0x72, 0x00, 0xf3, 0xc1, 0x71, 0x35, 0x52, 0x4d, 0x21,
-	0xc0, 0xf5, 0xc2, 0x2a, 0xe1, 0xc4, 0x9f, 0xd2, 0x01, 0xed, 0x45, 0x2d, 0xb7, 0x0e, 0x71, 0xa6,
+	0xa9, 0x9a, 0x47, 0x1d, 0xe6, 0xf9, 0xcc, 0x12, 0xa1, 0x45, 0x84, 0xfd, 0xec, 0xd3, 0x3f, 0xd7,
-	0xd1, 0x2e, 0x86, 0xf8, 0x04, 0x0a, 0x7d, 0xb5, 0xa3, 0x62, 0x2c, 0xd7, 0xcb, 0x69, 0x7d, 0xd0,
+	0x33, 0x95, 0xb9, 0x40, 0xb6, 0x86, 0x7c, 0x38, 0x06, 0xba, 0x90, 0x0a, 0xad, 0x20, 0xa2, 0xd4,
-	0x7e, 0x51, 0xf9, 0xda, 0xc7, 0x7a, 0x8c, 0xd4, 0x87, 0x52, 0x48, 0xdd, 0x47, 0xd4, 0xf7, 0xb3,
+	0x74, 0x2d, 0x8a, 0xba, 0xef, 0x72, 0xde, 0xc2, 0xda, 0xa8, 0x09, 0x2f, 0x8f, 0x7c, 0x19, 0x8c,
-	0xef, 0x4e, 0x09, 0x16, 0xba, 0x41, 0x7f, 0x18, 0xaa, 0x6e, 0xad, 0x34, 0xf4, 0xc2, 0x7a, 0x80,
+	0x54, 0x4d, 0x1c, 0xe0, 0x85, 0xab, 0x0d, 0xcd, 0xe1, 0x8d, 0x3f, 0x64, 0x1d, 0xd6, 0x0a, 0x5b,
-	0x55, 0xc6, 0x23, 0x4d, 0x4e, 0x75, 0x9b, 0x86, 0x34, 0x3a, 0xd5, 0xf2, 0xbb, 0xfe, 0x62, 0x05,
+	0x4e, 0x0f, 0xf1, 0x4e, 0xc3, 0x53, 0x0c, 0xf1, 0x1e, 0xcc, 0xb5, 0xe5, 0x89, 0x8c, 0xb1, 0x54,
-	0x16, 0x94, 0x3d, 0xf9, 0xd9, 0x80, 0x22, 0xca, 0x14, 0xd9, 0x49, 0x83, 0x9f, 0x22, 0xda, 0xe6,
+	0xce, 0x27, 0xf5, 0x41, 0xf9, 0x85, 0xe5, 0x2b, 0x1f, 0x7a, 0x0f, 0xa9, 0x0f, 0x85, 0x46, 0x58,
-	0xee, 0x6c, 0xc6, 0x1a, 0xc2, 0xaa, 0x7d, 0xfd, 0xc7, 0x3f, 0x3f, 0xcd, 0xed, 0x90, 0x2d, 0x27,
+	0x77, 0x99, 0xeb, 0xa6, 0xff, 0x76, 0x72, 0x30, 0xdb, 0xf4, 0xda, 0xdd, 0x40, 0x76, 0x6b, 0xb9,
-	0xe5, 0x91, 0x40, 0xf9, 0x72, 0x4e, 0xb1, 0xce, 0x33, 0xf2, 0xbb, 0x01, 0xab, 0x09, 0x19, 0x25,
+	0xa2, 0x36, 0xf4, 0x26, 0x56, 0x19, 0x8d, 0x34, 0x98, 0xea, 0x3a, 0x0b, 0x58, 0x38, 0xd5, 0x62,
-	0xb5, 0x1b, 0x53, 0x4e, 0x13, 0x6d, 0xb3, 0x7e, 0x1b, 0x17, 0x64, 0xfd, 0x50, 0xb1, 0xd6, 0xc9,
+	0x5d, 0xfe, 0x63, 0x05, 0x66, 0xa5, 0x3d, 0xf9, 0x5e, 0x83, 0x79, 0x7c, 0xa8, 0xc8, 0x4e, 0x12,
-	0xc3, 0x34, 0xd6, 0x48, 0xc3, 0xaf, 0x21, 0xbf, 0x30, 0xa0, 0x88, 0xb2, 0x99, 0xd1, 0xcc, 0xa4,
+	0xfc, 0x18, 0x3d, 0xd2, 0x77, 0xa7, 0x33, 0x56, 0x10, 0xb4, 0xf4, 0xd9, 0x6f, 0x7f, 0x7f, 0x77,
-	0x2e, 0x67, 0x34, 0xf3, 0x8a, 0x12, 0x5b, 0x75, 0x05, 0xb8, 0x4b, 0xb6, 0xd3, 0x00, 0x51, 0x98,
+	0x65, 0x87, 0x6c, 0x99, 0x09, 0xfa, 0x87, 0xcf, 0x97, 0x79, 0x8a, 0x75, 0x9e, 0x91, 0x5f, 0x34,
-	0x45, 0x0c, 0xed, 0x57, 0x03, 0x8a, 0x28, 0xa9, 0x19, 0x68, 0x49, 0x15, 0xcf, 0x40, 0xbb, 0xa2,
+	0x58, 0x89, 0x29, 0x04, 0x29, 0x4d, 0x4c, 0x39, 0x4e, 0x8f, 0xf4, 0xf2, 0x65, 0x5c, 0x90, 0xf5,
-	0xd2, 0xd6, 0x07, 0x0a, 0xad, 0x46, 0x9c, 0x34, 0x34, 0xa1, 0x1d, 0x26, 0x64, 0xce, 0xe9, 0x11,
+	0xb6, 0x64, 0x2d, 0x93, 0x5b, 0x49, 0xac, 0xa1, 0x3c, 0x8d, 0x20, 0xff, 0xaa, 0xc1, 0xea, 0xf0,
-	0x3b, 0x39, 0x23, 0xdf, 0x1b, 0x90, 0x97, 0x62, 0x4c, 0xaa, 0x19, 0x13, 0x1b, 0xeb, 0xbc, 0xb9,
+	0xf3, 0x4f, 0xde, 0x9c, 0x88, 0x90, 0xa0, 0x3d, 0xfa, 0x5b, 0x97, 0xf4, 0x42, 0xf6, 0x0f, 0x24,
-	0x35, 0x83, 0x25, 0x62, 0x39, 0x0a, 0x6b, 0x8b, 0x54, 0xd2, 0x47, 0xda, 0x4e, 0xb4, 0xeb, 0x47,
+	0xfb, 0x1d, 0x72, 0x3b, 0x89, 0xbd, 0x17, 0x7a, 0x0e, 0xf0, 0xa3, 0x1a, 0x77, 0x46, 0x7e, 0xd0,
-	0x03, 0x0a, 0x5a, 0xbe, 0xc9, 0xf6, 0x8d, 0x69, 0x12, 0xef, 0x82, 0xb9, 0x33, 0x93, 0x2d, 0x42,
+	0x60, 0x1e, 0x9f, 0xfe, 0x94, 0x81, 0x88, 0x6b, 0x4b, 0xca, 0x40, 0x0c, 0xa9, 0x09, 0x2d, 0x4b,
-	0xd9, 0x0a, 0xaa, 0x4a, 0x36, 0xd3, 0xa0, 0x50, 0x62, 0x9d, 0x53, 0x29, 0xf0, 0x6a, 0x84, 0x4b,
+	0xd0, 0x5d, 0xb2, 0x9d, 0x04, 0x8a, 0xe2, 0xe2, 0x47, 0xda, 0xfb, 0x93, 0x06, 0xf3, 0x28, 0x0b,
-	0x63, 0x29, 0x26, 0x0f, 0x6e, 0x3e, 0x32, 0x57, 0x9e, 0x0c, 0xd3, 0x9e, 0xd5, 0x7c, 0xd6, 0x0b,
+	0x29, 0x68, 0x71, 0x25, 0x4a, 0x41, 0x1b, 0x52, 0x1a, 0xfa, 0x8e, 0x44, 0x2b, 0x11, 0x33, 0x09,
-	0xdb, 0x92, 0x2e, 0x09, 0xbe, 0x5f, 0x0c, 0x80, 0x89, 0xca, 0x92, 0x19, 0x32, 0xc6, 0x85, 0xda,
+	0xcd, 0x57, 0x0e, 0x03, 0x32, 0xf3, 0xf4, 0xc8, 0x3e, 0x39, 0x23, 0x5f, 0x6b, 0x90, 0x15, 0x82,
-	0x74, 0x66, 0xb6, 0x47, 0xc4, 0x1d, 0x85, 0x78, 0x9f, 0xbc, 0x7b, 0x33, 0xa2, 0x52, 0x75, 0xf2,
+	0x42, 0x8a, 0x29, 0x53, 0xd7, 0xd7, 0x2a, 0x7d, 0x6b, 0x0a, 0x4b, 0xc4, 0x32, 0x25, 0xd6, 0x16,
-	0x9d, 0x01, 0x05, 0xad, 0xc1, 0x19, 0x03, 0x4d, 0xc8, 0x7e, 0xc6, 0x40, 0x93, 0x8f, 0x81, 0xb5,
+	0x29, 0x24, 0x8f, 0x65, 0x3d, 0xd6, 0xae, 0x6f, 0x35, 0x98, 0x53, 0x12, 0x44, 0xb6, 0x27, 0xa6,
-	0xa9, 0x80, 0x36, 0x48, 0x39, 0x0d, 0x48, 0xcb, 0xbe, 0x6a, 0xd4, 0x44, 0xa8, 0x33, 0x1a, 0x75,
+	0x89, 0x69, 0x9b, 0xbe, 0x33, 0x95, 0x2d, 0x42, 0x19, 0x12, 0xaa, 0x48, 0x36, 0x93, 0xa0, 0x50,
-	0xed, 0x6d, 0xc8, 0x68, 0xd4, 0xf5, 0x17, 0x20, 0xbb, 0x51, 0x42, 0xf9, 0x34, 0x5d, 0xea, 0xfb,
+	0x26, 0xcc, 0x53, 0x21, 0x52, 0xf2, 0x0a, 0x17, 0xfb, 0x72, 0x42, 0x6e, 0x4e, 0x1e, 0x99, 0x21,
-	0xfb, 0x7b, 0xaf, 0x2e, 0xca, 0xc6, 0xf9, 0x45, 0xd9, 0xf8, 0xfb, 0xa2, 0x6c, 0xfc, 0x70, 0x59,
+	0xd9, 0xd3, 0x8d, 0x69, 0xcd, 0xa7, 0x7d, 0x74, 0x6a, 0xc2, 0x25, 0xc6, 0xf7, 0xa3, 0x06, 0x30,
-	0xce, 0x9d, 0x5f, 0x96, 0x73, 0x7f, 0x5e, 0x96, 0x73, 0x5f, 0x55, 0xbc, 0x6e, 0xd8, 0x19, 0xb6,
+	0x50, 0x0a, 0x32, 0x45, 0xc6, 0xa8, 0xd8, 0xe8, 0xe6, 0xd4, 0xf6, 0x88, 0xb8, 0x23, 0x11, 0x6f,
-	0x6c, 0x97, 0xf7, 0x50, 0x02, 0x63, 0xf1, 0x8e, 0x55, 0xc4, 0xf0, 0xa4, 0xcf, 0x44, 0xab, 0xa0,
+	0x90, 0xd7, 0x27, 0x23, 0x4a, 0x65, 0x22, 0x5f, 0x6a, 0x30, 0xa7, 0x74, 0x24, 0xe5, 0x42, 0x63,
-	0xfe, 0xed, 0xbf, 0xf7, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x4b, 0xf0, 0x51, 0x91, 0xad, 0x0c,
+	0xd2, 0x95, 0x72, 0xa1, 0x71, 0x41, 0xa3, 0x9b, 0x12, 0x68, 0x83, 0xe4, 0x93, 0x80, 0x94, 0x74,
-	0x00, 0x00,
+	0xc9, 0x46, 0x0d, 0xc4, 0x26, 0xa5, 0x51, 0x23, 0xfa, 0x96, 0xd2, 0xa8, 0x51, 0x15, 0x4b, 0x6f,
+	0x94, 0x2f, 0x7d, 0xaa, 0x16, 0x73, 0xdd, 0xfd, 0xbd, 0xa7, 0xe7, 0x79, 0xed, 0xd9, 0x79, 0x5e,
+	0xfb, 0xeb, 0x3c, 0xaf, 0x7d, 0x73, 0x91, 0xcf, 0x3c, 0xbb, 0xc8, 0x67, 0x7e, 0xbf, 0xc8, 0x67,
+	0x3e, 0x2d, 0x38, 0xcd, 0xa0, 0xd1, 0xad, 0x19, 0x16, 0x6f, 0xe1, 0x33, 0x1e, 0x89, 0x77, 0x2c,
+	0x23, 0x06, 0x27, 0x6d, 0xdb, 0xaf, 0xcd, 0xc9, 0x3f, 0x63, 0x6f, 0xfc, 0x1b, 0x00, 0x00, 0xff,
+	0xff, 0xcd, 0x03, 0x04, 0x72, 0x4c, 0x0e, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -1054,8 +1164,10 @@ const _ = grpc.SupportPackageIsVersion4
 type QueryClient interface {
 	// Account queries an Ethereum account.
 	Account(ctx context.Context, in *QueryAccountRequest, opts ...grpc.CallOption) (*QueryAccountResponse, error)
-	// Account queries an Ethereum account's Cosmos Address.
+	// CosmosAccount queries an Ethereum account's Cosmos Address.
 	CosmosAccount(ctx context.Context, in *QueryCosmosAccountRequest, opts ...grpc.CallOption) (*QueryCosmosAccountResponse, error)
+	// ValidatorAccount queries an Ethereum account's from a validator consensus Address.
+	ValidatorAccount(ctx context.Context, in *QueryValidatorAccountRequest, opts ...grpc.CallOption) (*QueryValidatorAccountResponse, error)
 	// Balance queries the balance of a the EVM denomination for a single
 	// EthAccount.
 	Balance(ctx context.Context, in *QueryBalanceRequest, opts ...grpc.CallOption) (*QueryBalanceResponse, error)
@@ -1101,6 +1213,15 @@ func (c *queryClient) CosmosAccount(ctx context.Context, in *QueryCosmosAccountR
 	return out, nil
 }
 
+func (c *queryClient) ValidatorAccount(ctx context.Context, in *QueryValidatorAccountRequest, opts ...grpc.CallOption) (*QueryValidatorAccountResponse, error) {
+	out := new(QueryValidatorAccountResponse)
+	err := c.cc.Invoke(ctx, "/ethermint.evm.v1alpha1.Query/ValidatorAccount", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *queryClient) Balance(ctx context.Context, in *QueryBalanceRequest, opts ...grpc.CallOption) (*QueryBalanceResponse, error) {
 	out := new(QueryBalanceResponse)
 	err := c.cc.Invoke(ctx, "/ethermint.evm.v1alpha1.Query/Balance", in, out, opts...)
@@ -1177,8 +1298,10 @@ func (c *queryClient) StaticCall(ctx context.Context, in *QueryStaticCallRequest
 type QueryServer interface {
 	// Account queries an Ethereum account.
 	Account(context.Context, *QueryAccountRequest) (*QueryAccountResponse, error)
-	// Account queries an Ethereum account's Cosmos Address.
+	// CosmosAccount queries an Ethereum account's Cosmos Address.
 	CosmosAccount(context.Context, *QueryCosmosAccountRequest) (*QueryCosmosAccountResponse, error)
+	// ValidatorAccount queries an Ethereum account's from a validator consensus Address.
+	ValidatorAccount(context.Context, *QueryValidatorAccountRequest) (*QueryValidatorAccountResponse, error)
 	// Balance queries the balance of a the EVM denomination for a single
 	// EthAccount.
 	Balance(context.Context, *QueryBalanceRequest) (*QueryBalanceResponse, error)
@@ -1208,6 +1331,9 @@ func (*UnimplementedQueryServer) Account(ctx context.Context, req *QueryAccountR
 func (*UnimplementedQueryServer) CosmosAccount(ctx context.Context, req *QueryCosmosAccountRequest) (*QueryCosmosAccountResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method CosmosAccount not implemented")
 }
+func (*UnimplementedQueryServer) ValidatorAccount(ctx context.Context, req *QueryValidatorAccountRequest) (*QueryValidatorAccountResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ValidatorAccount not implemented")
+}
 func (*UnimplementedQueryServer) Balance(ctx context.Context, req *QueryBalanceRequest) (*QueryBalanceResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Balance not implemented")
 }
@@ -1273,6 +1399,24 @@ func _Query_CosmosAccount_Handler(srv interface{}, ctx context.Context, dec func
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Query_ValidatorAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryValidatorAccountRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).ValidatorAccount(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/ethermint.evm.v1alpha1.Query/ValidatorAccount",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).ValidatorAccount(ctx, req.(*QueryValidatorAccountRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Query_Balance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(QueryBalanceRequest)
 	if err := dec(in); err != nil {
@@ -1429,6 +1573,10 @@ var _Query_serviceDesc = grpc.ServiceDesc{
 			MethodName: "CosmosAccount",
 			Handler:    _Query_CosmosAccount_Handler,
 		},
+		{
+			MethodName: "ValidatorAccount",
+			Handler:    _Query_ValidatorAccount_Handler,
+		},
 		{
 			MethodName: "Balance",
 			Handler:    _Query_Balance_Handler,
@@ -1608,6 +1756,76 @@ func (m *QueryCosmosAccountResponse) MarshalToSizedBuffer(dAtA []byte) (int, err
 	return len(dAtA) - i, nil
 }
 
+func (m *QueryValidatorAccountRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *QueryValidatorAccountRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryValidatorAccountRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.ConsAddress) > 0 {
+		i -= len(m.ConsAddress)
+		copy(dAtA[i:], m.ConsAddress)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.ConsAddress)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *QueryValidatorAccountResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *QueryValidatorAccountResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryValidatorAccountResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.AccountNumber != 0 {
+		i = encodeVarintQuery(dAtA, i, uint64(m.AccountNumber))
+		i--
+		dAtA[i] = 0x18
+	}
+	if m.Sequence != 0 {
+		i = encodeVarintQuery(dAtA, i, uint64(m.Sequence))
+		i--
+		dAtA[i] = 0x10
+	}
+	if len(m.AccountAddress) > 0 {
+		i -= len(m.AccountAddress)
+		copy(dAtA[i:], m.AccountAddress)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.AccountAddress)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
 func (m *QueryBalanceRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -2205,6 +2423,38 @@ func (m *QueryCosmosAccountResponse) Size() (n int) {
 	return n
 }
 
+func (m *QueryValidatorAccountRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.ConsAddress)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
+func (m *QueryValidatorAccountResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.AccountAddress)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	if m.Sequence != 0 {
+		n += 1 + sovQuery(uint64(m.Sequence))
+	}
+	if m.AccountNumber != 0 {
+		n += 1 + sovQuery(uint64(m.AccountNumber))
+	}
+	return n
+}
+
 func (m *QueryBalanceRequest) Size() (n int) {
 	if m == nil {
 		return 0
@@ -2858,6 +3108,214 @@ func (m *QueryCosmosAccountResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *QueryValidatorAccountRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowQuery
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: QueryValidatorAccountRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryValidatorAccountRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ConsAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ConsAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *QueryValidatorAccountResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowQuery
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: QueryValidatorAccountResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryValidatorAccountResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AccountAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.AccountAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
+			}
+			m.Sequence = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Sequence |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AccountNumber", wireType)
+			}
+			m.AccountNumber = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.AccountNumber |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *QueryBalanceRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0

x/evm/types/query.pb.gw.go

@@ -139,6 +139,60 @@ func local_request_Query_CosmosAccount_0(ctx context.Context, marshaler runtime.
 
 }
 
+func request_Query_ValidatorAccount_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryValidatorAccountRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["cons_address"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "cons_address")
+	}
+
+	protoReq.ConsAddress, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "cons_address", err)
+	}
+
+	msg, err := client.ValidatorAccount(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_ValidatorAccount_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryValidatorAccountRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["cons_address"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "cons_address")
+	}
+
+	protoReq.ConsAddress, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "cons_address", err)
+	}
+
+	msg, err := server.ValidatorAccount(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
 func request_Query_Balance_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
 	var protoReq QueryBalanceRequest
 	var metadata runtime.ServerMetadata
@@ -567,6 +621,26 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 
 	})
 
+	mux.Handle("GET", pattern_Query_ValidatorAccount_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Query_ValidatorAccount_0(rctx, inboundMarshaler, server, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_ValidatorAccount_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	mux.Handle("GET", pattern_Query_Balance_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -808,6 +882,26 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
 
 	})
 
+	mux.Handle("GET", pattern_Query_ValidatorAccount_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Query_ValidatorAccount_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_ValidatorAccount_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	mux.Handle("GET", pattern_Query_Balance_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -976,6 +1070,8 @@ var (
 
 	pattern_Query_CosmosAccount_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"ethermint", "evm", "v1alpha1", "cosmos_account", "address"}, "", runtime.AssumeColonVerbOpt(true)))
 
+	pattern_Query_ValidatorAccount_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"ethermint", "evm", "v1alpha1", "validator_account", "cons_address"}, "", runtime.AssumeColonVerbOpt(true)))
+
 	pattern_Query_Balance_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"ethermint", "evm", "v1alpha1", "balances", "address"}, "", runtime.AssumeColonVerbOpt(true)))
 
 	pattern_Query_Storage_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"ethermint", "evm", "v1alpha1", "storage", "address", "key"}, "", runtime.AssumeColonVerbOpt(true)))
@@ -998,6 +1094,8 @@ var (
 
 	forward_Query_CosmosAccount_0 = runtime.ForwardResponseMessage
 
+	forward_Query_ValidatorAccount_0 = runtime.ForwardResponseMessage
+
 	forward_Query_Balance_0 = runtime.ForwardResponseMessage
 
 	forward_Query_Storage_0 = runtime.ForwardResponseMessage