Add verifiedbeaconreport and pendingbeaconreport

src/rpcblockchain.cpp

@@ -37,6 +37,10 @@ extern UniValue SuperblockReport(int lookback = 14, bool displaycontract = false
 extern bool ScraperSynchronizeDPOR();
 std::string ExplainMagnitude(std::string sCPID);
 
+extern ScraperPendingBeaconMap GetPendingBeaconsForReport();
+extern ScraperPendingBeaconMap GetVerifiedBeaconsForReport(bool from_global = false);
+
+
 extern UniValue GetJSONVersionReport(const int64_t lookback, const bool full_version);
 
 bool GetEarliestStakeTime(std::string grcaddress, std::string cpid);
@@ -735,18 +739,29 @@ UniValue revokebeacon(const UniValue& params, bool fHelp)
 
 UniValue beaconreport(const UniValue& params, bool fHelp)
 {
-    if (fHelp || params.size() != 0)
+    if (fHelp || params.size() > 0)
         throw runtime_error(
                 "beaconreport\n"
                 "\n"
                 "Displays list of valid beacons in the network\n");
 
-    LOCK(cs_main);
-
     UniValue results(UniValue::VARR);
 
-    for (const auto& beacon_pair : NN::GetBeaconRegistry().Beacons())
+    std::vector<std::pair<NN::Cpid, NN::Beacon>> active_beacons;
+
+    // Minimize the lock on cs_main.
+    {
+        LOCK(cs_main);
+
+        const auto& beacon_map = NN::GetBeaconRegistry().Beacons();
+
+        active_beacons.reserve(beacon_map.size());
+        active_beacons.assign(beacon_map.begin(), beacon_map.end());
+    }
+
+    for (const auto& beacon_pair : active_beacons)
     {
+
         UniValue entry(UniValue::VOBJ);
 
         entry.pushKV("cpid", beacon_pair.first.ToString());
@@ -759,6 +774,108 @@ UniValue beaconreport(const UniValue& params, bool fHelp)
     return results;
 }
 
+UniValue beaconconvergence(const UniValue& params, bool fHelp)
+{
+    if (fHelp || params.size() > 0)
+        throw runtime_error(
+                "verifiedbeaconreport\n"
+                "\n"
+                "Displays verified and pending beacons from the scraper viewpoint.\n");
+
+    UniValue results(UniValue::VOBJ);
+
+    std::vector<std::pair<NN::Cpid, NN::Beacon>> active_beacons;
+
+    UniValue verified_from_global(UniValue::VARR);
+
+    ScraperPendingBeaconMap verified_beacons_from_global = GetVerifiedBeaconsForReport(true);
+
+    for (const auto&verified_beacon_pair : verified_beacons_from_global)
+    {
+        UniValue entry(UniValue::VOBJ);
+
+        entry.pushKV("cpid", verified_beacon_pair.first);
+        entry.pushKV("timestamp", verified_beacon_pair.second.timestamp);
+
+        verified_from_global.push_back(entry);
+    }
+
+    results.pushKV("verified beacons from scraper global", verified_from_global);
+
+
+    UniValue verified_from_convergence(UniValue::VARR);
+
+    ScraperPendingBeaconMap verified_beacons_from_convergence = GetVerifiedBeaconsForReport(false);
+
+    for (const auto&verified_beacon_pair : verified_beacons_from_convergence)
+    {
+        UniValue entry(UniValue::VOBJ);
+
+        entry.pushKV("cpid", verified_beacon_pair.first);
+        entry.pushKV("timestamp", verified_beacon_pair.second.timestamp);
+
+        verified_from_convergence.push_back(entry);
+    }
+
+    results.pushKV("verified beacons from latest convergence", verified_from_convergence);
+
+    UniValue pending(UniValue::VARR);
+
+    ScraperPendingBeaconMap pending_beacons = GetPendingBeaconsForReport();
+
+    for (const auto& beacon_pair : pending_beacons)
+    {
+        UniValue entry(UniValue::VOBJ);
+
+        entry.pushKV("cpid", beacon_pair.second.cpid);
+        entry.pushKV("address", beacon_pair.first);
+        entry.pushKV("timestamp", beacon_pair.second.timestamp);
+
+        pending.push_back(entry);
+    }
+
+    results.pushKV("pending beacons from GetConsensusBeaconList", pending);
+
+    return results;
+}
+
+UniValue pendingbeaconreport(const UniValue& params, bool fHelp)
+{
+    if (fHelp || params.size() > 0)
+        throw runtime_error(
+                "pendingbeaconreport\n"
+                "\n"
+                "Displays pending beacons directly from the beacon registry.\n");
+
+    UniValue results(UniValue::VARR);
+
+    std::vector<std::pair<CKeyID, NN::PendingBeacon>> pending_beacons;
+
+    // Minimize the lock on cs_main.
+    {
+        LOCK(cs_main);
+
+        const auto& pending_beacon_map = NN::GetBeaconRegistry().PendingBeacons();
+
+        pending_beacons.reserve(pending_beacon_map.size());
+        pending_beacons.assign(pending_beacon_map.begin(), pending_beacon_map.end());
+    }
+
+    for (const auto& pending_beacon_pair : pending_beacons)
+    {
+
+        UniValue entry(UniValue::VOBJ);
+
+        entry.pushKV("cpid", pending_beacon_pair.second.m_cpid.ToString());
+        entry.pushKV("address", pending_beacon_pair.first.ToString());
+        entry.pushKV("timestamp", pending_beacon_pair.second.m_timestamp);
+
+        results.push_back(entry);
+    }
+
+    return results;
+}
+
 UniValue beaconstatus(const UniValue& params, bool fHelp)
 {
     if (fHelp || params.size() > 1)

src/rpcserver.cpp

@@ -340,6 +340,7 @@ static const CRPCCommand vRPCCommands[] =
 
   // Mining commands
     { "advertisebeacon",         &advertisebeacon,         cat_mining        },
+    { "beaconconvergence",       &beaconconvergence,       cat_mining        },
     { "beaconreport",            &beaconreport,            cat_mining        },
     { "beaconstatus",            &beaconstatus,            cat_mining        },
     { "explainmagnitude",        &explainmagnitude,        cat_mining        },
@@ -348,6 +349,7 @@ static const CRPCCommand vRPCCommands[] =
     { "magnitude",               &magnitude,               cat_mining        },
     { "myneuralhash",            &myneuralhash,            cat_mining        },
     { "neuralhash",              &neuralhash,              cat_mining        },
+    { "pendingbeaconreport",     &pendingbeaconreport,     cat_mining        },
     { "resetcpids",              &resetcpids,              cat_mining        },
     { "revokebeacon",            &revokebeacon,            cat_mining        },
     { "staketime",               &staketime,               cat_mining        },

src/rpcserver.h

@@ -159,13 +159,15 @@ extern UniValue walletpassphrasechange(const UniValue& params, bool fHelp);
 //Mining
 extern UniValue advertisebeacon(const UniValue& params, bool fHelp);
 extern UniValue beaconreport(const UniValue& params, bool fHelp);
+extern UniValue beaconconvergence(const UniValue& params, bool fHelp);
 extern UniValue beaconstatus(const UniValue& params, bool fHelp);
 extern UniValue explainmagnitude(const UniValue& params, bool fHelp);
 extern UniValue getmininginfo(const UniValue& params, bool fHelp);
 extern UniValue lifetime(const UniValue& params, bool fHelp);
 extern UniValue magnitude(const UniValue& params, bool fHelp);
 extern UniValue myneuralhash(const UniValue& params, bool fHelp);
 extern UniValue neuralhash(const UniValue& params, bool fHelp);
+extern UniValue pendingbeaconreport(const UniValue& params, bool fHelp);
 extern UniValue resetcpids(const UniValue& params, bool fHelp);
 extern UniValue revokebeacon(const UniValue& params, bool fHelp);
 extern UniValue staketime(const UniValue& params, bool fHelp);

src/scraper/scraper.cpp

@@ -4925,6 +4925,41 @@ ScraperStatsAndVerifiedBeacons GetScraperStatsAndVerifiedBeacons(const Converged
     return stats_and_verified_beacons;
 }
 
+// This is for rpc report functions.
+ScraperPendingBeaconMap GetPendingBeaconsForReport()
+{
+    return GetConsensusBeaconList().mPendingMap;
+}
+
+ScraperPendingBeaconMap GetVerifiedBeaconsForReport(bool from_global)
+{
+    ScraperPendingBeaconMap VerifiedBeacons;
+
+    if (from_global)
+    {
+        LOCK(cs_VerifiedBeacons);
+        _log(logattribute::INFO, "LOCK", "cs_VerifiedBeacons");
+
+        // An intentional copy.
+        VerifiedBeacons = GetVerifiedBeacons().mVerifiedMap;
+
+        _log(logattribute::INFO, "ENDLOCK", "cs_VerifiedBeacons");
+
+    }
+    else
+    {
+        LOCK(cs_ConvergedScraperStatsCache);
+        _log(logattribute::INFO, "LOCK", "cs_ConvergedScraperStatsCache");
+
+        // An intentional copy.
+        VerifiedBeacons = GetScraperStatsAndVerifiedBeacons(ConvergedScraperStatsCache).mVerifiedMap;
+
+        _log(logattribute::INFO, "ENDLOCK", "cs_ConvergedScraperStatsCache");
+    }
+
+    return VerifiedBeacons;
+}
+
 
 /***********************
 *    Neural Network    *

src/scraper/scraper.h

@@ -125,6 +125,8 @@ scraperSBvalidationtype ValidateSuperblock(const NN::Superblock& NewFormatSuperb
 std::vector<uint160> GetVerifiedBeaconIDs(const ConvergedManifest& StructConvergedManifest);
 std::vector<uint160> GetVerifiedBeaconIDs(const ScraperPendingBeaconMap& VerifiedBeaconMap);
 ScraperStatsAndVerifiedBeacons GetScraperStatsAndVerifiedBeacons(const ConvergedScraperStats &stats);
+ScraperPendingBeaconMap GetPendingBeaconsForReport();
+ScraperPendingBeaconMap GetVerifiedBeaconsForReport(bool from_global = false);
 
 static std::vector<std::string> vstatsobjecttypestrings = { "NetWorkWide", "byCPID", "byProject", "byCPIDbyProject" };