package app import ( sdkmath "cosmossdk.io/math" sdk "github.com/cosmos/cosmos-sdk/types" bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper" govkeeper "github.com/cosmos/cosmos-sdk/x/gov/keeper" govv1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1" stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" ) var _ govv1.TallyHandler = TallyHandler{} // TallyHandler is the tally handler for kava type TallyHandler struct { gk govkeeper.Keeper stk stakingkeeper.Keeper bk bankkeeper.Keeper } // NewTallyHandler creates a new tally handler. func NewTallyHandler( gk govkeeper.Keeper, stk stakingkeeper.Keeper, bk bankkeeper.Keeper, ) TallyHandler { return TallyHandler{ gk: gk, stk: stk, bk: bk, } } func (th TallyHandler) Tally( ctx sdk.Context, proposal govv1.Proposal, ) (passes bool, burnDeposits bool, tallyResults govv1.TallyResult) { results := make(map[govv1.VoteOption]sdk.Dec) results[govv1.OptionYes] = sdk.ZeroDec() results[govv1.OptionAbstain] = sdk.ZeroDec() results[govv1.OptionNo] = sdk.ZeroDec() results[govv1.OptionNoWithVeto] = sdk.ZeroDec() totalVotingPower := sdk.ZeroDec() currValidators := make(map[string]govv1.ValidatorGovInfo) // fetch all the bonded validators, insert them into currValidators th.stk.IterateBondedValidatorsByPower(ctx, func(index int64, validator stakingtypes.ValidatorI) (stop bool) { currValidators[validator.GetOperator().String()] = govv1.NewValidatorGovInfo( validator.GetOperator(), validator.GetBondedTokens(), validator.GetDelegatorShares(), sdk.ZeroDec(), govv1.WeightedVoteOptions{}, ) return false }) th.gk.IterateVotes(ctx, proposal.Id, func(vote govv1.Vote) bool { // if validator, just record it in the map voter, err := sdk.AccAddressFromBech32(vote.Voter) if err != nil { panic(err) } valAddrStr := sdk.ValAddress(voter.Bytes()).String() if val, ok := currValidators[valAddrStr]; ok { val.Vote = vote.Options currValidators[valAddrStr] = val } // iterate over all delegations from voter, deduct from any delegated-to validators th.stk.IterateDelegations(ctx, voter, func(index int64, delegation stakingtypes.DelegationI) (stop bool) { valAddrStr := delegation.GetValidatorAddr().String() if val, ok := currValidators[valAddrStr]; ok { // There is no need to handle the special case that validator address equal to voter address. // Because voter's voting power will tally again even if there will deduct voter's voting power from validator. val.DelegatorDeductions = val.DelegatorDeductions.Add(delegation.GetShares()) currValidators[valAddrStr] = val // delegation shares * bonded / total shares votingPower := delegation.GetShares().MulInt(val.BondedTokens).Quo(val.DelegatorShares) for _, option := range vote.Options { subPower := votingPower.Mul(sdk.MustNewDecFromStr(option.Weight)) results[option.Option] = results[option.Option].Add(subPower) } totalVotingPower = totalVotingPower.Add(votingPower) } return false }) // get voter bkava and update total voting power and results // addrBkava := th.getAddrBkava(ctx, voter).toCoins() // for _, coin := range addrBkava { // valAddr, err := liquidtypes.ParseLiquidStakingTokenDenom(coin.Denom) // if err != nil { // break // } // // reduce delegator shares by the amount of voter bkava for the validator // valAddrStr := valAddr.String() // if val, ok := currValidators[valAddrStr]; ok { // val.DelegatorDeductions = val.DelegatorDeductions.Add(sdk.NewDecFromInt(coin.Amount)) // currValidators[valAddrStr] = val // } // // votingPower = amount of ukava coin // stakedCoins, err := th.lk.GetStakedTokensForDerivatives(ctx, sdk.NewCoins(coin)) // if err != nil { // // error is returned only if the bkava denom is incorrect, which should never happen here. // panic(err) // } // votingPower := sdk.NewDecFromInt(stakedCoins.Amount) // for _, option := range vote.Options { // subPower := votingPower.Mul(sdk.MustNewDecFromStr(option.Weight)) // results[option.Option] = results[option.Option].Add(subPower) // } // totalVotingPower = totalVotingPower.Add(votingPower) // } th.gk.DeleteVote(ctx, vote.ProposalId, voter) return false }) // iterate over the validators again to tally their voting power for _, val := range currValidators { if len(val.Vote) == 0 { continue } sharesAfterDeductions := val.DelegatorShares.Sub(val.DelegatorDeductions) votingPower := sharesAfterDeductions.MulInt(val.BondedTokens).Quo(val.DelegatorShares) for _, option := range val.Vote { subPower := votingPower.Mul(sdk.MustNewDecFromStr(option.Weight)) results[option.Option] = results[option.Option].Add(subPower) } totalVotingPower = totalVotingPower.Add(votingPower) } tallyParams := th.gk.GetTallyParams(ctx) tallyResults = govv1.NewTallyResultFromMap(results) // TODO: Upgrade the spec to cover all of these cases & remove pseudocode. // If there is no staked coins, the proposal fails if th.stk.TotalBondedTokens(ctx).IsZero() { return false, false, tallyResults } // If there is not enough quorum of votes, the proposal fails percentVoting := totalVotingPower.Quo(sdk.NewDecFromInt(th.stk.TotalBondedTokens(ctx))) if percentVoting.LT(sdk.MustNewDecFromStr(tallyParams.Quorum)) { return false, true, tallyResults } // If no one votes (everyone abstains), proposal fails if totalVotingPower.Sub(results[govv1.OptionAbstain]).Equal(sdk.ZeroDec()) { return false, false, tallyResults } // If more than 1/3 of voters veto, proposal fails if results[govv1.OptionNoWithVeto].Quo(totalVotingPower).GT(sdk.MustNewDecFromStr(tallyParams.VetoThreshold)) { return false, true, tallyResults } // If more than 1/2 of non-abstaining voters vote Yes, proposal passes if results[govv1.OptionYes].Quo(totalVotingPower.Sub(results[govv1.OptionAbstain])).GT(sdk.MustNewDecFromStr(tallyParams.Threshold)) { return true, false, tallyResults } // If more than 1/2 of non-abstaining voters vote No, proposal fails return false, false, tallyResults } // bkavaByDenom a map of the bkava denom and the amount of bkava for that denom. type bkavaByDenom map[string]sdkmath.Int func (bkavaMap bkavaByDenom) add(coin sdk.Coin) { _, found := bkavaMap[coin.Denom] if !found { bkavaMap[coin.Denom] = sdk.ZeroInt() } bkavaMap[coin.Denom] = bkavaMap[coin.Denom].Add(coin.Amount) } func (bkavaMap bkavaByDenom) toCoins() sdk.Coins { coins := sdk.Coins{} for denom, amt := range bkavaMap { coins = coins.Add(sdk.NewCoin(denom, amt)) } return coins.Sort() } // getAddrBkava returns a map of validator address & the amount of bkava // of the addr for each validator. func (th TallyHandler) getAddrBkava(ctx sdk.Context, addr sdk.AccAddress) bkavaByDenom { results := make(bkavaByDenom) th.addBkavaFromWallet(ctx, addr, results) th.addBkavaFromSavings(ctx, addr, results) th.addBkavaFromEarn(ctx, addr, results) return results } // addBkavaFromWallet adds all addr balances of bkava in x/bank. func (th TallyHandler) addBkavaFromWallet(ctx sdk.Context, addr sdk.AccAddress, bkava bkavaByDenom) { // coins := th.bk.GetAllBalances(ctx, addr) // for _, coin := range coins { // if th.lk.IsDerivativeDenom(ctx, coin.Denom) { // bkava.add(coin) // } // } } // addBkavaFromSavings adds all addr deposits of bkava in x/savings. func (th TallyHandler) addBkavaFromSavings(ctx sdk.Context, addr sdk.AccAddress, bkava bkavaByDenom) { // deposit, found := th.svk.GetDeposit(ctx, addr) // if !found { // return // } // for _, coin := range deposit.Amount { // if th.lk.IsDerivativeDenom(ctx, coin.Denom) { // bkava.add(coin) // } // } } // addBkavaFromEarn adds all addr deposits of bkava in x/earn. func (th TallyHandler) addBkavaFromEarn(ctx sdk.Context, addr sdk.AccAddress, bkava bkavaByDenom) { // shares, found := th.ek.GetVaultAccountShares(ctx, addr) // if !found { // return // } // for _, share := range shares { // if th.lk.IsDerivativeDenom(ctx, share.Denom) { // if coin, err := th.ek.ConvertToAssets(ctx, share); err == nil { // bkava.add(coin) // } // } // } }