refactor: x/group proposal tally at the end of voting period

x/group/keeper/keeper.go

@@ -10,6 +10,7 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	authmiddleware "github.com/cosmos/cosmos-sdk/x/auth/middleware"
 	"github.com/cosmos/cosmos-sdk/x/group"
+	"github.com/cosmos/cosmos-sdk/x/group/errors"
 	"github.com/cosmos/cosmos-sdk/x/group/internal/orm"
 )
 
@@ -35,6 +36,7 @@ const (
 	ProposalTableSeqPrefix           byte = 0x31
 	ProposalByGroupPolicyIndexPrefix byte = 0x32
 	ProposalByProposerIndexPrefix    byte = 0x33
+	ProposalsByVotingPeriodEndPrefix byte = 0x34
 
 	// Vote Table
 	VoteTablePrefix           byte = 0x40
@@ -66,6 +68,7 @@ type Keeper struct {
 	proposalTable              orm.AutoUInt64Table
 	proposalByGroupPolicyIndex orm.Index
 	proposalByProposerIndex    orm.Index
+	proposalsByVotingPeriodEnd orm.Index
 
 	// Vote Table
 	voteTable           orm.PrimaryKeyTable
@@ -181,6 +184,13 @@ func NewKeeper(storeKey storetypes.StoreKey, cdc codec.Codec, router *authmiddle
 	if err != nil {
 		panic(err.Error())
 	}
+	k.proposalsByVotingPeriodEnd, err = orm.NewIndex(proposalTable, ProposalsByVotingPeriodEndPrefix, func(value interface{}) ([]interface{}, error) {
+		votingPeriodEnd := value.(*group.Proposal).VotingPeriodEnd
+		return []interface{}{sdk.FormatTimeBytes(votingPeriodEnd)}, nil
+	}, []byte{})
+	if err != nil {
+		panic(err.Error())
+	}
 	k.proposalTable = *proposalTable
 
 	// Vote Table
@@ -230,3 +240,62 @@ func (k Keeper) MaxMetadataLength() uint64 { return k.config.MaxMetadataLen }
 func (k Keeper) GetGroupSequence(ctx sdk.Context) uint64 {
 	return k.groupTable.Sequence().CurVal(ctx.KVStore(k.key))
 }
+
+func (k Keeper) iterateProposalsByVPEnd(ctx sdk.Context, cb func(proposal group.Proposal) (bool, error)) error {
+	timeBytes := sdk.FormatTimeBytes(ctx.BlockTime())
+	it, err := k.proposalsByVotingPeriodEnd.PrefixScan(ctx.KVStore(k.key), nil, timeBytes)
+
+	if err != nil {
+		return err
+	}
+	defer it.Close()
+
+	var proposal group.Proposal
+	for {
+		_, err := it.LoadNext(&proposal)
+		if errors.ErrORMIteratorDone.Is(err) {
+			break
+		}
+		if err != nil {
+			return err
+		}
+
+		stop, err := cb(proposal)
+		if err != nil {
+			return err
+		}
+		if stop {
+			break
+		}
+	}
+
+	return nil
+}
+
+func (k Keeper) UpdateTallyOfVPEndProposals(ctx sdk.Context) error {
+	k.iterateProposalsByVPEnd(ctx, func(proposal group.Proposal) (bool, error) {
+
+		policyInfo, err := k.getGroupPolicyInfo(ctx, proposal.Address)
+		if err != nil {
+			return true, err
+		}
+
+		electorate, err := k.getGroupInfo(ctx, policyInfo.GroupId)
+		if err != nil {
+			return true, err
+		}
+
+		err = k.doTallyAndUpdate(ctx, &proposal, electorate, policyInfo)
+		if err != nil {
+			return true, err
+		}
+
+		if err := k.proposalTable.Update(ctx.KVStore(k.key), proposal.Id, &proposal); err != nil {
+			return true, err
+		}
+
+		return false, nil
+	})
+
+	return nil
+}

x/group/keeper/keeper_test.go

@@ -20,6 +20,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/group"
 	"github.com/cosmos/cosmos-sdk/x/group/internal/math"
 	"github.com/cosmos/cosmos-sdk/x/group/keeper"
+	"github.com/cosmos/cosmos-sdk/x/group/module"
 )
 
 type TestSuite struct {
@@ -31,6 +32,7 @@ type TestSuite struct {
 	addrs           []sdk.AccAddress
 	groupID         uint64
 	groupPolicyAddr sdk.AccAddress
+	policy          group.DecisionPolicy
 	keeper          keeper.Keeper
 	blockTime       time.Time
 }
@@ -72,6 +74,7 @@ func (s *TestSuite) SetupTest() {
 	s.Require().NoError(err)
 	policyRes, err := s.keeper.CreateGroupPolicy(s.ctx, policyReq)
 	s.Require().NoError(err)
+	s.policy = policy
 	addr, err := sdk.AccAddressFromBech32(policyRes.Address)
 	s.Require().NoError(err)
 	s.groupPolicyAddr = addr
@@ -2443,6 +2446,138 @@ func (s *TestSuite) TestExecProposal() {
 	}
 }
 
+func (s *TestSuite) TestProposalsByVPEnd() {
+	addrs := s.addrs
+	addr2 := addrs[1]
+	groupPolicy := s.groupPolicyAddr
+
+	votingPeriod := s.policy.GetVotingPeriod()
+	ctx := s.sdkCtx
+	now := time.Now()
+
+	msgSend := &banktypes.MsgSend{
+		FromAddress: s.groupPolicyAddr.String(),
+		ToAddress:   addr2.String(),
+		Amount:      sdk.Coins{sdk.NewInt64Coin("test", 100)},
+	}
+
+	proposers := []string{addr2.String()}
+
+	specs := map[string]struct {
+		preRun            func(sdkCtx sdk.Context) uint64
+		proposalId        uint64
+		admin             string
+		expErrMsg         string
+		newCtx            sdk.Context
+		tallyRes          group.TallyResult
+		expStatus         group.ProposalStatus
+		expExecutorResult group.ProposalResult
+	}{
+		"tally updated after voting power end": {
+			preRun: func(sdkCtx sdk.Context) uint64 {
+				return submitProposal(sdkCtx, s, []sdk.Msg{msgSend}, proposers)
+			},
+			admin:             proposers[0],
+			newCtx:            ctx.WithBlockTime(now.Add(votingPeriod).Add(time.Hour)),
+			tallyRes:          group.DefaultTallyResult(),
+			expStatus:         group.PROPOSAL_STATUS_SUBMITTED,
+			expExecutorResult: group.PROPOSAL_RESULT_UNFINALIZED,
+		},
+		"tally within voting period": {
+			preRun: func(sdkCtx sdk.Context) uint64 {
+				return submitProposal(s.ctx, s, []sdk.Msg{msgSend}, proposers)
+			},
+			admin:             proposers[0],
+			newCtx:            ctx,
+			tallyRes:          group.DefaultTallyResult(),
+			expStatus:         group.PROPOSAL_STATUS_SUBMITTED,
+			expExecutorResult: group.PROPOSAL_RESULT_UNFINALIZED,
+		},
+		"tally within voting period(with votes)": {
+			preRun: func(sdkCtx sdk.Context) uint64 {
+				return submitProposalAndVote(s.ctx, s, []sdk.Msg{msgSend}, proposers, group.VOTE_OPTION_YES)
+			},
+			admin:             proposers[0],
+			newCtx:            ctx,
+			tallyRes:          group.DefaultTallyResult(),
+			expStatus:         group.PROPOSAL_STATUS_SUBMITTED,
+			expExecutorResult: group.PROPOSAL_RESULT_UNFINALIZED,
+		},
+		"tally after voting period(with votes)": {
+			preRun: func(sdkCtx sdk.Context) uint64 {
+				return submitProposalAndVote(s.ctx, s, []sdk.Msg{msgSend}, proposers, group.VOTE_OPTION_YES)
+			},
+			admin:  proposers[0],
+			newCtx: ctx.WithBlockTime(now.Add(votingPeriod).Add(time.Hour)),
+			tallyRes: group.TallyResult{
+				YesCount:        "2",
+				NoCount:         "0",
+				NoWithVetoCount: "0",
+				AbstainCount:    "0",
+			},
+			expStatus:         group.PROPOSAL_STATUS_CLOSED,
+			expExecutorResult: group.PROPOSAL_RESULT_ACCEPTED,
+		},
+		"tally of closed proposal": {
+			preRun: func(sdkCtx sdk.Context) uint64 {
+				pId := submitProposal(s.ctx, s, []sdk.Msg{msgSend}, proposers)
+				_, err := s.keeper.WithdrawProposal(s.ctx, &group.MsgWithdrawProposal{
+					ProposalId: pId,
+					Address:    groupPolicy.String(),
+				})
+
+				s.Require().NoError(err)
+				return pId
+			},
+			admin:             proposers[0],
+			newCtx:            ctx,
+			tallyRes:          group.DefaultTallyResult(),
+			expStatus:         group.PROPOSAL_STATUS_WITHDRAWN,
+			expExecutorResult: group.PROPOSAL_RESULT_UNFINALIZED,
+		},
+		"tally of closed proposal (with votes)": {
+			preRun: func(sdkCtx sdk.Context) uint64 {
+				pId := submitProposalAndVote(s.ctx, s, []sdk.Msg{msgSend}, proposers, group.VOTE_OPTION_YES)
+				_, err := s.keeper.WithdrawProposal(s.ctx, &group.MsgWithdrawProposal{
+					ProposalId: pId,
+					Address:    groupPolicy.String(),
+				})
+
+				s.Require().NoError(err)
+				return pId
+			},
+			admin:             proposers[0],
+			newCtx:            ctx,
+			tallyRes:          group.DefaultTallyResult(),
+			expStatus:         group.PROPOSAL_STATUS_WITHDRAWN,
+			expExecutorResult: group.PROPOSAL_RESULT_UNFINALIZED,
+		},
+	}
+
+	for msg, spec := range specs {
+		spec := spec
+		s.Run(msg, func() {
+			pId := spec.preRun(s.sdkCtx)
+
+			module.EndBlocker(spec.newCtx, s.keeper)
+			resp, err := s.keeper.Proposal(spec.newCtx, &group.QueryProposalRequest{
+				ProposalId: pId,
+			})
+
+			if spec.expErrMsg != "" {
+				s.Require().Error(err)
+				s.Require().Contains(err.Error(), spec.expErrMsg)
+				return
+			}
+
+			s.Require().NoError(err)
+			s.Require().Equal(resp.GetProposal().FinalTallyResult, spec.tallyRes)
+			s.Require().Equal(resp.GetProposal().Status, spec.expStatus)
+			s.Require().Equal(resp.GetProposal().Result, spec.expExecutorResult)
+		})
+	}
+}
+
 func (s *TestSuite) TestLeaveGroup() {
 	addrs := simapp.AddTestAddrsIncremental(s.app, s.sdkCtx, 7, sdk.NewInt(3000000))
 	admin1 := addrs[0]

x/group/module/abci.go

@@ -0,0 +1,12 @@
+package module
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/group/keeper"
+)
+
+func EndBlocker(ctx sdk.Context, k keeper.Keeper) {
+	if err := k.UpdateTallyOfVPEndProposals(ctx); err != nil {
+		panic(err)
+	}
+}