accrual mod WIP

Author: jamescowens

src/chainparams.h

@@ -134,5 +134,5 @@ inline int GetNewbieSnapshotFixHeight()
 {
     // This was the original hard fork point for the newbie accrual fix that didn't work.
     // return fTestNet ? 1393000 : 2104000;
-    return fTestNet ? 1479000 : 2104000;
+    return fTestNet ? 1393000 : 2104000;
 }

src/gridcoin/beacon.cpp

@@ -44,7 +44,10 @@ uint256 HashBeaconPayload(const BeaconPayload& payload)
 //! \return \c true if the supplied beacon contract matches an active beacon.
 //! This updates the matched beacon with a new timestamp.
 //!
-bool TryRenewal(BeaconRegistry::BeaconMap& beacons, const BeaconPayload& payload)
+bool TryRenewal(BeaconRegistry::BeaconMap& beacons,
+                BeaconRegistry::HistoricalBeaconMap& historical_beacons,
+                const BeaconPayload& payload,
+                const uint256& ctx_hash)
 {
     auto beacon_pair_iter = beacons.find(payload.m_cpid);
 
@@ -62,7 +65,12 @@ bool TryRenewal(BeaconRegistry::BeaconMap& beacons, const BeaconPayload& payload
         return false;
     }
 
+    // Insert current beacon into historical map.
+    historical_beacons.emplace(std::make_pair(ctx_hash, current_beacon));
+
+    // Update current beacon record.
     current_beacon.m_timestamp = payload.m_beacon.m_timestamp;
+    current_beacon.m_prev_beacon_txn_hash = ctx_hash;
 
     return true;
 }
@@ -93,6 +101,7 @@ Beacon::Beacon(CPubKey public_key)
 Beacon::Beacon(CPubKey public_key, int64_t timestamp)
     : m_public_key(std::move(public_key))
     , m_timestamp(timestamp)
+    , m_prev_beacon_txn_hash()
 {
 }
 
@@ -157,6 +166,12 @@ bool Beacon::Renewable(const int64_t now) const
     return Age(now) > RENEWAL_AGE;
 }
 
+bool Beacon::Renewed() const
+{
+    // If not empty, the beacon was a renewal.
+    return (m_prev_beacon_txn_hash != uint256());
+}
+
 CKeyID Beacon::GetId() const
 {
     return m_public_key.GetID();
@@ -276,6 +291,11 @@ const BeaconRegistry::PendingBeaconMap& BeaconRegistry::PendingBeacons() const
     return m_pending;
 }
 
+const BeaconRegistry::HistoricalBeaconMap &BeaconRegistry::HistoricalBeacons() const
+{
+    return m_historical;
+}
+
 BeaconOption BeaconRegistry::Try(const Cpid& cpid) const
 {
     const auto iter = m_beacons.find(cpid);
@@ -353,7 +373,7 @@ void BeaconRegistry::Add(const ContractContext& ctx)
     // For beacon renewals, check that the new beacon contains the same public
     // key. If it matches, we don't need to verify it again:
     //
-    if (TryRenewal(m_beacons, payload)) {
+    if (TryRenewal(m_beacons, m_historical, payload, ctx.m_tx.GetHash())) {
         return;
     }
 

src/gridcoin/beacon.h

@@ -68,6 +68,13 @@ class Beacon
     CPubKey m_public_key;      //!< Verifies blocks that claim research rewards.
     int64_t m_timestamp;       //!< Time of the the beacon contract transaction.
 
+    // The reason the transaction hash is included here instead of a pointer
+    // to the previous beacon, is that given the limited lookback scope, the
+    // previous beacon may not be in the map. This makes the linked list harder
+    // to deal with, but relieves us of dealing with the leading edge of the
+    // lookback window.
+    uint256 m_prev_beacon_txn_hash; //!< If a renewal contains the txn hash of the previous beacon.
+
     //!
     //! \brief Initialize an empty, invalid beacon instance.
     //!
@@ -140,6 +147,13 @@ class Beacon
     //!
     bool Renewable(const int64_t now) const;
 
+    //!
+    //! \brief Determine whether the beacon was renewed.
+    //!
+    //! \return \c true if the beacon is a renewal rather than new advertisement
+    //!
+    bool Renewed() const;
+
     //!
     //! \brief Get the hash of the beacon public key.
     //!
@@ -409,6 +423,11 @@ class BeaconRegistry : public IContractHandler
     //!
     typedef std::unordered_map<Cpid, Beacon> BeaconMap;
 
+    //!
+    //! \brief The type that associates historical beacons with the ctx hash.
+    //!
+    typedef std::map<uint256, Beacon> HistoricalBeaconMap;
+
     //!
     //! \brief Associates pending beacons with the hash of the beacon public
     //! keys.
@@ -429,6 +448,13 @@ class BeaconRegistry : public IContractHandler
     //!
     const PendingBeaconMap& PendingBeacons() const;
 
+    //!
+    //! \brief Get the collection of historical beacons.
+    //!
+    //! \return A reference to the historical beacons stored in the registry.
+    //!
+    const HistoricalBeaconMap& HistoricalBeacons() const;
+
     //!
     //! \brief Get the beacon for the specified CPID.
     //!
@@ -531,6 +557,7 @@ class BeaconRegistry : public IContractHandler
 private:
     BeaconMap m_beacons;        //!< Contains the active registered beacons.
     PendingBeaconMap m_pending; //!< Contains beacons awaiting verification.
+    HistoricalBeaconMap m_historical; //!< Contains historical beacons.
 }; // BeaconRegistry
 
 //!

src/gridcoin/tally.cpp

@@ -558,8 +558,8 @@ class ResearcherTally
     {
         const SnapshotCalculator calc(superblock.m_timestamp, m_current_superblock);
 
-        LogPrint(BCLog::LogFlags::ACCRUAL, "INFO %s: m_researchers.size() = %u",
-                 __func__, m_researchers.size());
+        LogPrint(BCLog::LogFlags::ACCRUAL, "INFO %s: superblock height = %u, m_researchers.size() = %u",
+                 __func__, superblock.m_height, m_researchers.size());
 
         for (auto& account_pair : m_researchers) {
             const Cpid cpid = account_pair.first;
@@ -594,7 +594,7 @@ class ResearcherTally
                 ResearchAccount& account = m_researchers[iter.Cpid()];
                 account.m_accrual = calc.AccrualDelta(iter.Cpid(), account);
 
-                LogPrint(BCLog::LogFlags::ACCRUAL, "INFO %s: accrual account not found"
+                LogPrint(BCLog::LogFlags::ACCRUAL, "INFO %s: accrual account not found "
                          "for CPID %s. Creating account with accrual %" PRId64" from "
                          "AccrualDelta() = %" PRId64 ". m_researchers.size() now %u",
                          __func__,
@@ -626,15 +626,16 @@ class ResearcherTally
 
                     account.m_accrual = accrual_correction + accrual_delta;
 
-                    LogPrint(BCLog::LogFlags::ACCRUAL, "INFO %s: accrual account not found"
+                    LogPrint(BCLog::LogFlags::ACCRUAL, "INFO %s: accrual account not found "
                              "for CPID %s. Creating account with accrual %" PRId64" from "
-                             "Accrual Correction = %" PRId64 ", Accrual Delta = %" PRId64
-                             ", m_researchers.size() now %u.",
+                             "Accrual Correction = %" PRId64 ", Accrual Delta = %" PRId64 ", "
+                             "superblock height = %" PRId64 ", m_researchers.size() = %u.",
                              __func__,
                              iter.Cpid().ToString(),
                              account.m_accrual,
                              accrual_correction,
                              accrual_delta,
+                             superblock.m_height,
                              m_researchers.size());
                 }
             }
@@ -644,7 +645,7 @@ class ResearcherTally
     //!
     //! \brief Compute "catch-up" accrual to correct for newbie accrual bug.
     //!
-    //! \param superblock Incoming superblock to calculate rewards at.
+    //! \param cpid for which to calculate the accrual correction.
     //!
     CAmount GetNewbieSuperblockAccrualCorrection(Cpid cpid)
     {
@@ -658,22 +659,7 @@ class ResearcherTally
         // similar to the calculation in the auditsnapshotaccrual RPC function.
         CAmount accrual = 0;
 
-        const GRC::BeaconRegistry& beacons = GRC::GetBeaconRegistry();
-
-        // This had better succeed, because it is coming from the incoming superblock cpids! If not just
-        // return 0 accrual, because the beacon is not actually active.
-        const GRC::BeaconOption beacon = beacons.Try(cpid);
-
-        if (!beacon) return accrual;
-
-        // Start at the tip.
-        const CBlockIndex* pindex = mapBlockIndex[hashBestChain];
-
-        // In the loop below we will be going BACKWARDS through the chain, so this will be at a HIGHER
-        // height.
-        const CBlockIndex* pindex_prev;
-
-        SuperblockPtr superblock;
+        //const GRC::BeaconRegistry& beacons = GRC::GetBeaconRegistry();
 
         // This lambda is almost a straight lift from the auditsnapshotaccrual RPC function. It is simplifed,
         // because since the accrual account doesn't exist, there has been no staking for this CPID and no payout,
@@ -685,10 +671,18 @@ class ResearcherTally
         {
             int64_t time_interval = high_time - low_time;
 
+            int64_t abs_time_interval = time_interval;
+
+            int sign = (time_interval >= 0) ? 1 : -1;
+
+            if (sign < 0) {
+                abs_time_interval = -time_interval;
+            }
+
             // This is the same way that AccrualDelta calculates accruals in the snapshot calculator. Here
             // we use the absolute value of the time interval to ensure negative values are carried through
             // correctly in the bignumber calculations.
-            const uint64_t base_accrual = time_interval
+            const uint64_t base_accrual = abs_time_interval
                 * magnitude.Scaled()
                 * MAG_UNIT_NUMERATOR;
 
@@ -701,11 +695,11 @@ class ResearcherTally
                 accrual_bn /= Magnitude::SCALE_FACTOR;
                 accrual_bn /= MAG_UNIT_DENOMINATOR;
 
-                period = accrual_bn.GetLow64();
+                period = accrual_bn.GetLow64() * (int64_t) sign;
             }
             else
             {
-                period = base_accrual
+                period = base_accrual * (int64_t) sign
                         * COIN
                         / 86400
                         / Magnitude::SCALE_FACTOR
@@ -729,27 +723,63 @@ class ResearcherTally
             return period;
         };
 
+
+        // This had better succeed, because it is coming from the incoming superblock cpids! If not just
+        // return 0 accrual, because the beacon is not actually active.
+        //const GRC::BeaconOption beacon = beacons.Try(cpid);
+
+        //if (!beacon) return accrual;
+
+        const CBlockIndex* pindex_baseline = GRC::Tally::GetBaseline();
+
+        // Start at the tip.
+        const CBlockIndex* pindex_high = mapBlockIndex[hashBestChain];
+
+        // Rewind pindex_high to the current superblock.
+        while (pindex_high->nHeight > m_current_superblock.m_height)
+        {
+            pindex_high = pindex_high->pprev;
+        }
+
+        // Set pindex to the block before: (pindex_high->pprev).
+        const CBlockIndex* pindex = pindex_high->pprev;
+
+        SuperblockPtr superblock;
         unsigned int period_num = 0;
-        while (pindex->nHeight < m_current_superblock.m_height)
+
+        while (pindex->nHeight >= pindex_baseline->nHeight)
         {
-            // This ensures we move to the next (lower height) superblock as the first period to
-            // accrue.
-            if (period_num && pindex->IsSuperblock())
+            if (pindex->IsSuperblock())
             {
                 superblock = SuperblockPtr::ReadFromDisk(pindex);
 
                 const GRC::Magnitude magnitude = superblock->m_cpids.MagnitudeOf(cpid);
 
-                tally_accrual_period(pindex->nTime, pindex_prev->nTime, magnitude);
+                CAmount period = tally_accrual_period(pindex->nTime, pindex_high->nTime, magnitude);
+
+                LogPrint(BCLog::LogFlags::ACCRUAL, "INFO %s: period_num = %u, "
+                         "low height = %i, high height = %u, magnitude at low height SB = %f, "
+                         "low time = %u, high time = %u, "
+                         "accrual for period = %" PRId64 ", accrual = %" PRId64 ".",
+                         __func__,
+                         period_num,
+                         pindex->nHeight,
+                         pindex_high->nHeight,
+                         magnitude.Floating(),
+                         pindex->nTime,
+                         pindex_high->nTime,
+                         period,
+                         accrual);
 
                 // Stop the accrual when we get to a superblock that is before the beacon advertisement.
-                if (pindex->nTime < beacon->m_timestamp) break;
+                //if (pindex->nTime < beacon->m_timestamp) break;
+
+                // We are going backwards through the chain.
+                pindex_high = pindex;
+                ++period_num;
             }
 
-            // We are going backwards through the chain.
-            pindex_prev = pindex;
             pindex = pindex->pprev;
-            ++period_num;
         }
 
         return accrual;

src/rpc/mining.cpp

@@ -316,6 +316,23 @@ UniValue auditsnapshotaccrual(const UniValue& params, bool fHelp)
         }
     }
 
+    const GRC::BeaconRegistry& beacons = GRC::GetBeaconRegistry();
+
+    GRC::BeaconOption beacon = beacons.Try(*cpid);
+
+    UniValue beacon_chain(UniValue::VARR);
+
+    beacon_chain.push_back(beacon->m_timestamp);
+
+    // This walks back the entries in the historical beacon map linked by renewal prev tx hash until the first
+    // beacon in the renewal chain is found (the original advertisement). The accrual starts no earlier than here.
+    while (beacon->Renewed())
+    {
+        beacon = &beacons.HistoricalBeacons().find(beacon->m_prev_beacon_txn_hash)->second;
+
+        beacon_chain.push_back(beacon->m_timestamp);
+    }
+
     // Set the pindex_low to the pindex_superblock. For right now, we are going to take the accrual at the first snapshot
     // after the flip to v11 (the second snapshot in the accrual directory recorded at the first SB after the transition
     // height) as gospel. This doesn't allow us to verify the accrual between the transition height and the first snapshot
@@ -413,6 +430,10 @@ UniValue auditsnapshotaccrual(const UniValue& params, bool fHelp)
     };
 
     for (; pindex; pindex = pindex->pnext) {
+
+        // Due not accrue for any block with a timestamp earlier than the first beacon in the renewal chain.
+        //if (pindex->nTime < beacon->m_timestamp) continue;
+
         if (pindex->ResearchSubsidy() > 0 && pindex->GetMiningId() == *cpid) {
             tally_accrual_period(
                 "stake",
@@ -441,15 +462,20 @@ UniValue auditsnapshotaccrual(const UniValue& params, bool fHelp)
 
     int64_t period = tally_accrual_period("tip", 0, pindex_low->nTime, now, 0);
 
+    result.pushKV("cpid", cpid->ToString());
+    result.pushKV("accrual_account_exists", accrual_account_exists);
+
     if (report_details) {
+        result.pushKV("beacon_chain", beacon_chain);
         result.pushKV("audit", audit);
         result.pushKV("computed", computed);
-        result.pushKV("accrual_account_exists", accrual_account_exists);
     } else {
+        result.pushKV("latest_beacon_timestamp", beacon_chain[0]);
+        result.pushKV("original_beacon_timestamp", beacon_chain[beacon_chain.size() - 1]);
+        result.pushKV("renewals", beacon_chain.size() - 1);
         result.pushKV("accrual_by_audit", accrual);
         result.pushKV("accrual_by_GetAccrual", computed);
         result.pushKV("accrual_last_period", period);
-        result.pushKV("accrual_account_exists", accrual_account_exists);
     }
 
     return result;