Make gRPC requests go through tendermint Query

baseapp/abci.go

@@ -52,6 +52,8 @@ func (app *BaseApp) InitChain(req abci.RequestInitChain) (res abci.ResponseInitC
 		app.StoreConsensusParams(app.deliverState.ctx, req.ConsensusParams)
 	}
 
+	app.grpcQueryRouter.dryRunMethodHandlers(app.checkState.ctx)
+
 	if app.initChainer == nil {
 		return
 	}

baseapp/grpcrouter.go

@@ -2,6 +2,7 @@ package baseapp
 
 import (
 	"fmt"
+	"reflect"
 
 	gogogrpc "github.com/gogo/protobuf/grpc"
 	abci "github.com/tendermint/tendermint/abci/types"
@@ -19,6 +20,7 @@ var protoCodec = encoding.GetCodec(proto.Name)
 // GRPCQueryRouter routes ABCI Query requests to GRPC handlers
 type GRPCQueryRouter struct {
 	routes            map[string]GRPCQueryHandler
+	returnTypes       map[string]reflect.Type // map of a FQ method name to its return type.
 	interfaceRegistry codectypes.InterfaceRegistry
 	serviceData       []serviceData
 }
@@ -34,7 +36,8 @@ var _ gogogrpc.Server = &GRPCQueryRouter{}
 // NewGRPCQueryRouter creates a new GRPCQueryRouter
 func NewGRPCQueryRouter() *GRPCQueryRouter {
 	return &GRPCQueryRouter{
-		routes: map[string]GRPCQueryHandler{},
+		returnTypes: map[string]reflect.Type{},
+		routes:      map[string]GRPCQueryHandler{},
 	}
 }
 
@@ -82,6 +85,13 @@ func (qrt *GRPCQueryRouter) RegisterService(sd *grpc.ServiceDesc, handler interf
 			// call the method handler from the service description with the handler object,
 			// a wrapped sdk.Context with proto-unmarshaled data from the ABCI request data
 			res, err := methodHandler(handler, sdk.WrapSDKContext(ctx), func(i interface{}) error {
+				// If it's the first time we call this handler, then we save
+				// the return type of the handler in the `returnTypes` map.
+				// The return type will be used for decoding subsequent requests.
+				if _, found := qrt.returnTypes[fqName]; !found {
+					qrt.returnTypes[fqName] = reflect.TypeOf(i)
+				}
+
 				err := protoCodec.Unmarshal(req.Data, i)
 				if err != nil {
 					return err
@@ -115,6 +125,18 @@ func (qrt *GRPCQueryRouter) RegisterService(sd *grpc.ServiceDesc, handler interf
 	})
 }
 
+// dryRunMethodHandlers runs all methods saved in `routes` once. This should
+// be called once at startup (after the stores are mounted), to populate the
+// `returnTypes` map. It is called from InitChain.
+func (qrt *GRPCQueryRouter) dryRunMethodHandlers(ctx sdk.Context) {
+	for fqName, handler := range qrt.routes {
+		fmt.Println("dry running fqNanem", fqName)
+		handler(ctx, abci.RequestQuery{
+			Path: fqName,
+		})
+	}
+}
+
 // SetInterfaceRegistry sets the interface registry for the router. This will
 // also register the interface reflection gRPC service.
 func (qrt *GRPCQueryRouter) SetInterfaceRegistry(interfaceRegistry codectypes.InterfaceRegistry) {

baseapp/grpcserver.go

@@ -2,17 +2,20 @@ package baseapp
 
 import (
 	"context"
+	"reflect"
 	"strconv"
 
 	gogogrpc "github.com/gogo/protobuf/grpc"
+	"github.com/gogo/protobuf/proto"
 	grpcmiddleware "github.com/grpc-ecosystem/go-grpc-middleware"
 	grpcrecovery "github.com/grpc-ecosystem/go-grpc-middleware/recovery"
+	abci "github.com/tendermint/tendermint/abci/types"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/metadata"
 	"google.golang.org/grpc/status"
 
-	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/client"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 	grpctypes "github.com/cosmos/cosmos-sdk/types/grpc"
 )
@@ -21,10 +24,10 @@ import (
 func (app *BaseApp) GRPCQueryRouter() *GRPCQueryRouter { return app.grpcQueryRouter }
 
 // RegisterGRPCServer registers gRPC services directly with the gRPC server.
-func (app *BaseApp) RegisterGRPCServer(server gogogrpc.Server) {
+func (app *BaseApp) RegisterGRPCServer(clientCtx client.Context, server gogogrpc.Server) {
 	// Define an interceptor for all gRPC queries: this interceptor will create
 	// a new sdk.Context, and pass it into the query handler.
-	interceptor := func(grpcCtx context.Context, req interface{}, _ *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {
+	interceptor := func(grpcCtx context.Context, req interface{}, info *grpc.UnaryServerInfo, _ grpc.UnaryHandler) (resp interface{}, err error) {
 		// If there's some metadata in the context, retrieve it.
 		md, ok := metadata.FromIncomingContext(grpcCtx)
 		if !ok {
@@ -38,31 +41,40 @@ func (app *BaseApp) RegisterGRPCServer(server gogogrpc.Server) {
 			if err != nil {
 				return nil, sdkerrors.Wrapf(
 					sdkerrors.ErrInvalidRequest,
-					"Baseapp.RegisterGRPCServer: invalid height header %q: %v", grpctypes.GRPCBlockHeightHeader, err)
+					"baseapp.RegisterGRPCServer: invalid height header %q: %v", grpctypes.GRPCBlockHeightHeader, err)
 			}
 			if err := checkNegativeHeight(height); err != nil {
 				return nil, err
 			}
 		}
 
-		// Create the sdk.Context. Passing false as 2nd arg, as we can't
-		// actually support proofs with gRPC right now.
-		sdkCtx, err := app.createQueryContext(height, false)
+		reqProto, ok := req.(proto.Message)
+		if !ok {
+			return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "expected %T, got %T", (proto.Message)(nil), req)
+		}
+		reqBz, err := proto.Marshal(reqProto)
 		if err != nil {
-			return nil, err
+			return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "cannot proto marshal: %v", err)
 		}
 
-		// Attach the sdk.Context into the gRPC's context.Context.
-		grpcCtx = context.WithValue(grpcCtx, sdk.SdkContextKey, sdkCtx)
+		abciReq := abci.RequestQuery{
+			Path:   info.FullMethod,
+			Data:   reqBz,
+			Height: height,
+			Prove:  false, // Enable here: https://github.com/cosmos/cosmos-sdk/issues/7036
+		}
+		abciRes, err := clientCtx.QueryABCI(abciReq)
+		if err != nil {
+			return nil, err
+		}
 
-		// Add relevant gRPC headers
-		if height == 0 {
-			height = sdkCtx.BlockHeight() // If height was not set in the request, set it to the latest
+		res := reflect.New(app.GRPCQueryRouter().returnTypes[info.FullMethod]).Elem().Interface()
+		err = protoCodec.Unmarshal(abciRes.Value, res)
+		if err != nil {
+			return nil, err
 		}
-		md = metadata.Pairs(grpctypes.GRPCBlockHeightHeader, strconv.FormatInt(height, 10))
-		grpc.SetHeader(grpcCtx, md)
 
-		return handler(grpcCtx, req)
+		return
 	}
 
 	// Loop through all services and methods, add the interceptor, and register

server/grpc/server.go

@@ -8,13 +8,14 @@ import (
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/reflection"
 
+	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/server/types"
 )
 
 // StartGRPCServer starts a gRPC server on the given address.
-func StartGRPCServer(app types.Application, address string) (*grpc.Server, error) {
+func StartGRPCServer(clientCtx client.Context, app types.Application, address string) (*grpc.Server, error) {
 	grpcSrv := grpc.NewServer()
-	app.RegisterGRPCServer(grpcSrv)
+	app.RegisterGRPCServer(clientCtx, grpcSrv)
 
 	// Reflection allows external clients to see what services and methods
 	// the gRPC server exposes.

server/start.go

@@ -318,7 +318,7 @@ func startInProcess(ctx *Context, clientCtx client.Context, appCreator types.App
 		grpcWebSrv *http.Server
 	)
 	if config.GRPC.Enable {
-		grpcSrv, err = servergrpc.StartGRPCServer(app, config.GRPC.Address)
+		grpcSrv, err = servergrpc.StartGRPCServer(clientCtx, app, config.GRPC.Address)
 		if err != nil {
 			return err
 		}

server/types/app.go

@@ -38,7 +38,7 @@ type (
 
 		// RegisterGRPCServer registers gRPC services directly with the gRPC
 		// server.
-		RegisterGRPCServer(grpc.Server)
+		RegisterGRPCServer(client.Context, grpc.Server)
 
 		// RegisterTxService registers the gRPC Query service for tx (such as tx
 		// simulation, fetching txs by hash...).

testutil/network/util.go

@@ -93,7 +93,7 @@ func startInProcess(cfg Config, val *Validator) error {
 	}
 
 	if val.AppConfig.GRPC.Enable {
-		grpcSrv, err := servergrpc.StartGRPCServer(app, val.AppConfig.GRPC.Address)
+		grpcSrv, err := servergrpc.StartGRPCServer(val.ClientCtx, app, val.AppConfig.GRPC.Address)
 		if err != nil {
 			return err
 		}