x/evidence: gRPC query service

proto/cosmos/evidence/query.proto

@@ -0,0 +1,39 @@
+syntax = "proto3";
+package cosmos.evidence;
+
+import "cosmos/query/pagination.proto";
+import "gogoproto/gogo.proto";
+import "google/protobuf/any.proto";
+
+option go_package = "github.com/cosmos/cosmos-sdk/x/evidence/types";
+
+// Query provides defines the gRPC querier service
+service Query {
+  // Evidence queries evidence based on evidence hash
+  rpc Evidence(QueryEvidenceRequest) returns (QueryEvidenceResponse) {}
+
+  // AllEvidence queries all evidence
+  rpc AllEvidence(QueryAllEvidenceRequest) returns (QueryAllEvidenceResponse) {}
+}
+
+// QueryEvidenceRequest is the request type for the Query/Evidence RPC method
+message QueryEvidenceRequest {
+  bytes evidence_hash = 1  [(gogoproto.casttype) = "github.com/tendermint/tendermint/libs/bytes.HexBytes"];;
+}
+
+// QueryEvidenceResponse is the response type for the Query/Evidence RPC method
+message QueryEvidenceResponse {
+  google.protobuf.Any evidence = 1;
+}
+
+// QueryEvidenceRequest is the request type for the Query/AllEvidence RPC method
+message QueryAllEvidenceRequest {
+  cosmos.query.PageRequest req = 1;
+}
+
+// QueryAllEvidenceResponse is the response type for the Query/AllEvidence RPC method
+message QueryAllEvidenceResponse {
+  repeated google.protobuf.Any evidence = 1;
+
+  cosmos.query.PageResponse res = 2;
+}

store/rootmulti/internal/proofs/create.go

@@ -5,6 +5,7 @@ import (
 	"sort"
 
 	ics23 "github.com/confio/ics23/go"
+
 	sdkmaps "github.com/cosmos/cosmos-sdk/store/rootmulti/internal/maps"
 )
 

x/evidence/keeper/grpc_query.go

@@ -0,0 +1,94 @@
+package keeper
+
+import (
+	"context"
+	"fmt"
+
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
+	"github.com/cosmos/cosmos-sdk/store/prefix"
+	"github.com/cosmos/cosmos-sdk/types/query"
+
+	proto "github.com/gogo/protobuf/proto"
+
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/evidence/exported"
+	"github.com/cosmos/cosmos-sdk/x/evidence/types"
+)
+
+var _ types.QueryServer = Keeper{}
+
+// Evidence implements the Query/Evidence gRPC method
+func (k Keeper) Evidence(c context.Context, req *types.QueryEvidenceRequest) (*types.QueryEvidenceResponse, error) {
+	if req == nil {
+		return nil, status.Errorf(codes.InvalidArgument, "empty request")
+	}
+
+	if req.EvidenceHash == nil {
+		return nil, status.Errorf(codes.InvalidArgument, "invalid hash")
+	}
+
+	ctx := sdk.UnwrapSDKContext(c)
+
+	evidence, _ := k.GetEvidence(ctx, req.EvidenceHash)
+	if evidence == nil {
+		return nil, status.Errorf(codes.NotFound, "evidence %s not found", req.EvidenceHash)
+	}
+
+	evidenceAny, err := ConvertEvidence(evidence)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, err.Error())
+	}
+
+	return &types.QueryEvidenceResponse{Evidence: evidenceAny}, nil
+}
+
+// AllEvidence implements the Query/AllEvidence gRPC method
+func (k Keeper) AllEvidence(c context.Context, req *types.QueryAllEvidenceRequest) (*types.QueryAllEvidenceResponse, error) {
+	if req == nil {
+		return nil, status.Errorf(codes.InvalidArgument, "empty request")
+	}
+	ctx := sdk.UnwrapSDKContext(c)
+
+	k.GetAllEvidence(ctx)
+
+	var evidence []*codectypes.Any
+	store := ctx.KVStore(k.storeKey)
+	evidenceStore := prefix.NewStore(store, types.KeyPrefixEvidence)
+
+	res, err := query.Paginate(evidenceStore, req.Req, func(key []byte, value []byte) error {
+		result, err := k.UnmarshalEvidence(value)
+		if err != nil {
+			return err
+		}
+		evidenceAny, err := ConvertEvidence(result)
+		if err != nil {
+			return err
+		}
+		evidence = append(evidence, evidenceAny)
+		return nil
+	})
+
+	if err != nil {
+		return &types.QueryAllEvidenceResponse{}, err
+	}
+
+	return &types.QueryAllEvidenceResponse{Evidence: evidence, Res: res}, nil
+}
+
+// ConvertEvidence converts Evidence to Any type
+func ConvertEvidence(evidence exported.Evidence) (*codectypes.Any, error) {
+	msg, ok := evidence.(proto.Message)
+	if !ok {
+		return nil, fmt.Errorf("can't protomarshal %T", msg)
+	}
+
+	any, err := codectypes.NewAnyWithValue(msg)
+	if err != nil {
+		return nil, err
+	}
+
+	return any, nil
+}

x/evidence/keeper/grpc_query_test.go

@@ -0,0 +1,78 @@
+package keeper_test
+
+import (
+	gocontext "context"
+
+	"github.com/cosmos/cosmos-sdk/baseapp"
+	"github.com/cosmos/cosmos-sdk/types/query"
+	"github.com/cosmos/cosmos-sdk/x/evidence/exported"
+	"github.com/cosmos/cosmos-sdk/x/evidence/types"
+
+	tmbytes "github.com/tendermint/tendermint/libs/bytes"
+)
+
+func (suite *KeeperTestSuite) TestQueryEvidence() {
+	app, ctx := suite.app, suite.ctx
+
+	queryHelper := baseapp.NewQueryServerTestHelper(ctx, app.InterfaceRegistry())
+	types.RegisterQueryServer(queryHelper, app.EvidenceKeeper)
+	queryClient := types.NewQueryClient(queryHelper)
+
+	_, err := queryClient.Evidence(gocontext.Background(), &types.QueryEvidenceRequest{})
+	suite.Require().Error(err)
+
+	_, err = queryClient.Evidence(gocontext.Background(), &types.QueryEvidenceRequest{EvidenceHash: tmbytes.HexBytes{}})
+	suite.Require().Error(err)
+
+	numEvidence := 100
+	evidence := suite.populateEvidence(ctx, numEvidence)
+
+	req := types.NewQueryEvidenceRequest(evidence[0].Hash())
+	res, err := queryClient.Evidence(gocontext.Background(), req)
+	suite.Require().NoError(err)
+	suite.Require().NotNil(res)
+	suite.Require().NotNil(res.Evidence)
+
+	var evi exported.Evidence
+	err = app.InterfaceRegistry().UnpackAny(res.Evidence, &evi)
+	suite.Require().NoError(err)
+	suite.Require().NotNil(evi)
+	suite.Require().Equal(evi, evidence[0])
+}
+
+func (suite *KeeperTestSuite) TestQueryAllEvidence() {
+	app, ctx := suite.app, suite.ctx
+
+	queryHelper := baseapp.NewQueryServerTestHelper(ctx, app.InterfaceRegistry())
+	types.RegisterQueryServer(queryHelper, app.EvidenceKeeper)
+	queryClient := types.NewQueryClient(queryHelper)
+
+	res, err := queryClient.AllEvidence(gocontext.Background(), &types.QueryAllEvidenceRequest{})
+	suite.Require().NoError(err)
+	suite.Require().NotNil(res)
+	suite.Require().Empty(res.Evidence)
+
+	numEvidence := 100
+	_ = suite.populateEvidence(ctx, numEvidence)
+	pageReq := &query.PageRequest{
+		Key:        nil,
+		Limit:      50,
+		CountTotal: false,
+	}
+	req := types.NewQueryAllEvidenceRequest(pageReq)
+	res, err = queryClient.AllEvidence(gocontext.Background(), req)
+	suite.Require().NoError(err)
+	suite.Require().NotNil(res)
+	suite.Equal(len(res.Evidence), 50)
+	suite.NotNil(res.Res.NextKey)
+
+	pageReq = &query.PageRequest{
+		Key:        res.Res.NextKey,
+		Limit:      50,
+		CountTotal: true,
+	}
+	req = types.NewQueryAllEvidenceRequest(pageReq)
+	res, err = queryClient.AllEvidence(gocontext.Background(), req)
+	suite.Equal(len(res.Evidence), 50)
+	suite.Nil(res.Res.NextKey)
+}

x/evidence/keeper/querier_test.go

@@ -15,7 +15,7 @@ const (
 	custom = "custom"
 )
 
-func (suite *KeeperTestSuite) TestQueryEvidence_Existing() {
+func (suite *KeeperTestSuite) TestQuerier_QueryEvidence_Existing() {
 	ctx := suite.ctx.WithIsCheckTx(false)
 	numEvidence := 100
 	cdc, _ := simapp.MakeCodecs()
@@ -35,7 +35,7 @@ func (suite *KeeperTestSuite) TestQueryEvidence_Existing() {
 	suite.Equal(evidence[0], e)
 }
 
-func (suite *KeeperTestSuite) TestQueryEvidence_NonExisting() {
+func (suite *KeeperTestSuite) TestQuerier_QueryEvidence_NonExisting() {
 	ctx := suite.ctx.WithIsCheckTx(false)
 	cdc, _ := simapp.MakeCodecs()
 	numEvidence := 100
@@ -51,7 +51,7 @@ func (suite *KeeperTestSuite) TestQueryEvidence_NonExisting() {
 	suite.Nil(bz)
 }
 
-func (suite *KeeperTestSuite) TestQueryAllEvidence() {
+func (suite *KeeperTestSuite) TestQuerier_QueryAllEvidence() {
 	ctx := suite.ctx.WithIsCheckTx(false)
 	cdc, _ := simapp.MakeCodecs()
 	numEvidence := 100
@@ -71,7 +71,7 @@ func (suite *KeeperTestSuite) TestQueryAllEvidence() {
 	suite.Len(e, numEvidence)
 }
 
-func (suite *KeeperTestSuite) TestQueryAllEvidence_InvalidPagination() {
+func (suite *KeeperTestSuite) TestQuerier_QueryAllEvidence_InvalidPagination() {
 	ctx := suite.ctx.WithIsCheckTx(false)
 	cdc, _ := simapp.MakeCodecs()
 	numEvidence := 100

x/evidence/types/querier.go

@@ -1,11 +1,27 @@
 package types
 
+import (
+	tmbytes "github.com/tendermint/tendermint/libs/bytes"
+
+	query "github.com/cosmos/cosmos-sdk/types/query"
+)
+
 // Querier routes for the evidence module
 const (
 	QueryEvidence    = "evidence"
 	QueryAllEvidence = "all_evidence"
 )
 
+// NewQueryEvidenceRequest creates a new instance of QueryEvidenceRequest.
+func NewQueryEvidenceRequest(hash tmbytes.HexBytes) *QueryEvidenceRequest {
+	return &QueryEvidenceRequest{EvidenceHash: hash}
+}
+
+// NewQueryAllEvidenceRequest creates a new instance of QueryAllEvidenceRequest.
+func NewQueryAllEvidenceRequest(req *query.PageRequest) *QueryAllEvidenceRequest {
+	return &QueryAllEvidenceRequest{Req: req}
+}
+
 // QueryEvidenceParams defines the parameters necessary for querying Evidence.
 type QueryEvidenceParams struct {
 	EvidenceHash string `json:"evidence_hash" yaml:"evidence_hash"`