GRPC querier init and bank

baseapp/abci.go

@@ -294,6 +294,10 @@ func (app *BaseApp) halt() {
 // Query implements the ABCI interface. It delegates to CommitMultiStore if it
 // implements Queryable.
 func (app *BaseApp) Query(req abci.RequestQuery) abci.ResponseQuery {
+	if grpcHandler := app.grpcRouter.Route(req.Path); grpcHandler != nil {
+		return handleQueryGRPC(app, grpcHandler, req)
+	}
+
 	path := splitPath(req.Path)
 	if len(path) == 0 {
 		sdkerrors.QueryResult(sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, "no query path provided"))
@@ -317,6 +321,51 @@ func (app *BaseApp) Query(req abci.RequestQuery) abci.ResponseQuery {
 	return sdkerrors.QueryResult(sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, "unknown query path"))
 }
 
+func handleQueryGRPC(app *BaseApp, handler GRPCHandler, req abci.RequestQuery) abci.ResponseQuery {
+	// when a client did not provide a query height, manually inject the latest
+	if req.Height == 0 {
+		req.Height = app.LastBlockHeight()
+	}
+
+	if req.Height <= 1 && req.Prove {
+		return sdkerrors.QueryResult(
+			sdkerrors.Wrap(
+				sdkerrors.ErrInvalidRequest,
+				"cannot query with proof when height <= 1; please provide a valid height",
+			),
+		)
+	}
+
+	cacheMS, err := app.cms.CacheMultiStoreWithVersion(req.Height)
+	if err != nil {
+		return sdkerrors.QueryResult(
+			sdkerrors.Wrapf(
+				sdkerrors.ErrInvalidRequest,
+				"failed to load state at height %d; %s (latest height: %d)", req.Height, err, app.LastBlockHeight(),
+			),
+		)
+	}
+
+	// cache wrap the commit-multistore for safety
+	ctx := sdk.NewContext(
+		cacheMS, app.checkState.ctx.BlockHeader(), true, app.logger,
+	).WithMinGasPrices(app.minGasPrices)
+
+	res, err := handler(ctx, req)
+
+	if err != nil {
+		space, code, log := sdkerrors.ABCIInfo(err, false)
+		return abci.ResponseQuery{
+			Code:      code,
+			Codespace: space,
+			Log:       log,
+			Height:    req.Height,
+		}
+	}
+
+	return res
+}
+
 func handleQueryApp(app *BaseApp, path []string, req abci.RequestQuery) abci.ResponseQuery {
 	if len(path) >= 2 {
 		switch path[1] {

baseapp/baseapp.go

@@ -6,6 +6,8 @@ import (
 	"runtime/debug"
 	"strings"
 
+	"github.com/gogo/protobuf/grpc"
+
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/crypto/tmhash"
 	"github.com/tendermint/tendermint/libs/log"
@@ -48,6 +50,7 @@ type BaseApp struct { // nolint: maligned
 	storeLoader StoreLoader          // function to handle store loading, may be overridden with SetStoreLoader()
 	router      sdk.Router           // handle any kind of message
 	queryRouter sdk.QueryRouter      // router for redirecting query calls
+	grpcRouter  *GRPCRouter          // router for redirecting gRPC query calls
 	txDecoder   sdk.TxDecoder        // unmarshal []byte into sdk.Tx
 
 	anteHandler    sdk.AnteHandler  // ante handler for fee and auth
@@ -108,6 +111,7 @@ func NewBaseApp(
 		storeLoader:    DefaultStoreLoader,
 		router:         NewRouter(),
 		queryRouter:    NewQueryRouter(),
+		grpcRouter:     NewGRPCRouter(),
 		txDecoder:      txDecoder,
 		fauxMerkleMode: false,
 	}
@@ -282,6 +286,9 @@ func (app *BaseApp) Router() sdk.Router {
 // QueryRouter returns the QueryRouter of a BaseApp.
 func (app *BaseApp) QueryRouter() sdk.QueryRouter { return app.queryRouter }
 
+// GRPCRouter returns the GRPCRouter of a BaseApp.
+func (app *BaseApp) GRPCRouter() grpc.Server { return app.grpcRouter }
+
 // Seal seals a BaseApp. It prohibits any further modifications to a BaseApp.
 func (app *BaseApp) Seal() { app.sealed = true }
 

baseapp/grpcrouter.go

@@ -0,0 +1,108 @@
+package baseapp
+
+import (
+	gocontext "context"
+	"fmt"
+
+	gogogrpc "github.com/gogo/protobuf/grpc"
+	abci "github.com/tendermint/tendermint/abci/types"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/encoding"
+	"google.golang.org/grpc/encoding/proto"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+var protoCodec = encoding.GetCodec(proto.Name)
+
+type GRPCRouter struct {
+	routes map[string]GRPCHandler
+}
+
+var _ gogogrpc.Server
+
+func NewGRPCRouter() *GRPCRouter {
+	return &GRPCRouter{
+		routes: map[string]GRPCHandler{},
+	}
+}
+
+type GRPCHandler = func(ctx sdk.Context, req abci.RequestQuery) (abci.ResponseQuery, error)
+
+// Route returns the Querier for a given query route path.
+func (qrt *GRPCRouter) Route(path string) GRPCHandler {
+	handler, found := qrt.routes[path]
+	if !found {
+		return nil
+	}
+	return handler
+}
+
+// RegisterService implements the grpc Server.RegisterService method
+func (qrt *GRPCRouter) RegisterService(sd *grpc.ServiceDesc, handler interface{}) {
+	// adds a top-level querier based on the GRPC service name
+	for _, method := range sd.Methods {
+		fqName := fmt.Sprintf("/%s/%s", sd.ServiceName, method.MethodName)
+		methodHandler := method.Handler
+
+		qrt.routes[fqName] = func(ctx sdk.Context, req abci.RequestQuery) (abci.ResponseQuery, error) {
+			res, err := methodHandler(handler, sdk.WrapSDKContext(ctx), func(i interface{}) error {
+				return protoCodec.Unmarshal(req.Data, i)
+			}, nil)
+			if err != nil {
+				return abci.ResponseQuery{}, err
+			}
+
+			resBytes, err := protoCodec.Marshal(res)
+			if err != nil {
+				return abci.ResponseQuery{}, err
+			}
+
+			return abci.ResponseQuery{
+				Height: req.Height,
+				Value:  resBytes,
+			}, nil
+		}
+	}
+}
+
+// QueryServiceTestHelper provides a helper for making grpc query service
+// rpc calls in unit tests. It implements both the grpc Server and ClientConn
+// interfaces needed to register a query service server and create a query
+// service client.
+type QueryServiceTestHelper struct {
+	*GRPCRouter
+	ctx sdk.Context
+}
+
+// NewQueryServerTestHelper creates a new QueryServiceTestHelper that wraps
+// the provided sdk.Context
+func NewQueryServerTestHelper(ctx sdk.Context) *QueryServiceTestHelper {
+	return &QueryServiceTestHelper{GRPCRouter: NewGRPCRouter(), ctx: ctx}
+}
+
+// Invoke implements the grpc ClientConn.Invoke method
+func (q *QueryServiceTestHelper) Invoke(_ gocontext.Context, method string, args, reply interface{}, _ ...grpc.CallOption) error {
+	querier := q.Route(method)
+	if querier == nil {
+		return fmt.Errorf("handler not found for %s", method)
+	}
+	reqBz, err := protoCodec.Marshal(args)
+	if err != nil {
+		return err
+	}
+	res, err := querier(q.ctx, abci.RequestQuery{Data: reqBz})
+
+	if err != nil {
+		return err
+	}
+	return protoCodec.Unmarshal(res.Value, reply)
+}
+
+// NewStream implements the grpc ClientConn.NewStream method
+func (q *QueryServiceTestHelper) NewStream(gocontext.Context, *grpc.StreamDesc, string, ...grpc.CallOption) (grpc.ClientStream, error) {
+	return nil, fmt.Errorf("not supported")
+}
+
+var _ gogogrpc.Server = &QueryServiceTestHelper{}
+var _ gogogrpc.ClientConn = &QueryServiceTestHelper{}

baseapp/grpcrouter_test.go

@@ -0,0 +1,49 @@
+package baseapp
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/cosmos/cosmos-sdk/codec/testdata"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+type testServer struct{}
+
+func (e testServer) Echo(_ context.Context, req *testdata.EchoRequest) (*testdata.EchoResponse, error) {
+	return &testdata.EchoResponse{Message: req.Message}, nil
+}
+
+func (e testServer) SayHello(_ context.Context, request *testdata.SayHelloRequest) (*testdata.SayHelloResponse, error) {
+	greeting := fmt.Sprintf("Hello %s!", request.Name)
+	return &testdata.SayHelloResponse{Greeting: greeting}, nil
+}
+
+var _ testdata.TestServiceServer = testServer{}
+
+func TestGRPCRouter(t *testing.T) {
+	qr := NewGRPCRouter()
+	testdata.RegisterTestServiceServer(qr, testServer{})
+	helper := &QueryServiceTestHelper{
+		GRPCRouter: qr,
+		ctx:        sdk.Context{},
+	}
+	client := testdata.NewTestServiceClient(helper)
+
+	res, err := client.Echo(context.Background(), &testdata.EchoRequest{Message: "hello"})
+	require.Nil(t, err)
+	require.NotNil(t, res)
+	require.Equal(t, "hello", res.Message)
+
+	require.Panics(t, func() {
+		_, _ = client.Echo(context.Background(), nil)
+	})
+
+	res2, err := client.SayHello(context.Background(), &testdata.SayHelloRequest{Name: "Foo"})
+	require.Nil(t, err)
+	require.NotNil(t, res)
+	require.Equal(t, "Hello Foo!", res2.Greeting)
+}

buf.yaml

@@ -12,6 +12,7 @@ lint:
     - UNARY_RPC
     - COMMENT_FIELD
     - PACKAGE_DIRECTORY_MATCH
+    - SERVICE_SUFFIX
   ignore:
     - third_party
     - codec/testdata
@@ -20,3 +21,4 @@ breaking:
     - FILE
   ignore:
     - third_party
+    - codec/testdata

client/query.go

@@ -1,9 +1,15 @@
 package client
 
 import (
+	"context"
 	"fmt"
 	"strings"
 
+	gogogrpc "github.com/gogo/protobuf/grpc"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/encoding"
+	"google.golang.org/grpc/encoding/proto"
+
 	"github.com/pkg/errors"
 
 	abci "github.com/tendermint/tendermint/abci/types"
@@ -233,3 +239,35 @@ func parseQueryStorePath(path string) (storeName string, err error) {
 
 	return paths[1], nil
 }
+
+// QueryConn returns a new grpc ClientConn for making grpc query calls that
+// get routed to the node's ABCI query handler
+func (ctx Context) QueryConn() gogogrpc.ClientConn {
+	return cliQueryConn{ctx}
+}
+
+type cliQueryConn struct {
+	ctx Context
+}
+
+var _ gogogrpc.ClientConn = cliQueryConn{}
+
+var protoCodec = encoding.GetCodec(proto.Name)
+
+// Invoke implements the grpc ClientConn.Invoke method
+func (c cliQueryConn) Invoke(_ context.Context, method string, args, reply interface{}, _ ...grpc.CallOption) error {
+	reqBz, err := protoCodec.Marshal(args)
+	if err != nil {
+		return err
+	}
+	resBz, _, err := c.ctx.QueryWithData(method, reqBz)
+	if err != nil {
+		return err
+	}
+	return protoCodec.Unmarshal(resBz, reply)
+}
+
+// NewStream implements the grpc ClientConn.NewStream method
+func (c cliQueryConn) NewStream(context.Context, *grpc.StreamDesc, string, ...grpc.CallOption) (grpc.ClientStream, error) {
+	return nil, fmt.Errorf("streaming rpc not supported")
+}