feat: wire new handlers to grpc

proto/cosmos/base/grpc/v2/service.proto

@@ -0,0 +1,31 @@
+syntax = "proto3";
+package cosmos.base.grpc.v2;
+
+import "google/protobuf/any.proto";
+
+option go_package = "cosmossdk.io/server/v2/api/grpc";
+
+service Service {
+  rpc Query(QueryRequest) returns (QueryResponse) {}
+
+  rpc ListQueryHandlers(ListQueryHandlersRequest) returns (ListQueryHandlersResponse) {}
+}
+
+message QueryRequest {
+  google.protobuf.Any request = 1;
+}
+
+message QueryResponse {
+  google.protobuf.Any response = 1;
+}
+
+message ListQueryHandlersRequest {}
+
+message ListQueryHandlersResponse {
+  repeated Handler handlers = 1;
+}
+
+message Handler {
+  string request_name  = 1;
+  string response_name = 2;
+}

server/v2/api/grpc/server.go

@@ -71,6 +71,11 @@ func (s *Server[T]) Init(appI serverv2.AppI[T], cfg map[string]any, logger log.L
 	// Reflection allows external clients to see what services and methods the gRPC server exposes.
 	gogoreflection.Register(grpcSrv, slices.Collect(maps.Keys(methodsMap)), logger.With("sub-module", "grpc-reflection"))
 
+	err := RegisterV2Service(grpcSrv, appI)
+	if err != nil {
+		return fmt.Errorf("failed to register V2 service: %w", err)
+	}
+
 	s.grpcSrv = grpcSrv
 	s.config = serverCfg
 	s.logger = logger.With(log.ModuleKey, s.Name())

server/v2/api/grpc/service.go

@@ -0,0 +1,91 @@
+package grpc
+
+import (
+	"context"
+	"errors"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
+	"cosmossdk.io/core/transaction"
+	serverv2 "cosmossdk.io/server/v2"
+	"github.com/cosmos/gogoproto/proto"
+	gogoproto "github.com/cosmos/gogoproto/types/any"
+)
+
+// RegisterV2Service registers the V2 gRPC service implementation with the given server.
+// It takes a generic type T that implements the transaction.Tx interface.
+func RegisterV2Service[T transaction.Tx](server *grpc.Server, app serverv2.AppI[T]) error {
+	if server == nil || app == nil {
+		return errors.New("nil server or app when registering service")
+	}
+	RegisterServiceServer(server, NewV2Service(app))
+
+	return nil
+}
+
+// V2Service implements the gRPC service interface for handling queries and listing handlers.
+type V2Service[T transaction.Tx] struct {
+	app serverv2.AppI[T]
+}
+
+// NewV2Service creates a new instance of V2Service with the provided app.
+func NewV2Service[T transaction.Tx](app serverv2.AppI[T]) *V2Service[T] {
+	return &V2Service[T]{app: app}
+}
+
+// Query handles incoming query requests by unmarshaling the request, processing it,
+// and returning the response in an Any protobuf message.
+func (s V2Service[T]) Query(ctx context.Context, request *QueryRequest) (*QueryResponse, error) {
+	if request == nil || request.Request == nil {
+		return nil, status.Error(codes.InvalidArgument, "empty request")
+	}
+
+	msgName := request.Request.TypeUrl
+	handlers := s.app.QueryHandlers()
+
+	handler, exists := handlers[msgName]
+	if !exists {
+		return nil, status.Errorf(codes.NotFound, "handler not found for %s", msgName)
+	}
+
+	protoMsg := handler.MakeMsg()
+	if err := proto.Unmarshal(request.Request.Value, protoMsg); err != nil {
+		return nil, status.Errorf(codes.InvalidArgument, "failed to unmarshal request: %v", err)
+	}
+
+	queryResp, err := s.app.Query(ctx, 0, protoMsg)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "query failed: %v", err)
+	}
+
+	respBytes, err := proto.Marshal(queryResp)
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "failed to marshal response: %v", err)
+	}
+
+	anyResp := &gogoproto.Any{
+		TypeUrl: "/" + proto.MessageName(queryResp),
+		Value:   respBytes,
+	}
+
+	return &QueryResponse{Response: anyResp}, nil
+}
+
+func (s V2Service[T]) ListQueryHandlers(_ context.Context, _ *ListQueryHandlersRequest) (*ListQueryHandlersResponse, error) {
+	handlersMap := s.app.QueryHandlers()
+
+	var handlerDescriptors []*Handler
+	for handlerName := range handlersMap {
+		msg := handlersMap[handlerName].MakeMsg()
+		resp := handlersMap[handlerName].MakeMsgResp()
+
+		handlerDescriptors = append(handlerDescriptors, &Handler{
+			RequestName:  proto.MessageName(msg),
+			ResponseName: proto.MessageName(resp),
+		})
+	}
+
+	return &ListQueryHandlersResponse{Handlers: handlerDescriptors}, nil
+}