package keeper import ( "fmt" errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/0glabs/0g-chain/x/committee/types" ) // SubmitProposal adds a proposal to a committee so that it can be voted on. func (k Keeper) SubmitProposal(ctx sdk.Context, proposer sdk.AccAddress, committeeID uint64, pubProposal types.PubProposal) (uint64, error) { // Limit proposals to only be submitted by committee members com, found := k.GetCommittee(ctx, committeeID) if !found { return 0, errorsmod.Wrapf(types.ErrUnknownCommittee, "%d", committeeID) } if !com.HasMember(proposer) { return 0, errorsmod.Wrap(sdkerrors.ErrUnauthorized, "proposer not member of committee") } // Check committee has permissions to enact proposal. if !com.HasPermissionsFor(ctx, k.cdc, k.paramKeeper, pubProposal) { return 0, errorsmod.Wrap(sdkerrors.ErrUnauthorized, "committee does not have permissions to enact proposal") } // Check proposal is valid if err := k.ValidatePubProposal(ctx, pubProposal); err != nil { return 0, err } // Get a new ID and store the proposal deadline := ctx.BlockTime().Add(com.GetProposalDuration()) proposalID, err := k.StoreNewProposal(ctx, pubProposal, committeeID, deadline) if err != nil { return 0, err } ctx.EventManager().EmitEvent( sdk.NewEvent( types.EventTypeProposalSubmit, sdk.NewAttribute(types.AttributeKeyCommitteeID, fmt.Sprintf("%d", com.GetID())), sdk.NewAttribute(types.AttributeKeyProposalID, fmt.Sprintf("%d", proposalID)), sdk.NewAttribute(types.AttributeKeyDeadline, deadline.String()), ), ) return proposalID, nil } // AddVote submits a vote on a proposal. func (k Keeper) AddVote(ctx sdk.Context, proposalID uint64, voter sdk.AccAddress, voteType types.VoteType) error { // Validate pr, found := k.GetProposal(ctx, proposalID) if !found { return errorsmod.Wrapf(types.ErrUnknownProposal, "%d", proposalID) } if pr.HasExpiredBy(ctx.BlockTime()) { return errorsmod.Wrapf(types.ErrProposalExpired, "%s ≥ %s", ctx.BlockTime(), pr.Deadline) } com, found := k.GetCommittee(ctx, pr.CommitteeID) if !found { return errorsmod.Wrapf(types.ErrUnknownCommittee, "%d", pr.CommitteeID) } if _, ok := com.(*types.MemberCommittee); ok { if !com.HasMember(voter) { return errorsmod.Wrap(sdkerrors.ErrUnauthorized, "voter must be a member of committee") } if voteType != types.VOTE_TYPE_YES { return errorsmod.Wrap(types.ErrInvalidVoteType, "member committees only accept yes votes") } } // Store vote, overwriting any prior vote k.SetVote(ctx, types.NewVote(proposalID, voter, voteType)) ctx.EventManager().EmitEvent( sdk.NewEvent( types.EventTypeProposalVote, sdk.NewAttribute(types.AttributeKeyCommitteeID, fmt.Sprintf("%d", com.GetID())), sdk.NewAttribute(types.AttributeKeyProposalID, fmt.Sprintf("%d", pr.ID)), sdk.NewAttribute(types.AttributeKeyVoter, voter.String()), sdk.NewAttribute(types.AttributeKeyVote, fmt.Sprintf("%d", voteType)), ), ) return nil } // ValidatePubProposal checks if a pubproposal is valid. func (k Keeper) ValidatePubProposal(ctx sdk.Context, pubProposal types.PubProposal) (returnErr error) { if pubProposal == nil { return errorsmod.Wrap(types.ErrInvalidPubProposal, "pub proposal cannot be nil") } if err := pubProposal.ValidateBasic(); err != nil { return err } if !k.router.HasRoute(pubProposal.ProposalRoute()) { return errorsmod.Wrapf(types.ErrNoProposalHandlerExists, "%T", pubProposal) } // Run the proposal's changes through the associated handler using a cached version of state to ensure changes are not permanent. cacheCtx, _ := ctx.CacheContext() handler := k.router.GetRoute(pubProposal.ProposalRoute()) // Handle an edge case where a param change proposal causes the proposal handler to panic. // A param change proposal with a registered subspace value but unregistered key value will cause a panic in the param change proposal handler. // This defer will catch panics and return a normal error: `recover()` gets the panic value, then the enclosing function's return value is swapped for an error. // reference: https://stackoverflow.com/questions/33167282/how-to-return-a-value-in-a-go-function-that-panics?noredirect=1&lq=1 defer func() { if r := recover(); r != nil { returnErr = errorsmod.Wrapf(types.ErrInvalidPubProposal, "proposal handler panicked: %s", r) } }() if err := handler(cacheCtx, pubProposal); err != nil { return err } return nil } func (k Keeper) ProcessProposals(ctx sdk.Context) { k.IterateProposals(ctx, func(proposal types.Proposal) bool { committee, found := k.GetCommittee(ctx, proposal.CommitteeID) if !found { k.CloseProposal(ctx, proposal, types.Failed) return false } if !proposal.HasExpiredBy(ctx.BlockTime()) { if committee.GetTallyOption() == types.TALLY_OPTION_FIRST_PAST_THE_POST { passed := k.GetProposalResult(ctx, proposal.ID, committee) if passed { outcome := k.attemptEnactProposal(ctx, proposal) k.CloseProposal(ctx, proposal, outcome) } } } else { passed := k.GetProposalResult(ctx, proposal.ID, committee) outcome := types.Failed if passed { outcome = k.attemptEnactProposal(ctx, proposal) } k.CloseProposal(ctx, proposal, outcome) } return false }) } func (k Keeper) GetProposalResult(ctx sdk.Context, proposalID uint64, committee types.Committee) bool { switch com := committee.(type) { case *types.MemberCommittee: return k.GetMemberCommitteeProposalResult(ctx, proposalID, com) case *types.TokenCommittee: return k.GetTokenCommitteeProposalResult(ctx, proposalID, com) default: // Should never hit default case return false } } // GetMemberCommitteeProposalResult gets the result of a member committee proposal func (k Keeper) GetMemberCommitteeProposalResult(ctx sdk.Context, proposalID uint64, committee types.Committee) bool { currVotes := k.TallyMemberCommitteeVotes(ctx, proposalID) possibleVotes := sdk.NewDec(int64(len(committee.GetMembers()))) return currVotes.GTE(committee.GetVoteThreshold().Mul(possibleVotes)) // vote threshold requirements } // TallyMemberCommitteeVotes returns the polling status of a member committee vote func (k Keeper) TallyMemberCommitteeVotes(ctx sdk.Context, proposalID uint64) (totalVotes sdk.Dec) { votes := k.GetVotesByProposal(ctx, proposalID) return sdk.NewDec(int64(len(votes))) } // GetTokenCommitteeProposalResult gets the result of a token committee proposal func (k Keeper) GetTokenCommitteeProposalResult(ctx sdk.Context, proposalID uint64, committee *types.TokenCommittee) bool { yesVotes, noVotes, totalVotes, possibleVotes := k.TallyTokenCommitteeVotes(ctx, proposalID, committee.TallyDenom) if totalVotes.GTE(committee.Quorum.Mul(possibleVotes)) { // quorum requirement nonAbstainVotes := yesVotes.Add(noVotes) if yesVotes.GTE(nonAbstainVotes.Mul(committee.VoteThreshold)) { // vote threshold requirements return true } } return false } // TallyMemberCommitteeVotes returns the polling status of a token committee vote. Returns yes votes, // total current votes, total possible votes (equal to token supply), vote threshold (yes vote ratio // required for proposal to pass), and quorum (votes tallied at this percentage). func (k Keeper) TallyTokenCommitteeVotes(ctx sdk.Context, proposalID uint64, tallyDenom string, ) (yesVotes, noVotes, totalVotes, possibleVotes sdk.Dec) { votes := k.GetVotesByProposal(ctx, proposalID) yesVotes = sdk.ZeroDec() noVotes = sdk.ZeroDec() totalVotes = sdk.ZeroDec() for _, vote := range votes { // 1 token = 1 vote acc := k.accountKeeper.GetAccount(ctx, vote.Voter) accNumCoins := k.bankKeeper.GetBalance(ctx, acc.GetAddress(), tallyDenom).Amount // Add votes to counters totalVotes = totalVotes.Add(sdk.NewDecFromInt(accNumCoins)) if vote.VoteType == types.VOTE_TYPE_YES { yesVotes = yesVotes.Add(sdk.NewDecFromInt(accNumCoins)) } else if vote.VoteType == types.VOTE_TYPE_NO { noVotes = noVotes.Add(sdk.NewDecFromInt(accNumCoins)) } } possibleVotesInt := k.bankKeeper.GetSupply(ctx, tallyDenom).Amount return yesVotes, noVotes, totalVotes, sdk.NewDecFromInt(possibleVotesInt) } func (k Keeper) attemptEnactProposal(ctx sdk.Context, proposal types.Proposal) types.ProposalOutcome { err := k.enactProposal(ctx, proposal) if err != nil { return types.Invalid } return types.Passed } // enactProposal makes the changes proposed in a proposal. func (k Keeper) enactProposal(ctx sdk.Context, proposal types.Proposal) error { // Check committee still has permissions for the proposal // Since the proposal was submitted params could have changed, invalidating the permission of the committee. com, found := k.GetCommittee(ctx, proposal.CommitteeID) if !found { return errorsmod.Wrapf(types.ErrUnknownCommittee, "%d", proposal.CommitteeID) } if !com.HasPermissionsFor(ctx, k.cdc, k.paramKeeper, proposal.GetContent()) { return errorsmod.Wrap(sdkerrors.ErrUnauthorized, "committee does not have permissions to enact proposal") } if err := k.ValidatePubProposal(ctx, proposal.GetContent()); err != nil { return err } // enact the proposal handler := k.router.GetRoute(proposal.GetContent().ProposalRoute()) if err := handler(ctx, proposal.GetContent()); err != nil { // the handler should not error as it was checked in ValidatePubProposal panic(fmt.Sprintf("unexpected handler error: %s", err)) } return nil } // GetProposalTallyResponse returns the tally results of a proposal. func (k Keeper) GetProposalTallyResponse(ctx sdk.Context, proposalID uint64) (*types.QueryTallyResponse, bool) { proposal, found := k.GetProposal(ctx, proposalID) if !found { return nil, found } committee, found := k.GetCommittee(ctx, proposal.CommitteeID) if !found { return nil, found } var proposalTally types.QueryTallyResponse switch com := committee.(type) { case *types.MemberCommittee: currVotes := k.TallyMemberCommitteeVotes(ctx, proposal.ID) possibleVotes := sdk.NewDec(int64(len(com.Members))) proposalTally = types.QueryTallyResponse{ ProposalID: proposal.ID, YesVotes: currVotes, NoVotes: sdk.ZeroDec(), CurrentVotes: currVotes, PossibleVotes: possibleVotes, VoteThreshold: com.VoteThreshold, Quorum: sdk.ZeroDec(), } case *types.TokenCommittee: yesVotes, noVotes, currVotes, possibleVotes := k.TallyTokenCommitteeVotes(ctx, proposal.ID, com.TallyDenom) proposalTally = types.QueryTallyResponse{ ProposalID: proposal.ID, YesVotes: yesVotes, NoVotes: noVotes, CurrentVotes: currVotes, PossibleVotes: possibleVotes, VoteThreshold: com.VoteThreshold, Quorum: com.Quorum, } } return &proposalTally, true } // CloseProposal deletes proposals and their votes, emitting an event denoting the final status of the proposal func (k Keeper) CloseProposal(ctx sdk.Context, proposal types.Proposal, outcome types.ProposalOutcome) { tally, _ := k.GetProposalTallyResponse(ctx, proposal.ID) k.DeleteProposalAndVotes(ctx, proposal.ID) bz, err := k.cdc.MarshalJSON(tally) if err != nil { fmt.Println("error marshaling proposal tally to bytes:", tally.String()) } ctx.EventManager().EmitEvent( sdk.NewEvent( types.EventTypeProposalClose, sdk.NewAttribute(types.AttributeKeyCommitteeID, fmt.Sprintf("%d", proposal.CommitteeID)), sdk.NewAttribute(types.AttributeKeyProposalID, fmt.Sprintf("%d", proposal.ID)), sdk.NewAttribute(types.AttributeKeyProposalTally, string(bz)), sdk.NewAttribute(types.AttributeKeyProposalOutcome, outcome.String()), ), ) }