feat(x/accounts): use router service from env (#20003)

simapp/app.go

@@ -287,10 +287,8 @@ func NewSimApp(
  // add keepers
  accountsKeeper, err := accounts.NewKeeper(
  appCodec,
- runtime.NewEnvironment(runtime.NewKVStoreService(keys[accounts.StoreKey]), logger),
+ runtime.NewEnvironment(runtime.NewKVStoreService(keys[accounts.StoreKey]), logger, runtime.EnvWithRouterService(app.GRPCQueryRouter(), app.MsgServiceRouter())),
  signingCtx.AddressCodec(),
- app.MsgServiceRouter(),
- app.GRPCQueryRouter(),
  appCodec.InterfaceRegistry(),
  // TESTING: do not add
  accountstd.AddAccount("counter", counter.NewAccount),

tests/integration/auth/keeper/msg_server_test.go

@@ -2,6 +2,7 @@ package keeper_test
 
 import (
  "context"
+ "fmt"
  "strings"
  "testing"
 
@@ -84,10 +85,8 @@ func initFixture(t *testing.T) *fixture {
  account := baseaccount.NewAccount("base", signing.NewHandlerMap(handler))
  accountsKeeper, err := accounts.NewKeeper(
  cdc,
- runtime.NewEnvironment(runtime.NewKVStoreService(keys[accounts.StoreKey]), log.NewNopLogger()),
+ runtime.NewEnvironment(runtime.NewKVStoreService(keys[accounts.StoreKey]), log.NewNopLogger(), runtime.EnvWithRouterService(queryRouter, router)),
  addresscodec.NewBech32Codec("cosmos"),
- router,
- queryRouter,
  cdc.InterfaceRegistry(),
  account,
  )
@@ -158,7 +157,7 @@ func TestAsyncExec(t *testing.T) {
  addrs := simtestutil.CreateIncrementalAccounts(2)
  coins := sdk.NewCoins(sdk.NewCoin("stake", sdkmath.NewInt(10)))
 
- assert.NilError(t, testutil.FundAccount(f.ctx, f.bankKeeper, addrs[0], sdk.NewCoins(sdk.NewInt64Coin("stake", 50))))
+ assert.NilError(t, testutil.FundAccount(f.ctx, f.bankKeeper, addrs[0], sdk.NewCoins(sdk.NewInt64Coin("stake", 500))))
 
  msg := &banktypes.MsgSend{
  FromAddress: addrs[0].String(),
@@ -276,7 +275,7 @@ func TestAsyncExec(t *testing.T) {
  if tc.expErrMsg != "" {
  for _, res := range result.Results {
  if res.Error != "" {
- assert.Assert(t, strings.Contains(res.Error, tc.expErrMsg))
+ assert.Assert(t, strings.Contains(res.Error, tc.expErrMsg), fmt.Sprintf("res.Error %s does not contain %s", res.Error, tc.expErrMsg))
  }
  continue
  }

x/accounts/depinject.go

@@ -34,9 +34,10 @@ type ModuleInputs struct {
  Cdc codec.Codec
  Environment appmodule.Environment
  AddressCodec address.Codec
- ExecRouter MsgRouter
- QueryRouter QueryRouter
  Registry cdctypes.InterfaceRegistry
+
+ // TODO: Add a way to inject custom accounts.
+ // Currently only the base account is supported.
 }
 
 type ModuleOutputs struct {
@@ -61,10 +62,7 @@ func (s directHandler) GetSignBytes(_ context.Context, _ signing.SignerData, _ s
 func ProvideModule(in ModuleInputs) ModuleOutputs {
  handler := directHandler{}
  account := baseaccount.NewAccount("base", signing.NewHandlerMap(handler))
- accountskeeper, err := NewKeeper(
- in.Cdc, in.Environment, in.AddressCodec,
- in.ExecRouter, in.QueryRouter, in.Registry, account,
- )
+ accountskeeper, err := NewKeeper(in.Cdc, in.Environment, in.AddressCodec, in.Registry, account)
  if err != nil {
  panic(err)
  }

x/accounts/genesis_test.go

@@ -1,7 +1,6 @@
 package accounts
 
 import (
- "context"
  "testing"
 
  "github.com/cosmos/gogoproto/types"
@@ -16,7 +15,6 @@ func TestGenesis(t *testing.T) {
  acc, err := NewTestAccount(deps)
  return "test", acc, err
  })
- k.queryRouter = mockQuery(func(ctx context.Context, req, resp implementation.ProtoMsg) error { return nil })
  // we init two accounts of the same type
 
  // we set counter to 10

x/accounts/keeper.go

@@ -35,19 +35,6 @@ var (
  AccountByNumber = collections.NewPrefix(2)
 )
 
-// QueryRouter represents a router which can be used to route queries to the correct module.
-// It returns the handler given the message name, if multiple handlers are returned, then
-// it is up to the caller to choose which one to call.
-type QueryRouter interface {
- HybridHandlerByRequestName(name string) []func(ctx context.Context, req, resp implementation.ProtoMsg) error
-}
-
-// MsgRouter represents a router which can be used to route messages to the correct module.
-type MsgRouter interface {
- HybridHandlerByMsgName(msgName string) func(ctx context.Context, req, resp implementation.ProtoMsg) error
- ResponseNameByMsgName(name string) string
-}
-
 type InterfaceRegistry interface {
  RegisterInterface(name string, iface any, impls ...protoiface.MessageV1)
  RegisterImplementations(iface any, impls ...protoiface.MessageV1)
@@ -57,18 +44,14 @@ func NewKeeper(
  cdc codec.Codec,
  env appmodule.Environment,
  addressCodec address.Codec,
- execRouter MsgRouter,
- queryRouter QueryRouter,
  ir InterfaceRegistry,
  accounts ...accountstd.AccountCreatorFunc,
 ) (Keeper, error) {
  sb := collections.NewSchemaBuilder(env.KVStoreService)
  keeper := Keeper{
  environment: env,
- addressCodec: addressCodec,
- msgRouter: execRouter,
  codec: cdc,
- queryRouter:  queryRouter,
+ addressCodec: addressCodec,
  makeSendCoinsMsg: defaultCoinsTransferMsgFunc(addressCodec),
  Schema: collections.Schema{},
  AccountNumber: collections.NewSequence(sb, AccountNumberKey, "account_number"),
@@ -95,8 +78,6 @@ type Keeper struct {
  environment appmodule.Environment
  addressCodec address.Codec
  codec codec.Codec
- msgRouter MsgRouter // todo use env
- queryRouter QueryRouter // todo use env
  makeSendCoinsMsg coinsTransferMsgFunc
 
  accounts map[string]implementation.Implementation
@@ -343,17 +324,11 @@ func (k Keeper) sendAnyMessages(ctx context.Context, sender []byte, anyMessages
 // SendModuleMessageUntyped can be used to send a message towards a module.
 // It should be used when the response type is not known by the caller.
 func (k Keeper) SendModuleMessageUntyped(ctx context.Context, sender []byte, msg implementation.ProtoMsg) (implementation.ProtoMsg, error) {
- // we need to fetch the response type from the request message type.
- // this is because the response type is not known.
- respName := k.msgRouter.ResponseNameByMsgName(implementation.MessageName(msg))
- if respName == "" {
- return nil, fmt.Errorf("could not find response type for message %T", msg)
- }
- // get response type
- resp, err := implementation.FindMessageByName(respName)
+ resp, err := k.environment.RouterService.MessageRouterService().InvokeUntyped(ctx, msg)
  if err != nil {
  return nil, err
  }
+
  // send the message
  return resp, k.sendModuleMessage(ctx, sender, msg, resp)
 }
@@ -373,27 +348,14 @@ func (k Keeper) sendModuleMessage(ctx context.Context, sender []byte, msg, msgRe
  if !bytes.Equal(sender, wantSenders[0]) {
  return fmt.Errorf("%w: sender does not match expected sender", ErrUnauthorized)
  }
- messageName := implementation.MessageName(msg)
- handler := k.msgRouter.HybridHandlerByMsgName(messageName)
- if handler == nil {
- return fmt.Errorf("unknown message: %s", messageName)
- }
- return handler(ctx, msg, msgResp)
+ return k.environment.RouterService.MessageRouterService().InvokeTyped(ctx, msg, msgResp)
 }
 
 // queryModule is the entrypoint for an account to query a module.
 // It will try to find the query handler for the given query and execute it.
 // If multiple query handlers are found, it will return an error.
 func (k Keeper) queryModule(ctx context.Context, queryReq, queryResp implementation.ProtoMsg) error {
- queryName := implementation.MessageName(queryReq)
- handlers := k.queryRouter.HybridHandlerByRequestName(queryName)
- if len(handlers) == 0 {
- return fmt.Errorf("unknown query: %s", queryName)
- }
- if len(handlers) > 1 {
- return fmt.Errorf("multiple handlers for query: %s", queryName)
- }
- return handlers[0](ctx, queryReq, queryResp)
+ return k.environment.RouterService.QueryRouterService().InvokeTyped(ctx, queryReq, queryResp)
 }
 
 // maybeSendFunds will send the provided coins between the provided addresses, if amt

x/accounts/keeper_test.go

@@ -1,29 +1,18 @@
 package accounts
 
 import (
- "context"
  "testing"
 
  "github.com/cosmos/gogoproto/types"
  "github.com/stretchr/testify/require"
- "google.golang.org/protobuf/proto"
 
- bankv1beta1 "cosmossdk.io/api/cosmos/bank/v1beta1"
- basev1beta1 "cosmossdk.io/api/cosmos/base/v1beta1"
  "cosmossdk.io/collections"
  "cosmossdk.io/x/accounts/accountstd"
  "cosmossdk.io/x/accounts/internal/implementation"
 )
 
 func TestKeeper_Init(t *testing.T) {
  m, ctx := newKeeper(t, accountstd.AddAccount("test", NewTestAccount))
- m.queryRouter = mockQuery(func(ctx context.Context, req, resp implementation.ProtoMsg) error {
- _, ok := req.(*bankv1beta1.QueryBalanceRequest)
- require.True(t, ok)
- _, ok = resp.(*bankv1beta1.QueryBalanceResponse)
- require.True(t, ok)
- return nil
- })
 
  t.Run("ok", func(t *testing.T) {
  sender := []byte("sender")
@@ -52,7 +41,6 @@ func TestKeeper_Init(t *testing.T) {
 
 func TestKeeper_Execute(t *testing.T) {
  m, ctx := newKeeper(t, accountstd.AddAccount("test", NewTestAccount))
- m.queryRouter = mockQuery(func(ctx context.Context, req, resp implementation.ProtoMsg) error { return nil })
 
  // create account
  sender := []byte("sender")
@@ -71,35 +59,14 @@ func TestKeeper_Execute(t *testing.T) {
  })
 
  t.Run("exec module", func(t *testing.T) {
- m.msgRouter = mockExec(func(ctx context.Context, msg, msgResp implementation.ProtoMsg) error {
- concrete, ok := msg.(*bankv1beta1.MsgSend)
- require.True(t, ok)
- require.Equal(t, concrete.ToAddress, "recipient")
- _, ok = msgResp.(*bankv1beta1.MsgSendResponse)
- require.True(t, ok)
- return nil
- })
-
- m.msgRouter = mockExec(func(ctx context.Context, msg, msgResp implementation.ProtoMsg) error {
- concrete, ok := msg.(*bankv1beta1.MsgSend)
- require.True(t, ok)
- require.Equal(t, concrete.FromAddress, string(accAddr))
- _, ok = msgResp.(*bankv1beta1.MsgSendResponse)
- require.True(t, ok)
-
- resp, err := m.Execute(ctx, accAddr, sender, &types.Int64Value{Value: 1000}, nil)
- require.NoError(t, err)
- require.True(t, implementation.Equal(&types.Empty{}, resp))
- return nil
- })
+ resp, err := m.Execute(ctx, accAddr, sender, &types.Int64Value{Value: 1000}, nil)
+ require.NoError(t, err)
+ require.True(t, implementation.Equal(&types.Empty{}, resp))
  })
 }
 
 func TestKeeper_Query(t *testing.T) {
  m, ctx := newKeeper(t, accountstd.AddAccount("test", NewTestAccount))
- m.queryRouter = mockQuery(func(ctx context.Context, req, resp implementation.ProtoMsg) error {
- return nil
- })
 
  // create account
  sender := []byte("sender")
@@ -118,21 +85,6 @@ func TestKeeper_Query(t *testing.T) {
  })
 
  t.Run("query module", func(t *testing.T) {
- // we inject the module query function, which accepts only a specific type of message
- // we force the response
- m.queryRouter = mockQuery(func(ctx context.Context, req, resp implementation.ProtoMsg) error {
- concrete, ok := req.(*bankv1beta1.QueryBalanceRequest)
- require.True(t, ok)
- require.Equal(t, string(accAddr), concrete.Address)
- require.Equal(t, concrete.Denom, "atom")
- copyResp := &bankv1beta1.QueryBalanceResponse{Balance: &basev1beta1.Coin{
- Denom: "atom",
- Amount: "1000",
- }}
- proto.Merge(resp.(proto.Message), copyResp)
- return nil
- })
-
  resp, err := m.Query(ctx, accAddr, &types.StringValue{Value: "atom"})
  require.NoError(t, err)
  require.True(t, implementation.Equal(&types.Int64Value{Value: 1000}, resp))

x/accounts/msg_server_test.go

@@ -1,29 +1,19 @@
 package accounts
 
 import (
- "context"
  "testing"
 
  "github.com/stretchr/testify/require"
- "google.golang.org/protobuf/proto"
  "google.golang.org/protobuf/types/known/emptypb"
  "google.golang.org/protobuf/types/known/wrapperspb"
 
- bankv1beta1 "cosmossdk.io/api/cosmos/bank/v1beta1"
  "cosmossdk.io/x/accounts/accountstd"
  "cosmossdk.io/x/accounts/internal/implementation"
  v1 "cosmossdk.io/x/accounts/v1"
 )
 
 func TestMsgServer(t *testing.T) {
  k, ctx := newKeeper(t, accountstd.AddAccount("test", NewTestAccount))
- k.queryRouter = mockQuery(func(ctx context.Context, req, resp implementation.ProtoMsg) error {
- _, ok := req.(*bankv1beta1.QueryBalanceRequest)
- require.True(t, ok)
- proto.Merge(resp.(proto.Message), &bankv1beta1.QueryBalanceResponse{})
- return nil
- })
-
  s := NewMsgServer(k)
 
  // create

x/accounts/query_server_test.go

@@ -1,7 +1,6 @@
 package accounts
 
 import (
- "context"
  "testing"
 
  "github.com/cosmos/gogoproto/types"
@@ -16,9 +15,6 @@ import (
 
 func TestQueryServer(t *testing.T) {
  k, ctx := newKeeper(t, accountstd.AddAccount("test", NewTestAccount))
- k.queryRouter = mockQuery(func(ctx context.Context, req, resp implementation.ProtoMsg) error {
- return nil
- })
 
  ms := NewMsgServer(k)
  qs := NewQueryServer(k)