cosmos-sdk/x/group/keeper/keeper.go

424 lines
13 KiB
Go

package keeper
import (
"fmt"
"time"
"github.com/tendermint/tendermint/libs/log"
"github.com/cosmos/cosmos-sdk/baseapp"
"github.com/cosmos/cosmos-sdk/codec"
storetypes "github.com/cosmos/cosmos-sdk/store/types"
sdk "github.com/cosmos/cosmos-sdk/types"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
"github.com/cosmos/cosmos-sdk/x/group"
"github.com/cosmos/cosmos-sdk/x/group/errors"
"github.com/cosmos/cosmos-sdk/x/group/internal/orm"
)
const (
// Group Table
GroupTablePrefix byte = 0x0
GroupTableSeqPrefix byte = 0x1
GroupByAdminIndexPrefix byte = 0x2
// Group Member Table
GroupMemberTablePrefix byte = 0x10
GroupMemberByGroupIndexPrefix byte = 0x11
GroupMemberByMemberIndexPrefix byte = 0x12
// Group Policy Table
GroupPolicyTablePrefix byte = 0x20
GroupPolicyTableSeqPrefix byte = 0x21
GroupPolicyByGroupIndexPrefix byte = 0x22
GroupPolicyByAdminIndexPrefix byte = 0x23
// Proposal Table
ProposalTablePrefix byte = 0x30
ProposalTableSeqPrefix byte = 0x31
ProposalByGroupPolicyIndexPrefix byte = 0x32
ProposalsByVotingPeriodEndPrefix byte = 0x33
// Vote Table
VoteTablePrefix byte = 0x40
VoteByProposalIndexPrefix byte = 0x41
VoteByVoterIndexPrefix byte = 0x42
)
type Keeper struct {
key storetypes.StoreKey
accKeeper group.AccountKeeper
// Group Table
groupTable orm.AutoUInt64Table
groupByAdminIndex orm.Index
// Group Member Table
groupMemberTable orm.PrimaryKeyTable
groupMemberByGroupIndex orm.Index
groupMemberByMemberIndex orm.Index
// Group Policy Table
groupPolicySeq orm.Sequence
groupPolicyTable orm.PrimaryKeyTable
groupPolicyByGroupIndex orm.Index
groupPolicyByAdminIndex orm.Index
// Proposal Table
proposalTable orm.AutoUInt64Table
proposalByGroupPolicyIndex orm.Index
proposalsByVotingPeriodEnd orm.Index
// Vote Table
voteTable orm.PrimaryKeyTable
voteByProposalIndex orm.Index
voteByVoterIndex orm.Index
router *baseapp.MsgServiceRouter
config group.Config
}
// NewKeeper creates a new group keeper.
func NewKeeper(storeKey storetypes.StoreKey, cdc codec.Codec, router *baseapp.MsgServiceRouter, accKeeper group.AccountKeeper, config group.Config) Keeper {
k := Keeper{
key: storeKey,
router: router,
accKeeper: accKeeper,
}
groupTable, err := orm.NewAutoUInt64Table([2]byte{GroupTablePrefix}, GroupTableSeqPrefix, &group.GroupInfo{}, cdc)
if err != nil {
panic(err.Error())
}
k.groupByAdminIndex, err = orm.NewIndex(groupTable, GroupByAdminIndexPrefix, func(val interface{}) ([]interface{}, error) {
addr, err := sdk.AccAddressFromBech32(val.(*group.GroupInfo).Admin)
if err != nil {
return nil, err
}
return []interface{}{addr.Bytes()}, nil
}, []byte{})
if err != nil {
panic(err.Error())
}
k.groupTable = *groupTable
// Group Member Table
groupMemberTable, err := orm.NewPrimaryKeyTable([2]byte{GroupMemberTablePrefix}, &group.GroupMember{}, cdc)
if err != nil {
panic(err.Error())
}
k.groupMemberByGroupIndex, err = orm.NewIndex(groupMemberTable, GroupMemberByGroupIndexPrefix, func(val interface{}) ([]interface{}, error) {
group := val.(*group.GroupMember).GroupId
return []interface{}{group}, nil
}, group.GroupMember{}.GroupId)
if err != nil {
panic(err.Error())
}
k.groupMemberByMemberIndex, err = orm.NewIndex(groupMemberTable, GroupMemberByMemberIndexPrefix, func(val interface{}) ([]interface{}, error) {
memberAddr := val.(*group.GroupMember).Member.Address
addr, err := sdk.AccAddressFromBech32(memberAddr)
if err != nil {
return nil, err
}
return []interface{}{addr.Bytes()}, nil
}, []byte{})
if err != nil {
panic(err.Error())
}
k.groupMemberTable = *groupMemberTable
// Group Policy Table
k.groupPolicySeq = orm.NewSequence(GroupPolicyTableSeqPrefix)
groupPolicyTable, err := orm.NewPrimaryKeyTable([2]byte{GroupPolicyTablePrefix}, &group.GroupPolicyInfo{}, cdc)
if err != nil {
panic(err.Error())
}
k.groupPolicyByGroupIndex, err = orm.NewIndex(groupPolicyTable, GroupPolicyByGroupIndexPrefix, func(value interface{}) ([]interface{}, error) {
return []interface{}{value.(*group.GroupPolicyInfo).GroupId}, nil
}, group.GroupPolicyInfo{}.GroupId)
if err != nil {
panic(err.Error())
}
k.groupPolicyByAdminIndex, err = orm.NewIndex(groupPolicyTable, GroupPolicyByAdminIndexPrefix, func(value interface{}) ([]interface{}, error) {
admin := value.(*group.GroupPolicyInfo).Admin
addr, err := sdk.AccAddressFromBech32(admin)
if err != nil {
return nil, err
}
return []interface{}{addr.Bytes()}, nil
}, []byte{})
if err != nil {
panic(err.Error())
}
k.groupPolicyTable = *groupPolicyTable
// Proposal Table
proposalTable, err := orm.NewAutoUInt64Table([2]byte{ProposalTablePrefix}, ProposalTableSeqPrefix, &group.Proposal{}, cdc)
if err != nil {
panic(err.Error())
}
k.proposalByGroupPolicyIndex, err = orm.NewIndex(proposalTable, ProposalByGroupPolicyIndexPrefix, func(value interface{}) ([]interface{}, error) {
account := value.(*group.Proposal).GroupPolicyAddress
addr, err := sdk.AccAddressFromBech32(account)
if err != nil {
return nil, err
}
return []interface{}{addr.Bytes()}, nil
}, []byte{})
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
voteTable, err := orm.NewPrimaryKeyTable([2]byte{VoteTablePrefix}, &group.Vote{}, cdc)
if err != nil {
panic(err.Error())
}
k.voteByProposalIndex, err = orm.NewIndex(voteTable, VoteByProposalIndexPrefix, func(value interface{}) ([]interface{}, error) {
return []interface{}{value.(*group.Vote).ProposalId}, nil
}, group.Vote{}.ProposalId)
if err != nil {
panic(err.Error())
}
k.voteByVoterIndex, err = orm.NewIndex(voteTable, VoteByVoterIndexPrefix, func(value interface{}) ([]interface{}, error) {
addr, err := sdk.AccAddressFromBech32(value.(*group.Vote).Voter)
if err != nil {
return nil, err
}
return []interface{}{addr.Bytes()}, nil
}, []byte{})
if err != nil {
panic(err.Error())
}
k.voteTable = *voteTable
if config.MaxMetadataLen == 0 {
config.MaxMetadataLen = group.DefaultConfig().MaxMetadataLen
}
if config.MaxExecutionPeriod == 0 {
config.MaxExecutionPeriod = group.DefaultConfig().MaxExecutionPeriod
}
k.config = config
return k
}
// 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))
}
// GetGroupSequence returns the current value of the group table sequence
func (k Keeper) GetGroupSequence(ctx sdk.Context) uint64 {
return k.groupTable.Sequence().CurVal(ctx.KVStore(k.key))
}
// GetGroupPolicySeq returns the current value of the group policy table sequence
func (k Keeper) GetGroupPolicySeq(ctx sdk.Context) uint64 {
return k.groupPolicySeq.CurVal(ctx.KVStore(k.key))
}
// 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) {
timeBytes := sdk.FormatTimeBytes(endTime)
it, err := k.proposalsByVotingPeriodEnd.PrefixScan(ctx.KVStore(k.key), nil, timeBytes)
if err != nil {
return proposals, err
}
defer it.Close()
for {
// Important: this following line cannot be outside of the for loop.
// It seems that when one unmarshals into the same `group.Proposal`
// reference, then gogoproto somehow "adds" the new bytes to the old
// object for some fields. When running simulations, for proposals with
// each 1-2 proposers, after a couple of loop iterations we got to a
// proposal with 60k+ proposers.
// So we're declaring a local variable that gets GCed.
//
// Also see `x/group/types/proposal_test.go`, TestGogoUnmarshalProposal().
var proposal group.Proposal
_, err := it.LoadNext(&proposal)
if errors.ErrORMIteratorDone.Is(err) {
break
}
if err != nil {
return proposals, err
}
proposals = append(proposals, proposal)
}
return proposals, nil
}
// pruneProposal deletes a proposal from state.
func (k Keeper) pruneProposal(ctx sdk.Context, proposalID uint64) error {
store := ctx.KVStore(k.key)
err := k.proposalTable.Delete(store, proposalID)
if err != nil {
return err
}
k.Logger(ctx).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 {
proposals, err := k.proposalsByGroupPolicy(ctx, groupPolicyAddr)
if err != nil {
return err
}
//nolint:gosec // "implicit memory aliasing in the for loop (because of the pointer on &proposalInfo)"
for _, proposalInfo := range proposals {
// Mark all proposals still in the voting phase as aborted.
if proposalInfo.Status == group.PROPOSAL_STATUS_SUBMITTED {
proposalInfo.Status = group.PROPOSAL_STATUS_ABORTED
if err := k.proposalTable.Update(ctx.KVStore(k.key), proposalInfo.Id, &proposalInfo); err != nil {
return err
}
}
}
return nil
}
// 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(ctx.KVStore(k.key), groupPolicyAddr.Bytes())
if err != nil {
return nil, err
}
defer proposalIt.Close()
var proposals []group.Proposal
for {
var proposalInfo group.Proposal
_, err = proposalIt.LoadNext(&proposalInfo)
if errors.ErrORMIteratorDone.Is(err) {
break
}
if err != nil {
return proposals, err
}
proposals = append(proposals, proposalInfo)
}
return proposals, nil
}
// pruneVotes prunes all votes for a proposal from state.
func (k Keeper) pruneVotes(ctx sdk.Context, proposalID uint64) error {
votes, err := k.votesByProposal(ctx, proposalID)
if err != nil {
return err
}
//nolint:gosec // "implicit memory aliasing in the for loop (because of the pointer on &v)"
for _, v := range votes {
err = k.voteTable.Delete(ctx.KVStore(k.key), &v)
if err != nil {
return err
}
}
return nil
}
// 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(ctx.KVStore(k.key), proposalID)
if err != nil {
return nil, err
}
defer it.Close()
var votes []group.Vote
for {
var vote group.Vote
_, err = it.LoadNext(&vote)
if errors.ErrORMIteratorDone.Is(err) {
break
}
if err != nil {
return votes, err
}
votes = append(votes, vote)
}
return votes, nil
}
// 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.BlockTime().Add(-k.config.MaxExecutionPeriod))
if err != nil {
return nil
}
for _, proposal := range proposals {
err := k.pruneProposal(ctx, proposal.Id)
if err != nil {
return err
}
}
return nil
}
// 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.BlockTime())
if err != nil {
return nil
}
//nolint:gosec // "implicit memory aliasing in the for loop (because of the pointers in the loop)"
for _, proposal := range proposals {
policyInfo, err := k.getGroupPolicyInfo(ctx, proposal.GroupPolicyAddress)
if err != nil {
return sdkerrors.Wrap(err, "group policy")
}
electorate, err := k.getGroupInfo(ctx, policyInfo.GroupId)
if err != nil {
return sdkerrors.Wrap(err, "group")
}
proposalID := proposal.Id
if proposal.Status == group.PROPOSAL_STATUS_ABORTED || proposal.Status == group.PROPOSAL_STATUS_WITHDRAWN {
if err := k.pruneProposal(ctx, proposalID); err != nil {
return err
}
if err := k.pruneVotes(ctx, proposalID); err != nil {
return err
}
} else {
err = k.doTallyAndUpdate(ctx, &proposal, electorate, policyInfo)
if err != nil {
return sdkerrors.Wrap(err, "doTallyAndUpdate")
}
if err := k.proposalTable.Update(ctx.KVStore(k.key), proposal.Id, &proposal); err != nil {
return sdkerrors.Wrap(err, "proposal update")
}
}
}
return nil
}