refactor(auth): decouple auth Keeper API from Msg and Query server implementation (#15985)

testinginprod · unknown unknown · web-flow · commit 3ada275c32ee · 2023-05-01T14:30:20.000Z
Co-authored-by: unknown unknown &lt;unknown@unknown&gt;
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -116,6 +116,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
 
 ### API Breaking Changes
 
+* (x/auth) [#15985](https://github.com/cosmos/cosmos-sdk/pull/15985) The `AccountKeeper` does not expose the `QueryServer` and `MsgServer` APIs anymore.
 * (x/authz) [#15962](https://github.com/cosmos/cosmos-sdk/issues/15962) `NewKeeper` now takes a `KVStoreService` instead of a `StoreKey`, methods in the `Keeper` now take a `context.Context` instead of a `sdk.Context`. The `Authorization` interface's `Accept` method now takes a `context.Context` instead of a `sdk.Context`.
 * (x/distribution) [#15948](https://github.com/cosmos/cosmos-sdk/issues/15948) `NewKeeper` now takes a `KVStoreService` instead of a `StoreKey` and methods in the `Keeper` now take a `context.Context` instead of a `sdk.Context`. Keeper methods also now return an `error`.
 * (x/bank) [#15891](https://github.com/cosmos/cosmos-sdk/issues/15891) `NewKeeper` now takes a `KVStoreService` instead of a `StoreKey` and methods in the `Keeper` now take a `context.Context` instead of a `sdk.Context`. Also `FundAccount` and `FundModuleAccount` from the `testutil` package accept a `context.Context` instead of a `sdk.Context`, and it's position was moved to the first place.
diff --git a/x/auth/keeper/deterministic_test.go b/x/auth/keeper/deterministic_test.go
@@ -74,7 +74,7 @@ func (suite *DeterministicTestSuite) SetupTest() {
 	)
 
 	queryHelper := baseapp.NewQueryServerTestHelper(suite.ctx, suite.encCfg.InterfaceRegistry)
-	types.RegisterQueryServer(queryHelper, suite.accountKeeper)
+	types.RegisterQueryServer(queryHelper, keeper.NewQueryServer(suite.accountKeeper))
 	suite.queryClient = types.NewQueryClient(queryHelper)
 
 	suite.key = key
@@ -239,7 +239,7 @@ func (suite *DeterministicTestSuite) TestGRPCQueryAccountInfo() {
 
 func (suite *DeterministicTestSuite) createAndReturnQueryClient(ak keeper.AccountKeeper) types.QueryClient {
 	queryHelper := baseapp.NewQueryServerTestHelper(suite.ctx, suite.encCfg.InterfaceRegistry)
-	types.RegisterQueryServer(queryHelper, ak)
+	types.RegisterQueryServer(queryHelper, keeper.NewQueryServer(ak))
 	return types.NewQueryClient(queryHelper)
 }
 
diff --git a/x/auth/keeper/grpc_query.go b/x/auth/keeper/grpc_query.go
@@ -19,9 +19,15 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/auth/types"
 )
 
-var _ types.QueryServer = AccountKeeper{}
+var _ types.QueryServer = queryServer{}
 
-func (ak AccountKeeper) AccountAddressByID(c context.Context, req *types.QueryAccountAddressByIDRequest) (*types.QueryAccountAddressByIDResponse, error) {
+func NewQueryServer(k AccountKeeper) types.QueryServer {
+	return queryServer{k: k}
+}
+
+type queryServer struct{ k AccountKeeper }
+
+func (s queryServer) AccountAddressByID(c context.Context, req *types.QueryAccountAddressByIDRequest) (*types.QueryAccountAddressByIDResponse, error) {
 	if req == nil {
 		return nil, status.Errorf(codes.InvalidArgument, "empty request")
 	}
@@ -33,25 +39,25 @@ func (ak AccountKeeper) AccountAddressByID(c context.Context, req *types.QueryAc
 	accID := req.AccountId
 
 	ctx := sdk.UnwrapSDKContext(c)
-	address := ak.GetAccountAddressByID(ctx, accID)
+	address := s.k.GetAccountAddressByID(ctx, accID)
 	if len(address) == 0 {
 		return nil, status.Errorf(codes.NotFound, "account address not found with account number %d", req.Id)
 	}
 
 	return &types.QueryAccountAddressByIDResponse{AccountAddress: address}, nil
 }
 
-func (ak AccountKeeper) Accounts(ctx context.Context, req *types.QueryAccountsRequest) (*types.QueryAccountsResponse, error) {
+func (s queryServer) Accounts(ctx context.Context, req *types.QueryAccountsRequest) (*types.QueryAccountsResponse, error) {
 	if req == nil {
 		return nil, status.Error(codes.InvalidArgument, "empty request")
 	}
 
-	store := ak.storeService.OpenKVStore(ctx)
+	store := s.k.storeService.OpenKVStore(ctx)
 	accountsStore := prefix.NewStore(runtime.KVStoreAdapter(store), types.AddressStoreKeyPrefix)
 
 	var accounts []*codectypes.Any
 	pageRes, err := query.Paginate(accountsStore, req.Pagination, func(key, value []byte) error {
-		account := ak.decodeAccount(value)
+		account := s.k.decodeAccount(value)
 		any, err := codectypes.NewAnyWithValue(account)
 		if err != nil {
 			return err
@@ -68,7 +74,7 @@ func (ak AccountKeeper) Accounts(ctx context.Context, req *types.QueryAccountsRe
 }
 
 // Account returns account details based on address
-func (ak AccountKeeper) Account(c context.Context, req *types.QueryAccountRequest) (*types.QueryAccountResponse, error) {
+func (s queryServer) Account(c context.Context, req *types.QueryAccountRequest) (*types.QueryAccountResponse, error) {
 	if req == nil {
 		return nil, status.Errorf(codes.InvalidArgument, "empty request")
 	}
@@ -78,11 +84,11 @@ func (ak AccountKeeper) Account(c context.Context, req *types.QueryAccountReques
 	}
 
 	ctx := sdk.UnwrapSDKContext(c)
-	addr, err := ak.StringToBytes(req.Address)
+	addr, err := s.k.StringToBytes(req.Address)
 	if err != nil {
 		return nil, err
 	}
-	account := ak.GetAccount(ctx, addr)
+	account := s.k.GetAccount(ctx, addr)
 	if account == nil {
 		return nil, status.Errorf(codes.NotFound, "account %s not found", req.Address)
 	}
@@ -96,35 +102,35 @@ func (ak AccountKeeper) Account(c context.Context, req *types.QueryAccountReques
 }
 
 // Params returns parameters of auth module
-func (ak AccountKeeper) Params(c context.Context, req *types.QueryParamsRequest) (*types.QueryParamsResponse, error) {
+func (s queryServer) Params(c context.Context, req *types.QueryParamsRequest) (*types.QueryParamsResponse, error) {
 	if req == nil {
 		return nil, status.Error(codes.InvalidArgument, "empty request")
 	}
 	ctx := sdk.UnwrapSDKContext(c)
-	params := ak.GetParams(ctx)
+	params := s.k.GetParams(ctx)
 
 	return &types.QueryParamsResponse{Params: params}, nil
 }
 
 // ModuleAccounts returns all the existing Module Accounts
-func (ak AccountKeeper) ModuleAccounts(c context.Context, req *types.QueryModuleAccountsRequest) (*types.QueryModuleAccountsResponse, error) {
+func (s queryServer) ModuleAccounts(c context.Context, req *types.QueryModuleAccountsRequest) (*types.QueryModuleAccountsResponse, error) {
 	if req == nil {
 		return nil, status.Error(codes.InvalidArgument, "empty request")
 	}
 
 	ctx := sdk.UnwrapSDKContext(c)
 
 	// For deterministic output, sort the permAddrs by module name.
-	sortedPermAddrs := make([]string, 0, len(ak.permAddrs))
-	for moduleName := range ak.permAddrs {
+	sortedPermAddrs := make([]string, 0, len(s.k.permAddrs))
+	for moduleName := range s.k.permAddrs {
 		sortedPermAddrs = append(sortedPermAddrs, moduleName)
 	}
 	sort.Strings(sortedPermAddrs)
 
-	modAccounts := make([]*codectypes.Any, 0, len(ak.permAddrs))
+	modAccounts := make([]*codectypes.Any, 0, len(s.k.permAddrs))
 
 	for _, moduleName := range sortedPermAddrs {
-		account := ak.GetModuleAccount(ctx, moduleName)
+		account := s.k.GetModuleAccount(ctx, moduleName)
 		if account == nil {
 			return nil, status.Errorf(codes.NotFound, "account %s not found", moduleName)
 		}
@@ -139,7 +145,7 @@ func (ak AccountKeeper) ModuleAccounts(c context.Context, req *types.QueryModule
 }
 
 // ModuleAccountByName returns module account by module name
-func (ak AccountKeeper) ModuleAccountByName(c context.Context, req *types.QueryModuleAccountByNameRequest) (*types.QueryModuleAccountByNameResponse, error) {
+func (s queryServer) ModuleAccountByName(c context.Context, req *types.QueryModuleAccountByNameRequest) (*types.QueryModuleAccountByNameResponse, error) {
 	if req == nil {
 		return nil, status.Errorf(codes.InvalidArgument, "empty request")
 	}
@@ -151,7 +157,7 @@ func (ak AccountKeeper) ModuleAccountByName(c context.Context, req *types.QueryM
 	ctx := sdk.UnwrapSDKContext(c)
 	moduleName := req.Name
 
-	account := ak.GetModuleAccount(ctx, moduleName)
+	account := s.k.GetModuleAccount(ctx, moduleName)
 	if account == nil {
 		return nil, status.Errorf(codes.NotFound, "account %s not found", moduleName)
 	}
@@ -164,8 +170,8 @@ func (ak AccountKeeper) ModuleAccountByName(c context.Context, req *types.QueryM
 }
 
 // Bech32Prefix returns the keeper internally stored bech32 prefix.
-func (ak AccountKeeper) Bech32Prefix(ctx context.Context, req *types.Bech32PrefixRequest) (*types.Bech32PrefixResponse, error) {
-	bech32Prefix, err := ak.getBech32Prefix()
+func (s queryServer) Bech32Prefix(ctx context.Context, req *types.Bech32PrefixRequest) (*types.Bech32PrefixResponse, error) {
+	bech32Prefix, err := s.k.getBech32Prefix()
 	if err != nil {
 		return nil, err
 	}
@@ -175,7 +181,7 @@ func (ak AccountKeeper) Bech32Prefix(ctx context.Context, req *types.Bech32Prefi
 
 // AddressBytesToString converts an address from bytes to string, using the
 // keeper's bech32 prefix.
-func (ak AccountKeeper) AddressBytesToString(ctx context.Context, req *types.AddressBytesToStringRequest) (*types.AddressBytesToStringResponse, error) {
+func (s queryServer) AddressBytesToString(ctx context.Context, req *types.AddressBytesToStringRequest) (*types.AddressBytesToStringResponse, error) {
 	if req == nil {
 		return nil, status.Error(codes.InvalidArgument, "empty request")
 	}
@@ -184,7 +190,7 @@ func (ak AccountKeeper) AddressBytesToString(ctx context.Context, req *types.Add
 		return nil, errors.New("empty address bytes is not allowed")
 	}
 
-	text, err := ak.BytesToString(req.AddressBytes)
+	text, err := s.k.BytesToString(req.AddressBytes)
 	if err != nil {
 		return nil, err
 	}
@@ -194,7 +200,7 @@ func (ak AccountKeeper) AddressBytesToString(ctx context.Context, req *types.Add
 
 // AddressStringToBytes converts an address from string to bytes, using the
 // keeper's bech32 prefix.
-func (ak AccountKeeper) AddressStringToBytes(ctx context.Context, req *types.AddressStringToBytesRequest) (*types.AddressStringToBytesResponse, error) {
+func (s queryServer) AddressStringToBytes(ctx context.Context, req *types.AddressStringToBytesRequest) (*types.AddressStringToBytesResponse, error) {
 	if req == nil {
 		return nil, status.Error(codes.InvalidArgument, "empty request")
 	}
@@ -203,7 +209,7 @@ func (ak AccountKeeper) AddressStringToBytes(ctx context.Context, req *types.Add
 		return nil, errors.New("empty address string is not allowed")
 	}
 
-	bz, err := ak.StringToBytes(req.AddressString)
+	bz, err := s.k.StringToBytes(req.AddressString)
 	if err != nil {
 		return nil, err
 	}
@@ -212,7 +218,7 @@ func (ak AccountKeeper) AddressStringToBytes(ctx context.Context, req *types.Add
 }
 
 // AccountInfo implements the AccountInfo query.
-func (ak AccountKeeper) AccountInfo(goCtx context.Context, req *types.QueryAccountInfoRequest) (*types.QueryAccountInfoResponse, error) {
+func (s queryServer) AccountInfo(goCtx context.Context, req *types.QueryAccountInfoRequest) (*types.QueryAccountInfoResponse, error) {
 	if req == nil {
 		return nil, status.Errorf(codes.InvalidArgument, "empty request")
 	}
@@ -222,12 +228,12 @@ func (ak AccountKeeper) AccountInfo(goCtx context.Context, req *types.QueryAccou
 	}
 
 	ctx := sdk.UnwrapSDKContext(goCtx)
-	addr, err := ak.StringToBytes(req.Address)
+	addr, err := s.k.StringToBytes(req.Address)
 	if err != nil {
 		return nil, err
 	}
 
-	account := ak.GetAccount(ctx, addr)
+	account := s.k.GetAccount(ctx, addr)
 	if account == nil {
 		return nil, status.Errorf(codes.NotFound, "account %s not found", req.Address)
 	}
diff --git a/x/auth/keeper/keeper.go b/x/auth/keeper/keeper.go
@@ -76,7 +76,7 @@ type AccountKeeper struct {
 	authority string
 
 	// State
-	ParamsState   collections.Item[types.Params] // NOTE: name is this because it conflicts with the Params gRPC method impl
+	Params        collections.Item[types.Params]
 	AccountNumber collections.Sequence
 }
 
@@ -107,7 +107,7 @@ func NewAccountKeeper(
 		cdc:           cdc,
 		permAddrs:     permAddrs,
 		authority:     authority,
-		ParamsState:   collections.NewItem(sb, types.ParamsKey, "params", codec.CollValue[types.Params](cdc)),
+		Params:        collections.NewItem(sb, types.ParamsKey, "params", codec.CollValue[types.Params](cdc)),
 		AccountNumber: collections.NewSequence(sb, types.GlobalAccountNumberKey, "account_number"),
 	}
 }
@@ -265,12 +265,12 @@ func (ak AccountKeeper) getBech32Prefix() (string, error) {
 // SetParams sets the auth module's parameters.
 // CONTRACT: This method performs no validation of the parameters.
 func (ak AccountKeeper) SetParams(ctx context.Context, params types.Params) error {
-	return ak.ParamsState.Set(ctx, params)
+	return ak.Params.Set(ctx, params)
 }
 
 // GetParams gets the auth module's parameters.
 func (ak AccountKeeper) GetParams(ctx context.Context) (params types.Params) {
-	params, err := ak.ParamsState.Get(ctx)
+	params, err := ak.Params.Get(ctx)
 	if err != nil && !errors.Is(err, collections.ErrNotFound) {
 		panic(err)
 	}
diff --git a/x/auth/keeper/keeper_test.go b/x/auth/keeper/keeper_test.go
@@ -71,7 +71,7 @@ func (suite *KeeperTestSuite) SetupTest() {
 	)
 	suite.msgServer = keeper.NewMsgServerImpl(suite.accountKeeper)
 	queryHelper := baseapp.NewQueryServerTestHelper(suite.ctx, suite.encCfg.InterfaceRegistry)
-	types.RegisterQueryServer(queryHelper, suite.accountKeeper)
+	types.RegisterQueryServer(queryHelper, keeper.NewQueryServer(suite.accountKeeper))
 	suite.queryClient = types.NewQueryClient(queryHelper)
 }
 
diff --git a/x/auth/keeper/msg_server.go b/x/auth/keeper/msg_server.go
@@ -13,27 +13,27 @@ import (
 var _ types.MsgServer = msgServer{}
 
 type msgServer struct {
-	AccountKeeper
+	ak AccountKeeper
 }
 
 // NewMsgServerImpl returns an implementation of the x/auth MsgServer interface.
 func NewMsgServerImpl(ak AccountKeeper) types.MsgServer {
 	return &msgServer{
-		AccountKeeper: ak,
+		ak: ak,
 	}
 }
 
 func (ms msgServer) UpdateParams(goCtx context.Context, msg *types.MsgUpdateParams) (*types.MsgUpdateParamsResponse, error) {
-	if ms.authority != msg.Authority {
-		return nil, errors.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", ms.authority, msg.Authority)
+	if ms.ak.authority != msg.Authority {
+		return nil, errors.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", ms.ak.authority, msg.Authority)
 	}
 
 	if err := msg.Params.Validate(); err != nil {
 		return nil, err
 	}
 
 	ctx := sdk.UnwrapSDKContext(goCtx)
-	if err := ms.SetParams(ctx, msg.Params); err != nil {
+	if err := ms.ak.SetParams(ctx, msg.Params); err != nil {
 		return nil, err
 	}
 
diff --git a/x/auth/module.go b/x/auth/module.go
@@ -133,7 +133,7 @@ func (AppModule) Name() string {
 // module-specific GRPC queries.
 func (am AppModule) RegisterServices(cfg module.Configurator) {
 	types.RegisterMsgServer(cfg.MsgServer(), keeper.NewMsgServerImpl(am.accountKeeper))
-	types.RegisterQueryServer(cfg.QueryServer(), am.accountKeeper)
+	types.RegisterQueryServer(cfg.QueryServer(), keeper.NewQueryServer(am.accountKeeper))
 
 	m := keeper.NewMigrator(am.accountKeeper, cfg.QueryServer(), am.legacySubspace)
 	if err := cfg.RegisterMigration(types.ModuleName, 1, m.Migrate1to2); err != nil {

Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ func (suite *DeterministicTestSuite) SetupTest() {`
`74`	`74`	`)`
`75`	`75`
`76`	`76`	`queryHelper := baseapp.NewQueryServerTestHelper(suite.ctx, suite.encCfg.InterfaceRegistry)`
`77`		`- types.RegisterQueryServer(queryHelper, suite.accountKeeper)`
	`77`	`+ types.RegisterQueryServer(queryHelper, keeper.NewQueryServer(suite.accountKeeper))`
`78`	`78`	`suite.queryClient = types.NewQueryClient(queryHelper)`
`79`	`79`
`80`	`80`	`suite.key = key`
`@@ -239,7 +239,7 @@ func (suite *DeterministicTestSuite) TestGRPCQueryAccountInfo() {`
`239`	`239`
`240`	`240`	`func (suite *DeterministicTestSuite) createAndReturnQueryClient(ak keeper.AccountKeeper) types.QueryClient {`
`241`	`241`	`queryHelper := baseapp.NewQueryServerTestHelper(suite.ctx, suite.encCfg.InterfaceRegistry)`
`242`		`- types.RegisterQueryServer(queryHelper, ak)`
	`242`	`+ types.RegisterQueryServer(queryHelper, keeper.NewQueryServer(ak))`
`243`	`243`	`return types.NewQueryClient(queryHelper)`
`244`	`244`	`}`
`245`	`245`
Original file line number	Diff line number	Diff line change
`@@ -19,9 +19,15 @@ import (`
`19`	`19`	`"github.com/cosmos/cosmos-sdk/x/auth/types"`
`20`	`20`	`)`
`21`	`21`
`22`		`-var _ types.QueryServer = AccountKeeper{}`
	`22`	`+var _ types.QueryServer = queryServer{}`
`23`	`23`
`24`		`-func (ak AccountKeeper) AccountAddressByID(c context.Context, req types.QueryAccountAddressByIDRequest) (types.QueryAccountAddressByIDResponse, error) {`
	`24`	`+func NewQueryServer(k AccountKeeper) types.QueryServer {`
	`25`	`+ return queryServer{k: k}`
	`26`	`+}`
	`27`	`+`
	`28`	`+type queryServer struct{ k AccountKeeper }`
	`29`	`+`
	`30`	`+func (s queryServer) AccountAddressByID(c context.Context, req types.QueryAccountAddressByIDRequest) (types.QueryAccountAddressByIDResponse, error) {`
`25`	`31`	`if req == nil {`
`26`	`32`	`return nil, status.Errorf(codes.InvalidArgument, "empty request")`
`27`	`33`	`}`
`@@ -33,25 +39,25 @@ func (ak AccountKeeper) AccountAddressByID(c context.Context, req *types.QueryAc`
`33`	`39`	`accID := req.AccountId`
`34`	`40`
`35`	`41`	`ctx := sdk.UnwrapSDKContext(c)`
`36`		`- address := ak.GetAccountAddressByID(ctx, accID)`
	`42`	`+ address := s.k.GetAccountAddressByID(ctx, accID)`
`37`	`43`	`if len(address) == 0 {`
`38`	`44`	`return nil, status.Errorf(codes.NotFound, "account address not found with account number %d", req.Id)`
`39`	`45`	`}`
`40`	`46`
`41`	`47`	`return &types.QueryAccountAddressByIDResponse{AccountAddress: address}, nil`
`42`	`48`	`}`
`43`	`49`
`44`		`-func (ak AccountKeeper) Accounts(ctx context.Context, req types.QueryAccountsRequest) (types.QueryAccountsResponse, error) {`
	`50`	`+func (s queryServer) Accounts(ctx context.Context, req types.QueryAccountsRequest) (types.QueryAccountsResponse, error) {`
`45`	`51`	`if req == nil {`
`46`	`52`	`return nil, status.Error(codes.InvalidArgument, "empty request")`
`47`	`53`	`}`
`48`	`54`
`49`		`- store := ak.storeService.OpenKVStore(ctx)`
	`55`	`+ store := s.k.storeService.OpenKVStore(ctx)`
`50`	`56`	`accountsStore := prefix.NewStore(runtime.KVStoreAdapter(store), types.AddressStoreKeyPrefix)`
`51`	`57`
`52`	`58`	`var accounts []*codectypes.Any`
`53`	`59`	`pageRes, err := query.Paginate(accountsStore, req.Pagination, func(key, value []byte) error {`
`54`		`- account := ak.decodeAccount(value)`
	`60`	`+ account := s.k.decodeAccount(value)`
`55`	`61`	`any, err := codectypes.NewAnyWithValue(account)`
`56`	`62`	`if err != nil {`
`57`	`63`	`return err`
`@@ -68,7 +74,7 @@ func (ak AccountKeeper) Accounts(ctx context.Context, req *types.QueryAccountsRe`
`68`	`74`	`}`
`69`	`75`
`70`	`76`	`// Account returns account details based on address`
`71`		`-func (ak AccountKeeper) Account(c context.Context, req types.QueryAccountRequest) (types.QueryAccountResponse, error) {`
	`77`	`+func (s queryServer) Account(c context.Context, req types.QueryAccountRequest) (types.QueryAccountResponse, error) {`
`72`	`78`	`if req == nil {`
`73`	`79`	`return nil, status.Errorf(codes.InvalidArgument, "empty request")`
`74`	`80`	`}`
`@@ -78,11 +84,11 @@ func (ak AccountKeeper) Account(c context.Context, req *types.QueryAccountReques`
`78`	`84`	`}`
`79`	`85`
`80`	`86`	`ctx := sdk.UnwrapSDKContext(c)`
`81`		`- addr, err := ak.StringToBytes(req.Address)`
	`87`	`+ addr, err := s.k.StringToBytes(req.Address)`
`82`	`88`	`if err != nil {`
`83`	`89`	`return nil, err`
`84`	`90`	`}`
`85`		`- account := ak.GetAccount(ctx, addr)`
	`91`	`+ account := s.k.GetAccount(ctx, addr)`
`86`	`92`	`if account == nil {`
`87`	`93`	`return nil, status.Errorf(codes.NotFound, "account %s not found", req.Address)`
`88`	`94`	`}`
`@@ -96,35 +102,35 @@ func (ak AccountKeeper) Account(c context.Context, req *types.QueryAccountReques`
`96`	`102`	`}`
`97`	`103`
`98`	`104`	`// Params returns parameters of auth module`
`99`		`-func (ak AccountKeeper) Params(c context.Context, req types.QueryParamsRequest) (types.QueryParamsResponse, error) {`
	`105`	`+func (s queryServer) Params(c context.Context, req types.QueryParamsRequest) (types.QueryParamsResponse, error) {`
`100`	`106`	`if req == nil {`
`101`	`107`	`return nil, status.Error(codes.InvalidArgument, "empty request")`
`102`	`108`	`}`
`103`	`109`	`ctx := sdk.UnwrapSDKContext(c)`
`104`		`- params := ak.GetParams(ctx)`
	`110`	`+ params := s.k.GetParams(ctx)`
`105`	`111`
`106`	`112`	`return &types.QueryParamsResponse{Params: params}, nil`
`107`	`113`	`}`
`108`	`114`
`109`	`115`	`// ModuleAccounts returns all the existing Module Accounts`
`110`		`-func (ak AccountKeeper) ModuleAccounts(c context.Context, req types.QueryModuleAccountsRequest) (types.QueryModuleAccountsResponse, error) {`
	`116`	`+func (s queryServer) ModuleAccounts(c context.Context, req types.QueryModuleAccountsRequest) (types.QueryModuleAccountsResponse, error) {`
`111`	`117`	`if req == nil {`
`112`	`118`	`return nil, status.Error(codes.InvalidArgument, "empty request")`
`113`	`119`	`}`
`114`	`120`
`115`	`121`	`ctx := sdk.UnwrapSDKContext(c)`
`116`	`122`
`117`	`123`	`// For deterministic output, sort the permAddrs by module name.`
`118`		`- sortedPermAddrs := make([]string, 0, len(ak.permAddrs))`
`119`		`- for moduleName := range ak.permAddrs {`
	`124`	`+ sortedPermAddrs := make([]string, 0, len(s.k.permAddrs))`
	`125`	`+ for moduleName := range s.k.permAddrs {`
`120`	`126`	`sortedPermAddrs = append(sortedPermAddrs, moduleName)`
`121`	`127`	`}`
`122`	`128`	`sort.Strings(sortedPermAddrs)`
`123`	`129`
`124`		`- modAccounts := make([]*codectypes.Any, 0, len(ak.permAddrs))`
	`130`	`+ modAccounts := make([]*codectypes.Any, 0, len(s.k.permAddrs))`
`125`	`131`
`126`	`132`	`for _, moduleName := range sortedPermAddrs {`
`127`		`- account := ak.GetModuleAccount(ctx, moduleName)`
	`133`	`+ account := s.k.GetModuleAccount(ctx, moduleName)`
`128`	`134`	`if account == nil {`
`129`	`135`	`return nil, status.Errorf(codes.NotFound, "account %s not found", moduleName)`
`130`	`136`	`}`
`@@ -139,7 +145,7 @@ func (ak AccountKeeper) ModuleAccounts(c context.Context, req *types.QueryModule`
`139`	`145`	`}`
`140`	`146`
`141`	`147`	`// ModuleAccountByName returns module account by module name`
`142`		`-func (ak AccountKeeper) ModuleAccountByName(c context.Context, req types.QueryModuleAccountByNameRequest) (types.QueryModuleAccountByNameResponse, error) {`
	`148`	`+func (s queryServer) ModuleAccountByName(c context.Context, req types.QueryModuleAccountByNameRequest) (types.QueryModuleAccountByNameResponse, error) {`
`143`	`149`	`if req == nil {`
`144`	`150`	`return nil, status.Errorf(codes.InvalidArgument, "empty request")`
`145`	`151`	`}`
`@@ -151,7 +157,7 @@ func (ak AccountKeeper) ModuleAccountByName(c context.Context, req *types.QueryM`
`151`	`157`	`ctx := sdk.UnwrapSDKContext(c)`
`152`	`158`	`moduleName := req.Name`
`153`	`159`
`154`		`- account := ak.GetModuleAccount(ctx, moduleName)`
	`160`	`+ account := s.k.GetModuleAccount(ctx, moduleName)`
`155`	`161`	`if account == nil {`
`156`	`162`	`return nil, status.Errorf(codes.NotFound, "account %s not found", moduleName)`
`157`	`163`	`}`
`@@ -164,8 +170,8 @@ func (ak AccountKeeper) ModuleAccountByName(c context.Context, req *types.QueryM`
`164`	`170`	`}`
`165`	`171`
`166`	`172`	`// Bech32Prefix returns the keeper internally stored bech32 prefix.`
`167`		`-func (ak AccountKeeper) Bech32Prefix(ctx context.Context, req types.Bech32PrefixRequest) (types.Bech32PrefixResponse, error) {`
`168`		`- bech32Prefix, err := ak.getBech32Prefix()`
	`173`	`+func (s queryServer) Bech32Prefix(ctx context.Context, req types.Bech32PrefixRequest) (types.Bech32PrefixResponse, error) {`
	`174`	`+ bech32Prefix, err := s.k.getBech32Prefix()`
`169`	`175`	`if err != nil {`
`170`	`176`	`return nil, err`
`171`	`177`	`}`
`@@ -175,7 +181,7 @@ func (ak AccountKeeper) Bech32Prefix(ctx context.Context, req *types.Bech32Prefi`
`175`	`181`
`176`	`182`	`// AddressBytesToString converts an address from bytes to string, using the`
`177`	`183`	`// keeper's bech32 prefix.`
`178`		`-func (ak AccountKeeper) AddressBytesToString(ctx context.Context, req types.AddressBytesToStringRequest) (types.AddressBytesToStringResponse, error) {`
	`184`	`+func (s queryServer) AddressBytesToString(ctx context.Context, req types.AddressBytesToStringRequest) (types.AddressBytesToStringResponse, error) {`
`179`	`185`	`if req == nil {`
`180`	`186`	`return nil, status.Error(codes.InvalidArgument, "empty request")`
`181`	`187`	`}`
`@@ -184,7 +190,7 @@ func (ak AccountKeeper) AddressBytesToString(ctx context.Context, req *types.Add`
`184`	`190`	`return nil, errors.New("empty address bytes is not allowed")`
`185`	`191`	`}`
`186`	`192`
`187`		`- text, err := ak.BytesToString(req.AddressBytes)`
	`193`	`+ text, err := s.k.BytesToString(req.AddressBytes)`
`188`	`194`	`if err != nil {`
`189`	`195`	`return nil, err`
`190`	`196`	`}`
`@@ -194,7 +200,7 @@ func (ak AccountKeeper) AddressBytesToString(ctx context.Context, req *types.Add`
`194`	`200`
`195`	`201`	`// AddressStringToBytes converts an address from string to bytes, using the`
`196`	`202`	`// keeper's bech32 prefix.`
`197`		`-func (ak AccountKeeper) AddressStringToBytes(ctx context.Context, req types.AddressStringToBytesRequest) (types.AddressStringToBytesResponse, error) {`
	`203`	`+func (s queryServer) AddressStringToBytes(ctx context.Context, req types.AddressStringToBytesRequest) (types.AddressStringToBytesResponse, error) {`
`198`	`204`	`if req == nil {`
`199`	`205`	`return nil, status.Error(codes.InvalidArgument, "empty request")`
`200`	`206`	`}`
`@@ -203,7 +209,7 @@ func (ak AccountKeeper) AddressStringToBytes(ctx context.Context, req *types.Add`
`203`	`209`	`return nil, errors.New("empty address string is not allowed")`
`204`	`210`	`}`
`205`	`211`
`206`		`- bz, err := ak.StringToBytes(req.AddressString)`
	`212`	`+ bz, err := s.k.StringToBytes(req.AddressString)`
`207`	`213`	`if err != nil {`
`208`	`214`	`return nil, err`
`209`	`215`	`}`
`@@ -212,7 +218,7 @@ func (ak AccountKeeper) AddressStringToBytes(ctx context.Context, req *types.Add`
`212`	`218`	`}`
`213`	`219`
`214`	`220`	`// AccountInfo implements the AccountInfo query.`
`215`		`-func (ak AccountKeeper) AccountInfo(goCtx context.Context, req types.QueryAccountInfoRequest) (types.QueryAccountInfoResponse, error) {`
	`221`	`+func (s queryServer) AccountInfo(goCtx context.Context, req types.QueryAccountInfoRequest) (types.QueryAccountInfoResponse, error) {`
`216`	`222`	`if req == nil {`
`217`	`223`	`return nil, status.Errorf(codes.InvalidArgument, "empty request")`
`218`	`224`	`}`
`@@ -222,12 +228,12 @@ func (ak AccountKeeper) AccountInfo(goCtx context.Context, req *types.QueryAccou`
`222`	`228`	`}`
`223`	`229`
`224`	`230`	`ctx := sdk.UnwrapSDKContext(goCtx)`
`225`		`- addr, err := ak.StringToBytes(req.Address)`
	`231`	`+ addr, err := s.k.StringToBytes(req.Address)`
`226`	`232`	`if err != nil {`
`227`	`233`	`return nil, err`
`228`	`234`	`}`
`229`	`235`
`230`		`- account := ak.GetAccount(ctx, addr)`
	`236`	`+ account := s.k.GetAccount(ctx, addr)`
`231`	`237`	`if account == nil {`
`232`	`238`	`return nil, status.Errorf(codes.NotFound, "account %s not found", req.Address)`
`233`	`239`	`}`
Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ type AccountKeeper struct {`
`76`	`76`	`authority string`
`77`	`77`
`78`	`78`	`// State`
`79`		`- ParamsState collections.Item[types.Params] // NOTE: name is this because it conflicts with the Params gRPC method impl`
	`79`	`+ Params collections.Item[types.Params]`
`80`	`80`	`AccountNumber collections.Sequence`
`81`	`81`	`}`
`82`	`82`
`@@ -107,7 +107,7 @@ func NewAccountKeeper(`
`107`	`107`	`cdc: cdc,`
`108`	`108`	`permAddrs: permAddrs,`
`109`	`109`	`authority: authority,`
`110`		`- ParamsState: collections.NewItem(sb, types.ParamsKey, "params", codec.CollValue[types.Params](cdc)),`
	`110`	`+ Params: collections.NewItem(sb, types.ParamsKey, "params", codec.CollValue[types.Params](cdc)),`
`111`	`111`	`AccountNumber: collections.NewSequence(sb, types.GlobalAccountNumberKey, "account_number"),`
`112`	`112`	`}`
`113`	`113`	`}`
`@@ -265,12 +265,12 @@ func (ak AccountKeeper) getBech32Prefix() (string, error) {`
`265`	`265`	`// SetParams sets the auth module's parameters.`
`266`	`266`	`// CONTRACT: This method performs no validation of the parameters.`
`267`	`267`	`func (ak AccountKeeper) SetParams(ctx context.Context, params types.Params) error {`
`268`		`- return ak.ParamsState.Set(ctx, params)`
	`268`	`+ return ak.Params.Set(ctx, params)`
`269`	`269`	`}`
`270`	`270`
`271`	`271`	`// GetParams gets the auth module's parameters.`
`272`	`272`	`func (ak AccountKeeper) GetParams(ctx context.Context) (params types.Params) {`
`273`		`- params, err := ak.ParamsState.Get(ctx)`
	`273`	`+ params, err := ak.Params.Get(ctx)`
`274`	`274`	`if err != nil && !errors.Is(err, collections.ErrNotFound) {`
`275`	`275`	`panic(err)`
`276`	`276`	`}`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ func (suite *KeeperTestSuite) SetupTest() {`
`71`	`71`	`)`
`72`	`72`	`suite.msgServer = keeper.NewMsgServerImpl(suite.accountKeeper)`
`73`	`73`	`queryHelper := baseapp.NewQueryServerTestHelper(suite.ctx, suite.encCfg.InterfaceRegistry)`
`74`		`- types.RegisterQueryServer(queryHelper, suite.accountKeeper)`
	`74`	`+ types.RegisterQueryServer(queryHelper, keeper.NewQueryServer(suite.accountKeeper))`
`75`	`75`	`suite.queryClient = types.NewQueryClient(queryHelper)`
`76`	`76`	`}`
`77`	`77`
Original file line number	Diff line number	Diff line change
`@@ -13,27 +13,27 @@ import (`
`13`	`13`	`var _ types.MsgServer = msgServer{}`
`14`	`14`
`15`	`15`	`type msgServer struct {`
`16`		`- AccountKeeper`
	`16`	`+ ak AccountKeeper`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`// NewMsgServerImpl returns an implementation of the x/auth MsgServer interface.`
`20`	`20`	`func NewMsgServerImpl(ak AccountKeeper) types.MsgServer {`
`21`	`21`	`return &msgServer{`
`22`		`- AccountKeeper: ak,`
	`22`	`+ ak: ak,`
`23`	`23`	`}`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`func (ms msgServer) UpdateParams(goCtx context.Context, msg types.MsgUpdateParams) (types.MsgUpdateParamsResponse, error) {`
`27`		`- if ms.authority != msg.Authority {`
`28`		`- return nil, errors.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", ms.authority, msg.Authority)`
	`27`	`+ if ms.ak.authority != msg.Authority {`
	`28`	`+ return nil, errors.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", ms.ak.authority, msg.Authority)`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`if err := msg.Params.Validate(); err != nil {`
`32`	`32`	`return nil, err`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`ctx := sdk.UnwrapSDKContext(goCtx)`
`36`		`- if err := ms.SetParams(ctx, msg.Params); err != nil {`
	`36`	`+ if err := ms.ak.SetParams(ctx, msg.Params); err != nil {`
`37`	`37`	`return nil, err`
`38`	`38`	`}`
`39`	`39`