Add ADR 031 BaseApp and codec infrastructure

baseapp/baseapp.go

@@ -45,15 +45,16 @@ type (
 // BaseApp reflects the ABCI application implementation.
 type BaseApp struct { // nolint: maligned
 	// initialized on creation
-	logger          log.Logger
-	name            string               // application name from abci.Info
-	db              dbm.DB               // common DB backend
-	cms             sdk.CommitMultiStore // Main (uncached) state
-	storeLoader     StoreLoader          // function to handle store loading, may be overridden with SetStoreLoader()
-	router          sdk.Router           // handle any kind of message
-	queryRouter     sdk.QueryRouter      // router for redirecting query calls
-	grpcQueryRouter *GRPCQueryRouter     // router for redirecting gRPC query calls
-	txDecoder       sdk.TxDecoder        // unmarshal []byte into sdk.Tx
+	logger           log.Logger
+	name             string               // application name from abci.Info
+	db               dbm.DB               // common DB backend
+	cms              sdk.CommitMultiStore // Main (uncached) state
+	storeLoader      StoreLoader          // function to handle store loading, may be overridden with SetStoreLoader()
+	router           sdk.Router           // handle any kind of message
+	queryRouter      sdk.QueryRouter      // router for redirecting query calls
+	grpcQueryRouter  *GRPCQueryRouter     // router for redirecting gRPC query calls
+	msgServiceRouter *MsgServiceRouter    // router for redirecting Msg service messages
+	txDecoder        sdk.TxDecoder        // unmarshal []byte into sdk.Tx
 
 	anteHandler    sdk.AnteHandler  // ante handler for fee and auth
 	initChainer    sdk.InitChainer  // initialize state with validators and state blob
@@ -136,16 +137,17 @@ func NewBaseApp(
 	name string, logger log.Logger, db dbm.DB, txDecoder sdk.TxDecoder, options ...func(*BaseApp),
 ) *BaseApp {
 	app := &BaseApp{
-		logger:          logger,
-		name:            name,
-		db:              db,
-		cms:             store.NewCommitMultiStore(db),
-		storeLoader:     DefaultStoreLoader,
-		router:          NewRouter(),
-		queryRouter:     NewQueryRouter(),
-		grpcQueryRouter: NewGRPCQueryRouter(),
-		txDecoder:       txDecoder,
-		fauxMerkleMode:  false,
+		logger:           logger,
+		name:             name,
+		db:               db,
+		cms:              store.NewCommitMultiStore(db),
+		storeLoader:      DefaultStoreLoader,
+		router:           NewRouter(),
+		queryRouter:      NewQueryRouter(),
+		grpcQueryRouter:  NewGRPCQueryRouter(),
+		msgServiceRouter: NewMsgServiceRouter(),
+		txDecoder:        txDecoder,
+		fauxMerkleMode:   false,
 	}
 
 	for _, option := range options {
@@ -683,7 +685,12 @@ func (app *BaseApp) runMsgs(ctx sdk.Context, msgs []sdk.Msg, mode runTxMode) (*s
 		}
 
 		msgRoute := msg.Route()
-		handler := app.router.Route(ctx, msgRoute)
+		// First, check if the MsgService router handles the route.
+		handler := app.MsgServiceRouter().Route(msgRoute)
+		// If not, then check if the legacy router handles the route.
+		if handler == nil {
+			handler = app.router.Route(ctx, msgRoute)
+		}
 
 		if handler == nil {
 			return nil, sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "unrecognized message route: %s; message index: %d", msgRoute, i)

baseapp/baseapp_test.go

@@ -1692,9 +1692,9 @@ func TestQuery(t *testing.T) {
 
 func TestGRPCQuery(t *testing.T) {
 	grpcQueryOpt := func(bapp *BaseApp) {
-		testdata.RegisterTestServiceServer(
+		testdata.RegisterQueryServer(
 			bapp.GRPCQueryRouter(),
-			testdata.TestServiceImpl{},
+			testdata.QueryImpl{},
 		)
 	}
 
@@ -1711,7 +1711,7 @@ func TestGRPCQuery(t *testing.T) {
 
 	reqQuery := abci.RequestQuery{
 		Data: reqBz,
-		Path: "/testdata.TestService/SayHello",
+		Path: "/testdata.Query/SayHello",
 	}
 
 	resQuery := app.Query(reqQuery)

baseapp/grpcrouter_helpers.go

@@ -4,12 +4,11 @@ import (
 	gocontext "context"
 	"fmt"
 
-	"github.com/cosmos/cosmos-sdk/codec/types"
-
 	gogogrpc "github.com/gogo/protobuf/grpc"
 	abci "github.com/tendermint/tendermint/abci/types"
 	"google.golang.org/grpc"
 
+	"github.com/cosmos/cosmos-sdk/codec/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
@@ -22,6 +21,9 @@ type QueryServiceTestHelper struct {
 	ctx sdk.Context
 }
 
+var _ gogogrpc.Server = &QueryServiceTestHelper{}
+var _ gogogrpc.ClientConn = &QueryServiceTestHelper{}
+
 // NewQueryServerTestHelper creates a new QueryServiceTestHelper that wraps
 // the provided sdk.Context
 func NewQueryServerTestHelper(ctx sdk.Context, interfaceRegistry types.InterfaceRegistry) *QueryServiceTestHelper {
@@ -62,6 +64,3 @@ func (q *QueryServiceTestHelper) Invoke(_ gocontext.Context, method string, args
 func (q *QueryServiceTestHelper) NewStream(gocontext.Context, *grpc.StreamDesc, string, ...grpc.CallOption) (grpc.ClientStream, error) {
 	return nil, fmt.Errorf("not supported")
 }
-
-var _ gogogrpc.Server = &QueryServiceTestHelper{}
-var _ gogogrpc.ClientConn = &QueryServiceTestHelper{}

baseapp/grpcrouter_test.go

@@ -15,12 +15,12 @@ func TestGRPCRouter(t *testing.T) {
 	qr := NewGRPCQueryRouter()
 	interfaceRegistry := testdata.NewTestInterfaceRegistry()
 	qr.SetInterfaceRegistry(interfaceRegistry)
-	testdata.RegisterTestServiceServer(qr, testdata.TestServiceImpl{})
+	testdata.RegisterQueryServer(qr, testdata.QueryImpl{})
 	helper := &QueryServiceTestHelper{
 		GRPCQueryRouter: qr,
 		ctx:             sdk.Context{}.WithContext(context.Background()),
 	}
-	client := testdata.NewTestServiceClient(helper)
+	client := testdata.NewQueryClient(helper)
 
 	res, err := client.Echo(context.Background(), &testdata.EchoRequest{Message: "hello"})
 	require.Nil(t, err)

baseapp/msg_server.go

@@ -0,0 +1,4 @@
+package baseapp
+
+// MsgServiceRouter returns the MsgServiceRouter of a BaseApp.
+func (app *BaseApp) MsgServiceRouter() *MsgServiceRouter { return app.msgServiceRouter }

baseapp/msg_service_router.go

@@ -0,0 +1,83 @@
+package baseapp
+
+import (
+	"fmt"
+
+	gogogrpc "github.com/gogo/protobuf/grpc"
+	"google.golang.org/grpc"
+
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// MsgServiceRouter routes Msg Service fully-qualified service methods to their
+// handler.
+type MsgServiceRouter struct {
+	interfaceRegistry codectypes.InterfaceRegistry
+	routes            map[string]sdk.Handler
+}
+
+var _ gogogrpc.Server = &MsgServiceRouter{}
+
+// NewMsgServiceRouter creates a new MsgServiceRouter.
+func NewMsgServiceRouter() *MsgServiceRouter {
+	return &MsgServiceRouter{
+		routes: map[string]sdk.Handler{},
+	}
+}
+
+// sdk.Handler defines a function type which handles Msg service message.
+// It's similar to sdk.Handler, but with simplified version of `Msg`, without
+// `Route()`, `Type()` and `GetSignBytes()`.
+type MsgServiceHandler = func(ctx sdk.Context, msgRequest sdk.MsgRequest) (*sdk.Result, error)
+
+// Route returns the sdk.Handler for a given query route path or nil
+// if not found.
+func (msr *MsgServiceRouter) Route(path string) sdk.Handler {
+	handler, found := msr.routes[path]
+	if !found {
+		return nil
+	}
+
+	return handler
+}
+
+// RegisterService implements the gRPC Server.RegisterService method. sd is a gRPC
+// service description, handler is an object which implements that gRPC service.
+func (msr *MsgServiceRouter) RegisterService(sd *grpc.ServiceDesc, handler interface{}) {
+	// adds a top-level query handler based on the gRPC service name
+	for _, method := range sd.Methods {
+		fqMethod := fmt.Sprintf("/%s/%s", sd.ServiceName, method.MethodName)
+		methodHandler := method.Handler
+
+		msr.routes[fqMethod] = func(ctx sdk.Context, _ sdk.Msg) (*sdk.Result, error) {
+			// call the method handler from the service description with the handler object,
+			// a wrapped sdk.Context with proto-unmarshaled data from the ABCI request data
+			res, err := methodHandler(handler, sdk.WrapSDKContext(ctx), func(i interface{}) error {
+				if msr.interfaceRegistry != nil {
+					return codectypes.UnpackInterfaces(i, msr.interfaceRegistry)
+				}
+				return nil
+			}, nil)
+			if err != nil {
+				return nil, err
+			}
+
+			// proto marshal the result bytes
+			resBytes, err := protoCodec.Marshal(res)
+			if err != nil {
+				return nil, err
+			}
+
+			// return the result bytes as the response value
+			return &sdk.Result{
+				Data: resBytes,
+			}, nil
+		}
+	}
+}
+
+// SetInterfaceRegistry sets the interface registry for the router.
+func (msr *MsgServiceRouter) SetInterfaceRegistry(interfaceRegistry codectypes.InterfaceRegistry) {
+	msr.interfaceRegistry = interfaceRegistry
+}

client/context_test.go

@@ -108,7 +108,7 @@ func TestCLIQueryConn(t *testing.T) {
 	n := network.New(t, cfg)
 	defer n.Cleanup()
 
-	testClient := testdata.NewTestServiceClient(n.Validators[0].ClientCtx)
+	testClient := testdata.NewQueryClient(n.Validators[0].ClientCtx)
 	res, err := testClient.Echo(context.Background(), &testdata.EchoRequest{Message: "hello"})
 	require.NoError(t, err)
 	require.Equal(t, "hello", res.Message)

client/grpc_query_test.go

@@ -43,7 +43,7 @@ func (s *IntegrationTestSuite) TestGRPCQuery() {
 	val0 := s.network.Validators[0]
 
 	// gRPC query to test service should work
-	testClient := testdata.NewTestServiceClient(val0.ClientCtx)
+	testClient := testdata.NewQueryClient(val0.ClientCtx)
 	testRes, err := testClient.Echo(context.Background(), &testdata.EchoRequest{Message: "hello"})
 	s.Require().NoError(err)
 	s.Require().Equal("hello", testRes.Message)

scripts/protocgen.sh

@@ -22,7 +22,7 @@ done
 
 # generate codec/testdata proto code
 protoc -I "proto" -I "third_party/proto" -I "testutil/testdata" --gocosmos_out=plugins=interfacetype+grpc,\
-Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types:. ./testutil/testdata/proto.proto
+Mgoogle/protobuf/any.proto=github.com/cosmos/cosmos-sdk/codec/types:. ./testutil/testdata/*.proto
 
 # move proto files to the right places
 cp -r github.com/cosmos/cosmos-sdk/* ./

server/grpc/server_test.go

@@ -50,7 +50,7 @@ func (s *IntegrationTestSuite) TestGRPCServer() {
 	s.Require().NoError(err)
 
 	// gRPC query to test service should work
-	testClient := testdata.NewTestServiceClient(conn)
+	testClient := testdata.NewQueryClient(conn)
 	testRes, err := testClient.Echo(context.Background(), &testdata.EchoRequest{Message: "hello"})
 	s.Require().NoError(err)
 	s.Require().Equal("hello", testRes.Message)

simapp/app.go

@@ -362,7 +362,7 @@ func NewSimApp(
 	app.mm.RegisterServices(module.NewConfigurator(app.GRPCQueryRouter()))
 
 	// add test gRPC service for testing gRPC queries in isolation
-	testdata.RegisterTestServiceServer(app.GRPCQueryRouter(), testdata.TestServiceImpl{})
+	testdata.RegisterQueryServer(app.GRPCQueryRouter(), testdata.QueryImpl{})
 
 	// create the simulation manager and define the order of the modules for deterministic simulations
 	//

simapp/msg_service_test.go

@@ -0,0 +1,38 @@
+package simapp_test
+
+import (
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/tendermint/tendermint/libs/log"
+	dbm "github.com/tendermint/tm-db"
+
+	"github.com/cosmos/cosmos-sdk/baseapp"
+	"github.com/cosmos/cosmos-sdk/client/tx"
+	"github.com/cosmos/cosmos-sdk/simapp"
+	"github.com/cosmos/cosmos-sdk/testutil/testdata"
+)
+
+func TestMsgService(t *testing.T) {
+	db := dbm.NewMemDB()
+	encCfg := simapp.MakeEncodingConfig()
+	msgServiceOpt := func(bapp *baseapp.BaseApp) {
+		testdata.RegisterMsgServer(
+			bapp.MsgServiceRouter(),
+			testdata.MsgImpl{},
+		)
+	}
+	app := simapp.NewSimApp(log.NewTMLogger(log.NewSyncWriter(os.Stdout)), db, nil, true, map[int64]bool{}, simapp.DefaultNodeHome, 0, encCfg, msgServiceOpt)
+
+	msg, err := testdata.NewServiceMsgCreateDog(&testdata.MsgCreateDog{Dog: &testdata.Dog{Name: "Spot"}})
+	require.NoError(t, err)
+
+	txf := tx.Factory{}.
+		WithTxConfig(encCfg.TxConfig).
+		WithAccountNumber(50).
+		WithSequence(23).
+		WithFees("50stake").
+		WithMemo("memo").
+		WithChainID("test-chain")
+}

testutil/testdata/test_service.go → testutil/testdata/grpc_query.go

@@ -9,9 +9,11 @@ import (
 	"github.com/cosmos/cosmos-sdk/codec/types"
 )
 
-type TestServiceImpl struct{}
+type QueryImpl struct{}
 
-func (e TestServiceImpl) TestAny(_ context.Context, request *TestAnyRequest) (*TestAnyResponse, error) {
+var _ QueryServer = QueryImpl{}
+
+func (e QueryImpl) TestAny(_ context.Context, request *TestAnyRequest) (*TestAnyResponse, error) {
 	animal, ok := request.AnyAnimal.GetCachedValue().(Animal)
 	if !ok {
 		return nil, fmt.Errorf("expected Animal")
@@ -28,17 +30,15 @@ func (e TestServiceImpl) TestAny(_ context.Context, request *TestAnyRequest) (*T
 	}}, nil
 }
 
-func (e TestServiceImpl) Echo(_ context.Context, req *EchoRequest) (*EchoResponse, error) {
+func (e QueryImpl) Echo(_ context.Context, req *EchoRequest) (*EchoResponse, error) {
 	return &EchoResponse{Message: req.Message}, nil
 }
 
-func (e TestServiceImpl) SayHello(_ context.Context, request *SayHelloRequest) (*SayHelloResponse, error) {
+func (e QueryImpl) SayHello(_ context.Context, request *SayHelloRequest) (*SayHelloResponse, error) {
 	greeting := fmt.Sprintf("Hello %s!", request.Name)
 	return &SayHelloResponse{Greeting: greeting}, nil
 }
 
-var _ TestServiceServer = TestServiceImpl{}
-
 var _ types.UnpackInterfacesMessage = &TestAnyRequest{}
 
 func (m *TestAnyRequest) UnpackInterfaces(unpacker types.AnyUnpacker) error {

testutil/testdata/msg_server.go

@@ -0,0 +1,16 @@
+package testdata
+
+import (
+	"context"
+)
+
+type MsgImpl struct{}
+
+var _ MsgServer = MsgImpl{}
+
+// CreateDog implements the MsgServer interface.
+func (m MsgImpl) CreateDog(_ context.Context, msg *MsgCreateDog) (*MsgCreateDogResponse, error) {
+	return &MsgCreateDogResponse{
+		Name: msg.Dog.Name,
+	}, nil
+}