LaconicNetwork/cosmos-sdk
7
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

feat(x/group): Add env bundler to group module (#19489)

Browse Source
This commit is contained in:
Likhita Polavarapu 2024-02-20 15:54:32 +05:30 committed by GitHub
parent b0db3ea299
commit b050ec2f3f
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
19 changed files with 207 additions and 219 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
simapp/app.go
View File

@ -365,7 +365,7 @@ func NewSimApp(
config.MaxProposalTitleLen = 255 // example max title length in characters
config.MaxProposalSummaryLen = 10200 // example max summary length in characters
*/
app.GroupKeeper = groupkeeper.NewKeeper(runtime.NewKVStoreService(keys[group.StoreKey]), appCodec, app.MsgServiceRouter(), app.AuthKeeper, groupConfig)
app.GroupKeeper = groupkeeper.NewKeeper(runtime.NewEnvironment(runtime.NewKVStoreService(keys[group.StoreKey]), logger), appCodec, app.MsgServiceRouter(), app.AuthKeeper, groupConfig)
// get skipUpgradeHeights from the app options
skipUpgradeHeights := map[int64]bool{}

1
x/group/CHANGELOG.md
View File

@ -34,4 +34,5 @@ Ref: https://keepachangelog.com/en/1.0.0/
### API Breaking Changes
* [#19489](https://github.com/cosmos/cosmos-sdk/pull/19489) `appmodule.Environment` is received on the Keeper to get access to different application services.
* [#19410](https://github.com/cosmos/cosmos-sdk/pull/19410) Migrate to Store Service.

15
x/group/keeper/abci.go Normal file
View File

@ -0,0 +1,15 @@
package keeper
import (
"context"
)
// EndBlocker called at every block, updates proposal's `FinalTallyResult` and
// prunes expired proposals.
func (k Keeper) EndBlocker(ctx context.Context) error {
if err := k.TallyProposalsAtVPEnd(ctx, k.environment); err != nil {
return err
}
return k.PruneProposals(ctx, k.environment)
}

47
x/group/module/abci_test.go → x/group/keeper/abci_test.go
View File

@ -1,4 +1,4 @@
package module_test
package keeper_test
import (
"context"
@ -17,7 +17,6 @@ import (
banktypes "cosmossdk.io/x/bank/types"
"cosmossdk.io/x/group"
"cosmossdk.io/x/group/keeper"
"cosmossdk.io/x/group/module"
grouptestutil "cosmossdk.io/x/group/testutil"
stakingkeeper "cosmossdk.io/x/staking/keeper"
@ -164,7 +163,7 @@ func (s *IntegrationTestSuite) TestEndBlockerPruning() {
"proposal pruned after executor result success": {
setupProposal: func(ctx sdk.Context) uint64 {
msgs := []sdk.Msg{msgSend1}
pID, err := submitProposalAndVote(s, s.app, ctx, msgs, proposers, groupPolicyAddr, group.VOTE_OPTION_YES)
pID, err := submitProposalAndVoteHelper(s, s.app, ctx, msgs, proposers, groupPolicyAddr, group.VOTE_OPTION_YES)
s.Require().NoError(err)
_, err = s.groupKeeper.Exec(ctx, &group.MsgExec{Executor: addr3.String(), ProposalId: pID})
s.Require().NoError(err)
@ -179,7 +178,7 @@ func (s *IntegrationTestSuite) TestEndBlockerPruning() {
"proposal with multiple messages pruned when executed with result success": {
setupProposal: func(ctx sdk.Context) uint64 {
msgs := []sdk.Msg{msgSend1, msgSend1}
pID, err := submitProposalAndVote(s, s.app, ctx, msgs, proposers, groupPolicyAddr, group.VOTE_OPTION_YES)
pID, err := submitProposalAndVoteHelper(s, s.app, ctx, msgs, proposers, groupPolicyAddr, group.VOTE_OPTION_YES)
s.Require().NoError(err)
_, err = s.groupKeeper.Exec(ctx, &group.MsgExec{Executor: addr3.String(), ProposalId: pID})
s.Require().NoError(err)
@ -194,7 +193,7 @@ func (s *IntegrationTestSuite) TestEndBlockerPruning() {
"proposal not pruned when not executed and rejected": {
setupProposal: func(ctx sdk.Context) uint64 {
msgs := []sdk.Msg{msgSend1}
pID, err := submitProposalAndVote(s, s.app, ctx, msgs, proposers, groupPolicyAddr, group.VOTE_OPTION_NO)
pID, err := submitProposalAndVoteHelper(s, s.app, ctx, msgs, proposers, groupPolicyAddr, group.VOTE_OPTION_NO)
s.Require().NoError(err)
_, err = s.groupKeeper.Exec(ctx, &group.MsgExec{Executor: addr3.String(), ProposalId: pID})
s.Require().NoError(err)
@ -209,7 +208,7 @@ func (s *IntegrationTestSuite) TestEndBlockerPruning() {
},
"open proposal is not pruned which must not fail ": {
setupProposal: func(ctx sdk.Context) uint64 {
pID, err := submitProposal(s, s.app, ctx, []sdk.Msg{msgSend1}, proposers, groupPolicyAddr)
pID, err := submitProposalHelper(s, s.app, ctx, []sdk.Msg{msgSend1}, proposers, groupPolicyAddr)
s.Require().NoError(err)
_, err = s.groupKeeper.Exec(ctx, &group.MsgExec{Executor: addr3.String(), ProposalId: pID})
s.Require().NoError(err)
@ -223,7 +222,7 @@ func (s *IntegrationTestSuite) TestEndBlockerPruning() {
},
"proposal not pruned with group policy modified before tally": {
setupProposal: func(ctx sdk.Context) uint64 {
pID, err := submitProposal(s, s.app, ctx, []sdk.Msg{msgSend1}, proposers, groupPolicyAddr)
pID, err := submitProposalHelper(s, s.app, ctx, []sdk.Msg{msgSend1}, proposers, groupPolicyAddr)
s.Require().NoError(err)
_, err = s.groupKeeper.UpdateGroupPolicyMetadata(ctx, &group.MsgUpdateGroupPolicyMetadata{
Admin: addr1.String(),
@ -243,7 +242,7 @@ func (s *IntegrationTestSuite) TestEndBlockerPruning() {
"pruned when proposal is executable when failed before": {
setupProposal: func(ctx sdk.Context) uint64 {
msgs := []sdk.Msg{msgSend1}
pID, err := submitProposalAndVote(s, s.app, ctx, msgs, proposers, groupPolicyAddr, group.VOTE_OPTION_YES)
pID, err := submitProposalAndVoteHelper(s, s.app, ctx, msgs, proposers, groupPolicyAddr, group.VOTE_OPTION_YES)
s.Require().NoError(err)
_, err = s.groupKeeper.Exec(ctx, &group.MsgExec{Executor: s.addrs[2].String(), ProposalId: pID})
s.Require().NoError(err)
@ -255,7 +254,7 @@ func (s *IntegrationTestSuite) TestEndBlockerPruning() {
},
"proposal with status withdrawn is pruned after voting period end": {
setupProposal: func(sdkCtx sdk.Context) uint64 {
pID, err := submitProposal(s, s.app, sdkCtx, []sdk.Msg{msgSend1}, proposers, groupPolicyAddr)
pID, err := submitProposalHelper(s, s.app, sdkCtx, []sdk.Msg{msgSend1}, proposers, groupPolicyAddr)
s.Require().NoError(err)
_, err = s.groupKeeper.WithdrawProposal(ctx, &group.MsgWithdrawProposal{
ProposalId: pID,
@ -270,7 +269,7 @@ func (s *IntegrationTestSuite) TestEndBlockerPruning() {
},
"proposal with status withdrawn is not pruned (before voting period)": {
setupProposal: func(sdkCtx sdk.Context) uint64 {
pID, err := submitProposal(s, s.app, sdkCtx, []sdk.Msg{msgSend1}, proposers, groupPolicyAddr)
pID, err := submitProposalHelper(s, s.app, sdkCtx, []sdk.Msg{msgSend1}, proposers, groupPolicyAddr)
s.Require().NoError(err)
_, err = s.groupKeeper.WithdrawProposal(ctx, &group.MsgWithdrawProposal{
ProposalId: pID,
@ -286,7 +285,7 @@ func (s *IntegrationTestSuite) TestEndBlockerPruning() {
},
"proposal with status aborted is pruned after voting period end (due to updated group policy decision policy)": {
setupProposal: func(sdkCtx sdk.Context) uint64 {
pID, err := submitProposal(s, s.app, sdkCtx, []sdk.Msg{msgSend2}, proposers, groupPolicyAddr2)
pID, err := submitProposalHelper(s, s.app, sdkCtx, []sdk.Msg{msgSend2}, proposers, groupPolicyAddr2)
s.Require().NoError(err)
policy := group.NewThresholdDecisionPolicy("3", time.Second, 0)
@ -308,7 +307,7 @@ func (s *IntegrationTestSuite) TestEndBlockerPruning() {
},
"proposal with status aborted is not pruned before voting period end (due to updated group policy)": {
setupProposal: func(sdkCtx sdk.Context) uint64 {
pID, err := submitProposal(s, s.app, sdkCtx, []sdk.Msg{msgSend2}, proposers, groupPolicyAddr2)
pID, err := submitProposalHelper(s, s.app, sdkCtx, []sdk.Msg{msgSend2}, proposers, groupPolicyAddr2)
s.Require().NoError(err)
policy := group.NewThresholdDecisionPolicy("3", time.Second, 0)
@ -334,7 +333,7 @@ func (s *IntegrationTestSuite) TestEndBlockerPruning() {
s.Run(msg, func() {
proposalID := spec.setupProposal(ctx)
err := module.EndBlocker(spec.newCtx, s.groupKeeper)
err := s.groupKeeper.EndBlocker(spec.newCtx)
s.Require().NoError(err)
if spec.expErrMsg != "" && spec.expExecutorResult != group.PROPOSAL_EXECUTOR_RESULT_SUCCESS {
@ -426,7 +425,7 @@ func (s *IntegrationTestSuite) TestEndBlockerTallying() {
}{
"tally updated after voting period end": {
preRun: func(sdkCtx sdk.Context) uint64 {
pID, err := submitProposal(s, app, sdkCtx, []sdk.Msg{msgSend}, proposers, groupPolicyAddr)
pID, err := submitProposalHelper(s, app, sdkCtx, []sdk.Msg{msgSend}, proposers, groupPolicyAddr)
s.Require().NoError(err)
return pID
},
@ -437,7 +436,7 @@ func (s *IntegrationTestSuite) TestEndBlockerTallying() {
},
"tally within voting period": {
preRun: func(sdkCtx sdk.Context) uint64 {
pID, err := submitProposal(s, app, sdkCtx, []sdk.Msg{msgSend}, proposers, groupPolicyAddr)
pID, err := submitProposalHelper(s, app, sdkCtx, []sdk.Msg{msgSend}, proposers, groupPolicyAddr)
s.Require().NoError(err)
return pID
@ -449,7 +448,7 @@ func (s *IntegrationTestSuite) TestEndBlockerTallying() {
},
"tally within voting period(with votes)": {
preRun: func(sdkCtx sdk.Context) uint64 {
pID, err := submitProposalAndVote(s, app, ctx, []sdk.Msg{msgSend}, proposers, groupPolicyAddr, group.VOTE_OPTION_YES)
pID, err := submitProposalAndVoteHelper(s, app, ctx, []sdk.Msg{msgSend}, proposers, groupPolicyAddr, group.VOTE_OPTION_YES)
s.Require().NoError(err)
return pID
@ -462,7 +461,7 @@ func (s *IntegrationTestSuite) TestEndBlockerTallying() {
"tally after voting period (not passing)": {
preRun: func(sdkCtx sdk.Context) uint64 {
// `addrs[1]` has weight 1
pID, err := submitProposalAndVote(s, app, ctx, []sdk.Msg{msgSend}, []string{addrs[1].String()}, groupPolicyAddr, group.VOTE_OPTION_YES)
pID, err := submitProposalAndVoteHelper(s, app, ctx, []sdk.Msg{msgSend}, []string{addrs[1].String()}, groupPolicyAddr, group.VOTE_OPTION_YES)
s.Require().NoError(err)
return pID
@ -479,7 +478,7 @@ func (s *IntegrationTestSuite) TestEndBlockerTallying() {
},
"tally after voting period(with votes)": {
preRun: func(sdkCtx sdk.Context) uint64 {
pID, err := submitProposalAndVote(s, app, ctx, []sdk.Msg{msgSend}, proposers, groupPolicyAddr, group.VOTE_OPTION_YES)
pID, err := submitProposalAndVoteHelper(s, app, ctx, []sdk.Msg{msgSend}, proposers, groupPolicyAddr, group.VOTE_OPTION_YES)
s.Require().NoError(err)
return pID
@ -496,7 +495,7 @@ func (s *IntegrationTestSuite) TestEndBlockerTallying() {
},
"tally of withdrawn proposal": {
preRun: func(sdkCtx sdk.Context) uint64 {
pID, err := submitProposal(s, app, sdkCtx, []sdk.Msg{msgSend}, proposers, groupPolicyAddr)
pID, err := submitProposalHelper(s, app, sdkCtx, []sdk.Msg{msgSend}, proposers, groupPolicyAddr)
s.Require().NoError(err)
_, err = s.groupKeeper.WithdrawProposal(ctx, &group.MsgWithdrawProposal{
@ -514,7 +513,7 @@ func (s *IntegrationTestSuite) TestEndBlockerTallying() {
},
"tally of withdrawn proposal (with votes)": {
preRun: func(sdkCtx sdk.Context) uint64 {
pID, err := submitProposalAndVote(s, app, ctx, []sdk.Msg{msgSend}, proposers, groupPolicyAddr, group.VOTE_OPTION_YES)
pID, err := submitProposalAndVoteHelper(s, app, ctx, []sdk.Msg{msgSend}, proposers, groupPolicyAddr, group.VOTE_OPTION_YES)
s.Require().NoError(err)
_, err = s.groupKeeper.WithdrawProposal(ctx, &group.MsgWithdrawProposal{
@ -537,7 +536,7 @@ func (s *IntegrationTestSuite) TestEndBlockerTallying() {
spec := spec
pID := spec.preRun(ctx)
err := module.EndBlocker(spec.newCtx, s.groupKeeper)
err := s.groupKeeper.EndBlocker(spec.newCtx)
s.Require().NoError(err)
resp, err := s.groupKeeper.Proposal(spec.newCtx, &group.QueryProposalRequest{
ProposalId: pID,
@ -556,7 +555,7 @@ func (s *IntegrationTestSuite) TestEndBlockerTallying() {
}
}
func submitProposal(s *IntegrationTestSuite, app *runtime.App, ctx context.Context, msgs []sdk.Msg, proposers []string, groupPolicyAddr sdk.AccAddress) (uint64, error) {
func submitProposalHelper(s *IntegrationTestSuite, app *runtime.App, ctx context.Context, msgs []sdk.Msg, proposers []string, groupPolicyAddr sdk.AccAddress) (uint64, error) {
proposalReq := &group.MsgSubmitProposal{
GroupPolicyAddress: groupPolicyAddr.String(),
Proposers: proposers,
@ -574,11 +573,11 @@ func submitProposal(s *IntegrationTestSuite, app *runtime.App, ctx context.Conte
return proposalRes.ProposalId, nil
}
func submitProposalAndVote(
func submitProposalAndVoteHelper(
s *IntegrationTestSuite, app *runtime.App, ctx context.Context, msgs []sdk.Msg,
proposers []string, groupPolicyAddr sdk.AccAddress, voteOption group.VoteOption,
) (uint64, error) {
myProposalID, err := submitProposal(s, app, ctx, msgs, proposers, groupPolicyAddr)
myProposalID, err := submitProposalHelper(s, app, ctx, msgs, proposers, groupPolicyAddr)
if err != nil {
return 0, err
}

4
x/group/keeper/genesis.go
View File

@ -17,7 +17,7 @@ func (k Keeper) InitGenesis(ctx context.Context, cdc codec.JSONCodec, data json.
var genesisState group.GenesisState
cdc.MustUnmarshalJSON(data, &genesisState)
store := k.storeService.OpenKVStore(ctx)
store := k.environment.KVStoreService.OpenKVStore(ctx)
if err := k.groupTable.Import(store, genesisState.Groups, genesisState.GroupSeq); err != nil {
panic(errors.Wrap(err, "groups"))
@ -52,7 +52,7 @@ func (k Keeper) ExportGenesis(ctx context.Context, _ codec.JSONCodec) *group.Gen
var groups []*group.GroupInfo
store := k.storeService.OpenKVStore(ctx)
store := k.environment.KVStoreService.OpenKVStore(ctx)
groupSeq, err := k.groupTable.Export(store, &groups)
if err != nil {

3
x/group/keeper/genesis_test.go
View File

@ -53,6 +53,7 @@ func (s *GenesisTestSuite) SetupTest() {
storeService := runtime.NewKVStoreService(key)
testCtx := testutil.DefaultContextWithDB(s.T(), key, storetypes.NewTransientStoreKey("transient_test"))
encCfg := moduletestutil.MakeTestEncodingConfig(module.AppModuleBasic{})
env := runtime.NewEnvironment(storeService, log.NewNopLogger())
ctrl := gomock.NewController(s.T())
accountKeeper := grouptestutil.NewMockAccountKeeper(ctrl)
@ -73,7 +74,7 @@ func (s *GenesisTestSuite) SetupTest() {
s.cdc = codec.NewProtoCodec(encCfg.InterfaceRegistry)
s.ctx = s.sdkCtx
s.keeper = keeper.NewKeeper(storeService, s.cdc, bApp.MsgServiceRouter(), accountKeeper, group.DefaultConfig())
s.keeper = keeper.NewKeeper(env, s.cdc, bApp.MsgServiceRouter(), accountKeeper, group.DefaultConfig())
}
func (s *GenesisTestSuite) TestInitExportGenesis() {

91
x/group/keeper/grpc_query.go
View File

@ -19,8 +19,7 @@ import (
var _ group.QueryServer = Keeper{}
// GroupInfo queries info about a group.
func (k Keeper) GroupInfo(goCtx context.Context, request *group.QueryGroupInfoRequest) (*group.QueryGroupInfoResponse, error) {
ctx := sdk.UnwrapSDKContext(goCtx)
func (k Keeper) GroupInfo(ctx context.Context, request *group.QueryGroupInfoRequest) (*group.QueryGroupInfoResponse, error) {
groupID := request.GroupId
groupInfo, err := k.getGroupInfo(ctx, groupID)
if err != nil {
@ -31,20 +30,19 @@ func (k Keeper) GroupInfo(goCtx context.Context, request *group.QueryGroupInfoRe
}
// getGroupInfo gets the group info of the given group id.
func (k Keeper) getGroupInfo(ctx sdk.Context, id uint64) (group.GroupInfo, error) {
func (k Keeper) getGroupInfo(ctx context.Context, id uint64) (group.GroupInfo, error) {
var obj group.GroupInfo
_, err := k.groupTable.GetOne(k.storeService.OpenKVStore(ctx), id, &obj)
_, err := k.groupTable.GetOne(k.environment.KVStoreService.OpenKVStore(ctx), id, &obj)
return obj, err
}
// GroupPolicyInfo queries info about a group policy.
func (k Keeper) GroupPolicyInfo(goCtx context.Context, request *group.QueryGroupPolicyInfoRequest) (*group.QueryGroupPolicyInfoResponse, error) {
func (k Keeper) GroupPolicyInfo(ctx context.Context, request *group.QueryGroupPolicyInfoRequest) (*group.QueryGroupPolicyInfoResponse, error) {
_, err := k.accKeeper.AddressCodec().StringToBytes(request.Address)
if err != nil {
return nil, err
}
ctx := sdk.UnwrapSDKContext(goCtx)
groupPolicyInfo, err := k.getGroupPolicyInfo(ctx, request.Address)
if err != nil {
return nil, errorsmod.Wrap(err, "group policy")
@ -54,14 +52,13 @@ func (k Keeper) GroupPolicyInfo(goCtx context.Context, request *group.QueryGroup
}
// getGroupPolicyInfo gets the group policy info of the given account address.
func (k Keeper) getGroupPolicyInfo(ctx sdk.Context, accountAddress string) (group.GroupPolicyInfo, error) {
func (k Keeper) getGroupPolicyInfo(ctx context.Context, accountAddress string) (group.GroupPolicyInfo, error) {
var obj group.GroupPolicyInfo
return obj, k.groupPolicyTable.GetOne(k.storeService.OpenKVStore(ctx), orm.PrimaryKey(&group.GroupPolicyInfo{Address: accountAddress}), &obj)
return obj, k.groupPolicyTable.GetOne(k.environment.KVStoreService.OpenKVStore(ctx), orm.PrimaryKey(&group.GroupPolicyInfo{Address: accountAddress}), &obj)
}
// GroupMembers queries all members of a group.
func (k Keeper) GroupMembers(goCtx context.Context, request *group.QueryGroupMembersRequest) (*group.QueryGroupMembersResponse, error) {
ctx := sdk.UnwrapSDKContext(goCtx)
func (k Keeper) GroupMembers(ctx context.Context, request *group.QueryGroupMembersRequest) (*group.QueryGroupMembersResponse, error) {
groupID := request.GroupId
it, err := k.getGroupMembers(ctx, groupID, request.Pagination)
if err != nil {
@ -81,13 +78,12 @@ func (k Keeper) GroupMembers(goCtx context.Context, request *group.QueryGroupMem
}
// getGroupMembers returns an iterator for the given group id and page request.
func (k Keeper) getGroupMembers(ctx sdk.Context, id uint64, pageRequest *query.PageRequest) (orm.Iterator, error) {
return k.groupMemberByGroupIndex.GetPaginated(k.storeService.OpenKVStore(ctx), id, pageRequest)
func (k Keeper) getGroupMembers(ctx context.Context, id uint64, pageRequest *query.PageRequest) (orm.Iterator, error) {
return k.groupMemberByGroupIndex.GetPaginated(k.environment.KVStoreService.OpenKVStore(ctx), id, pageRequest)
}
// GroupsByAdmin queries all groups where a given address is admin.
func (k Keeper) GroupsByAdmin(goCtx context.Context, request *group.QueryGroupsByAdminRequest) (*group.QueryGroupsByAdminResponse, error) {
ctx := sdk.UnwrapSDKContext(goCtx)
func (k Keeper) GroupsByAdmin(ctx context.Context, request *group.QueryGroupsByAdminRequest) (*group.QueryGroupsByAdminResponse, error) {
addr, err := k.accKeeper.AddressCodec().StringToBytes(request.Admin)
if err != nil {
return nil, err
@ -110,13 +106,12 @@ func (k Keeper) GroupsByAdmin(goCtx context.Context, request *group.QueryGroupsB
}
// getGroupsByAdmin returns an iterator for the given admin account address and page request.
func (k Keeper) getGroupsByAdmin(ctx sdk.Context, admin sdk.AccAddress, pageRequest *query.PageRequest) (orm.Iterator, error) {
return k.groupByAdminIndex.GetPaginated(k.storeService.OpenKVStore(ctx), admin.Bytes(), pageRequest)
func (k Keeper) getGroupsByAdmin(ctx context.Context, admin sdk.AccAddress, pageRequest *query.PageRequest) (orm.Iterator, error) {
return k.groupByAdminIndex.GetPaginated(k.environment.KVStoreService.OpenKVStore(ctx), admin.Bytes(), pageRequest)
}
// GroupPoliciesByGroup queries all groups policies of a given group.
func (k Keeper) GroupPoliciesByGroup(goCtx context.Context, request *group.QueryGroupPoliciesByGroupRequest) (*group.QueryGroupPoliciesByGroupResponse, error) {
ctx := sdk.UnwrapSDKContext(goCtx)
func (k Keeper) GroupPoliciesByGroup(ctx context.Context, request *group.QueryGroupPoliciesByGroupRequest) (*group.QueryGroupPoliciesByGroupResponse, error) {
groupID := request.GroupId
it, err := k.getGroupPoliciesByGroup(ctx, groupID, request.Pagination)
if err != nil {
@ -136,14 +131,13 @@ func (k Keeper) GroupPoliciesByGroup(goCtx context.Context, request *group.Query
}
// getGroupPoliciesByGroup returns an iterator for the given group id and page request.
func (k Keeper) getGroupPoliciesByGroup(ctx sdk.Context, id uint64, pageRequest *query.PageRequest) (orm.Iterator, error) {
return k.groupPolicyByGroupIndex.GetPaginated(k.storeService.OpenKVStore(ctx), id, pageRequest)
func (k Keeper) getGroupPoliciesByGroup(ctx context.Context, id uint64, pageRequest *query.PageRequest) (orm.Iterator, error) {
return k.groupPolicyByGroupIndex.GetPaginated(k.environment.KVStoreService.OpenKVStore(ctx), id, pageRequest)
}
// GroupPoliciesByAdmin queries all groups policies where a given address is
// admin.
func (k Keeper) GroupPoliciesByAdmin(goCtx context.Context, request *group.QueryGroupPoliciesByAdminRequest) (*group.QueryGroupPoliciesByAdminResponse, error) {
ctx := sdk.UnwrapSDKContext(goCtx)
func (k Keeper) GroupPoliciesByAdmin(ctx context.Context, request *group.QueryGroupPoliciesByAdminRequest) (*group.QueryGroupPoliciesByAdminResponse, error) {
addr, err := k.accKeeper.AddressCodec().StringToBytes(request.Admin)
if err != nil {
return nil, err
@ -166,13 +160,12 @@ func (k Keeper) GroupPoliciesByAdmin(goCtx context.Context, request *group.Query
}
// getGroupPoliciesByAdmin returns an iterator for the given admin account address and page request.
func (k Keeper) getGroupPoliciesByAdmin(ctx sdk.Context, admin sdk.AccAddress, pageRequest *query.PageRequest) (orm.Iterator, error) {
return k.groupPolicyByAdminIndex.GetPaginated(k.storeService.OpenKVStore(ctx), admin.Bytes(), pageRequest)
func (k Keeper) getGroupPoliciesByAdmin(ctx context.Context, admin sdk.AccAddress, pageRequest *query.PageRequest) (orm.Iterator, error) {
return k.groupPolicyByAdminIndex.GetPaginated(k.environment.KVStoreService.OpenKVStore(ctx), admin.Bytes(), pageRequest)
}
// Proposal queries a proposal.
func (k Keeper) Proposal(goCtx context.Context, request *group.QueryProposalRequest) (*group.QueryProposalResponse, error) {
ctx := sdk.UnwrapSDKContext(goCtx)
func (k Keeper) Proposal(ctx context.Context, request *group.QueryProposalRequest) (*group.QueryProposalResponse, error) {
proposalID := request.ProposalId
proposal, err := k.getProposal(ctx, proposalID)
if err != nil {
@ -183,8 +176,7 @@ func (k Keeper) Proposal(goCtx context.Context, request *group.QueryProposalRequ
}
// ProposalsByGroupPolicy queries all proposals of a group policy.
func (k Keeper) ProposalsByGroupPolicy(goCtx context.Context, request *group.QueryProposalsByGroupPolicyRequest) (*group.QueryProposalsByGroupPolicyResponse, error) {
ctx := sdk.UnwrapSDKContext(goCtx)
func (k Keeper) ProposalsByGroupPolicy(ctx context.Context, request *group.QueryProposalsByGroupPolicyRequest) (*group.QueryProposalsByGroupPolicyResponse, error) {
addr, err := k.accKeeper.AddressCodec().StringToBytes(request.Address)
if err != nil {
return nil, err
@ -207,22 +199,21 @@ func (k Keeper) ProposalsByGroupPolicy(goCtx context.Context, request *group.Que
}
// getProposalsByGroupPolicy returns an iterator for the given account address and page request.
func (k Keeper) getProposalsByGroupPolicy(ctx sdk.Context, account sdk.AccAddress, pageRequest *query.PageRequest) (orm.Iterator, error) {
return k.proposalByGroupPolicyIndex.GetPaginated(k.storeService.OpenKVStore(ctx), account.Bytes(), pageRequest)
func (k Keeper) getProposalsByGroupPolicy(ctx context.Context, account sdk.AccAddress, pageRequest *query.PageRequest) (orm.Iterator, error) {
return k.proposalByGroupPolicyIndex.GetPaginated(k.environment.KVStoreService.OpenKVStore(ctx), account.Bytes(), pageRequest)
}
// getProposal gets the proposal info of the given proposal id.
func (k Keeper) getProposal(ctx sdk.Context, proposalID uint64) (group.Proposal, error) {
func (k Keeper) getProposal(ctx context.Context, proposalID uint64) (group.Proposal, error) {
var p group.Proposal
if _, err := k.proposalTable.GetOne(k.storeService.OpenKVStore(ctx), proposalID, &p); err != nil {
if _, err := k.proposalTable.GetOne(k.environment.KVStoreService.OpenKVStore(ctx), proposalID, &p); err != nil {
return group.Proposal{}, errorsmod.Wrap(err, "load proposal")
}
return p, nil
}
// VoteByProposalVoter queries a vote given a voter and a proposal ID.
func (k Keeper) VoteByProposalVoter(goCtx context.Context, request *group.QueryVoteByProposalVoterRequest) (*group.QueryVoteByProposalVoterResponse, error) {
ctx := sdk.UnwrapSDKContext(goCtx)
func (k Keeper) VoteByProposalVoter(ctx context.Context, request *group.QueryVoteByProposalVoterRequest) (*group.QueryVoteByProposalVoterResponse, error) {
addr, err := k.accKeeper.AddressCodec().StringToBytes(request.Voter)
if err != nil {
return nil, err
@ -238,8 +229,7 @@ func (k Keeper) VoteByProposalVoter(goCtx context.Context, request *group.QueryV
}
// VotesByProposal queries all votes on a proposal.
func (k Keeper) VotesByProposal(goCtx context.Context, request *group.QueryVotesByProposalRequest) (*group.QueryVotesByProposalResponse, error) {
ctx := sdk.UnwrapSDKContext(goCtx)
func (k Keeper) VotesByProposal(ctx context.Context, request *group.QueryVotesByProposalRequest) (*group.QueryVotesByProposalResponse, error) {
proposalID := request.ProposalId
it, err := k.getVotesByProposal(ctx, proposalID, request.Pagination)
if err != nil {
@ -259,8 +249,7 @@ func (k Keeper) VotesByProposal(goCtx context.Context, request *group.QueryVotes
}
// VotesByVoter queries all votes of a voter.
func (k Keeper) VotesByVoter(goCtx context.Context, request *group.QueryVotesByVoterRequest) (*group.QueryVotesByVoterResponse, error) {
ctx := sdk.UnwrapSDKContext(goCtx)
func (k Keeper) VotesByVoter(ctx context.Context, request *group.QueryVotesByVoterRequest) (*group.QueryVotesByVoterResponse, error) {
addr, err := k.accKeeper.AddressCodec().StringToBytes(request.Voter)
if err != nil {
return nil, err
@ -283,18 +272,17 @@ func (k Keeper) VotesByVoter(goCtx context.Context, request *group.QueryVotesByV
}
// GroupsByMember queries all groups where the given address is a member of.
func (k Keeper) GroupsByMember(goCtx context.Context, request *group.QueryGroupsByMemberRequest) (*group.QueryGroupsByMemberResponse, error) {
func (k Keeper) GroupsByMember(ctx context.Context, request *group.QueryGroupsByMemberRequest) (*group.QueryGroupsByMemberResponse, error) {
if request == nil {
return nil, status.Errorf(codes.InvalidArgument, "empty request")
}
ctx := sdk.UnwrapSDKContext(goCtx)
member, err := k.accKeeper.AddressCodec().StringToBytes(request.Address)
if err != nil {
return nil, err
}
iter, err := k.groupMemberByMemberIndex.GetPaginated(k.storeService.OpenKVStore(ctx), member, request.Pagination)
iter, err := k.groupMemberByMemberIndex.GetPaginated(k.environment.KVStoreService.OpenKVStore(ctx), member, request.Pagination)
if err != nil {
return nil, err
}
@ -321,24 +309,23 @@ func (k Keeper) GroupsByMember(goCtx context.Context, request *group.QueryGroups
}
// getVote gets the vote info for the given proposal id and voter address.
func (k Keeper) getVote(ctx sdk.Context, proposalID uint64, voter sdk.AccAddress) (group.Vote, error) {
func (k Keeper) getVote(ctx context.Context, proposalID uint64, voter sdk.AccAddress) (group.Vote, error) {
var v group.Vote
return v, k.voteTable.GetOne(k.storeService.OpenKVStore(ctx), orm.PrimaryKey(&group.Vote{ProposalId: proposalID, Voter: voter.String()}), &v)
return v, k.voteTable.GetOne(k.environment.KVStoreService.OpenKVStore(ctx), orm.PrimaryKey(&group.Vote{ProposalId: proposalID, Voter: voter.String()}), &v)
}
// getVotesByProposal returns an iterator for the given proposal id and page request.
func (k Keeper) getVotesByProposal(ctx sdk.Context, proposalID uint64, pageRequest *query.PageRequest) (orm.Iterator, error) {
return k.voteByProposalIndex.GetPaginated(k.storeService.OpenKVStore(ctx), proposalID, pageRequest)
func (k Keeper) getVotesByProposal(ctx context.Context, proposalID uint64, pageRequest *query.PageRequest) (orm.Iterator, error) {
return k.voteByProposalIndex.GetPaginated(k.environment.KVStoreService.OpenKVStore(ctx), proposalID, pageRequest)
}
// getVotesByVoter returns an iterator for the given voter address and page request.
func (k Keeper) getVotesByVoter(ctx sdk.Context, voter sdk.AccAddress, pageRequest *query.PageRequest) (orm.Iterator, error) {
return k.voteByVoterIndex.GetPaginated(k.storeService.OpenKVStore(ctx), voter.Bytes(), pageRequest)
func (k Keeper) getVotesByVoter(ctx context.Context, voter sdk.AccAddress, pageRequest *query.PageRequest) (orm.Iterator, error) {
return k.voteByVoterIndex.GetPaginated(k.environment.KVStoreService.OpenKVStore(ctx), voter.Bytes(), pageRequest)
}
// TallyResult computes the live tally result of a proposal.
func (k Keeper) TallyResult(goCtx context.Context, request *group.QueryTallyResultRequest) (*group.QueryTallyResultResponse, error) {
ctx := sdk.UnwrapSDKContext(goCtx)
func (k Keeper) TallyResult(ctx context.Context, request *group.QueryTallyResultRequest) (*group.QueryTallyResultResponse, error) {
proposalID := request.ProposalId
proposal, err := k.getProposal(ctx, proposalID)
@ -366,10 +353,8 @@ func (k Keeper) TallyResult(goCtx context.Context, request *group.QueryTallyResu
}
// Groups returns all the groups present in the state.
func (k Keeper) Groups(goCtx context.Context, request *group.QueryGroupsRequest) (*group.QueryGroupsResponse, error) {
ctx := sdk.UnwrapSDKContext(goCtx)
it, err := k.groupTable.PrefixScan(k.storeService.OpenKVStore(ctx), 1, math.MaxUint64)
func (k Keeper) Groups(ctx context.Context, request *group.QueryGroupsRequest) (*group.QueryGroupsResponse, error) {
it, err := k.groupTable.PrefixScan(k.environment.KVStoreService.OpenKVStore(ctx), 1, math.MaxUint64)
if err != nil {
return nil, err
}

4
x/group/keeper/grpc_query_test.go
View File

@ -69,7 +69,9 @@ func initKeeper(t *testing.T) *fixture {
accountKeeper.EXPECT().NewAccount(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
accountKeeper.EXPECT().SetAccount(gomock.Any(), gomock.Any()).AnyTimes()
groupKeeper = groupkeeper.NewKeeper(storeService, encCfg.Codec, bApp.MsgServiceRouter(), accountKeeper, group.DefaultConfig())
env := runtime.NewEnvironment(storeService, log.NewNopLogger())
groupKeeper = groupkeeper.NewKeeper(env, encCfg.Codec, bApp.MsgServiceRouter(), accountKeeper, group.DefaultConfig())
queryHelper := baseapp.NewQueryServerTestHelper(ctx, interfaceRegistry)
group.RegisterQueryServer(queryHelper, groupKeeper)
queryClient := group.NewQueryClient(queryHelper)

2
x/group/keeper/invariants.go
View File

@ -26,7 +26,7 @@ func RegisterInvariants(ir sdk.InvariantRegistry, keeper Keeper) {
// GroupTotalWeightInvariant checks that group's TotalWeight must be equal to the sum of its members.
func GroupTotalWeightInvariant(keeper Keeper) sdk.Invariant {
return func(ctx sdk.Context) (string, bool) {
msg, broken := GroupTotalWeightInvariantHelper(ctx, keeper.storeService, keeper.groupTable, keeper.groupMemberByGroupIndex)
msg, broken := GroupTotalWeightInvariantHelper(ctx, keeper.environment.KVStoreService, keeper.groupTable, keeper.groupMemberByGroupIndex)
return sdk.FormatInvariant(group.ModuleName, weightInvariant, msg), broken
}
}

73
x/group/keeper/keeper.go
View File

@ -1,10 +1,11 @@
package keeper
import (
"context"
"fmt"
"time"
corestoretypes "cosmossdk.io/core/store"
"cosmossdk.io/core/appmodule"
errorsmod "cosmossdk.io/errors"
"cosmossdk.io/log"
"cosmossdk.io/x/group"
@ -46,9 +47,8 @@ const (
)
type Keeper struct {
storeService corestoretypes.KVStoreService
accKeeper group.AccountKeeper
environment appmodule.Environment
accKeeper group.AccountKeeper
// Group Table
groupTable orm.AutoUInt64Table
@ -83,12 +83,12 @@ type Keeper struct {
}
// NewKeeper creates a new group keeper.
func NewKeeper(storeService corestoretypes.KVStoreService, cdc codec.Codec, router baseapp.MessageRouter, accKeeper group.AccountKeeper, config group.Config) Keeper {
func NewKeeper(env appmodule.Environment, cdc codec.Codec, router baseapp.MessageRouter, accKeeper group.AccountKeeper, config group.Config) Keeper {
k := Keeper{
storeService: storeService,
router: router,
accKeeper: accKeeper,
cdc: cdc,
environment: env,
router: router,
accKeeper: accKeeper,
cdc: cdc,
}
/*
@ -236,24 +236,24 @@ func NewKeeper(storeService corestoretypes.KVStoreService, cdc codec.Codec, rout
}
// Logger returns a module-specific logger.
func (k Keeper) Logger(ctx sdk.Context) log.Logger {
return ctx.Logger().With("module", fmt.Sprintf("x/%s", group.ModuleName))
func (k Keeper) Logger() log.Logger {
return k.environment.Logger.With("module", fmt.Sprintf("x/%s", group.ModuleName))
}
// GetGroupSequence returns the current value of the group table sequence
func (k Keeper) GetGroupSequence(ctx sdk.Context) uint64 {
return k.groupTable.Sequence().CurVal(k.storeService.OpenKVStore(ctx))
return k.groupTable.Sequence().CurVal(k.environment.KVStoreService.OpenKVStore(ctx))
}
// GetGroupPolicySeq returns the current value of the group policy table sequence
func (k Keeper) GetGroupPolicySeq(ctx sdk.Context) uint64 {
return k.groupPolicySeq.CurVal(k.storeService.OpenKVStore(ctx))
return k.groupPolicySeq.CurVal(k.environment.KVStoreService.OpenKVStore(ctx))
}
// proposalsByVPEnd returns all proposals whose voting_period_end is after the `endTime` time argument.
func (k Keeper) proposalsByVPEnd(ctx sdk.Context, endTime time.Time) (proposals []group.Proposal, err error) {
func (k Keeper) proposalsByVPEnd(ctx context.Context, endTime time.Time) (proposals []group.Proposal, err error) {
timeBytes := sdk.FormatTimeBytes(endTime)
it, err := k.proposalsByVotingPeriodEnd.PrefixScan(k.storeService.OpenKVStore(ctx), nil, timeBytes)
it, err := k.proposalsByVotingPeriodEnd.PrefixScan(k.environment.KVStoreService.OpenKVStore(ctx), nil, timeBytes)
if err != nil {
return proposals, err
}
@ -284,19 +284,19 @@ func (k Keeper) proposalsByVPEnd(ctx sdk.Context, endTime time.Time) (proposals
}
// pruneProposal deletes a proposal from state.
func (k Keeper) pruneProposal(ctx sdk.Context, proposalID uint64) error {
err := k.proposalTable.Delete(k.storeService.OpenKVStore(ctx), proposalID)
func (k Keeper) pruneProposal(ctx context.Context, proposalID uint64) error {
err := k.proposalTable.Delete(k.environment.KVStoreService.OpenKVStore(ctx), proposalID)
if err != nil {
return err
}
k.Logger(ctx).Debug(fmt.Sprintf("Pruned proposal %d", proposalID))
k.Logger().Debug(fmt.Sprintf("Pruned proposal %d", proposalID))
return nil
}
// abortProposals iterates through all proposals by group policy index
// and marks submitted proposals as aborted.
func (k Keeper) abortProposals(ctx sdk.Context, groupPolicyAddr sdk.AccAddress) error {
func (k Keeper) abortProposals(ctx context.Context, groupPolicyAddr sdk.AccAddress) error {
proposals, err := k.proposalsByGroupPolicy(ctx, groupPolicyAddr)
if err != nil {
return err
@ -308,7 +308,7 @@ func (k Keeper) abortProposals(ctx sdk.Context, groupPolicyAddr sdk.AccAddress)
if proposalInfo.Status == group.PROPOSAL_STATUS_SUBMITTED {
proposalInfo.Status = group.PROPOSAL_STATUS_ABORTED
if err := k.proposalTable.Update(k.storeService.OpenKVStore(ctx), proposalInfo.Id, &proposalInfo); err != nil {
if err := k.proposalTable.Update(k.environment.KVStoreService.OpenKVStore(ctx), proposalInfo.Id, &proposalInfo); err != nil {
return err
}
}
@ -317,8 +317,8 @@ func (k Keeper) abortProposals(ctx sdk.Context, groupPolicyAddr sdk.AccAddress)
}
// proposalsByGroupPolicy returns all proposals for a given group policy.
func (k Keeper) proposalsByGroupPolicy(ctx sdk.Context, groupPolicyAddr sdk.AccAddress) ([]group.Proposal, error) {
proposalIt, err := k.proposalByGroupPolicyIndex.Get(k.storeService.OpenKVStore(ctx), groupPolicyAddr.Bytes())
func (k Keeper) proposalsByGroupPolicy(ctx context.Context, groupPolicyAddr sdk.AccAddress) ([]group.Proposal, error) {
proposalIt, err := k.proposalByGroupPolicyIndex.Get(k.environment.KVStoreService.OpenKVStore(ctx), groupPolicyAddr.Bytes())
if err != nil {
return nil, err
}
@ -341,7 +341,7 @@ func (k Keeper) proposalsByGroupPolicy(ctx sdk.Context, groupPolicyAddr sdk.AccA
}
// pruneVotes prunes all votes for a proposal from state.
func (k Keeper) pruneVotes(ctx sdk.Context, proposalID uint64) error {
func (k Keeper) pruneVotes(ctx context.Context, proposalID uint64) error {
votes, err := k.votesByProposal(ctx, proposalID)
if err != nil {
return err
@ -349,7 +349,7 @@ func (k Keeper) pruneVotes(ctx sdk.Context, proposalID uint64) error {
//nolint:gosec // "implicit memory aliasing in the for loop (because of the pointer on &v)"
for _, v := range votes {
err = k.voteTable.Delete(k.storeService.OpenKVStore(ctx), &v)
err = k.voteTable.Delete(k.environment.KVStoreService.OpenKVStore(ctx), &v)
if err != nil {
return err
}
@ -359,8 +359,8 @@ func (k Keeper) pruneVotes(ctx sdk.Context, proposalID uint64) error {
}
// votesByProposal returns all votes for a given proposal.
func (k Keeper) votesByProposal(ctx sdk.Context, proposalID uint64) ([]group.Vote, error) {
it, err := k.voteByProposalIndex.Get(k.storeService.OpenKVStore(ctx), proposalID)
func (k Keeper) votesByProposal(ctx context.Context, proposalID uint64) ([]group.Vote, error) {
it, err := k.voteByProposalIndex.Get(k.environment.KVStoreService.OpenKVStore(ctx), proposalID)
if err != nil {
return nil, err
}
@ -384,8 +384,9 @@ func (k Keeper) votesByProposal(ctx sdk.Context, proposalID uint64) ([]group.Vot
// PruneProposals prunes all proposals that are expired, i.e. whose
// `voting_period + max_execution_period` is greater than the current block
// time.
func (k Keeper) PruneProposals(ctx sdk.Context) error {
proposals, err := k.proposalsByVPEnd(ctx, ctx.HeaderInfo().Time.Add(-k.config.MaxExecutionPeriod))
func (k Keeper) PruneProposals(ctx context.Context, env appmodule.Environment) error {
endTime := env.HeaderService.GetHeaderInfo(ctx).Time.Add(-k.config.MaxExecutionPeriod)
proposals, err := k.proposalsByVPEnd(ctx, endTime)
if err != nil {
return nil
}
@ -397,12 +398,13 @@ func (k Keeper) PruneProposals(ctx sdk.Context) error {
return err
}
// Emit event for proposal finalized with its result
if err := ctx.EventManager().EmitTypedEvent(
if err := k.environment.EventService.EventManager(ctx).Emit(
&group.EventProposalPruned{
ProposalId: proposal.Id,
Status: proposal.Status,
TallyResult: &proposal.FinalTallyResult,
}); err != nil {
},
); err != nil {
return err
}
}
@ -413,8 +415,8 @@ func (k Keeper) PruneProposals(ctx sdk.Context) error {
// TallyProposalsAtVPEnd iterates over all proposals whose voting period
// has ended, tallies their votes, prunes them, and updates the proposal's
// `FinalTallyResult` field.
func (k Keeper) TallyProposalsAtVPEnd(ctx sdk.Context) error {
proposals, err := k.proposalsByVPEnd(ctx, ctx.HeaderInfo().Time)
func (k Keeper) TallyProposalsAtVPEnd(ctx context.Context, env appmodule.Environment) error {
proposals, err := k.proposalsByVPEnd(ctx, env.HeaderService.GetHeaderInfo(ctx).Time)
if err != nil {
return nil
}
@ -439,11 +441,12 @@ func (k Keeper) TallyProposalsAtVPEnd(ctx sdk.Context) error {
return err
}
// Emit event for proposal finalized with its result
if err := ctx.EventManager().EmitTypedEvent(
if err := k.environment.EventService.EventManager(ctx).Emit(
&group.EventProposalPruned{
ProposalId: proposal.Id,
Status: proposal.Status,
}); err != nil {
},
); err != nil {
return err
}
} else if proposal.Status == group.PROPOSAL_STATUS_SUBMITTED {
@ -451,7 +454,7 @@ func (k Keeper) TallyProposalsAtVPEnd(ctx sdk.Context) error {
return errorsmod.Wrap(err, "doTallyAndUpdate")
}
if err := k.proposalTable.Update(k.storeService.OpenKVStore(ctx), proposal.Id, &proposal); err != nil {
if err := k.proposalTable.Update(k.environment.KVStoreService.OpenKVStore(ctx), proposal.Id, &proposal); err != nil {
return errorsmod.Wrap(err, "proposal update")
}
}

24
x/group/keeper/keeper_test.go
View File

@ -9,6 +9,7 @@ import (
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/suite"
"cosmossdk.io/core/appmodule"
"cosmossdk.io/core/header"
"cosmossdk.io/log"
storetypes "cosmossdk.io/store/types"
@ -45,6 +46,7 @@ type TestSuite struct {
blockTime time.Time
bankKeeper *grouptestutil.MockBankKeeper
accountKeeper *grouptestutil.MockAccountKeeper
environment appmodule.Environment
}
func (s *TestSuite) SetupTest() {
@ -56,6 +58,8 @@ func (s *TestSuite) SetupTest() {
encCfg := moduletestutil.MakeTestEncodingConfig(module.AppModuleBasic{}, bank.AppModuleBasic{})
s.addrs = simtestutil.CreateIncrementalAccounts(6)
env := runtime.NewEnvironment(storeService, log.NewNopLogger())
// setup gomock and initialize some globally expected executions
ctrl := gomock.NewController(s.T())
s.accountKeeper = grouptestutil.NewMockAccountKeeper(ctrl)
@ -76,10 +80,12 @@ func (s *TestSuite) SetupTest() {
banktypes.RegisterMsgServer(bApp.MsgServiceRouter(), s.bankKeeper)
config := group.DefaultConfig()
s.groupKeeper = keeper.NewKeeper(storeService, encCfg.Codec, bApp.MsgServiceRouter(), s.accountKeeper, config)
s.groupKeeper = keeper.NewKeeper(env, encCfg.Codec, bApp.MsgServiceRouter(), s.accountKeeper, config)
s.ctx = testCtx.Ctx.WithHeaderInfo(header.Info{Time: s.blockTime})
s.sdkCtx = sdk.UnwrapSDKContext(s.ctx)
s.environment = env
// Initial group, group policy and balance setup
members := []group.MemberRequest{
{Address: s.addrs[4].String(), Weight: "1"}, {Address: s.addrs[1].String(), Weight: "2"},
@ -271,7 +277,7 @@ func (s *TestSuite) TestProposalsByVPEnd() {
s.Run(msg, func() {
pID := spec.preRun(s.sdkCtx)
err := module.EndBlocker(spec.newCtx, s.groupKeeper)
err := s.groupKeeper.EndBlocker(spec.newCtx)
s.Require().NoError(err)
resp, err := s.groupKeeper.Proposal(spec.newCtx, &group.QueryProposalRequest{
ProposalId: pID,
@ -333,7 +339,7 @@ func (s *TestSuite) TestPruneProposals() {
s.sdkCtx = s.sdkCtx.WithHeaderInfo(header.Info{Time: s.sdkCtx.HeaderInfo().Time.Add(expirationTime)})
// Prune Expired Proposals
err = s.groupKeeper.PruneProposals(s.sdkCtx)
err = s.groupKeeper.PruneProposals(s.sdkCtx, s.environment)
s.Require().NoError(err)
postPrune, err := s.groupKeeper.Proposal(s.ctx, &queryProposal)
s.Require().Nil(postPrune)
@ -456,9 +462,9 @@ func (s *TestSuite) TestTallyProposalsAtVPEnd() {
s.Require().Equal("1", result.Tally.YesCount)
s.Require().NoError(err)
s.Require().NoError(s.groupKeeper.TallyProposalsAtVPEnd(ctx))
s.Require().NoError(s.groupKeeper.TallyProposalsAtVPEnd(ctx, s.environment))
s.NotPanics(func() {
err := module.EndBlocker(ctx, s.groupKeeper)
err := s.groupKeeper.EndBlocker(ctx)
if err != nil {
panic(err)
}
@ -523,9 +529,9 @@ func (s *TestSuite) TestTallyProposalsAtVPEnd_GroupMemberLeaving() {
ctx := s.sdkCtx.WithHeaderInfo(header.Info{Time: s.sdkCtx.HeaderInfo().Time.Add(votingPeriod + 1)})
// Tally the result. This saves the tally result to state.
s.Require().NoError(s.groupKeeper.TallyProposalsAtVPEnd(ctx))
s.Require().NoError(s.groupKeeper.TallyProposalsAtVPEnd(ctx, s.environment))
s.NotPanics(func() {
err := module.EndBlocker(ctx, s.groupKeeper)
err := s.groupKeeper.EndBlocker(ctx)
if err != nil {
panic(err)
}
@ -538,9 +544,9 @@ func (s *TestSuite) TestTallyProposalsAtVPEnd_GroupMemberLeaving() {
})
s.Require().NoError(err)
s.Require().NoError(s.groupKeeper.TallyProposalsAtVPEnd(ctx))
s.Require().NoError(s.groupKeeper.TallyProposalsAtVPEnd(ctx, s.environment))
s.NotPanics(func() {
err := module.EndBlocker(ctx, s.groupKeeper)
err := s.groupKeeper.EndBlocker(ctx)
if err != nil {
panic(err)
}

2
x/group/keeper/migrations.go
View File

@ -20,7 +20,7 @@ func NewMigrator(keeper Keeper) Migrator {
func (m Migrator) Migrate1to2(ctx context.Context) error {
return v2.Migrate(
ctx,
m.keeper.storeService,
m.keeper.environment.KVStoreService,
m.keeper.accKeeper,
m.keeper.groupPolicySeq,
m.keeper.groupPolicyTable,

118
x/group/keeper/msg_server.go
View File

@ -26,7 +26,7 @@ var _ group.MsgServer = Keeper{}
// Tracking issues https://github.com/cosmos/cosmos-sdk/issues/9054, https://github.com/cosmos/cosmos-sdk/discussions/9072
const gasCostPerIteration = uint64(20)
func (k Keeper) CreateGroup(goCtx context.Context, msg *group.MsgCreateGroup) (*group.MsgCreateGroupResponse, error) {
func (k Keeper) CreateGroup(ctx context.Context, msg *group.MsgCreateGroup) (*group.MsgCreateGroupResponse, error) {
if _, err := k.accKeeper.AddressCodec().StringToBytes(msg.Admin); err != nil {
return nil, errorsmod.Wrapf(sdkerrors.ErrInvalidAddress, "invalid admin address: %s", msg.Admin)
}
@ -61,15 +61,14 @@ func (k Keeper) CreateGroup(goCtx context.Context, msg *group.MsgCreateGroup) (*
}
// Create a new group in the groupTable.
ctx := sdk.UnwrapSDKContext(goCtx)
kvStore := k.storeService.OpenKVStore(goCtx)
kvStore := k.environment.KVStoreService.OpenKVStore(ctx)
groupInfo := &group.GroupInfo{
Id: k.groupTable.Sequence().PeekNextVal(kvStore),
Admin: msg.Admin,
Metadata: msg.Metadata,
Version: 1,
TotalWeight: totalWeight.String(),
CreatedAt: ctx.HeaderInfo().Time,
CreatedAt: k.environment.HeaderService.GetHeaderInfo(ctx).Time,
}
groupID, err := k.groupTable.Create(kvStore, groupInfo)
if err != nil {
@ -84,7 +83,7 @@ func (k Keeper) CreateGroup(goCtx context.Context, msg *group.MsgCreateGroup) (*
Address: m.Address,
Weight: m.Weight,
Metadata: m.Metadata,
AddedAt: ctx.HeaderInfo().Time,
AddedAt: k.environment.HeaderService.GetHeaderInfo(ctx).Time,
},
})
if err != nil {
@ -92,14 +91,14 @@ func (k Keeper) CreateGroup(goCtx context.Context, msg *group.MsgCreateGroup) (*
}
}
if err := ctx.EventManager().EmitTypedEvent(&group.EventCreateGroup{GroupId: groupID}); err != nil {
if err := k.environment.EventService.EventManager(ctx).Emit(&group.EventCreateGroup{GroupId: groupID}); err != nil {
return nil, err
}
return &group.MsgCreateGroupResponse{GroupId: groupID}, nil
}
func (k Keeper) UpdateGroupMembers(goCtx context.Context, msg *group.MsgUpdateGroupMembers) (*group.MsgUpdateGroupMembersResponse, error) {
func (k Keeper) UpdateGroupMembers(ctx context.Context, msg *group.MsgUpdateGroupMembers) (*group.MsgUpdateGroupMembersResponse, error) {
if msg.GroupId == 0 {
return nil, errorsmod.Wrap(errors.ErrEmpty, "group id")
}
@ -112,8 +111,7 @@ func (k Keeper) UpdateGroupMembers(goCtx context.Context, msg *group.MsgUpdateGr
return nil, errorsmod.Wrap(err, "members")
}
ctx := sdk.UnwrapSDKContext(goCtx)
kvStore := k.storeService.OpenKVStore(goCtx)
kvStore := k.environment.KVStoreService.OpenKVStore(ctx)
action := func(g *group.GroupInfo) error {
totalWeight, err := math.NewNonNegativeDecFromString(g.TotalWeight)
if err != nil {
@ -191,7 +189,7 @@ func (k Keeper) UpdateGroupMembers(goCtx context.Context, msg *group.MsgUpdateGr
return errorsmod.Wrap(err, "add member")
}
} else { // else handle create.
groupMember.Member.AddedAt = ctx.HeaderInfo().Time
groupMember.Member.AddedAt = k.environment.HeaderService.GetHeaderInfo(ctx).Time
if err := k.groupMemberTable.Create(kvStore, &groupMember); err != nil {
return errorsmod.Wrap(err, "add member")
}
@ -220,7 +218,7 @@ func (k Keeper) UpdateGroupMembers(goCtx context.Context, msg *group.MsgUpdateGr
return &group.MsgUpdateGroupMembersResponse{}, nil
}
func (k Keeper) UpdateGroupAdmin(goCtx context.Context, msg *group.MsgUpdateGroupAdmin) (*group.MsgUpdateGroupAdminResponse, error) {
func (k Keeper) UpdateGroupAdmin(ctx context.Context, msg *group.MsgUpdateGroupAdmin) (*group.MsgUpdateGroupAdminResponse, error) {
if msg.GroupId == 0 {
return nil, errorsmod.Wrap(errors.ErrEmpty, "group id")
}
@ -237,8 +235,7 @@ func (k Keeper) UpdateGroupAdmin(goCtx context.Context, msg *group.MsgUpdateGrou
return nil, errorsmod.Wrap(sdkerrors.ErrInvalidAddress, "new admin address")
}
ctx := sdk.UnwrapSDKContext(goCtx)
kvStore := k.storeService.OpenKVStore(goCtx)
kvStore := k.environment.KVStoreService.OpenKVStore(ctx)
action := func(g *group.GroupInfo) error {
g.Admin = msg.NewAdmin
g.Version++
@ -253,7 +250,7 @@ func (k Keeper) UpdateGroupAdmin(goCtx context.Context, msg *group.MsgUpdateGrou
return &group.MsgUpdateGroupAdminResponse{}, nil
}
func (k Keeper) UpdateGroupMetadata(goCtx context.Context, msg *group.MsgUpdateGroupMetadata) (*group.MsgUpdateGroupMetadataResponse, error) {
func (k Keeper) UpdateGroupMetadata(ctx context.Context, msg *group.MsgUpdateGroupMetadata) (*group.MsgUpdateGroupMetadataResponse, error) {
if msg.GroupId == 0 {
return nil, errorsmod.Wrap(errors.ErrEmpty, "group id")
}
@ -266,8 +263,7 @@ func (k Keeper) UpdateGroupMetadata(goCtx context.Context, msg *group.MsgUpdateG
return nil, errorsmod.Wrap(sdkerrors.ErrInvalidAddress, "admin address")
}
ctx := sdk.UnwrapSDKContext(goCtx)
kvStore := k.storeService.OpenKVStore(goCtx)
kvStore := k.environment.KVStoreService.OpenKVStore(ctx)
action := func(g *group.GroupInfo) error {
g.Metadata = msg.Metadata
g.Version++
@ -329,7 +325,7 @@ func (k Keeper) CreateGroupWithPolicy(ctx context.Context, msg *group.MsgCreateG
return &group.MsgCreateGroupWithPolicyResponse{GroupId: groupID, GroupPolicyAddress: groupPolicyRes.Address}, nil
}
func (k Keeper) CreateGroupPolicy(goCtx context.Context, msg *group.MsgCreateGroupPolicy) (*group.MsgCreateGroupPolicyResponse, error) {
func (k Keeper) CreateGroupPolicy(ctx context.Context, msg *group.MsgCreateGroupPolicy) (*group.MsgCreateGroupPolicyResponse, error) {
if msg.GroupId == 0 {
return nil, errorsmod.Wrap(errors.ErrEmpty, "group id")
}
@ -352,7 +348,6 @@ func (k Keeper) CreateGroupPolicy(goCtx context.Context, msg *group.MsgCreateGro
return nil, errorsmod.Wrap(err, "request admin")
}
ctx := sdk.UnwrapSDKContext(goCtx)
groupInfo, err := k.getGroupInfo(ctx, msg.GetGroupID())
if err != nil {
return nil, err
@ -372,7 +367,7 @@ func (k Keeper) CreateGroupPolicy(goCtx context.Context, msg *group.MsgCreateGro
return nil, err
}
kvStore := k.storeService.OpenKVStore(goCtx)
kvStore := k.environment.KVStoreService.OpenKVStore(ctx)
// Generate account address of group policy.
var accountAddr sdk.AccAddress
@ -413,7 +408,7 @@ func (k Keeper) CreateGroupPolicy(goCtx context.Context, msg *group.MsgCreateGro
msg.GetMetadata(),
1,
policy,
ctx.HeaderInfo().Time,
k.environment.HeaderService.GetHeaderInfo(ctx).Time,
)
if err != nil {
return nil, err
@ -423,14 +418,14 @@ func (k Keeper) CreateGroupPolicy(goCtx context.Context, msg *group.MsgCreateGro
return nil, errorsmod.Wrap(err, "could not create group policy")
}
if err := ctx.EventManager().EmitTypedEvent(&group.EventCreateGroupPolicy{Address: accountAddr.String()}); err != nil {
if err := k.environment.EventService.EventManager(ctx).Emit(&group.EventCreateGroupPolicy{Address: accountAddr.String()}); err != nil {
return nil, err
}
return &group.MsgCreateGroupPolicyResponse{Address: accountAddr.String()}, nil
}
func (k Keeper) UpdateGroupPolicyAdmin(goCtx context.Context, msg *group.MsgUpdateGroupPolicyAdmin) (*group.MsgUpdateGroupPolicyAdminResponse, error) {
func (k Keeper) UpdateGroupPolicyAdmin(ctx context.Context, msg *group.MsgUpdateGroupPolicyAdmin) (*group.MsgUpdateGroupPolicyAdminResponse, error) {
if strings.EqualFold(msg.Admin, msg.NewAdmin) {
return nil, errorsmod.Wrap(errors.ErrInvalid, "new and old admin are same")
}
@ -439,8 +434,7 @@ func (k Keeper) UpdateGroupPolicyAdmin(goCtx context.Context, msg *group.MsgUpda
return nil, errorsmod.Wrap(sdkerrors.ErrInvalidAddress, "new admin address")
}
ctx := sdk.UnwrapSDKContext(goCtx)
kvStore := k.storeService.OpenKVStore(goCtx)
kvStore := k.environment.KVStoreService.OpenKVStore(ctx)
action := func(groupPolicy *group.GroupPolicyInfo) error {
groupPolicy.Admin = msg.NewAdmin
groupPolicy.Version++
@ -454,7 +448,7 @@ func (k Keeper) UpdateGroupPolicyAdmin(goCtx context.Context, msg *group.MsgUpda
return &group.MsgUpdateGroupPolicyAdminResponse{}, nil
}
func (k Keeper) UpdateGroupPolicyDecisionPolicy(goCtx context.Context, msg *group.MsgUpdateGroupPolicyDecisionPolicy) (*group.MsgUpdateGroupPolicyDecisionPolicyResponse, error) {
func (k Keeper) UpdateGroupPolicyDecisionPolicy(ctx context.Context, msg *group.MsgUpdateGroupPolicyDecisionPolicy) (*group.MsgUpdateGroupPolicyDecisionPolicyResponse, error) {
policy, err := msg.GetDecisionPolicy()
if err != nil {
return nil, errorsmod.Wrap(err, "decision policy")
@ -464,8 +458,7 @@ func (k Keeper) UpdateGroupPolicyDecisionPolicy(goCtx context.Context, msg *grou
return nil, errorsmod.Wrap(err, "decision policy")
}
ctx := sdk.UnwrapSDKContext(goCtx)
kvStore := k.storeService.OpenKVStore(goCtx)
kvStore := k.environment.KVStoreService.OpenKVStore(ctx)
action := func(groupPolicy *group.GroupPolicyInfo) error {
groupInfo, err := k.getGroupInfo(ctx, groupPolicy.GroupId)
if err != nil {
@ -493,10 +486,9 @@ func (k Keeper) UpdateGroupPolicyDecisionPolicy(goCtx context.Context, msg *grou
return &group.MsgUpdateGroupPolicyDecisionPolicyResponse{}, nil
}
func (k Keeper) UpdateGroupPolicyMetadata(goCtx context.Context, msg *group.MsgUpdateGroupPolicyMetadata) (*group.MsgUpdateGroupPolicyMetadataResponse, error) {
ctx := sdk.UnwrapSDKContext(goCtx)
func (k Keeper) UpdateGroupPolicyMetadata(ctx context.Context, msg *group.MsgUpdateGroupPolicyMetadata) (*group.MsgUpdateGroupPolicyMetadataResponse, error) {
metadata := msg.GetMetadata()
kvStore := k.storeService.OpenKVStore(goCtx)
kvStore := k.environment.KVStoreService.OpenKVStore(ctx)
action := func(groupPolicy *group.GroupPolicyInfo) error {
groupPolicy.Metadata = metadata
@ -516,7 +508,7 @@ func (k Keeper) UpdateGroupPolicyMetadata(goCtx context.Context, msg *group.MsgU
return &group.MsgUpdateGroupPolicyMetadataResponse{}, nil
}
func (k Keeper) SubmitProposal(goCtx context.Context, msg *group.MsgSubmitProposal) (*group.MsgSubmitProposalResponse, error) {
func (k Keeper) SubmitProposal(ctx context.Context, msg *group.MsgSubmitProposal) (*group.MsgSubmitProposalResponse, error) {
if len(msg.Proposers) == 0 {
return nil, errorsmod.Wrap(errors.ErrEmpty, "proposers")
}
@ -568,8 +560,7 @@ func (k Keeper) SubmitProposal(goCtx context.Context, msg *group.MsgSubmitPropos
return nil, err
}
ctx := sdk.UnwrapSDKContext(goCtx)
kvStore := k.storeService.OpenKVStore(goCtx)
kvStore := k.environment.KVStoreService.OpenKVStore(ctx)
policyAcc, err := k.getGroupPolicyInfo(ctx, msg.GroupPolicyAddress)
if err != nil {
return nil, errorsmod.Wrapf(err, "load group policy: %s", msg.GroupPolicyAddress)
@ -607,12 +598,12 @@ func (k Keeper) SubmitProposal(goCtx context.Context, msg *group.MsgSubmitPropos
GroupPolicyAddress: msg.GroupPolicyAddress,
Metadata: msg.Metadata,
Proposers: msg.Proposers,
SubmitTime: ctx.HeaderInfo().Time,
SubmitTime: k.environment.HeaderService.GetHeaderInfo(ctx).Time,
GroupVersion: groupInfo.Version,
GroupPolicyVersion: policyAcc.Version,
Status: group.PROPOSAL_STATUS_SUBMITTED,
ExecutorResult: group.PROPOSAL_EXECUTOR_RESULT_NOT_RUN,
VotingPeriodEnd: ctx.HeaderInfo().Time.Add(policy.GetVotingPeriod()), // The voting window begins as soon as the proposal is submitted.
VotingPeriodEnd: k.environment.HeaderService.GetHeaderInfo(ctx).Time.Add(policy.GetVotingPeriod()), // The voting window begins as soon as the proposal is submitted.
FinalTallyResult: group.DefaultTallyResult(),
Title: msg.Title,
Summary: msg.Summary,
@ -627,7 +618,7 @@ func (k Keeper) SubmitProposal(goCtx context.Context, msg *group.MsgSubmitPropos
return nil, errorsmod.Wrap(err, "create proposal")
}
if err := ctx.EventManager().EmitTypedEvent(&group.EventSubmitProposal{ProposalId: id}); err != nil {
if err := k.environment.EventService.EventManager(ctx).Emit(&group.EventSubmitProposal{ProposalId: id}); err != nil {
return nil, err
}
@ -635,7 +626,7 @@ func (k Keeper) SubmitProposal(goCtx context.Context, msg *group.MsgSubmitPropos
if msg.Exec == group.Exec_EXEC_TRY {
// Consider proposers as Yes votes
for _, proposer := range msg.Proposers {
ctx.GasMeter().ConsumeGas(gasCostPerIteration, "vote on proposal")
k.environment.GasService.GetGasMeter(ctx).Consume(gasCostPerIteration, "vote on proposal")
_, err = k.Vote(ctx, &group.MsgVote{
ProposalId: id,
Voter: proposer,
@ -661,7 +652,7 @@ func (k Keeper) SubmitProposal(goCtx context.Context, msg *group.MsgSubmitPropos
return &group.MsgSubmitProposalResponse{ProposalId: id}, nil
}
func (k Keeper) WithdrawProposal(goCtx context.Context, msg *group.MsgWithdrawProposal) (*group.MsgWithdrawProposalResponse, error) {
func (k Keeper) WithdrawProposal(ctx context.Context, msg *group.MsgWithdrawProposal) (*group.MsgWithdrawProposalResponse, error) {
if msg.ProposalId == 0 {
return nil, errorsmod.Wrap(errors.ErrEmpty, "proposal id")
}
@ -670,8 +661,7 @@ func (k Keeper) WithdrawProposal(goCtx context.Context, msg *group.MsgWithdrawPr
return nil, errorsmod.Wrapf(sdkerrors.ErrInvalidAddress, "invalid group policy admin / proposer address: %s", msg.Address)
}
ctx := sdk.UnwrapSDKContext(goCtx)
kvStore := k.storeService.OpenKVStore(goCtx)
kvStore := k.environment.KVStoreService.OpenKVStore(ctx)
proposal, err := k.getProposal(ctx, msg.ProposalId)
if err != nil {
return nil, err
@ -697,14 +687,14 @@ func (k Keeper) WithdrawProposal(goCtx context.Context, msg *group.MsgWithdrawPr
return nil, err
}
if err := ctx.EventManager().EmitTypedEvent(&group.EventWithdrawProposal{ProposalId: msg.ProposalId}); err != nil {
if err := k.environment.EventService.EventManager(ctx).Emit(&group.EventWithdrawProposal{ProposalId: msg.ProposalId}); err != nil {
return nil, err
}
return &group.MsgWithdrawProposalResponse{}, nil
}
func (k Keeper) Vote(goCtx context.Context, msg *group.MsgVote) (*group.MsgVoteResponse, error) {
func (k Keeper) Vote(ctx context.Context, msg *group.MsgVote) (*group.MsgVoteResponse, error) {
if msg.ProposalId == 0 {
return nil, errorsmod.Wrap(errors.ErrEmpty, "proposal id")
}
@ -726,8 +716,7 @@ func (k Keeper) Vote(goCtx context.Context, msg *group.MsgVote) (*group.MsgVoteR
return nil, errorsmod.Wrapf(sdkerrors.ErrInvalidAddress, "invalid voter address: %s", msg.Voter)
}
ctx := sdk.UnwrapSDKContext(goCtx)
kvStore := k.storeService.OpenKVStore(goCtx)
kvStore := k.environment.KVStoreService.OpenKVStore(ctx)
proposal, err := k.getProposal(ctx, msg.ProposalId)
if err != nil {
return nil, err
@ -738,7 +727,7 @@ func (k Keeper) Vote(goCtx context.Context, msg *group.MsgVote) (*group.MsgVoteR
return nil, errorsmod.Wrap(errors.ErrInvalid, "proposal not open for voting")
}
if ctx.HeaderInfo().Time.After(proposal.VotingPeriodEnd) {
if k.environment.HeaderService.GetHeaderInfo(ctx).Time.After(proposal.VotingPeriodEnd) {
return nil, errorsmod.Wrap(errors.ErrExpired, "voting period has ended already")
}
@ -762,7 +751,7 @@ func (k Keeper) Vote(goCtx context.Context, msg *group.MsgVote) (*group.MsgVoteR
Voter: msg.Voter,
Option: msg.Option,
Metadata: msg.Metadata,
SubmitTime: ctx.HeaderInfo().Time,
SubmitTime: k.environment.HeaderService.GetHeaderInfo(ctx).Time,
}
// The ORM will return an error if the vote already exists,
@ -771,7 +760,7 @@ func (k Keeper) Vote(goCtx context.Context, msg *group.MsgVote) (*group.MsgVoteR
return nil, errorsmod.Wrap(err, "store vote")
}
if err := ctx.EventManager().EmitTypedEvent(&group.EventVote{ProposalId: msg.ProposalId}); err != nil {
if err := k.environment.EventService.EventManager(ctx).Emit(&group.EventVote{ProposalId: msg.ProposalId}); err != nil {
return nil, err
}
@ -789,7 +778,7 @@ func (k Keeper) Vote(goCtx context.Context, msg *group.MsgVote) (*group.MsgVoteR
// doTallyAndUpdate performs a tally, and, if the tally result is final, then:
// - updates the proposal's `Status` and `FinalTallyResult` fields,
// - prune all the votes.
func (k Keeper) doTallyAndUpdate(ctx sdk.Context, p *group.Proposal, groupInfo group.GroupInfo, policyInfo group.GroupPolicyInfo) error {
func (k Keeper) doTallyAndUpdate(ctx context.Context, p *group.Proposal, groupInfo group.GroupInfo, policyInfo group.GroupPolicyInfo) error {
policy, err := policyInfo.GetDecisionPolicy()
if err != nil {
return err
@ -807,7 +796,7 @@ func (k Keeper) doTallyAndUpdate(ctx sdk.Context, p *group.Proposal, groupInfo g
// If the result was final (i.e. enough votes to pass) or if the voting
// period ended, then we consider the proposal as final.
if isFinal := result.Final || ctx.HeaderInfo().Time.After(p.VotingPeriodEnd); isFinal {
if isFinal := result.Final || k.environment.HeaderService.GetHeaderInfo(ctx).Time.After(p.VotingPeriodEnd); isFinal {
if err := k.pruneVotes(ctx, p.Id); err != nil {
return err
}
@ -873,7 +862,7 @@ func (k Keeper) Exec(goCtx context.Context, msg *group.MsgExec) (*group.MsgExecR
if results, err := k.doExecuteMsgs(cacheCtx, k.router, proposal, addr, decisionPolicy); err != nil {
proposal.ExecutorResult = group.PROPOSAL_EXECUTOR_RESULT_FAILURE
logs = fmt.Sprintf("proposal execution failed on proposal %d, because of error %s", proposal.Id, err.Error())
k.Logger(ctx).Info("proposal execution failed", "cause", err, "proposalID", proposal.Id)
k.Logger().Info("proposal execution failed", "cause", err, "proposalID", proposal.Id)
} else {
proposal.ExecutorResult = group.PROPOSAL_EXECUTOR_RESULT_SUCCESS
flush()
@ -893,7 +882,7 @@ func (k Keeper) Exec(goCtx context.Context, msg *group.MsgExec) (*group.MsgExecR
}
// Emit event for proposal finalized with its result
if err := ctx.EventManager().EmitTypedEvent(
if err := k.environment.EventService.EventManager(ctx).Emit(
&group.EventProposalPruned{
ProposalId: proposal.Id,
Status: proposal.Status,
@ -902,13 +891,13 @@ func (k Keeper) Exec(goCtx context.Context, msg *group.MsgExec) (*group.MsgExecR
return nil, err
}
} else {
store := k.storeService.OpenKVStore(goCtx)
store := k.environment.KVStoreService.OpenKVStore(ctx)
if err := k.proposalTable.Update(store, proposal.Id, &proposal); err != nil {
return nil, err
}
}
if err := ctx.EventManager().EmitTypedEvent(&group.EventExec{
if err := k.environment.EventService.EventManager(ctx).Emit(&group.EventExec{
ProposalId: proposal.Id,
Logs: logs,
Result: proposal.ExecutorResult,
@ -922,7 +911,7 @@ func (k Keeper) Exec(goCtx context.Context, msg *group.MsgExec) (*group.MsgExecR
}
// LeaveGroup implements the MsgServer/LeaveGroup method.
func (k Keeper) LeaveGroup(goCtx context.Context, msg *group.MsgLeaveGroup) (*group.MsgLeaveGroupResponse, error) {
func (k Keeper) LeaveGroup(ctx context.Context, msg *group.MsgLeaveGroup) (*group.MsgLeaveGroupResponse, error) {
if msg.GroupId == 0 {
return nil, errorsmod.Wrap(errors.ErrEmpty, "group-id")
}
@ -932,7 +921,6 @@ func (k Keeper) LeaveGroup(goCtx context.Context, msg *group.MsgLeaveGroup) (*gr
return nil, errorsmod.Wrap(err, "group member")
}
ctx := sdk.UnwrapSDKContext(goCtx)
groupInfo, err := k.getGroupInfo(ctx, msg.GroupId)
if err != nil {
return nil, errorsmod.Wrap(err, "group")
@ -961,7 +949,7 @@ func (k Keeper) LeaveGroup(goCtx context.Context, msg *group.MsgLeaveGroup) (*gr
return nil, err
}
kvStore := k.storeService.OpenKVStore(goCtx)
kvStore := k.environment.KVStoreService.OpenKVStore(ctx)
// delete group member in the groupMemberTable.
if err := k.groupMemberTable.Delete(kvStore, gm); err != nil {
@ -980,7 +968,7 @@ func (k Keeper) LeaveGroup(goCtx context.Context, msg *group.MsgLeaveGroup) (*gr
return nil, err
}
if err := ctx.EventManager().EmitTypedEvent(&group.EventLeaveGroup{
if err := k.environment.EventService.EventManager(ctx).Emit(&group.EventLeaveGroup{
GroupId: msg.GroupId,
Address: msg.Address,
}); err != nil {
@ -990,8 +978,8 @@ func (k Keeper) LeaveGroup(goCtx context.Context, msg *group.MsgLeaveGroup) (*gr
return &group.MsgLeaveGroupResponse{}, nil
}
func (k Keeper) getGroupMember(ctx sdk.Context, member *group.GroupMember) (*group.GroupMember, error) {
kvStore := k.storeService.OpenKVStore(ctx)
func (k Keeper) getGroupMember(ctx context.Context, member *group.GroupMember) (*group.GroupMember, error) {
kvStore := k.environment.KVStoreService.OpenKVStore(ctx)
var groupMember group.GroupMember
switch err := k.groupMemberTable.GetOne(kvStore,
orm.PrimaryKey(member), &groupMember); {
@ -1013,7 +1001,7 @@ type (
// doUpdateGroupPolicy first makes sure that the group policy admin initiated the group policy update,
// before performing the group policy update and emitting an event.
func (k Keeper) doUpdateGroupPolicy(ctx sdk.Context, reqGroupPolicy, reqAdmin string, action groupPolicyActionFn, note string) error {
func (k Keeper) doUpdateGroupPolicy(ctx context.Context, reqGroupPolicy, reqAdmin string, action groupPolicyActionFn, note string) error {
groupPolicyAddr, err := k.accKeeper.AddressCodec().StringToBytes(reqGroupPolicy)
if err != nil {
return errorsmod.Wrap(err, "group policy address")
@ -1042,7 +1030,7 @@ func (k Keeper) doUpdateGroupPolicy(ctx sdk.Context, reqGroupPolicy, reqAdmin st
return err
}
if err = ctx.EventManager().EmitTypedEvent(&group.EventUpdateGroupPolicy{Address: groupPolicyInfo.Address}); err != nil {
if err = k.environment.EventService.EventManager(ctx).Emit(&group.EventUpdateGroupPolicy{Address: groupPolicyInfo.Address}); err != nil {
return err
}
@ -1051,7 +1039,7 @@ func (k Keeper) doUpdateGroupPolicy(ctx sdk.Context, reqGroupPolicy, reqAdmin st
// doUpdateGroup first makes sure that the group admin initiated the group update,
// before performing the group update and emitting an event.
func (k Keeper) doUpdateGroup(ctx sdk.Context, groupID uint64, reqGroupAdmin string, action actionFn, errNote string) error {
func (k Keeper) doUpdateGroup(ctx context.Context, groupID uint64, reqGroupAdmin string, action actionFn, errNote string) error {
groupInfo, err := k.getGroupInfo(ctx, groupID)
if err != nil {
return err
@ -1065,7 +1053,7 @@ func (k Keeper) doUpdateGroup(ctx sdk.Context, groupID uint64, reqGroupAdmin str
return errorsmod.Wrap(err, errNote)
}
if err := ctx.EventManager().EmitTypedEvent(&group.EventUpdateGroup{GroupId: groupID}); err != nil {
if err := k.environment.EventService.EventManager(ctx).Emit(&group.EventUpdateGroup{GroupId: groupID}); err != nil {
return err
}
@ -1074,8 +1062,8 @@ func (k Keeper) doUpdateGroup(ctx sdk.Context, groupID uint64, reqGroupAdmin str
// validateDecisionPolicies loops through all decision policies from the group,
// and calls each of their Validate() method.
func (k Keeper) validateDecisionPolicies(ctx sdk.Context, g group.GroupInfo) error {
kvStore := k.storeService.OpenKVStore(ctx)
func (k Keeper) validateDecisionPolicies(ctx context.Context, g group.GroupInfo) error {
kvStore := k.environment.KVStoreService.OpenKVStore(ctx)
it, err := k.groupPolicyByGroupIndex.Get(kvStore, g.Id)
if err != nil {
return err

7
x/group/keeper/msg_server_test.go
View File

@ -12,6 +12,8 @@ import (
"github.com/golang/mock/gomock"
"cosmossdk.io/core/header"
"cosmossdk.io/log"
storetypes "cosmossdk.io/store/types"
banktypes "cosmossdk.io/x/bank/types"
"cosmossdk.io/x/group"
"cosmossdk.io/x/group/internal/math"
@ -19,6 +21,7 @@ import (
minttypes "cosmossdk.io/x/mint/types"
"github.com/cosmos/cosmos-sdk/codec/address"
"github.com/cosmos/cosmos-sdk/runtime"
simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
"github.com/cosmos/cosmos-sdk/testutil/testdata"
sdk "github.com/cosmos/cosmos-sdk/types"
@ -2024,10 +2027,12 @@ func (s *TestSuite) TestWithdrawProposal() {
postRun: func(sdkCtx sdk.Context) {
resp, err := s.groupKeeper.Proposal(s.ctx, &group.QueryProposalRequest{ProposalId: proposalID})
s.Require().NoError(err)
key := storetypes.NewKVStoreKey(group.StoreKey)
env := runtime.NewEnvironment(runtime.NewKVStoreService(key), log.NewNopLogger())
vpe := resp.Proposal.VotingPeriodEnd
timeDiff := vpe.Sub(s.sdkCtx.HeaderInfo().Time)
ctxVPE := sdkCtx.WithHeaderInfo(header.Info{Time: s.sdkCtx.HeaderInfo().Time.Add(timeDiff).Add(time.Second * 1)})
s.Require().NoError(s.groupKeeper.TallyProposalsAtVPEnd(ctxVPE))
s.Require().NoError(s.groupKeeper.TallyProposalsAtVPEnd(ctxVPE, env))
events := ctxVPE.EventManager().ABCIEvents()
s.Require().True(eventTypeFound(events, EventProposalPruned))

1
x/group/keeper/proposal_executor.go
View File

@ -16,6 +16,7 @@ import (
// doExecuteMsgs routes the messages to the registered handlers. Messages are limited to those that require no authZ or
// by the account of group policy only. Otherwise this gives access to other peoples accounts as the sdk middlewares are bypassed
// TODO: use context.Context and env bundler service once baseapp's MsgServiceHandler is migrated to use context.Context
func (s Keeper) doExecuteMsgs(ctx sdk.Context, router baseapp.MessageRouter, proposal group.Proposal, groupPolicyAcc sdk.AccAddress, decisionPolicy group.DecisionPolicy) ([]sdk.Result, error) {
// Ensure it's not too early to execute the messages.
minExecutionDate := proposal.SubmitTime.Add(decisionPolicy.GetMinExecutionPeriod())

7
x/group/keeper/tally.go
View File

@ -1,18 +1,19 @@
package keeper
import (
"context"
errorsmod "cosmossdk.io/errors"
"cosmossdk.io/x/group"
"cosmossdk.io/x/group/errors"
"cosmossdk.io/x/group/internal/orm"
sdk "github.com/cosmos/cosmos-sdk/types"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
)
// Tally is a function that tallies a proposal by iterating through its votes,
// and returns the tally result without modifying the proposal or any state.
func (k Keeper) Tally(ctx sdk.Context, p group.Proposal, groupID uint64) (group.TallyResult, error) {
func (k Keeper) Tally(ctx context.Context, p group.Proposal, groupID uint64) (group.TallyResult, error) {
// If proposal has already been tallied and updated, then its status is
// accepted/rejected, in which case we just return the previously stored result.
//
@ -22,7 +23,7 @@ func (k Keeper) Tally(ctx sdk.Context, p group.Proposal, groupID uint64) (group.
return p.FinalTallyResult, nil
}
kvStore := k.storeService.OpenKVStore(ctx)
kvStore := k.environment.KVStoreService.OpenKVStore(ctx)
it, err := k.voteByProposalIndex.Get(kvStore, p.Id)
if err != nil {

17
x/group/module/abci.go
View File

@ -1,17 +0,0 @@
package module
import (
"cosmossdk.io/x/group/keeper"
sdk "github.com/cosmos/cosmos-sdk/types"
)
// EndBlocker called at every block, updates proposal's `FinalTallyResult` and
// prunes expired proposals.
func EndBlocker(ctx sdk.Context, k keeper.Keeper) error {
if err := k.TallyProposalsAtVPEnd(ctx); err != nil {
return err
}
return k.PruneProposals(ctx)
}

5
x/group/module/depinject.go
View File

@ -3,7 +3,6 @@ package module
import (
modulev1 "cosmossdk.io/api/cosmos/group/module/v1"
"cosmossdk.io/core/appmodule"
"cosmossdk.io/core/store"
"cosmossdk.io/depinject"
"cosmossdk.io/depinject/appconfig"
"cosmossdk.io/x/group"
@ -30,7 +29,7 @@ type GroupInputs struct {
depinject.In
Config *modulev1.Module
StoreService store.KVStoreService
Environment appmodule.Environment
Cdc codec.Codec
AccountKeeper group.AccountKeeper
BankKeeper group.BankKeeper
@ -46,7 +45,7 @@ type GroupOutputs struct {
}
func ProvideModule(in GroupInputs) GroupOutputs {
k := keeper.NewKeeper(in.StoreService,
k := keeper.NewKeeper(in.Environment,
in.Cdc,
in.MsgServiceRouter,
in.AccountKeeper,

3
x/group/module/module.go
View File

@ -148,8 +148,7 @@ func (AppModule) ConsensusVersion() uint64 { return ConsensusVersion }
// EndBlock implements the group module's EndBlock.
func (am AppModule) EndBlock(ctx context.Context) error {
c := sdk.UnwrapSDKContext(ctx)
return EndBlocker(c, am.keeper)
return am.keeper.EndBlocker(ctx)
}
// GenerateGenesisState creates a randomized GenState of the group module.