chore: upstream runtime/v2 (#20320)

Co-authored-by: Julien Robert <julien@rbrt.fr>

server/v2/stf/core_router_service.go

@@ -0,0 +1,128 @@
+package stf
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+
+	"google.golang.org/protobuf/runtime/protoiface"
+
+	appmodulev2 "cosmossdk.io/core/appmodule/v2"
+	"cosmossdk.io/core/router"
+)
+
+// NewRouterService creates a router.Service which allows to invoke messages and queries using the msg router.
+func NewRouterService(queryRouterBuilder, msgRouterBuilder *MsgRouterBuilder) router.Service {
+	queryRouter, err := queryRouterBuilder.Build()
+	if err != nil {
+		panic("cannot create queryRouter")
+	}
+
+	msgRouter, err := msgRouterBuilder.Build()
+	if err != nil {
+		panic("cannot create msgRouter")
+	}
+
+	return &routerService{
+		queryRouterService: &queryRouterService{
+			builder: queryRouterBuilder,
+			handler: queryRouter,
+		},
+		msgRouterService: &msgRouterService{
+			builder: msgRouterBuilder,
+			handler: msgRouter,
+		},
+	}
+}
+
+var _ router.Service = (*routerService)(nil)
+
+type routerService struct {
+	queryRouterService router.Router
+	msgRouterService   router.Router
+}
+
+// MessageRouterService implements router.Service.
+func (r *routerService) MessageRouterService() router.Router {
+	return r.msgRouterService
+}
+
+// QueryRouterService implements router.Service.
+func (r *routerService) QueryRouterService() router.Router {
+	return r.queryRouterService
+}
+
+var _ router.Router = (*msgRouterService)(nil)
+
+type msgRouterService struct {
+	builder *MsgRouterBuilder
+	handler appmodulev2.Handler
+}
+
+// CanInvoke returns an error if the given message cannot be invoked.
+func (m *msgRouterService) CanInvoke(ctx context.Context, typeURL string) error {
+	if typeURL == "" {
+		return errors.New("missing type url")
+	}
+
+	typeURL = strings.TrimPrefix(typeURL, "/")
+	if exists := m.builder.HandlerExists(typeURL); exists {
+		return fmt.Errorf("unknown request: %s", typeURL)
+	}
+
+	return nil
+}
+
+// InvokeTyped execute a message and fill-in a response.
+// The response must be known and passed as a parameter.
+// Use InvokeUntyped if the response type is not known.
+func (m *msgRouterService) InvokeTyped(ctx context.Context, msg, resp protoiface.MessageV1) error {
+	// see https://github.com/cosmos/cosmos-sdk/pull/20349
+	panic("not implemented")
+}
+
+// InvokeUntyped execute a message and returns a response.
+func (m *msgRouterService) InvokeUntyped(ctx context.Context, msg protoiface.MessageV1) (protoiface.MessageV1, error) {
+	return m.handler(ctx, msg)
+}
+
+var _ router.Router = (*queryRouterService)(nil)
+
+type queryRouterService struct {
+	builder *MsgRouterBuilder
+	handler appmodulev2.Handler
+}
+
+// CanInvoke returns an error if the given request cannot be invoked.
+func (m *queryRouterService) CanInvoke(ctx context.Context, typeURL string) error {
+	if typeURL == "" {
+		return errors.New("missing type url")
+	}
+
+	typeURL = strings.TrimPrefix(typeURL, "/")
+	if exists := m.builder.HandlerExists(typeURL); exists {
+		return fmt.Errorf("unknown request: %s", typeURL)
+	}
+
+	return nil
+}
+
+// InvokeTyped execute a message and fill-in a response.
+// The response must be known and passed as a parameter.
+// Use InvokeUntyped if the response type is not known.
+func (m *queryRouterService) InvokeTyped(
+	ctx context.Context,
+	req, resp protoiface.MessageV1,
+) error {
+	// see https://github.com/cosmos/cosmos-sdk/pull/20349
+	panic("not implemented")
+}
+
+// InvokeUntyped execute a message and returns a response.
+func (m *queryRouterService) InvokeUntyped(
+	ctx context.Context,
+	req protoiface.MessageV1,
+) (protoiface.MessageV1, error) {
+	return m.handler(ctx, req)
+}

server/v2/stf/export_test.go

@@ -11,4 +11,3 @@ func GetExecutionContext(ctx context.Context) *executionContext {
 	}
 	return executionCtx
 }
-

server/v2/stf/mock/tx.go

@@ -22,8 +22,8 @@ func (t Tx) Hash() [32]byte {
 	return sha256.Sum256(t.Bytes())
 }
 
-func (t Tx) GetMessages() []transaction.Msg {
-	return []transaction.Msg{t.Msg}
+func (t Tx) GetMessages() ([]transaction.Msg, error) {
+	return []transaction.Msg{t.Msg}, nil
 }
 
 func (t Tx) GetSenders() ([]transaction.Identity, error) {

server/v2/stf/stf.go

@@ -290,7 +290,7 @@ func (s STF[T]) runTxMsgs(
 	if err != nil {
 		return nil, 0, nil, err
 	}
-	msgs := tx.GetMessages()
+	msgs, err := tx.GetMessages()
 	if err != nil {
 		return nil, 0, nil, err
 	}

server/v2/stf/stf_router.go

@@ -55,6 +55,11 @@ func (b *MsgRouterBuilder) RegisterGlobalPostHandler(handler appmodulev2.PostMsg
 	b.globalPostHandlers = append(b.globalPostHandlers, handler)
 }
 
+func (b *MsgRouterBuilder) HandlerExists(msgType string) bool {
+	_, ok := b.handlers[msgType]
+	return ok
+}
+
 func (b *MsgRouterBuilder) Build() (appmodulev2.Handler, error) {
 	handlers := make(map[string]appmodulev2.Handler)