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         _, err := s.node.BatchSendBTM(s.rewardCfg.AccountID, s.rewardCfg.Password, s.rewards)
  90         return err
  91 }
  92
  93 func (s *SettlementReward) getStandbyNodeReward(height uint64) (uint64, error) {
  94         voteInfos, err := s.node.GetVoteByHeight(height)
  95         if err != nil {
  96                 return 0, errors.Wrapf(err, "get alternative node reward")
  97         }
  98
  99         voteInfos = common.CalcStandByNodes(voteInfos)
 100
 101         totalVoteNum, xpubVoteNum := uint64(0), uint64(0)
 102         for _, voteInfo := range voteInfos {
 103                 totalVoteNum += voteInfo.VoteNum
 104                 if s.rewardCfg.XPub == voteInfo.Vote {
 105                         xpubVoteNum = voteInfo.VoteNum
 106                 }
 107         }
 108
 109         if xpubVoteNum == 0 {
 110                 return 0, errNotStandbyNode
 111         }
 112
 113         amount := big.NewInt(0).SetUint64(standbyNodesRewardForConsensusCycle)
 114         rewardRatio := big.NewInt(0).SetUint64(s.rewardCfg.RewardRatio)
 115         amount.Mul(amount, rewardRatio).Div(amount, big.NewInt(100))
 116         total := big.NewInt(0).SetUint64(totalVoteNum)
 117         voteNum := big.NewInt(0).SetUint64(xpubVoteNum)
 118         return amount.Mul(amount, voteNum).Div(amount, total).Uint64(), nil
 119 }
 120
 121 func (s *SettlementReward) getCoinbaseReward(height uint64) (uint64, error) {
 122         block, err := s.node.GetBlockByHeight(height)
 123         if err != nil {
 124                 return 0, err
 125         }
 126
 127         miningControl, err := common.GetControlProgramFromAddress(s.rewardCfg.MiningAddress)
 128         if err != nil {
 129                 return 0, err
 130         }
 131
 132         for _, output := range block.Transactions[0].Outputs {
 133                 output, ok := output.TypedOutput.(*types.IntraChainOutput)
 134                 if !ok {
 135                         return 0, errors.New("Output type error")
 136                 }
 137
 138                 if output.Amount == 0 {
 139                         continue
 140                 }
 141
 142                 if bytes.Equal(miningControl, output.ControlProgram) {
 143                         amount := big.NewInt(0).SetUint64(output.Amount)
 144                         rewardRatio := big.NewInt(0).SetUint64(s.rewardCfg.RewardRatio)
 145                         amount.Mul(amount, rewardRatio).Div(amount, big.NewInt(100))
 146
 147                         return amount.Uint64(), nil
 148                 }
 149         }
 150         return 0, errNotFoundReward
 151 }
 152
 153 func (s *SettlementReward) calcVoterRewards(voteResults []*voteResult, totalReward uint64) {
 154         totalVoteNum := uint64(0)
 155         for _, voteResult := range voteResults {
 156                 totalVoteNum += voteResult.VoteNum
 157         }
 158
 159         for _, voteResult := range voteResults {
 160                 // voteNum / totalVoteNum  * totalReward
 161                 voteNum := big.NewInt(0).SetUint64(voteResult.VoteNum)
 162                 total := big.NewInt(0).SetUint64(totalVoteNum)
 163                 reward := big.NewInt(0).SetUint64(totalReward)
 164
 165                 amount := voteNum.Mul(voteNum, reward).Div(voteNum, total).Uint64()
 166
 167                 if amount != 0 {
 168                         s.rewards[voteResult.VoteAddress] += amount
 169                 }
 170         }
 171 }