crit when get voters, voter capacity

contracts/utils.go

@@ -27,7 +27,6 @@ import (
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/params"
@@ -295,57 +294,37 @@ func GetRewardForCheckpoint(chain consensus.ChainReader, blockSignerAddr common.
 	masternodes := XDPoS.GetMasternodesFromCheckpointHeader(prevHeaderCheckpoint)
 
 	if len(masternodes) > 0 {
-
-        var wg sync.WaitGroup
-        squeue := make(chan []common.Address, 1)
-        wg.Add(900)
-
 		for i := startBlockNumber; i <= endBlockNumber; i++ {
-            go func(i uint64) {
+			block := chain.GetHeaderByNumber(i)
-                block := chain.GetHeaderByNumber(i)
+			addrs, err := GetSignersFromContract(blockSignerAddr, client, block.Hash())
-                addrs, err := GetSignersFromContract(blockSignerAddr, client, block.Hash())
+			if err != nil {
-                if err != nil {
+				log.Crit("Fail to get signers from smartcontract.", "error", err, "blockNumber", i)
-                    log.Crit("Fail to get signers from smartcontract.", "error", err, "blockNumber", i)
+			}
-                    // return nil, err
+			// Filter duplicate address.
-                }
+			if len(addrs) > 0 {
-                squeue <- addrs
+				addrSigners := make(map[common.Address]bool)
-            }(i)
+				for _, masternode := range masternodes {
-        }
+					for _, addr := range addrs {
+						if addr == masternode {
+							if _, ok := addrSigners[addr]; !ok {
+								addrSigners[addr] = true
+							}
+							break
+						}
+					}
+				}
 
-        fsigner := func() {
+				for addr := range addrSigners {
-            for addrs := range squeue {
+					_, exist := signers[addr]
-                // Filter duplicate address.
+					if exist {
-                if len(addrs) > 0 {
+						signers[addr].Sign++
-                    addrSigners := make(map[common.Address]bool)
+					} else {
-                    for _, masternode := range masternodes {
+						signers[addr] = &rewardLog{1, new(big.Int)}
-                        for _, addr := range addrs {
+					}
-                            if addr == masternode {
+					*totalSigner++
-                                if _, ok := addrSigners[addr]; !ok {
+				}
-                                    addrSigners[addr] = true
+			}
-                                }
+		}
-                                break
-                            }
-                        }
-                    }
-
-                    for addr := range addrSigners {
-                        _, exist := signers[addr]
-                        if exist {
-                            signers[addr].Sign++
-                        } else {
-                            signers[addr] = &rewardLog{1, new(big.Int)}
-                        }
-                        *totalSigner++
-                    }
-                }
-                wg.Done()
-            }
-        }
-
-        go fsigner()
-
-        wg.Wait()
-        fmt.Println("totalSigner", *totalSigner)
 	}
 
 	log.Info("Calculate reward at checkpoint", "startBlock", startBlockNumber, "endBlock", endBlockNumber)
@@ -379,17 +358,6 @@ func CalculateRewardForSigner(chainReward *big.Int, signers map[common.Address]*
 }
 
 // Get candidate owner by address.
-func GetCandidatesOwnerBySigner2(vmenv *vm.EVM, signerAddr common.Address) common.Address {
-	owner := signerAddr
-	owner, err := core.GetCandidateOwner(signerAddr, vmenv)
-	if err != nil {
-		log.Error("Fail get candidate owner", "error", err)
-		return owner
-	}
-
-	return owner
-}
-
 func GetCandidatesOwnerBySigner(validator *contractValidator.XDCValidator, signerAddr common.Address) common.Address {
 	owner := signerAddr
 	opts := new(bind.CallOpts)
@@ -402,81 +370,6 @@ func GetCandidatesOwnerBySigner(validator *contractValidator.XDCValidator, signe
 	return owner
 }
 
-// Calculate reward for holders.
-func CalculateRewardForHolders2(foudationWalletAddr common.Address, vmenv *vm.EVM, state *state.StateDB, signer common.Address, calcReward *big.Int) (error, map[common.Address]*big.Int) {
-	rewards, err := GetRewardBalancesRate2(foudationWalletAddr, signer, calcReward, vmenv)
-	if err != nil {
-		return err, nil
-	}
-	if len(rewards) > 0 {
-		for holder, reward := range rewards {
-			state.AddBalance(holder, reward)
-		}
-	}
-	return nil, rewards
-}
-
-// Get reward balance rates for master node, founder and holders.
-func GetRewardBalancesRate2(foudationWalletAddr common.Address, masterAddr common.Address, totalReward *big.Int, vmenv *vm.EVM) (map[common.Address]*big.Int, error) {
-	owner := GetCandidatesOwnerBySigner2(vmenv, masterAddr)
-	balances := make(map[common.Address]*big.Int)
-	rewardMaster := new(big.Int).Mul(totalReward, new(big.Int).SetInt64(common.RewardMasterPercent))
-	rewardMaster = new(big.Int).Div(rewardMaster, new(big.Int).SetInt64(100))
-	balances[owner] = rewardMaster
-	// Get voters for masternode.
-	voters, err := core.GetVoters(masterAddr, vmenv)
-	if err != nil {
-		log.Error("Fail to get voters", "error", err)
-		return nil, err
-	}
-
-	if len(voters) > 0 {
-		totalVoterReward := new(big.Int).Mul(totalReward, new(big.Int).SetUint64(common.RewardVoterPercent))
-		totalVoterReward = new(big.Int).Div(totalVoterReward, new(big.Int).SetUint64(100))
-		totalCap := new(big.Int)
-		// Get voters capacities.
-		voterCaps := make(map[common.Address]*big.Int)
-		for _, voteAddr := range voters {
-			voterCap, err := core.GetVoterCap(masterAddr, voteAddr, vmenv)
-			if err != nil {
-				log.Error("Fail to get vote capacity", "error", err)
-				return nil, err
-			}
-
-			totalCap.Add(totalCap, voterCap)
-			voterCaps[voteAddr] = voterCap
-		}
-		if totalCap.Cmp(new(big.Int).SetInt64(0)) > 0 {
-			for addr, voteCap := range voterCaps {
-				// Only valid voter has cap > 0.
-				if voteCap.Cmp(new(big.Int).SetInt64(0)) > 0 {
-					rcap := new(big.Int).Mul(totalVoterReward, voteCap)
-					rcap = new(big.Int).Div(rcap, totalCap)
-					if balances[addr] != nil {
-						balances[addr].Add(balances[addr], rcap)
-					} else {
-						balances[addr] = rcap
-					}
-				}
-			}
-		}
-	}
-
-	foudationReward := new(big.Int).Mul(totalReward, new(big.Int).SetInt64(common.RewardFoundationPercent))
-	foudationReward = new(big.Int).Div(foudationReward, new(big.Int).SetInt64(100))
-	balances[foudationWalletAddr] = foudationReward
-
-	jsonHolders, err := json.Marshal(balances)
-	if err != nil {
-		log.Error("Fail to parse json holders", "error", err)
-		return nil, err
-	}
-	log.Info("Holders reward", "holders", string(jsonHolders), "master node", masterAddr.String())
-	fmt.Println("Holders reward", "holders", string(jsonHolders), "master node", masterAddr.String())
-
-	return balances, nil
-}
-
 // Calculate reward for holders.
 func CalculateRewardForHolders(foudationWalletAddr common.Address, validator *contractValidator.XDCValidator, state *state.StateDB, signer common.Address, calcReward *big.Int) (error, map[common.Address]*big.Int) {
 	rewards, err := GetRewardBalancesRate(foudationWalletAddr, signer, calcReward, validator)
@@ -502,8 +395,7 @@ func GetRewardBalancesRate(foudationWalletAddr common.Address, masterAddr common
 	opts := new(bind.CallOpts)
 	voters, err := validator.GetVoters(opts, masterAddr)
 	if err != nil {
-		log.Error("Fail to get voters", "error", err)
+		log.Crit("Fail to get voters", "error", err)
-		return nil, err
 	}
 
 	if len(voters) > 0 {
@@ -515,8 +407,7 @@ func GetRewardBalancesRate(foudationWalletAddr common.Address, masterAddr common
 		for _, voteAddr := range voters {
 			voterCap, err := validator.GetVoterCap(opts, masterAddr, voteAddr)
 			if err != nil {
-				log.Error("Fail to get vote capacity", "error", err)
+				log.Crit("Fail to get vote capacity", "error", err)
-				return nil, err
 			}
 
 			totalCap.Add(totalCap, voterCap)