fix: separate mocked time from steady_clock in worker threads

PastaPastaPasta · PastaPastaPasta · commit ae2dc7a826e7 · 2025-10-17T18:09:56.000-05:00
Fixes time-mixing bugs where mocked time (controllable in tests) was being
used to compute steady_clock deadlines. Since mocked time and system time
move independently, this caused incorrect wait behavior in tests.

Changes:
- Use steady_clock::time_point for all wait deadlines (nextAttemptTime, lastCleanupTimeSteady)
- Keep mocked time (GetTime&lt;&gt;()) for business logic only (timeouts, session tracking)
- Remove redundant workEpoch increments (NotifyWorker already does this)
- Move NotifyWorker() calls to individual message handlers for better control

This ensures that:
1. In production: steady_clock provides monotonic, reliable timing
2. In tests: mocked time controls business logic while steady_clock handles waits
3. No double-incrementing of workEpoch that could cause busy-wait issues
diff --git a/src/llmq/signing.cpp b/src/llmq/signing.cpp
@@ -431,7 +431,6 @@ MessageProcessingResult CSigningManager::ProcessMessage(NodeId from, std::string
     }
 
     pendingRecoveredSigs[from].emplace_back(recoveredSig);
-    workEpoch.fetch_add(1, std::memory_order_acq_rel);
     NotifyWorker();
     return ret;
 }
@@ -523,13 +522,9 @@ bool CSigningManager::ProcessPendingRecoveredSigs(PeerManager& peerman)
     const size_t nMaxBatchSize{32};
     CollectPendingRecoveredSigsToVerify(nMaxBatchSize, recSigsByNode, quorums);
     if (recSigsByNode.empty()) {
-        // Check if reconstructed queue has work pending so the caller can keep looping
-        {
-            LOCK(cs_pending);
-            if (!pendingReconstructedRecoveredSigs.empty() || !pendingRecoveredSigs.empty()) {
-                return true;
-            }
-        }
+        // No work in this batch. Don't proactively check queues for work that may have been
+        // added by listeners during processing, as this causes busy-wait when combined with
+        // epoch changes. External threads will call NotifyWorker() to wake us if needed.
         return false;
     }
 
@@ -582,13 +577,10 @@ bool CSigningManager::ProcessPendingRecoveredSigs(PeerManager& peerman)
         }
     }
 
-    // If we still have pending items in queues, report more work to avoid sleeping
-    bool more_in_queues = false;
-    {
-        LOCK(cs_pending);
-        more_in_queues = !pendingReconstructedRecoveredSigs.empty() || !pendingRecoveredSigs.empty();
-    }
-    return more_in_queues || recSigsByNode.size() >= nMaxBatchSize;
+    // Only report more work if we processed a full batch, indicating there's likely more
+    // work from the original collection. Don't check queues for work added by listeners
+    // during processing, as that would cause busy-wait with epoch-based wake conditions.
+    return recSigsByNode.size() >= nMaxBatchSize;
 }
 
 // signature must be verified already
@@ -640,15 +632,14 @@ void CSigningManager::ProcessRecoveredSig(const std::shared_ptr<const CRecovered
     }
 
     GetMainSignals().NotifyRecoveredSig(recoveredSig, recoveredSig->GetHash().ToString());
-    workEpoch.fetch_add(1, std::memory_order_acq_rel);
-    NotifyWorker();
+    // Note: Don't call NotifyWorker() here as this function is called by the worker thread itself
+    // NotifyWorker() is only needed when external threads add work
 }
 
 void CSigningManager::PushReconstructedRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& recoveredSig)
 {
     LOCK(cs_pending);
     pendingReconstructedRecoveredSigs.emplace(std::piecewise_construct, std::forward_as_tuple(recoveredSig->GetHash()), std::forward_as_tuple(recoveredSig));
-    workEpoch.fetch_add(1, std::memory_order_acq_rel);
     NotifyWorker();
 }
 
@@ -670,6 +661,7 @@ void CSigningManager::Cleanup()
     db.CleanupOldVotes(maxAge);
 
     lastCleanupTime = TicksSinceEpoch<std::chrono::milliseconds>(SystemClock::now());
+    lastCleanupTimeSteady = std::chrono::steady_clock::now();
 }
 
 void CSigningManager::RegisterRecoveredSigsListener(CRecoveredSigsListener* l)
@@ -845,11 +837,10 @@ void CSigningManager::WorkThreadMain(PeerManager& peerman)
         // new work arrives or the deadline is reached.
         auto next_deadline = std::chrono::steady_clock::time_point::max();
         {
-            int64_t now_ms = TicksSinceEpoch<std::chrono::milliseconds>(SystemClock::now());
-            int64_t target_ms = lastCleanupTime + 5000;
-            if (target_ms > now_ms) {
-                auto delta_ms = target_ms - now_ms;
-                next_deadline = std::chrono::steady_clock::now() + std::chrono::milliseconds(delta_ms);
+            auto now_steady = std::chrono::steady_clock::now();
+            auto next_cleanup = lastCleanupTimeSteady + std::chrono::milliseconds(5000);
+            if (next_cleanup > now_steady) {
+                next_deadline = next_cleanup;
             }
         }
         if (next_deadline == std::chrono::steady_clock::time_point::max()) {
diff --git a/src/llmq/signing.h b/src/llmq/signing.h
@@ -177,6 +177,7 @@ class CSigningManager
     FastRandomContext rnd GUARDED_BY(cs_pending);
 
     int64_t lastCleanupTime{0};
+    std::chrono::steady_clock::time_point lastCleanupTimeSteady{};
 
     mutable Mutex cs_listeners;
     std::vector<CRecoveredSigsListener*> recoveredSigsListeners GUARDED_BY(cs_listeners);
diff --git a/src/llmq/signing_shares.cpp b/src/llmq/signing_shares.cpp
@@ -239,6 +239,7 @@ void CSigSharesManager::ProcessMessage(const CNode& pfrom, PeerManager& peerman,
         for (const auto& sigShare : receivedSigShares) {
             ProcessMessageSigShare(pfrom.GetId(), peerman, sigShare);
         }
+        NotifyWorker();
     }
 
     if (msg_type == NetMsgType::QSIGSESANN) {
@@ -254,6 +255,7 @@ void CSigSharesManager::ProcessMessage(const CNode& pfrom, PeerManager& peerman,
             BanNode(pfrom.GetId(), peerman);
             return;
         }
+        NotifyWorker();
     } else if (msg_type == NetMsgType::QSIGSHARESINV) {
         std::vector<CSigSharesInv> msgs;
         vRecv >> msgs;
@@ -267,6 +269,7 @@ void CSigSharesManager::ProcessMessage(const CNode& pfrom, PeerManager& peerman,
             BanNode(pfrom.GetId(), peerman);
             return;
         }
+        NotifyWorker();
     } else if (msg_type == NetMsgType::QGETSIGSHARES) {
         std::vector<CSigSharesInv> msgs;
         vRecv >> msgs;
@@ -280,6 +283,7 @@ void CSigSharesManager::ProcessMessage(const CNode& pfrom, PeerManager& peerman,
             BanNode(pfrom.GetId(), peerman);
             return;
         }
+        NotifyWorker();
     } else if (msg_type == NetMsgType::QBSIGSHARES) {
         std::vector<CBatchedSigShares> msgs;
         vRecv >> msgs;
@@ -297,10 +301,8 @@ void CSigSharesManager::ProcessMessage(const CNode& pfrom, PeerManager& peerman,
             BanNode(pfrom.GetId(), peerman);
             return;
         }
+        NotifyWorker();
     }
-
-    // New inbound messages can create work (requests, shares, announcements)
-    NotifyWorker();
 }
 
 bool CSigSharesManager::ProcessMessageSigSesAnn(const CNode& pfrom, const CSigSesAnn& ann)
@@ -732,7 +734,6 @@ void CSigSharesManager::ProcessSigShare(PeerManager& peerman, const CSigShare& s
         return;
     }
 
-    bool queued_announce = false;
     {
         LOCK(cs);
 
@@ -741,7 +742,6 @@ void CSigSharesManager::ProcessSigShare(PeerManager& peerman, const CSigShare& s
         }
         if (!IsAllMembersConnectedEnabled(llmqType, m_sporkman)) {
             sigSharesQueuedToAnnounce.Add(sigShare.GetKey(), true);
-            queued_announce = true;
         }
 
         // Update the time we've seen the last sigShare
@@ -763,9 +763,9 @@ void CSigSharesManager::ProcessSigShare(PeerManager& peerman, const CSigShare& s
         }
     }
 
-    if (queued_announce) {
-        NotifyWorker();
-    }
+    // Note: Don't call NotifyWorker() here even when queued_announce is true
+    // When called from worker thread: SendMessages() will handle announcements in same iteration
+    // When called from external thread: ProcessMessage() already calls NotifyWorker() (line 303)
 
     if (canTryRecovery) {
         TryRecoverSig(peerman, quorum, sigShare.getId(), sigShare.getMsgHash());
@@ -1029,7 +1029,7 @@ void CSigSharesManager::CollectSigSharesToSendConcentrated(std::unordered_map<No
         proTxToNode.try_emplace(verifiedProRegTxHash, pnode);
     }
 
-    auto curTime = GetTime<std::chrono::milliseconds>().count();
+    auto curTime = std::chrono::steady_clock::now();
 
     for (auto& [_, signedSession] : signedSessions) {
         if (!IsAllMembersConnectedEnabled(signedSession.quorum->params.type, m_sporkman)) {
@@ -1043,7 +1043,7 @@ void CSigSharesManager::CollectSigSharesToSendConcentrated(std::unordered_map<No
         if (curTime >= signedSession.nextAttemptTime) {
             int64_t waitTime = exp2(signedSession.attempt) * EXP_SEND_FOR_RECOVERY_TIMEOUT;
             waitTime = std::min(MAX_SEND_FOR_RECOVERY_TIMEOUT, waitTime);
-            signedSession.nextAttemptTime = curTime + waitTime;
+            signedSession.nextAttemptTime = curTime + std::chrono::milliseconds(waitTime);
             auto dmn = SelectMemberForRecovery(signedSession.quorum, signedSession.sigShare.getId(), signedSession.attempt);
             signedSession.attempt++;
 
@@ -1430,6 +1430,7 @@ void CSigSharesManager::Cleanup(const CConnman& connman)
     }
 
     lastCleanupTime = GetTime<std::chrono::seconds>().count();
+    lastCleanupTimeSteady = std::chrono::steady_clock::now();
 }
 
 void CSigSharesManager::RemoveSigSharesForSession(const uint256& signHash)
@@ -1519,24 +1520,19 @@ void CSigSharesManager::WorkThreadMain(CConnman& connman, PeerManager& peerman)
         auto next_deadline = std::chrono::steady_clock::time_point::max();
         // Respect cleanup cadence (~5s) even when idle
         {
-            auto now_tp = std::chrono::steady_clock::now();
-            int64_t now_s = GetTime<std::chrono::seconds>().count();
-            int64_t target_s = lastCleanupTime + 5;
-            if (target_s > now_s) {
-                auto delta_ms = (target_s - now_s) * 1000;
-                auto cand = now_tp + std::chrono::milliseconds(delta_ms);
-                if (cand < next_deadline) next_deadline = cand;
+            auto now_steady = std::chrono::steady_clock::now();
+            auto next_cleanup = lastCleanupTimeSteady + std::chrono::seconds(5);
+            if (next_cleanup > now_steady) {
+                if (next_cleanup < next_deadline) next_deadline = next_cleanup;
             }
         }
         {
             // Consider next recovery attempt times for signed sessions to avoid polling
             LOCK(cs);
-            int64_t cur_ms = TicksSinceEpoch<std::chrono::milliseconds>(SystemClock::now());
+            auto now_steady = std::chrono::steady_clock::now();
             for (const auto& [_, s] : signedSessions) {
-                if (s.nextAttemptTime > cur_ms) {
-                    auto d = s.nextAttemptTime - cur_ms;
-                    auto cand = std::chrono::steady_clock::now() + std::chrono::milliseconds(d);
-                    if (cand < next_deadline) next_deadline = cand;
+                if (s.nextAttemptTime > now_steady) {
+                    if (s.nextAttemptTime < next_deadline) next_deadline = s.nextAttemptTime;
                 }
             }
         }
@@ -1581,13 +1577,13 @@ void CSigSharesManager::SignPendingSigShares(const CConnman& connman, PeerManage
                 auto& session = signedSessions[sigShare.GetSignHash()];
                 session.sigShare = sigShare;
                 session.quorum = pQuorum;
-                session.nextAttemptTime = 0;
+                session.nextAttemptTime = std::chrono::steady_clock::time_point{};
                 session.attempt = 0;
             }
         }
     }
-    // New sig shares or recovery attempts may be available
-    NotifyWorker();
+    // Note: Don't call NotifyWorker() here as this function is called by the worker thread itself
+    // NotifyWorker() is only needed when external threads add work
 }
 
 std::optional<CSigShare> CSigSharesManager::CreateSigShare(const CQuorumCPtr& quorum, const uint256& id, const uint256& msgHash) const
diff --git a/src/llmq/signing_shares.h b/src/llmq/signing_shares.h
@@ -355,7 +355,7 @@ class CSignedSession
     CSigShare sigShare;
     CQuorumCPtr quorum;
 
-    int64_t nextAttemptTime{0};
+    std::chrono::steady_clock::time_point nextAttemptTime{};
     int attempt{0};
 };
 
@@ -414,6 +414,7 @@ class CSigSharesManager : public CRecoveredSigsListener
     const CSporkManager& m_sporkman;
 
     int64_t lastCleanupTime{0};
+    std::chrono::steady_clock::time_point lastCleanupTimeSteady{};
     std::atomic<uint32_t> recoveredSigsCounter{0};
 
 public:

Original file line number	Diff line number	Diff line change
`@@ -431,7 +431,6 @@ MessageProcessingResult CSigningManager::ProcessMessage(NodeId from, std::string`
`431`	`431`	`}`
`432`	`432`
`433`	`433`	`pendingRecoveredSigs[from].emplace_back(recoveredSig);`
`434`		`- workEpoch.fetch_add(1, std::memory_order_acq_rel);`
`435`	`434`	`NotifyWorker();`
`436`	`435`	`return ret;`
`437`	`436`	`}`
`@@ -523,13 +522,9 @@ bool CSigningManager::ProcessPendingRecoveredSigs(PeerManager& peerman)`
`523`	`522`	`const size_t nMaxBatchSize{32};`
`524`	`523`	`CollectPendingRecoveredSigsToVerify(nMaxBatchSize, recSigsByNode, quorums);`
`525`	`524`	`if (recSigsByNode.empty()) {`
`526`		`- // Check if reconstructed queue has work pending so the caller can keep looping`
`527`		`- {`
`528`		`- LOCK(cs_pending);`
`529`		`- if (!pendingReconstructedRecoveredSigs.empty() \|\| !pendingRecoveredSigs.empty()) {`
`530`		`- return true;`
`531`		`- }`
`532`		`- }`
	`525`	`+ // No work in this batch. Don't proactively check queues for work that may have been`
	`526`	`+ // added by listeners during processing, as this causes busy-wait when combined with`
	`527`	`+ // epoch changes. External threads will call NotifyWorker() to wake us if needed.`
`533`	`528`	`return false;`
`534`	`529`	`}`
`535`	`530`
`@@ -582,13 +577,10 @@ bool CSigningManager::ProcessPendingRecoveredSigs(PeerManager& peerman)`
`582`	`577`	`}`
`583`	`578`	`}`
`584`	`579`
`585`		`- // If we still have pending items in queues, report more work to avoid sleeping`
`586`		`- bool more_in_queues = false;`
`587`		`- {`
`588`		`- LOCK(cs_pending);`
`589`		`- more_in_queues = !pendingReconstructedRecoveredSigs.empty() \|\| !pendingRecoveredSigs.empty();`
`590`		`- }`
`591`		`- return more_in_queues \|\| recSigsByNode.size() >= nMaxBatchSize;`
	`580`	`+ // Only report more work if we processed a full batch, indicating there's likely more`
	`581`	`+ // work from the original collection. Don't check queues for work added by listeners`
	`582`	`+ // during processing, as that would cause busy-wait with epoch-based wake conditions.`
	`583`	`+ return recSigsByNode.size() >= nMaxBatchSize;`
`592`	`584`	`}`
`593`	`585`
`594`	`586`	`// signature must be verified already`
`@@ -640,15 +632,14 @@ void CSigningManager::ProcessRecoveredSig(const std::shared_ptr<const CRecovered`
`640`	`632`	`}`
`641`	`633`
`642`	`634`	`GetMainSignals().NotifyRecoveredSig(recoveredSig, recoveredSig->GetHash().ToString());`
`643`		`- workEpoch.fetch_add(1, std::memory_order_acq_rel);`
`644`		`- NotifyWorker();`
	`635`	`+ // Note: Don't call NotifyWorker() here as this function is called by the worker thread itself`
	`636`	`+ // NotifyWorker() is only needed when external threads add work`
`645`	`637`	`}`
`646`	`638`
`647`	`639`	`void CSigningManager::PushReconstructedRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& recoveredSig)`
`648`	`640`	`{`
`649`	`641`	`LOCK(cs_pending);`
`650`	`642`	`pendingReconstructedRecoveredSigs.emplace(std::piecewise_construct, std::forward_as_tuple(recoveredSig->GetHash()), std::forward_as_tuple(recoveredSig));`
`651`		`- workEpoch.fetch_add(1, std::memory_order_acq_rel);`
`652`	`643`	`NotifyWorker();`
`653`	`644`	`}`
`654`	`645`
`@@ -670,6 +661,7 @@ void CSigningManager::Cleanup()`
`670`	`661`	`db.CleanupOldVotes(maxAge);`
`671`	`662`
`672`	`663`	`lastCleanupTime = TicksSinceEpoch<std::chrono::milliseconds>(SystemClock::now());`
	`664`	`+ lastCleanupTimeSteady = std::chrono::steady_clock::now();`
`673`	`665`	`}`
`674`	`666`
`675`	`667`	`void CSigningManager::RegisterRecoveredSigsListener(CRecoveredSigsListener* l)`
`@@ -845,11 +837,10 @@ void CSigningManager::WorkThreadMain(PeerManager& peerman)`
`845`	`837`	`// new work arrives or the deadline is reached.`
`846`	`838`	`auto next_deadline = std::chrono::steady_clock::time_point::max();`
`847`	`839`	`{`
`848`		`- int64_t now_ms = TicksSinceEpoch<std::chrono::milliseconds>(SystemClock::now());`
`849`		`- int64_t target_ms = lastCleanupTime + 5000;`
`850`		`- if (target_ms > now_ms) {`
`851`		`- auto delta_ms = target_ms - now_ms;`
`852`		`- next_deadline = std::chrono::steady_clock::now() + std::chrono::milliseconds(delta_ms);`
	`840`	`+ auto now_steady = std::chrono::steady_clock::now();`
	`841`	`+ auto next_cleanup = lastCleanupTimeSteady + std::chrono::milliseconds(5000);`
	`842`	`+ if (next_cleanup > now_steady) {`
	`843`	`+ next_deadline = next_cleanup;`
`853`	`844`	`}`
`854`	`845`	`}`
`855`	`846`	`if (next_deadline == std::chrono::steady_clock::time_point::max()) {`
Original file line number	Diff line number	Diff line change
`@@ -239,6 +239,7 @@ void CSigSharesManager::ProcessMessage(const CNode& pfrom, PeerManager& peerman,`
`239`	`239`	`for (const auto& sigShare : receivedSigShares) {`
`240`	`240`	`ProcessMessageSigShare(pfrom.GetId(), peerman, sigShare);`
`241`	`241`	`}`
	`242`	`+ NotifyWorker();`
`242`	`243`	`}`
`243`	`244`
`244`	`245`	`if (msg_type == NetMsgType::QSIGSESANN) {`
`@@ -254,6 +255,7 @@ void CSigSharesManager::ProcessMessage(const CNode& pfrom, PeerManager& peerman,`
`254`	`255`	`BanNode(pfrom.GetId(), peerman);`
`255`	`256`	`return;`
`256`	`257`	`}`
	`258`	`+ NotifyWorker();`
`257`	`259`	`} else if (msg_type == NetMsgType::QSIGSHARESINV) {`
`258`	`260`	`std::vector<CSigSharesInv> msgs;`
`259`	`261`	`vRecv >> msgs;`
`@@ -267,6 +269,7 @@ void CSigSharesManager::ProcessMessage(const CNode& pfrom, PeerManager& peerman,`
`267`	`269`	`BanNode(pfrom.GetId(), peerman);`
`268`	`270`	`return;`
`269`	`271`	`}`
	`272`	`+ NotifyWorker();`
`270`	`273`	`} else if (msg_type == NetMsgType::QGETSIGSHARES) {`
`271`	`274`	`std::vector<CSigSharesInv> msgs;`
`272`	`275`	`vRecv >> msgs;`
`@@ -280,6 +283,7 @@ void CSigSharesManager::ProcessMessage(const CNode& pfrom, PeerManager& peerman,`
`280`	`283`	`BanNode(pfrom.GetId(), peerman);`
`281`	`284`	`return;`
`282`	`285`	`}`
	`286`	`+ NotifyWorker();`
`283`	`287`	`} else if (msg_type == NetMsgType::QBSIGSHARES) {`
`284`	`288`	`std::vector<CBatchedSigShares> msgs;`
`285`	`289`	`vRecv >> msgs;`
`@@ -297,10 +301,8 @@ void CSigSharesManager::ProcessMessage(const CNode& pfrom, PeerManager& peerman,`
`297`	`301`	`BanNode(pfrom.GetId(), peerman);`
`298`	`302`	`return;`
`299`	`303`	`}`
	`304`	`+ NotifyWorker();`
`300`	`305`	`}`
`301`		`-`
`302`		`- // New inbound messages can create work (requests, shares, announcements)`
`303`		`- NotifyWorker();`
`304`	`306`	`}`
`305`	`307`
`306`	`308`	`bool CSigSharesManager::ProcessMessageSigSesAnn(const CNode& pfrom, const CSigSesAnn& ann)`
`@@ -732,7 +734,6 @@ void CSigSharesManager::ProcessSigShare(PeerManager& peerman, const CSigShare& s`
`732`	`734`	`return;`
`733`	`735`	`}`
`734`	`736`
`735`		`- bool queued_announce = false;`
`736`	`737`	`{`
`737`	`738`	`LOCK(cs);`
`738`	`739`
`@@ -741,7 +742,6 @@ void CSigSharesManager::ProcessSigShare(PeerManager& peerman, const CSigShare& s`
`741`	`742`	`}`
`742`	`743`	`if (!IsAllMembersConnectedEnabled(llmqType, m_sporkman)) {`
`743`	`744`	`sigSharesQueuedToAnnounce.Add(sigShare.GetKey(), true);`
`744`		`- queued_announce = true;`
`745`	`745`	`}`
`746`	`746`
`747`	`747`	`// Update the time we've seen the last sigShare`
`@@ -763,9 +763,9 @@ void CSigSharesManager::ProcessSigShare(PeerManager& peerman, const CSigShare& s`
`763`	`763`	`}`
`764`	`764`	`}`
`765`	`765`
`766`		`- if (queued_announce) {`
`767`		`- NotifyWorker();`
`768`		`- }`
	`766`	`+ // Note: Don't call NotifyWorker() here even when queued_announce is true`
	`767`	`+ // When called from worker thread: SendMessages() will handle announcements in same iteration`
	`768`	`+ // When called from external thread: ProcessMessage() already calls NotifyWorker() (line 303)`
`769`	`769`
`770`	`770`	`if (canTryRecovery) {`
`771`	`771`	`TryRecoverSig(peerman, quorum, sigShare.getId(), sigShare.getMsgHash());`
`@@ -1029,7 +1029,7 @@ void CSigSharesManager::CollectSigSharesToSendConcentrated(std::unordered_map<No`
`1029`	`1029`	`proTxToNode.try_emplace(verifiedProRegTxHash, pnode);`
`1030`	`1030`	`}`
`1031`	`1031`
`1032`		`- auto curTime = GetTime<std::chrono::milliseconds>().count();`
	`1032`	`+ auto curTime = std::chrono::steady_clock::now();`
`1033`	`1033`
`1034`	`1034`	`for (auto& [_, signedSession] : signedSessions) {`
`1035`	`1035`	`if (!IsAllMembersConnectedEnabled(signedSession.quorum->params.type, m_sporkman)) {`
`@@ -1043,7 +1043,7 @@ void CSigSharesManager::CollectSigSharesToSendConcentrated(std::unordered_map<No`
`1043`	`1043`	`if (curTime >= signedSession.nextAttemptTime) {`
`1044`	`1044`	`int64_t waitTime = exp2(signedSession.attempt) * EXP_SEND_FOR_RECOVERY_TIMEOUT;`
`1045`	`1045`	`waitTime = std::min(MAX_SEND_FOR_RECOVERY_TIMEOUT, waitTime);`
`1046`		`- signedSession.nextAttemptTime = curTime + waitTime;`
	`1046`	`+ signedSession.nextAttemptTime = curTime + std::chrono::milliseconds(waitTime);`
`1047`	`1047`	`auto dmn = SelectMemberForRecovery(signedSession.quorum, signedSession.sigShare.getId(), signedSession.attempt);`
`1048`	`1048`	`signedSession.attempt++;`
`1049`	`1049`
`@@ -1430,6 +1430,7 @@ void CSigSharesManager::Cleanup(const CConnman& connman)`
`1430`	`1430`	`}`
`1431`	`1431`
`1432`	`1432`	`lastCleanupTime = GetTime<std::chrono::seconds>().count();`
	`1433`	`+ lastCleanupTimeSteady = std::chrono::steady_clock::now();`
`1433`	`1434`	`}`
`1434`	`1435`
`1435`	`1436`	`void CSigSharesManager::RemoveSigSharesForSession(const uint256& signHash)`
`@@ -1519,24 +1520,19 @@ void CSigSharesManager::WorkThreadMain(CConnman& connman, PeerManager& peerman)`
`1519`	`1520`	`auto next_deadline = std::chrono::steady_clock::time_point::max();`
`1520`	`1521`	`// Respect cleanup cadence (~5s) even when idle`
`1521`	`1522`	`{`
`1522`		`- auto now_tp = std::chrono::steady_clock::now();`
`1523`		`- int64_t now_s = GetTime<std::chrono::seconds>().count();`
`1524`		`- int64_t target_s = lastCleanupTime + 5;`
`1525`		`- if (target_s > now_s) {`
`1526`		`- auto delta_ms = (target_s - now_s) * 1000;`
`1527`		`- auto cand = now_tp + std::chrono::milliseconds(delta_ms);`
`1528`		`- if (cand < next_deadline) next_deadline = cand;`
	`1523`	`+ auto now_steady = std::chrono::steady_clock::now();`
	`1524`	`+ auto next_cleanup = lastCleanupTimeSteady + std::chrono::seconds(5);`
	`1525`	`+ if (next_cleanup > now_steady) {`
	`1526`	`+ if (next_cleanup < next_deadline) next_deadline = next_cleanup;`
`1529`	`1527`	`}`
`1530`	`1528`	`}`
`1531`	`1529`	`{`
`1532`	`1530`	`// Consider next recovery attempt times for signed sessions to avoid polling`
`1533`	`1531`	`LOCK(cs);`
`1534`		`- int64_t cur_ms = TicksSinceEpoch<std::chrono::milliseconds>(SystemClock::now());`
	`1532`	`+ auto now_steady = std::chrono::steady_clock::now();`
`1535`	`1533`	`for (const auto& [_, s] : signedSessions) {`
`1536`		`- if (s.nextAttemptTime > cur_ms) {`
`1537`		`- auto d = s.nextAttemptTime - cur_ms;`
`1538`		`- auto cand = std::chrono::steady_clock::now() + std::chrono::milliseconds(d);`
`1539`		`- if (cand < next_deadline) next_deadline = cand;`
	`1534`	`+ if (s.nextAttemptTime > now_steady) {`
	`1535`	`+ if (s.nextAttemptTime < next_deadline) next_deadline = s.nextAttemptTime;`
`1540`	`1536`	`}`
`1541`	`1537`	`}`
`1542`	`1538`	`}`
`@@ -1581,13 +1577,13 @@ void CSigSharesManager::SignPendingSigShares(const CConnman& connman, PeerManage`
`1581`	`1577`	`auto& session = signedSessions[sigShare.GetSignHash()];`
`1582`	`1578`	`session.sigShare = sigShare;`
`1583`	`1579`	`session.quorum = pQuorum;`
`1584`		`- session.nextAttemptTime = 0;`
	`1580`	`+ session.nextAttemptTime = std::chrono::steady_clock::time_point{};`
`1585`	`1581`	`session.attempt = 0;`
`1586`	`1582`	`}`
`1587`	`1583`	`}`
`1588`	`1584`	`}`
`1589`		`- // New sig shares or recovery attempts may be available`
`1590`		`- NotifyWorker();`
	`1585`	`+ // Note: Don't call NotifyWorker() here as this function is called by the worker thread itself`
	`1586`	`+ // NotifyWorker() is only needed when external threads add work`
`1591`	`1587`	`}`
`1592`	`1588`
`1593`	`1589`	`std::optional<CSigShare> CSigSharesManager::CreateSigShare(const CQuorumCPtr& quorum, const uint256& id, const uint256& msgHash) const`