continue implementation

Author: knst

src/dsnotificationinterface.cpp

@@ -19,6 +19,7 @@
 #include <llmq/chainlocks.h>
 #include <llmq/context.h>
 #include <llmq/dkgsessionmgr.h>
+#include <llmq/ehf_signals.h>
 #include <llmq/instantsend.h>
 #include <llmq/quorums.h>
 

src/llmq/chainlocks.cpp

@@ -207,6 +207,7 @@ void CChainLocksHandler::UpdatedBlockTip()
     // EnforceBestChainLock switching chains.
     // atomic[If tryLockChainTipScheduled is false, do (set it to true] and schedule signing).
     if (bool expected = false; tryLockChainTipScheduled.compare_exchange_strong(expected, true)) {
+        // TODO: use here pindexRev instead m_chainstate.m_chain.Tip()
         scheduler->scheduleFromNow([&]() {
             CheckActiveState();
             EnforceBestChainLock();

src/llmq/context.cpp

@@ -46,7 +46,7 @@ LLMQContext::LLMQContext(CChainState& chainstate, CConnman& connman, CEvoDB& evo
         llmq::quorumInstantSendManager = std::make_unique<llmq::CInstantSendManager>(*llmq::chainLocksHandler, chainstate, connman, *llmq::quorumManager, *sigman, *shareman, sporkman, mempool, *::masternodeSync, peerman, unit_tests, wipe);
         return llmq::quorumInstantSendManager.get();
     }()},
-    ehfSignalsHandler{std::make_unique<llmq:CEHFSignalsHandler>(mnhfman)}
+    ehfSignalsHandler{std::make_unique<llmq:CEHFSignalsHandler>(*sigman, *shareman, mnhfman)}
 {
     // NOTE: we use this only to wipe the old db, do NOT use it for anything else
     // TODO: remove it in some future version

src/llmq/ehf_signals.cpp

@@ -6,12 +6,15 @@
 
 //#include <scheduler.h>
 
-namespace llmq;
+namespace llmq {
 
 
 //std::unique_ptr<CEHFSignalsHandler> ehfSignalsHandler;
 
-CEHFSignalsHandler::CEHFSignalsHandler(CMNHFManager& mnhfManager) :
+CEHFSignalsHandler::CEHFSignalsHandler(CSigningManager& sigman, CSigSharesManager& shareman,
+                                       CMNHFManager& mnhfManager) :
+    sigman(sigman),
+    shareman(shareman),
     mnhfManager(mnhfManager)
     /*,
     scheduler(std::make_unique<CScheduler>()),
@@ -47,19 +50,47 @@ void CEHFSignalsHandler::Stop()
     sigman.UnregisterRecoveredSigsListener(this);
 }
 
-void CEHFSignalsHandler::UpdatedBlockTip()
+void CEHFSignalsHandler::UpdatedBlockTip(const CBlockIndex* const pindexNew)
 {
-    // don't call TrySignChainTip directly but instead let the scheduler call it. This way we ensure that cs_main is
-    // never locked and TrySignChainTip is not called twice in parallel. Also avoids recursive calls due to
-    // EnforceBestChainLock switching chains.
-    // atomic[If tryLockChainTipScheduled is false, do (set it to true] and schedule signing).
-    if (bool expected = false; tryLockChainTipScheduled.compare_exchange_strong(expected, true)) {
-        scheduler->scheduleFromNow([&]() {
-            CheckActiveState();
-            EnforceBestChainLock();
-            TrySignChainTip();
-            tryLockChainTipScheduled = false;
-        }, std::chrono::seconds{0});
+/*
+    scheduler->scheduleFromNow([&]() {
+        CheckActiveState();
+        EnforceBestChainLock();
+        TrySignChainTip();
+        tryLockChainTipScheduled = false;
+    }, std::chrono::seconds{0});
+    */
+    if (IsV20Active(pindexNew)) {
+        trySignEHFSignal(bit MN reward);
+    }
+}
+
+void CEHFSignalsHandler::trySignEHFSignal(int bit)
+{
+    if (!fMasternodeMode) {
+        return;
     }
+
+    if (!m_mn_sync.IsBlockchainSynced()) {
+        return;
+    }
+
+    uint256 requestId = ::SerializeHash(std::make_pair(MNHF_REQUESTID_PREFIX, pindex->nHeight));
+    /*
+    uint256 msgHash = pindex->GetBlockHash();
+
+    {
+        LOCK(cs);
+        if (bestChainLock.getHeight() >= pindex->nHeight) {
+            // might have happened while we didn't hold cs
+            return;
+        }
+        lastSignedHeight = pindex->nHeight;
+        lastSignedRequestId = requestId;
+        lastSignedMsgHash = msgHash;
+    }
+    */
+
+    sigman.AsyncSignIfMember(Params().GetConsensus().llmqTypeMNHF, shareman, requestId, msgHash);
 }
 

src/llmq/ehf_signals.h

@@ -17,19 +17,21 @@ class CSigSharesManager;
 class CEHFSignalsHandler : public CRecoveredSigsListener
 {
 private:
+    CSigningManager& sigman;
+    CSigSharesManager& shareman;
     CMNHFManager& mnhfManager;
 
 /*    std::unique_ptr<CScheduler> scheduler;
     std::unique_ptr<std::thread> scheduler_thread;
     */
 public:
-    explicit CEHFSignalsHandler(CMNHFManager& mnhfManager);
+    explicit CEHFSignalsHandler(CSigningManager& sigman, CSigSharesManager& shareman, CMNHFManager& mnhfManager);
     ~CEHFSignalsHandler();
 
     void Start();
     void Stop();
 
-    void UpdatedBlockTip();
+    void UpdatedBlockTip(const CBlockIndex* const pindexNew);
 
     /*
     void BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex) LOCKS_EXCLUDED(cs);