feat(server/v2)!: grpcgateway autoregistration

server/v2/api/grpcgateway/interceptor.go

@@ -0,0 +1,125 @@
+package grpcgateway
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	gogoproto "github.com/cosmos/gogoproto/proto"
+	"github.com/grpc-ecosystem/grpc-gateway/runtime"
+	"google.golang.org/genproto/googleapis/api/annotations"
+	"google.golang.org/protobuf/reflect/protoreflect"
+
+	"google.golang.org/protobuf/proto"
+
+	"cosmossdk.io/core/transaction"
+	"cosmossdk.io/server/v2/appmanager"
+)
+
+var _ http.Handler = &gatewayInterceptor[transaction.Tx]{}
+
+// gatewayInterceptor handles routing grpc-gateway queries to the app manager's query router.
+type gatewayInterceptor[T transaction.Tx] struct {
+	// gateway is the fallback grpc gateway mux handler.
+	gateway *runtime.ServeMux
+
+	// customEndpointMapping is a mapping of custom GET options on proto RPC handlers, to the fully qualified method name.
+	//
+	// example: /cosmos/bank/v1beta1/denoms_metadata -> cosmos.bank.v1beta1.Query.DenomsMetadata
+	customEndpointMapping map[string]string
+
+	// appManager is used to route queries to the application.
+	appManager appmanager.AppManager[T]
+}
+
+// newGatewayInterceptor creates a new gatewayInterceptor.
+func newGatewayInterceptor[T transaction.Tx](gateway *runtime.ServeMux, am appmanager.AppManager[T]) (*gatewayInterceptor[T], error) {
+	getMapping, err := getHTTPGetAnnotationMapping()
+	if err != nil {
+		return nil, err
+	}
+	return &gatewayInterceptor[T]{
+		gateway:               gateway,
+		customEndpointMapping: getMapping,
+		appManager:            am,
+	}, nil
+}
+
+// ServeHTTP implements the http.Handler interface. This function will attempt to match http requests to the
+// interceptors internal mapping of http annotations to query request type names.
+// If no match can be made, it falls back to the runtime gateway server mux.
+func (g *gatewayInterceptor[T]) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
+	uri := request.URL.RequestURI()
+	uriMatch := matchURI(uri, g.customEndpointMapping)
+	if uriMatch != nil {
+		var msg gogoproto.Message
+		var err error
+
+		switch request.Method {
+		case http.MethodPost:
+			msg, err = createMessageFromJSON(uriMatch, request)
+		case http.MethodGet:
+			msg, err = createMessage(uriMatch)
+		default:
+			http.Error(writer, "unsupported http method", http.StatusMethodNotAllowed)
+			return
+		}
+		if err != nil {
+			http.Error(writer, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		query, err := g.appManager.Query(request.Context(), 0, msg)
+		if err != nil {
+			http.Error(writer, "Error querying", http.StatusInternalServerError)
+			return
+		}
+		writer.Header().Set("Content-Type", "application/json")
+		if err := json.NewEncoder(writer).Encode(query); err != nil {
+			http.Error(writer, fmt.Sprintf("Error encoding response: %v", err), http.StatusInternalServerError)
+		}
+	} else {
+		g.gateway.ServeHTTP(writer, request)
+	}
+}
+
+// getHTTPGetAnnotationMapping returns a mapping of proto query input type full name to its RPC method's HTTP GET annotation.
+//
+// example: "/cosmos/auth/v1beta1/account_info/{address}":"cosmos.auth.v1beta1.Query.AccountInfo"
+func getHTTPGetAnnotationMapping() (map[string]string, error) {
+	protoFiles, err := gogoproto.MergedRegistry()
+	if err != nil {
+		return nil, err
+	}
+
+	httpGets := make(map[string]string)
+	protoFiles.RangeFiles(func(fd protoreflect.FileDescriptor) bool {
+		for i := 0; i < fd.Services().Len(); i++ {
+			// Get the service descriptor
+			sd := fd.Services().Get(i)
+
+			for j := 0; j < sd.Methods().Len(); j++ {
+				// Get the method descriptor
+				md := sd.Methods().Get(j)
+
+				httpOption := proto.GetExtension(md.Options(), annotations.E_Http)
+				if httpOption == nil {
+					continue
+				}
+
+				httpRule, ok := httpOption.(*annotations.HttpRule)
+				if !ok || httpRule == nil {
+					continue
+				}
+				if httpRule.GetGet() == "" {
+					continue
+				}
+
+				httpGets[httpRule.GetGet()] = string(md.Input().FullName())
+			}
+		}
+		return true
+	})
+
+	return httpGets, nil
+}

server/v2/api/grpcgateway/server.go

@@ -14,6 +14,7 @@ import (
 	"cosmossdk.io/core/transaction"
 	"cosmossdk.io/log"
 	serverv2 "cosmossdk.io/server/v2"
+	"cosmossdk.io/server/v2/appmanager"
 )
 
 var (
@@ -37,6 +38,7 @@ func New[T transaction.Tx](
 	logger log.Logger,
 	config server.ConfigMap,
 	ir jsonpb.AnyResolver,
+	appManager appmanager.AppManager[T],
 	cfgOptions ...CfgOption,
 ) (*Server[T], error) {
 	// The default JSON marshaller used by the gRPC-Gateway is unable to marshal non-nullable non-scalar fields.
@@ -76,7 +78,11 @@ func New[T transaction.Tx](
 	s.logger = logger.With(log.ModuleKey, s.Name())
 	s.config = serverCfg
 	mux := http.NewServeMux()
-	mux.Handle("/", s.GRPCGatewayRouter)
+	interceptor, err := newGatewayInterceptor[T](s.GRPCGatewayRouter, appManager)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create grpc-gateway interceptor: %w", err)
+	}
+	mux.Handle("/", interceptor)
 
 	s.server = &http.Server{
 		Addr:    s.config.Address,

server/v2/api/grpcgateway/uri.go

@@ -0,0 +1,169 @@
+package grpcgateway
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"reflect"
+	"regexp"
+	"strings"
+
+	"github.com/cosmos/gogoproto/jsonpb"
+	gogoproto "github.com/cosmos/gogoproto/proto"
+	"github.com/mitchellh/mapstructure"
+)
+
+const maxBodySize = 1 << 20 // 1 MB
+
+// uriMatch contains information related to a URI match.
+type uriMatch struct {
+	// QueryInputName is the fully qualified name of the proto input type of the query rpc method.
+	QueryInputName string
+
+	// Params are any wildcard params found in the request.
+	//
+	// example: foo/bar/{baz} - foo/bar/qux -> {baz: qux}
+	Params map[string]string
+}
+
+// HasParams reports whether the uriMatch has any params.
+func (uri uriMatch) HasParams() bool {
+	return len(uri.Params) > 0
+}
+
+// matchURI attempts to find a match for the given URI.
+// NOTE: if no match is found, nil is returned.
+func matchURI(uri string, getPatternToQueryInputName map[string]string) *uriMatch {
+	uri = strings.TrimRight(uri, "/")
+
+	// for simple cases where there are no wildcards, we can just do a map lookup.
+	if inputName, ok := getPatternToQueryInputName[uri]; ok {
+		return &uriMatch{
+			QueryInputName: inputName,
+		}
+	}
+
+	// attempt to find a match in the pattern map.
+	for getPattern, queryInputName := range getPatternToQueryInputName {
+		getPattern = strings.TrimRight(getPattern, "/")
+
+		regexPattern, wildcardNames := patternToRegex(getPattern)
+
+		regex := regexp.MustCompile(regexPattern)
+		matches := regex.FindStringSubmatch(uri)
+
+		if matches != nil && len(matches) > 1 {
+			// first match is the full string, subsequent matches are capture groups
+			params := make(map[string]string)
+			for i, name := range wildcardNames {
+				params[name] = matches[i+1]
+			}
+
+			return &uriMatch{
+				QueryInputName: queryInputName,
+				Params:         params,
+			}
+		}
+	}
+
+	return nil
+}
+
+// patternToRegex converts a URI pattern with wildcards to a regex pattern.
+// Returns the regex pattern and a slice of wildcard names in order
+func patternToRegex(pattern string) (string, []string) {
+	escaped := regexp.QuoteMeta(pattern)
+	var wildcardNames []string
+
+	// extract and replace {param=**} patterns
+	r1 := regexp.MustCompile(`\\\{([^}]+?)=\\\*\\\*\\}`)
+	escaped = r1.ReplaceAllStringFunc(escaped, func(match string) string {
+		// extract wildcard name without the =** suffix
+		name := regexp.MustCompile(`\\\{(.+?)=`).FindStringSubmatch(match)[1]
+		wildcardNames = append(wildcardNames, name)
+		return "(.+)"
+	})
+
+	// extract and replace {param} patterns
+	r2 := regexp.MustCompile(`\\\{([^}]+)\\}`)
+	escaped = r2.ReplaceAllStringFunc(escaped, func(match string) string {
+		// extract wildcard name from the curl braces {}.
+		name := regexp.MustCompile(`\\\{(.*?)\\}`).FindStringSubmatch(match)[1]
+		wildcardNames = append(wildcardNames, name)
+		return "([^/]+)"
+	})
+
+	return "^" + escaped + "$", wildcardNames
+}
+
+// createMessageFromJSON creates a message from the uriMatch given the JSON body in the http request.
+func createMessageFromJSON(match *uriMatch, r *http.Request) (gogoproto.Message, error) {
+	requestType := gogoproto.MessageType(match.QueryInputName)
+	if requestType == nil {
+		return nil, fmt.Errorf("unknown request type")
+	}
+
+	msg, ok := reflect.New(requestType.Elem()).Interface().(gogoproto.Message)
+	if !ok {
+		return nil, fmt.Errorf("failed to create message instance")
+	}
+
+	defer r.Body.Close()
+	limitedReader := io.LimitReader(r.Body, maxBodySize)
+	err := jsonpb.Unmarshal(limitedReader, msg)
+	if err != nil {
+		return nil, fmt.Errorf("error parsing body: %w", err)
+	}
+
+	return msg, nil
+
+}
+
+// createMessage creates a message from the given uriMatch. If the match has params, the message will be populated
+// with the value of those params. Otherwise, an empty message is returned.
+func createMessage(match *uriMatch) (gogoproto.Message, error) {
+	requestType := gogoproto.MessageType(match.QueryInputName)
+	if requestType == nil {
+		return nil, fmt.Errorf("unknown request type")
+	}
+
+	msg, ok := reflect.New(requestType.Elem()).Interface().(gogoproto.Message)
+	if !ok {
+		return nil, fmt.Errorf("failed to create message instance")
+	}
+
+	// if the uri match has params, we need to populate the message with the values of those params.
+	if match.HasParams() {
+		// create a map with the proper field names from protobuf tags
+		fieldMap := make(map[string]string)
+		v := reflect.ValueOf(msg).Elem()
+		t := v.Type()
+
+		for key, value := range match.Params {
+			// attempt to match wildcard name to protobuf struct tag.
+			for i := 0; i < t.NumField(); i++ {
+				field := t.Field(i)
+				tag := field.Tag.Get("protobuf")
+				if nameMatch := regexp.MustCompile(`name=(\w+)`).FindStringSubmatch(tag); len(nameMatch) > 1 {
+					if nameMatch[1] == key {
+						fieldMap[field.Name] = value
+						break
+					}
+				}
+			}
+		}
+
+		decoder, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{
+			Result:           msg,
+			WeaklyTypedInput: true, // TODO(technicallyty): should we put false here?
+		})
+		if err != nil {
+			return nil, fmt.Errorf("failed to create decoder: %w", err)
+		}
+
+		if err := decoder.Decode(fieldMap); err != nil {
+			return nil, fmt.Errorf("failed to decode params: %w", err)
+		}
+	}
+	return msg, nil
+}