Merge branch 'develop' of https://github.com/dashpay/dash into develop

Author: PastaPastaPasta

doc/release-notes-7062.md

@@ -0,0 +1,8 @@
+# RPC changes
+
+- `quorum dkginfo` will now require that nodes run either in watch-only mode (`-watchquorums`) or as an
+  active masternode (i.e. masternode mode) as regular nodes do not have insight into network DKG activity.
+
+- `quorum dkgstatus` will no longer emit the return values `time`, `timeStr` and `session` on nodes that
+  do not run in either watch-only or masternode mode as regular nodes do not have insight into network
+  DKG activity.

src/Makefile.qt.include

@@ -139,6 +139,7 @@ BITCOIN_QT_H = \
   qt/proposalwizard.h \
   qt/guiconstants.h \
   qt/guiutil.h \
+  qt/guiutil_font.h \
   qt/initexecutor.h \
   qt/intro.h \
   qt/macdockiconhandler.h \
@@ -230,6 +231,7 @@ BITCOIN_QT_BASE_CPP = \
   qt/clientmodel.cpp \
   qt/csvmodelwriter.cpp \
   qt/guiutil.cpp \
+  qt/guiutil_font.cpp \
   qt/initexecutor.cpp \
   qt/intro.cpp \
   qt/modaloverlay.cpp \

src/init.cpp

@@ -2225,9 +2225,8 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         g_active_notification_interface = std::make_unique<ActiveNotificationInterface>(*node.active_ctx, *node.mn_activeman);
         RegisterValidationInterface(g_active_notification_interface.get());
     } else if (quorums_watch) {
-        node.observer_ctx = std::make_unique<llmq::ObserverContext>(*node.llmq_ctx->bls_worker, *node.dmnman, *node.mn_metaman, *node.llmq_ctx->dkg_debugman,
-                                                                    *node.llmq_ctx->quorum_block_processor, *node.llmq_ctx->qman, *node.llmq_ctx->qsnapman, chainman,
-                                                                    *node.sporkman, dash_db_params);
+        node.observer_ctx = std::make_unique<llmq::ObserverContext>(*node.llmq_ctx->bls_worker, *node.dmnman, *node.mn_metaman, *node.llmq_ctx->quorum_block_processor,
+                                                                    *node.llmq_ctx->qman, *node.llmq_ctx->qsnapman, chainman, *node.sporkman, dash_db_params);
         RegisterValidationInterface(node.observer_ctx.get());
     }
 

src/llmq/context.cpp

@@ -8,7 +8,6 @@
 #include <chainlock/chainlock.h>
 #include <instantsend/instantsend.h>
 #include <llmq/blockprocessor.h>
-#include <llmq/debug.h>
 #include <llmq/quorums.h>
 #include <llmq/signing.h>
 #include <llmq/snapshot.h>
@@ -20,7 +19,6 @@ LLMQContext::LLMQContext(ChainstateManager& chainman, CDeterministicMNManager& d
                          const llmq::QvvecSyncModeMap& sync_map, const util::DbWrapperParams& db_params,
                          bool quorums_recovery, bool quorums_watch, int8_t bls_threads, int64_t max_recsigs_age) :
     bls_worker{std::make_shared<CBLSWorker>()},
-    dkg_debugman{std::make_unique<llmq::CDKGDebugManager>()},
     qsnapman{std::make_unique<llmq::CQuorumSnapshotManager>(evo_db)},
     quorum_block_processor{std::make_unique<llmq::CQuorumBlockProcessor>(chainman.ActiveChainstate(), dmnman, evo_db,
                                                                          *qsnapman, bls_threads)},

src/llmq/context.h

@@ -21,7 +21,6 @@ class PeerManager;
 
 namespace llmq {
 class CChainLocksHandler;
-class CDKGDebugManager;
 class CInstantSendManager;
 class CQuorumBlockProcessor;
 class CQuorumManager;
@@ -58,7 +57,6 @@ struct LLMQContext {
      *  but it still guarantees that objects are created and valid
      */
     const std::shared_ptr<CBLSWorker> bls_worker;
-    const std::unique_ptr<llmq::CDKGDebugManager> dkg_debugman;
     const std::unique_ptr<llmq::CQuorumSnapshotManager> qsnapman;
     const std::unique_ptr<llmq::CQuorumBlockProcessor> quorum_block_processor;
     const std::unique_ptr<llmq::CQuorumManager> qman;

src/llmq/core_write.cpp

@@ -78,13 +78,13 @@ RPCResult CDKGDebugSessionStatus::GetJsonHelp(const std::string& key, bool optio
 }
 
 // CDKGDebugStatus::ToJson() defined in llmq/debug.cpp
-RPCResult CDKGDebugStatus::GetJsonHelp(const std::string& key, bool optional)
+RPCResult CDKGDebugStatus::GetJsonHelp(const std::string& key, bool optional, bool inner_optional)
 {
     return {RPCResult::Type::OBJ, key, optional, key.empty() ? "" : "The state of the node's DKG sessions",
     {
-        {RPCResult::Type::NUM, "time", "Adjusted time for the last update, timestamp"},
-        {RPCResult::Type::STR, "timeStr", "Adjusted time for the last update, human friendly"},
-        {RPCResult::Type::ARR, "session", "", {
+        {RPCResult::Type::NUM, "time", inner_optional, "Adjusted time for the last update, timestamp"},
+        {RPCResult::Type::STR, "timeStr", inner_optional, "Adjusted time for the last update, human friendly"},
+        {RPCResult::Type::ARR, "session", inner_optional, "", {
             {RPCResult::Type::OBJ, "", "", {
                 {RPCResult::Type::NUM, "llmqType", "Name of quorum"},
                 GetRpcResult("quorumIndex"),

src/llmq/debug.h

@@ -92,7 +92,7 @@ class CDKGDebugStatus
     //std::map<Consensus::LLMQType, CDKGDebugSessionStatus> sessions;
 
 public:
-    [[nodiscard]] static RPCResult GetJsonHelp(const std::string& key, bool optional);
+    [[nodiscard]] static RPCResult GetJsonHelp(const std::string& key, bool optional, bool inner_optional = false);
     [[nodiscard]] UniValue ToJson(CDeterministicMNManager& dmnman, CQuorumSnapshotManager& qsnapman,
                                   const ChainstateManager& chainman, int detailLevel) const;
 };

src/llmq/observer/context.cpp

@@ -4,19 +4,20 @@
 
 #include <llmq/observer/context.h>
 
+#include <llmq/debug.h>
 #include <llmq/dkgsessionmgr.h>
 #include <llmq/quorums.h>
 
 namespace llmq {
-ObserverContext::ObserverContext(CBLSWorker& bls_worker, CDeterministicMNManager& dmnman,
-                                 CMasternodeMetaMan& mn_metaman, llmq::CDKGDebugManager& dkg_debugman,
+ObserverContext::ObserverContext(CBLSWorker& bls_worker, CDeterministicMNManager& dmnman, CMasternodeMetaMan& mn_metaman,
                                  llmq::CQuorumBlockProcessor& qblockman, llmq::CQuorumManager& qman,
                                  llmq::CQuorumSnapshotManager& qsnapman, const ChainstateManager& chainman,
                                  const CSporkManager& sporkman, const util::DbWrapperParams& db_params) :
     m_qman{qman},
-    qdkgsman{std::make_unique<llmq::CDKGSessionManager>(bls_worker, dmnman, dkg_debugman, mn_metaman, qblockman,
-                                                        qsnapman, /*mn_activeman=*/nullptr, chainman, sporkman,
-                                                        db_params, /*quorums_watch=*/true)}
+    dkgdbgman{std::make_unique<llmq::CDKGDebugManager>()},
+    qdkgsman{std::make_unique<llmq::CDKGSessionManager>(bls_worker, dmnman, *dkgdbgman, mn_metaman, qblockman, qsnapman,
+                                                        /*mn_activeman=*/nullptr, chainman, sporkman, db_params,
+                                                        /*quorums_watch=*/true)}
 {
     m_qman.ConnectManager(qdkgsman.get());
 }

src/llmq/observer/context.h

@@ -36,8 +36,8 @@ struct ObserverContext final : public CValidationInterface {
     ObserverContext(const ObserverContext&) = delete;
     ObserverContext& operator=(const ObserverContext&) = delete;
     ObserverContext(CBLSWorker& bls_worker, CDeterministicMNManager& dmnman, CMasternodeMetaMan& mn_metaman,
-                    llmq::CDKGDebugManager& dkg_debugman, llmq::CQuorumBlockProcessor& qblockman,
-                    llmq::CQuorumManager& qman, llmq::CQuorumSnapshotManager& qsnapman, const ChainstateManager& chainman,
+                    llmq::CQuorumBlockProcessor& qblockman, llmq::CQuorumManager& qman,
+                    llmq::CQuorumSnapshotManager& qsnapman, const ChainstateManager& chainman,
                     const CSporkManager& sporkman, const util::DbWrapperParams& db_params);
     ~ObserverContext();
 
@@ -46,6 +46,7 @@ struct ObserverContext final : public CValidationInterface {
     void UpdatedBlockTip(const CBlockIndex* pindexNew, const CBlockIndex* pindexFork, bool fInitialDownload) override;
 
 public:
+    const std::unique_ptr<llmq::CDKGDebugManager> dkgdbgman;
     const std::unique_ptr<llmq::CDKGSessionManager> qdkgsman;
 };
 } // namespace llmq

src/masternode/active/context.cpp

@@ -11,6 +11,7 @@
 #include <instantsend/instantsend.h>
 #include <instantsend/signing.h>
 #include <llmq/context.h>
+#include <llmq/debug.h>
 #include <llmq/dkgsessionmgr.h>
 #include <llmq/ehf_signals.h>
 #include <llmq/quorums.h>
@@ -25,8 +26,9 @@ ActiveContext::ActiveContext(CCoinJoinServer& cj_server, CConnman& connman, CDet
     m_llmq_ctx{llmq_ctx},
     m_cj_server(cj_server),
     gov_signer{std::make_unique<GovernanceSigner>(connman, dmnman, govman, mn_activeman, chainman, mn_sync)},
-    qdkgsman{std::make_unique<llmq::CDKGSessionManager>(*llmq_ctx.bls_worker, dmnman, *llmq_ctx.dkg_debugman,
-                                                        mn_metaman, *llmq_ctx.quorum_block_processor, *llmq_ctx.qsnapman,
+    dkgdbgman{std::make_unique<llmq::CDKGDebugManager>()},
+    qdkgsman{std::make_unique<llmq::CDKGSessionManager>(*llmq_ctx.bls_worker, dmnman, *dkgdbgman, mn_metaman,
+                                                        *llmq_ctx.quorum_block_processor, *llmq_ctx.qsnapman,
                                                         &mn_activeman, chainman, sporkman, db_params, quorums_watch)},
     shareman{std::make_unique<llmq::CSigSharesManager>(connman, chainman.ActiveChainstate(), *llmq_ctx.sigman, peerman,
                                                        mn_activeman, *llmq_ctx.qman, sporkman)},