[Refactor] Use arith_uint256 for masternode ranking computations

src/budget/budgetproposal.h

@@ -127,13 +127,17 @@ class CBudgetProposal
     void Relay();
 
     // compare proposals by proposal hash
-    inline bool operator>(const CBudgetProposal& other) const { return GetHash() > other.GetHash(); }
+    inline bool operator>(const CBudgetProposal& other) const
+    {
+        return UintToArith256(GetHash()) > UintToArith256(other.GetHash());
+    }
+    //
     // compare proposals pointers by net yes count (solve tie with feeHash)
     static inline bool PtrHigherYes(CBudgetProposal* a, CBudgetProposal* b)
     {
         const int netYes_a = a->GetYeas() - a->GetNays();
         const int netYes_b = b->GetYeas() - b->GetNays();
-        if (netYes_a == netYes_b) return a->GetFeeTXHash() > b->GetFeeTXHash();
+        if (netYes_a == netYes_b) return UintToArith256(a->GetFeeTXHash()) > UintToArith256(b->GetFeeTXHash());
         return netYes_a > netYes_b;
     }
 

src/budget/finalizedbudget.cpp

@@ -413,7 +413,7 @@ bool CFinalizedBudget::operator>(const CFinalizedBudget& other) const
     const int count = GetVoteCount();
     const int otherCount = other.GetVoteCount();
 
-    if (count == otherCount) return GetFeeTXHash() > other.GetFeeTXHash();
+    if (count == otherCount) return UintToArith256(GetFeeTXHash()) > UintToArith256(other.GetFeeTXHash());
 
     return count > otherCount;
 }

src/budget/finalizedbudget.h

@@ -167,7 +167,10 @@ class CTxBudgetPayment
     }
 
     // compare payments by proposal hash
-    inline bool operator>(const CTxBudgetPayment& other) const { return nProposalHash > other.nProposalHash; }
+    inline bool operator>(const CTxBudgetPayment& other) const
+    {
+        return UintToArith256(nProposalHash) > UintToArith256(other.nProposalHash);
+    }
 
 };
 

src/masternode.cpp

@@ -144,17 +144,17 @@ bool CMasternode::UpdateFromNewBroadcast(CMasternodeBroadcast& mnb)
 // the proof of work for that block. The further away they are the better, the furthest will win the election
 // and get paid this block
 //
-uint256 CMasternode::CalculateScore(const uint256& hash) const
+arith_uint256 CMasternode::CalculateScore(const uint256& hash) const
 {
     CHashWriter ss(SER_GETHASH, PROTOCOL_VERSION);
     ss << hash;
-    const uint256& hash2 = ss.GetHash();
+    const arith_uint256& hash2 = UintToArith256(ss.GetHash());
 
     CHashWriter ss2(SER_GETHASH, PROTOCOL_VERSION);
     ss2 << hash;
-    const uint256& aux = vin.prevout.hash + vin.prevout.n;
+    const arith_uint256& aux = UintToArith256(vin.prevout.hash) + vin.prevout.n;
     ss2 << aux;
-    const uint256& hash3 = ss2.GetHash();
+    const arith_uint256& hash3 = UintToArith256(ss2.GetHash());
 
     return (hash3 > hash2 ? hash3 - hash2 : hash2 - hash3);
 }

src/masternode.h

@@ -152,7 +152,7 @@ class CMasternode : public CSignedMessage
         return !(a.vin == b.vin);
     }
 
-    uint256 CalculateScore(const uint256& hash) const;
+    arith_uint256 CalculateScore(const uint256& hash) const;
 
     ADD_SERIALIZE_METHODS;
 

src/masternodeman.cpp

@@ -504,13 +504,13 @@ MasternodeRef CMasternodeMan::GetNextMasternodeInQueueForPayment(int nBlockHeigh
     //  -- (chance per block * chances before IsScheduled will fire)
     int nTenthNetwork = nMnCount / 10;
     int nCountTenth = 0;
-    uint256 nHigh;
+    arith_uint256 nHigh;
     const uint256& hash = GetHashAtHeight(nBlockHeight - 101);
     for (const auto& s: vecMasternodeLastPaid) {
         const MasternodeRef pmn = s.second;
         if (!pmn) break;
 
-        const uint256& n = pmn->CalculateScore(hash);
+        const arith_uint256& n = pmn->CalculateScore(hash);
         if (n > nHigh) {
             nHigh = n;
             pBestMasternode = pmn;
@@ -563,7 +563,7 @@ int CMasternodeMan::GetMasternodeRank(const CTxIn& vin, int64_t nBlockHeight) co
 {
     const uint256& hash = GetHashAtHeight(nBlockHeight - 1);
     // height outside range
-    if (!hash) return -1;
+    if (hash == UINT256_ZERO) return -1;
 
     // scan for winner
     int minProtocol = ActiveProtocol();
@@ -605,7 +605,7 @@ std::vector<std::pair<int64_t, MasternodeRef>> CMasternodeMan::GetMasternodeRank
     std::vector<std::pair<int64_t, MasternodeRef>> vecMasternodeScores;
     const uint256& hash = GetHashAtHeight(nBlockHeight - 1);
     // height outside range
-    if (!hash) return vecMasternodeScores;
+    if (hash == UINT256_ZERO) return vecMasternodeScores;
     {
         LOCK(cs);
         // scan for winner
@@ -813,7 +813,7 @@ int64_t CMasternodeMan::SecondsSincePayment(const MasternodeRef& mn, const CBloc
     CHashWriter ss(SER_GETHASH, PROTOCOL_VERSION);
     ss << mn->vin;
     ss << mn->sigTime;
-    uint256 hash = ss.GetHash();
+    const arith_uint256& hash = UintToArith256(ss.GetHash());
 
     // return some deterministic value for unknown/unpaid but force it to be more than 30 days old
     return month + hash.GetCompact(false);
@@ -832,7 +832,7 @@ int64_t CMasternodeMan::GetLastPaid(const MasternodeRef& mn, const CBlockIndex*
     uint256 hash = ss.GetHash();
 
     // use a deterministic offset to break a tie -- 2.5 minutes
-    int64_t nOffset = hash.GetCompact(false) % 150;
+    int64_t nOffset = UintToArith256(hash).GetCompact(false) % 150;
 
     int nMnCount = CountEnabled() * 1.25;
     for (int n = 0; n < nMnCount; n++) {