From ea34ede07b768753ff3e157df89b0669e1a5bd12 Mon Sep 17 00:00:00 2001 From: Julien Robert Date: Fri, 6 Sep 2024 16:40:31 +0200 Subject: [PATCH] updates --- core/appmodule/v2/handlers.go | 23 ++++++++++-------- runtime/v2/manager.go | 2 +- server/v2/stf/stf_router.go | 46 +++-------------------------------- server/v2/stf/stf_test.go | 1 + 4 files changed, 18 insertions(+), 54 deletions(-) diff --git a/core/appmodule/v2/handlers.go b/core/appmodule/v2/handlers.go index 099cfb8cf130..e1aae28554e7 100644 --- a/core/appmodule/v2/handlers.go +++ b/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) } diff --git a/runtime/v2/manager.go b/runtime/v2/manager.go index 925851e8bda1..eea180843800 100644 --- a/runtime/v2/manager.go +++ b/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) { diff --git a/server/v2/stf/stf_router.go b/server/v2/stf/stf_router.go index 7be34b944ce0..1cab21cf2dd8 100644 --- a/server/v2/stf/stf_router.go +++ b/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) diff --git a/server/v2/stf/stf_test.go b/server/v2/stf/stf_test.go index f7197d8a2adc..5fa4fce15b40 100644 --- a/server/v2/stf/stf_test.go +++ b/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)