Refactor AVW calculations into the poll Result class

Implement integer based poll validation boolan in result based on
poll type avw rules.

Author: jamescowens

src/gridcoin/voting/registry.cpp

@@ -311,6 +311,8 @@ ClaimMessage GRC::PackPollMessage(const Poll& poll, const CTransaction& tx)
 
 PollReference::PollReference()
     : m_ptxid(nullptr)
+    , m_payload_version(0)
+    , m_type(PollType::UNKNOWN)
     , m_ptitle(nullptr)
     , m_timestamp(0)
     , m_duration_days(0)
@@ -356,6 +358,16 @@ uint256 PollReference::Txid() const
     return *m_ptxid;
 }
 
+uint32_t PollReference::GetPollPayloadVersion() const
+{
+    return m_payload_version;
+}
+
+PollType PollReference::GetPollType() const
+{
+    return m_type;
+}
+
 const std::string& PollReference::Title() const
 {
     if (!m_ptitle) {
@@ -909,6 +921,8 @@ void PollRegistry::AddPoll(const ContractContext& ctx)
 
         PollReference& poll_ref = result_pair.first->second;
         poll_ref.m_ptitle = &title;
+        poll_ref.m_payload_version = payload->m_version;
+        poll_ref.m_type = payload->m_poll.m_type.Value();
         poll_ref.m_timestamp = ctx.m_tx.nTime;
         poll_ref.m_duration_days = payload->m_poll.m_duration_days;
 

src/gridcoin/voting/registry.h

@@ -8,6 +8,8 @@
 #include "gridcoin/contract/handler.h"
 #include "gridcoin/voting/filter.h"
 #include "gridcoin/voting/fwd.h"
+#include "uint256.h"
+#include <map>
 
 class CTxDB;
 
@@ -55,6 +57,16 @@ class PollReference
     //!
     uint256 Txid() const;
 
+    //!
+    //! \brief Get the poll (payload) version
+    //!
+    uint32_t GetPollPayloadVersion() const;
+
+    //!
+    //! \brief Get the poll type
+    //!
+    PollType GetPollType() const;
+
     //!
     //! \brief Get the title of the associated poll.
     //!
@@ -127,6 +139,11 @@ class PollReference
     //!
     std::optional<int> GetEndingHeight() const;
 
+    //!
+    //! \brief Computes the Active Vote Weight for the poll, which is used to determine whether the poll is validated.
+    //! \param result: The actual tabulated votes (poll result)
+    //! \return ActiveVoteWeight
+    //!
     std::optional<CAmount> GetActiveVoteWeight(const PollResultOption &result) const;
 
     //!
@@ -146,6 +163,8 @@ class PollReference
 
 private:
     const uint256* m_ptxid;       //!< Hash of the poll transaction.
+    uint32_t m_payload_version;   //!< Version of the poll (payload).
+    PollType m_type;              //!< Type of the poll.
     const std::string* m_ptitle;  //!< Title of the poll.
     int64_t m_timestamp;          //!< Timestamp of the poll transaction.
     uint32_t m_duration_days;     //!< Number of days the poll remains active.

src/gridcoin/voting/result.cpp

@@ -1108,6 +1108,9 @@ PollResult::PollResult(Poll poll)
     , m_total_weight(0)
     , m_invalid_votes(0)
     , m_pools_voted({})
+    , m_active_vote_weight()
+    , m_vote_percent_avw()
+    , m_poll_results_validated()
     , m_finished(m_poll.Expired(GetAdjustedTime()))
 {
     m_responses.resize(m_poll.Choices().size());
@@ -1128,6 +1131,25 @@ PollResultOption PollResult::BuildFor(const PollReference& poll_ref)
 
         counter.CountVotes(result, poll_ref.Votes());
 
+        if (auto active_vote_weight = poll_ref.GetActiveVoteWeight(result)) {
+            result.m_active_vote_weight = active_vote_weight;
+
+            result.m_vote_percent_avw = (double) result.m_total_weight / (double) *result.m_active_vote_weight * 100.0;
+
+            // For purposes of validation, integer arithmetic is used.
+            uint32_t vote_percent_avw_for_validation = (uint32_t)((int64_t) result.m_total_weight * (int64_t) 100
+                                                                  / (int64_t) *result.m_active_vote_weight);
+
+            // For v1 and v2 polls, there is only one type, SURVEY, that was used on the blockchain for all polls, so this
+            // can only be done for v3+.
+            if (poll_ref.GetPollPayloadVersion() > 2) {
+                uint32_t min_vote_percent_avw_for_validation
+                        = Poll::POLL_TYPE_RULES[(int) poll_ref.GetPollType()].m_min_vote_percent_AVW;
+
+                result.m_poll_results_validated = (vote_percent_avw_for_validation >= min_vote_percent_avw_for_validation);
+            }
+        }
+
         return result;
     }
 

src/gridcoin/voting/result.h

@@ -77,11 +77,14 @@ class PollResult
         bool Empty() const;
     };
 
-    const Poll m_poll;               //!< The poll associated with the result.
-    Weight m_total_weight;           //!< Aggregate weight of all the votes submitted.
-    size_t m_invalid_votes;          //!< Number of votes that failed validation.
-    std::vector<Cpid> m_pools_voted; //!< Cpids of pools that actually voted
-    bool m_finished;                 //!< Whether the poll finished as of this result.
+    const Poll m_poll;                            //!< The poll associated with the result.
+    Weight m_total_weight;                        //!< Aggregate weight of all the votes submitted.
+    size_t m_invalid_votes;                       //!< Number of votes that failed validation.
+    std::vector<Cpid> m_pools_voted;              //!< Cpids of pools that actually voted.
+    std::optional<CAmount> m_active_vote_weight;  //!< Active vote weight of poll.
+    std::optional<double> m_vote_percent_avw;     //!< Vote weight percent of AVW.
+    std::optional<bool> m_poll_results_validated; //!< Whether the poll's AVW is >= the minimum AVW for the poll.
+    bool m_finished;                              //!< Whether the poll finished as of this result.
 
     //!
     //! \brief The aggregated voting weight tallied for each poll choice.

src/qt/voting/votingmodel.cpp

@@ -62,15 +62,14 @@ std::optional<PollItem> BuildPollItem(const PollRegistry::Sequence::Iterator& it
     item.m_total_votes = result->m_votes.size();
     item.m_total_weight = result->m_total_weight / COIN;
 
-    if (auto active_vote_weight = ref.GetActiveVoteWeight(result)) {
-        item.m_active_weight = *active_vote_weight / COIN;
-    } else {
-        item.m_active_weight = 0;
+    item.m_active_weight = 0;
+    if (result->m_active_vote_weight) {
+        item.m_active_weight = *result->m_active_vote_weight / COIN;
     }
 
     item.m_vote_percent_AVW = 0;
-    if (item.m_active_weight > 0) {
-        item.m_vote_percent_AVW = (double) item.m_total_weight / (double) item.m_active_weight * 100.0;
+    if (result->m_vote_percent_avw) {
+        item.m_vote_percent_AVW = *result->m_vote_percent_avw;
     }
 
     item.m_finished = result->m_finished;

src/rpc/voting.cpp

@@ -101,9 +101,16 @@ UniValue PollResultToJson(const PollResult& result, const PollReference& poll_re
     json.pushKV("invalid_votes", (uint64_t)result.m_invalid_votes);
     json.pushKV("total_weight", ValueFromAmount(result.m_total_weight));
 
-    if (auto active_vote_weight = poll_ref.GetActiveVoteWeight(result)) {
-        json.pushKV("active_vote_weight", ValueFromAmount(*active_vote_weight));
-        json.pushKV("vote_percent_avw", (double) result.m_total_weight / (double) *active_vote_weight * 100.0);
+    if (result.m_active_vote_weight) {
+        json.pushKV("active_vote_weight", ValueFromAmount(*result.m_active_vote_weight));
+    }
+
+    if (result.m_vote_percent_avw) {
+        json.pushKV("vote_percent_avw", *result.m_vote_percent_avw);
+    }
+
+    if (result.m_poll_results_validated) {
+        json.pushKV("poll_results_validated", *result.m_poll_results_validated);
     }
 
     if (!result.m_votes.empty()) {