toolbar/vote_reward/settlementvotereward/settlementreward.go

   1 package settlementvotereward
   2
   3 import (
   4         "bytes"
   5         "math/big"
   6
   7         "github.com/jinzhu/gorm"
   8
   9         "github.com/vapor/consensus"
  10         "github.com/vapor/errors"
  11         "github.com/vapor/protocol/bc/types"
  12         "github.com/vapor/toolbar/apinode"
  13         "github.com/vapor/toolbar/common"
  14         "github.com/vapor/toolbar/vote_reward/config"
  15 )
  16
  17 var (
  18         errNotFoundReward = errors.New("No reward found")
  19         errNotStandbyNode = errors.New("No Standby Node")
  20         errNotRewardTx    = errors.New("No reward transaction")
  21 )
  22
  23 const standbyNodesRewardForConsensusCycle = 7610350076 // 400000000000000 / (365 * 24 * 60 / (500 * 1200 / 1000 / 60))
  24
  25 type voteResult struct {
  26         VoteAddress string
  27         VoteNum     uint64
  28 }
  29
  30 type SettlementReward struct {
  31         rewardCfg   *config.RewardConfig
  32         node        *apinode.Node
  33         db          *gorm.DB
  34         rewards     map[string]uint64
  35         startHeight uint64
  36         endHeight   uint64
  37 }
  38
  39 func NewSettlementReward(db *gorm.DB, cfg *config.Config, startHeight, endHeight uint64) *SettlementReward {
  40         return &SettlementReward{
  41                 db:          db,
  42                 rewardCfg:   cfg.RewardConf,
  43                 node:        apinode.NewNode(cfg.NodeIP),
  44                 rewards:     make(map[string]uint64),
  45                 startHeight: startHeight,
  46                 endHeight:   endHeight,
  47         }
  48 }
  49
  50 func (s *SettlementReward) getVoteResultFromDB(height uint64) (voteResults []*voteResult, err error) {
  51         query := s.db.Table("utxos").Select("vote_address, sum(vote_num) as vote_num")
  52         query = query.Where("(veto_height >= ? or veto_height = 0) and vote_height <= ? and xpub = ?", height-consensus.ActiveNetParams.RoundVoteBlockNums+1, height-consensus.ActiveNetParams.RoundVoteBlockNums, s.rewardCfg.XPub)
  53         query = query.Group("vote_address")
  54         if err := query.Scan(&voteResults).Error; err != nil {
  55                 return nil, err
  56         }
  57
  58         return voteResults, nil
  59 }
  60
  61 func (s *SettlementReward) Settlement() error {
  62         for height := s.startHeight + consensus.ActiveNetParams.RoundVoteBlockNums; height <= s.endHeight; height += consensus.ActiveNetParams.RoundVoteBlockNums {
  63                 totalReward, err := s.getCoinbaseReward(height + 1)
  64                 if err == errNotFoundReward {
  65                         totalReward, err = s.getStandbyNodeReward(height - consensus.ActiveNetParams.RoundVoteBlockNums)
  66                 }
  67
  68                 if err == errNotStandbyNode {
  69                         continue
  70                 }
  71
  72                 if err != nil {
  73                         return errors.Wrapf(err, "get total reward at height: %d", height)
  74                 }
  75
  76                 voteResults, err := s.getVoteResultFromDB(height)
  77                 if err != nil {
  78                         return err
  79                 }
  80
  81                 s.calcVoterRewards(voteResults, totalReward)
  82         }
  83
  84         if len(s.rewards) == 0 {
  85                 return errNotRewardTx
  86         }
  87
  88         // send transactions
  89         return s.node.BatchSendBTM(s.rewardCfg.AccountID, s.rewardCfg.Password, s.rewards)
  90 }
  91
  92 func (s *SettlementReward) getStandbyNodeReward(height uint64) (uint64, error) {
  93         voteInfos, err := s.node.GetVoteByHeight(height)
  94         if err != nil {
  95                 return 0, errors.Wrapf(err, "get alternative node reward")
  96         }
  97
  98         voteInfos = common.CalcStandByNodes(voteInfos)
  99
 100         totalVoteNum, xpubVoteNum := uint64(0), uint64(0)
 101         for _, voteInfo := range voteInfos {
 102                 totalVoteNum += voteInfo.VoteNum
 103                 if s.rewardCfg.XPub == voteInfo.Vote {
 104                         xpubVoteNum = voteInfo.VoteNum
 105                 }
 106         }
 107
 108         if xpubVoteNum == 0 {
 109                 return 0, errNotStandbyNode
 110         }
 111
 112         amount := big.NewInt(0).SetUint64(standbyNodesRewardForConsensusCycle)
 113         rewardRatio := big.NewInt(0).SetUint64(s.rewardCfg.RewardRatio)
 114         amount.Mul(amount, rewardRatio).Div(amount, big.NewInt(100))
 115         total := big.NewInt(0).SetUint64(totalVoteNum)
 116         voteNum := big.NewInt(0).SetUint64(xpubVoteNum)
 117         return amount.Mul(amount, voteNum).Div(amount, total).Uint64(), nil
 118 }
 119
 120 func (s *SettlementReward) getCoinbaseReward(height uint64) (uint64, error) {
 121         block, err := s.node.GetBlockByHeight(height)
 122         if err != nil {
 123                 return 0, err
 124         }
 125
 126         miningControl, err := common.GetControlProgramFromAddress(s.rewardCfg.MiningAddress)
 127         if err != nil {
 128                 return 0, err
 129         }
 130
 131         for _, output := range block.Transactions[0].Outputs {
 132                 output, ok := output.TypedOutput.(*types.IntraChainOutput)
 133                 if !ok {
 134                         return 0, errors.New("Output type error")
 135                 }
 136
 137                 if output.Amount == 0 {
 138                         continue
 139                 }
 140
 141                 if bytes.Equal(miningControl, output.ControlProgram) {
 142                         amount := big.NewInt(0).SetUint64(output.Amount)
 143                         rewardRatio := big.NewInt(0).SetUint64(s.rewardCfg.RewardRatio)
 144                         amount.Mul(amount, rewardRatio).Div(amount, big.NewInt(100))
 145
 146                         return amount.Uint64(), nil
 147                 }
 148         }
 149         return 0, errNotFoundReward
 150 }
 151
 152 func (s *SettlementReward) calcVoterRewards(voteResults []*voteResult, totalReward uint64) {
 153         totalVoteNum := uint64(0)
 154         for _, voteResult := range voteResults {
 155                 totalVoteNum += voteResult.VoteNum
 156         }
 157
 158         for _, voteResult := range voteResults {
 159                 // voteNum / totalVoteNum  * totalReward
 160                 voteNum := big.NewInt(0).SetUint64(voteResult.VoteNum)
 161                 total := big.NewInt(0).SetUint64(totalVoteNum)
 162                 reward := big.NewInt(0).SetUint64(totalReward)
 163
 164                 amount := voteNum.Mul(voteNum, reward).Div(voteNum, total).Uint64()
 165
 166                 if amount != 0 {
 167                         s.rewards[voteResult.VoteAddress] += amount
 168                 }
 169         }
 170 }