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

x/group/keeper/grpc_query.go

@@ -35,15 +35,15 @@ func (q Keeper) getGroupInfo(ctx sdk.Context, id uint64) (group.GroupInfo, error
 
 func (q Keeper) GroupPolicyInfo(goCtx context.Context, request *group.QueryGroupPolicyInfoRequest) (*group.QueryGroupPolicyInfoResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
-	groupPolicyInfo, err := q.getGroupPolicyInfo(ctx, request.Address)
+	groupPolicyInfo, err := q.GetGroupPolicyInfo(ctx, request.Address)
 	if err != nil {
 		return nil, err
 	}
 
 	return &group.QueryGroupPolicyInfoResponse{Info: &groupPolicyInfo}, nil
 }
 
-func (q Keeper) getGroupPolicyInfo(ctx sdk.Context, accountAddress string) (group.GroupPolicyInfo, error) {
+func (q Keeper) GetGroupPolicyInfo(ctx sdk.Context, accountAddress string) (group.GroupPolicyInfo, error) {
 	var obj group.GroupPolicyInfo
 	return obj, q.groupPolicyTable.GetOne(ctx.KVStore(q.key), orm.PrimaryKey(&group.GroupPolicyInfo{Address: accountAddress}), &obj)
 }
@@ -356,3 +356,48 @@ func (q Keeper) Tally(ctx sdk.Context, p group.Proposal, groupId uint64) (group.
 
 	return tallyResult, nil
 }
+
+func (q Keeper) UpdateTallyOfVPEndProposals(ctx sdk.Context) error {
+	timeBytes := sdk.FormatTimeBytes(ctx.BlockTime())
+	it, _ := q.ProposalsByVotingPeriodEnd.Get(ctx.KVStore(q.key), sdk.PrefixEndBytes(timeBytes))
+
+	var proposal group.Proposal
+	for {
+		_, err := it.LoadNext(&proposal)
+		if errors.ErrORMIteratorDone.Is(err) {
+			break
+		}
+		if err != nil {
+			return err
+		}
+
+		// check whether the proposal can be tallied.
+		if proposal.Status != group.PROPOSAL_STATUS_SUBMITTED {
+			continue
+		}
+
+		var policyInfo group.GroupPolicyInfo
+		if policyInfo, err = q.GetGroupPolicyInfo(ctx, proposal.Address); err != nil {
+			return err
+		}
+
+		tallyRes, err := q.Tally(ctx, proposal, policyInfo.GroupId)
+		if err != nil {
+			return err
+		}
+
+		proposal.FinalTallyResult = tallyRes
+		storeUpdates := func() error {
+			if err := q.proposalTable.Update(ctx.KVStore(q.key), proposal.Id, &proposal); err != nil {
+				return err
+			}
+			return nil
+		}
+
+		if err := storeUpdates(); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

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,38 @@ 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) UpdateProposal(ctx sdk.Context, proposal group.Proposal) error {
+	if err := k.proposalTable.Update(ctx.KVStore(k.key), proposal.Id, &proposal); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (k Keeper) IterateVPEndProposals(ctx sdk.Context, timeBytes []byte, cb func(proposal group.Proposal) (stop bool)) error {
+	it, _ := k.ProposalsByVotingPeriodEnd.Get(ctx.KVStore(k.key), sdk.PrefixEndBytes(timeBytes))
+	var proposal group.Proposal
+	defer it.Close()
+
+	for {
+		_, err := it.LoadNext(&proposal)
+		if errors.ErrORMIteratorDone.Is(err) {
+			break
+		}
+		if err != nil {
+			return err
+		}
+
+		// check whether the proposal status is submitted.
+		if proposal.Status != group.PROPOSAL_STATUS_SUBMITTED {
+			continue
+		}
+
+		if cb(proposal) {
+			break
+		}
+	}
+
+	return nil
+}

x/group/keeper/msg_server.go

@@ -439,7 +439,7 @@ func (k Keeper) SubmitProposal(goCtx context.Context, req *group.MsgSubmitPropos
 		return nil, err
 	}
 
-	policyAcc, err := k.getGroupPolicyInfo(ctx, req.Address)
+	policyAcc, err := k.GetGroupPolicyInfo(ctx, req.Address)
 	if err != nil {
 		return nil, sdkerrors.Wrap(err, "load group policy")
 	}
@@ -547,7 +547,7 @@ func (k Keeper) WithdrawProposal(goCtx context.Context, req *group.MsgWithdrawPr
 	}
 
 	var policyInfo group.GroupPolicyInfo
-	if policyInfo, err = k.getGroupPolicyInfo(ctx, proposal.Address); err != nil {
+	if policyInfo, err = k.GetGroupPolicyInfo(ctx, proposal.Address); err != nil {
 		return nil, sdkerrors.Wrap(err, "load group policy")
 	}
 
@@ -618,7 +618,7 @@ func (k Keeper) Vote(goCtx context.Context, req *group.MsgVote) (*group.MsgVoteR
 	var policyInfo group.GroupPolicyInfo
 
 	// Ensure that group policy hasn't been modified since the proposal submission.
-	if policyInfo, err = k.getGroupPolicyInfo(ctx, proposal.Address); err != nil {
+	if policyInfo, err = k.GetGroupPolicyInfo(ctx, proposal.Address); err != nil {
 		return nil, sdkerrors.Wrap(err, "load group policy")
 	}
 	if proposal.GroupPolicyVersion != policyInfo.Version {
@@ -722,7 +722,7 @@ func (k Keeper) Exec(goCtx context.Context, req *group.MsgExec) (*group.MsgExecR
 	}
 
 	var policyInfo group.GroupPolicyInfo
-	if policyInfo, err = k.getGroupPolicyInfo(ctx, proposal.Address); err != nil {
+	if policyInfo, err = k.GetGroupPolicyInfo(ctx, proposal.Address); err != nil {
 		return nil, sdkerrors.Wrap(err, "load group policy")
 	}
 
@@ -804,7 +804,7 @@ type groupPolicyActionFn func(m *group.GroupPolicyInfo) error
 // 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, groupPolicy string, admin string, action groupPolicyActionFn, note string) error {
-	groupPolicyInfo, err := k.getGroupPolicyInfo(ctx, groupPolicy)
+	groupPolicyInfo, err := k.GetGroupPolicyInfo(ctx, groupPolicy)
 	if err != nil {
 		return sdkerrors.Wrap(err, "load group policy")
 	}

x/group/module/abci.go

@@ -0,0 +1,33 @@
+package module
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/group"
+	"github.com/cosmos/cosmos-sdk/x/group/keeper"
+)
+
+func EndBlocker(ctx sdk.Context, k keeper.Keeper) {
+	updateTallyOfVPEndProposals(ctx, k)
+}
+
+func updateTallyOfVPEndProposals(ctx sdk.Context, k keeper.Keeper) error {
+	k.IterateVPEndProposals(ctx, sdk.FormatTimeBytes(ctx.BlockTime()), func(proposal group.Proposal) (stop bool) {
+
+		policyInfo, err := k.GetGroupPolicyInfo(ctx, proposal.Address)
+		if err != nil {
+			return true
+		}
+
+		tallyRes, err := k.Tally(ctx, proposal, policyInfo.GroupId)
+		if err != nil {
+			return true
+		}
+
+		proposal.FinalTallyResult = tallyRes
+		err = k.UpdateProposal(ctx, proposal)
+
+		return err != nil
+	})
+
+	return nil
+}