updates

core/appmodule/v2/handlers.go

@@ -21,7 +21,7 @@ type (
 type PreMsgRouter interface {
 	// RegisterPreHandler will register a specific message handler hooking into the message with
 	// the provided name.
-	RegisterPreMsgHandler(handler PreMsgHandler) error
+	RegisterPreMsgHandler(msgName string, handler PreMsgHandler) error
 	// RegisterGlobalPreHandler will register a global message handler hooking into any message
 	// being executed.
 	RegisterGlobalPreMsgHandler(handler PreMsgHandler) error
@@ -42,12 +42,13 @@ type HasPreMsgHandlers interface {
 //
 //	func (m Module) RegisterPreMsgHandlers(router appmodule.PreMsgRouter) {
 //		handlers := keeper.NewHandlers(m.keeper)
-//	    appmodule.RegisterMsgPreHandler(router, handlers.BeforeSend)
+//	    appmodule.RegisterMsgPreHandler(router, gogoproto.MessageName(types.MsgSend{}), handlers.BeforeSend)
 //	}
 //
 // ```
 func RegisterMsgPreHandler[Req transaction.Msg](
 	router PreMsgRouter,
+	msgName string,
 	handler func(ctx context.Context, msg Req) error,
 ) {
 	untypedHandler := func(ctx context.Context, m transaction.Msg) error {
@@ -57,14 +58,14 @@ func RegisterMsgPreHandler[Req transaction.Msg](
 		}
 		return handler(ctx, typed)
 	}
-	router.RegisterPreMsgHandler(untypedHandler)
+	router.RegisterPreMsgHandler(msgName, untypedHandler)
 }
 
 // PostMsgRouter is a router that allows you to register PostMsgHandlers for specific message types.
 type PostMsgRouter interface {
 	// RegisterPostHandler will register a specific message handler hooking after the execution of message with
 	// the provided name.
-	RegisterPostMsgHandler(handler PostMsgHandler) error
+	RegisterPostMsgHandler(msgName string, handler PostMsgHandler) error
 	// RegisterGlobalPostHandler will register a global message handler hooking after the execution of any message.
 	RegisterGlobalPostMsgHandler(handler PostMsgHandler) error
 }
@@ -84,12 +85,13 @@ type HasPostMsgHandlers interface {
 //
 //	func (m Module) RegisterPostMsgHandlers(router appmodule.PostMsgRouter) {
 //		handlers := keeper.NewHandlers(m.keeper)
-//	    appmodule.RegisterPostMsgHandler(router, handlers.AfterSend)
+//	    appmodule.RegisterPostMsgHandler(router, gogoproto.MessageName(types.MsgSend{}), handlers.AfterSend)
 //	}
 //
 // ```
 func RegisterPostMsgHandler[Req, Resp transaction.Msg](
 	router PostMsgRouter,
+	msgName string,
 	handler func(ctx context.Context, msg Req, msgResp Resp) error,
 ) {
 	untypedHandler := func(ctx context.Context, m, mResp transaction.Msg) error {
@@ -103,12 +105,12 @@ func RegisterPostMsgHandler[Req, Resp transaction.Msg](
 		}
 		return handler(ctx, typed, typedResp)
 	}
-	router.RegisterPostMsgHandler(untypedHandler)
+	router.RegisterPostMsgHandler(msgName, untypedHandler)
 }
 
 // MsgRouter is a router that allows you to register Handlers for specific message types.
 type MsgRouter interface {
-	RegisterHandler(handler Handler) error
+	RegisterHandler(msgName string, handler Handler) error
 }
 
 // HasMsgHandlers is an interface that modules must implement if they want to register Handlers.
@@ -138,17 +140,18 @@ type HasQueryHandlers interface {
 //
 //	func (m Module) RegisterMsgHandlers(router appmodule.MsgRouter) {
 //		handlers := keeper.NewHandlers(m.keeper)
-//	    appmodule.RegisterHandler(router, handlers.MsgMint)
+//	    appmodule.RegisterHandler(router, gogoproto.MessageName(types.MsgMint{}), handlers.MsgMint)
 //	}
 //
 //	func (m Module) RegisterQueryHandlers(router appmodule.QueryRouter) {
 //		handlers := keeper.NewHandlers(m.keeper)
-//	    appmodule.RegisterHandler(router, handlers.QueryBalance)
+//	    appmodule.RegisterHandler(router, gogoproto.MessageName(types.QueryBalanceRequest{}), handlers.QueryBalance)
 //	}
 //
 // ```
 func RegisterHandler[R MsgRouter, Req, Resp transaction.Msg](
 	router R,
+	msgName string,
 	handler func(ctx context.Context, msg Req) (msgResp Resp, err error),
 ) {
 	untypedHandler := func(ctx context.Context, m transaction.Msg) (transaction.Msg, error) {
@@ -158,5 +161,5 @@ func RegisterHandler[R MsgRouter, Req, Resp transaction.Msg](
 		}
 		return handler(ctx, typed)
 	}
-	router.RegisterHandler(untypedHandler)
+	router.RegisterHandler(msgName, untypedHandler)
 }

runtime/v2/manager.go

@@ -711,7 +711,7 @@ func registerMethod(
 		return "", err
 	}
 
-	return string(requestName), stfRouter.RegisterHandler(func(
+	return string(requestName), stfRouter.RegisterHandler(string(requestName), func(
 		ctx context.Context,
 		msg transaction.Msg,
 	) (resp transaction.Msg, err error) {

server/v2/stf/stf_router.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"reflect"
 	"strings"
 
 	gogoproto "github.com/cosmos/gogoproto/proto"
@@ -33,12 +32,7 @@ type MsgRouterBuilder struct {
 	globalPostHandlers []appmodulev2.PostMsgHandler
 }
 
-func (b *MsgRouterBuilder) RegisterHandler(handler appmodulev2.Handler) error {
-	msgType, err := msgTypeURLFromHandler(handler)
-	if err != nil {
-		return err
-	}
-
+func (b *MsgRouterBuilder) RegisterHandler(msgType string, handler appmodulev2.Handler) error {
 	// panic on override
 	if _, ok := b.handlers[msgType]; ok {
 		return fmt.Errorf("handler already registered: %s", msgType)
@@ -52,22 +46,12 @@ func (b *MsgRouterBuilder) RegisterGlobalPreMsgHandler(handler appmodulev2.PreMs
 	return nil
 }
 
-func (b *MsgRouterBuilder) RegisterPreMsgHandler(handler appmodulev2.PreMsgHandler) error {
-	msgType, err := msgTypeURLFromHandler(handler)
-	if err != nil {
-		return err
-	}
-
+func (b *MsgRouterBuilder) RegisterPreMsgHandler(msgType string, handler appmodulev2.PreMsgHandler) error {
 	b.preHandlers[msgType] = append(b.preHandlers[msgType], handler)
 	return nil
 }
 
-func (b *MsgRouterBuilder) RegisterPostMsgHandler(handler appmodulev2.PostMsgHandler) error {
-	msgType, err := msgTypeURLFromHandler(handler)
-	if err != nil {
-		return err
-	}
-
+func (b *MsgRouterBuilder) RegisterPostMsgHandler(msgType string, handler appmodulev2.PostMsgHandler) error {
 	b.postHandlers[msgType] = append(b.postHandlers[msgType], handler)
 	return nil
 }
@@ -155,30 +139,6 @@ func buildHandler(
 	}
 }
 
-func msgTypeURLFromHandler(handler any) (string, error) {
-	handlerType := reflect.TypeOf(handler)
-	if handlerType.Kind() != reflect.Func {
-		return "", fmt.Errorf("handler must be a function")
-	}
-	if handlerType.NumIn() != 2 && handlerType.NumIn() != 3 {
-		return "", fmt.Errorf("handler must have 2-3 input parameters")
-	}
-
-	// Get the type of the second parameter (transaction.Msg)
-	msgType := handlerType.In(1)
-
-	if !msgType.Implements(reflect.TypeOf((*transaction.Msg)(nil)).Elem()) {
-		return "", fmt.Errorf("second parameter must implement transaction.Msg")
-	}
-
-	msgName := msgTypeURL(*reflect.New(msgType).Interface().(*gogoproto.Message))
-	if msgName == "" {
-		return "", fmt.Errorf("could not get message name")
-	}
-
-	return msgName, nil
-}
-
 // msgTypeURL returns the TypeURL of a proto message.
 func msgTypeURL(msg gogoproto.Message) string {
 	return gogoproto.MessageName(msg)

server/v2/stf/stf_test.go

@@ -35,6 +35,7 @@ func addMsgHandlerToSTF[T any, PT interface {
 	t.Helper()
 	msgRouterBuilder := NewMsgRouterBuilder()
 	err := msgRouterBuilder.RegisterHandler(
+		msgTypeURL(PT(new(T))),
 		func(ctx context.Context, msg transaction.Msg) (msgResp transaction.Msg, err error) {
 			typedReq := msg.(PT)
 			typedResp, err := handler(ctx, typedReq)