chore: some extra logs for ehf signaling

src/llmq/ehf_signals.cpp

@@ -91,9 +91,10 @@ void CEHFSignalsHandler::trySignEHFSignal(int bit, const CBlockIndex* const pind
     LogPrint(BCLog::EHF, "CEHFSignalsHandler::trySignEHFSignal: bit=%d at height=%d id=%s\n", bit, pindex->nHeight, requestId.ToString());
     mnhfPayload.signal.quorumHash = quorum->qc->quorumHash;
     const uint256 msgHash = mnhfPayload.PrepareTx().GetHash();
+    LogPrint(BCLog::EHF, "CEHFSignalsHandler::trySignEHFSignal: msgHash=%s quorum=%s id=%s\n", msgHash.ToString(), quorum->qc->quorumHash.ToString(), requestId.ToString());
 
     WITH_LOCK(cs, ids.insert(requestId));
-    sigman.AsyncSignIfMember(llmqType, shareman, requestId, msgHash);
+    sigman.AsyncSignIfMember(llmqType, shareman, requestId, msgHash, quorum->qc->quorumHash, false, true);
 }
 
 void CEHFSignalsHandler::HandleNewRecoveredSig(const CRecoveredSig& recoveredSig)

src/llmq/signing.cpp

@@ -876,11 +876,18 @@ void CSigningManager::UnregisterRecoveredSigsListener(CRecoveredSigsListener* l)
     recoveredSigsListeners.erase(itRem, recoveredSigsListeners.end());
 }
 
-bool CSigningManager::AsyncSignIfMember(Consensus::LLMQType llmqType, CSigSharesManager& shareman, const uint256& id, const uint256& msgHash, const uint256& quorumHash, bool allowReSign)
+bool CSigningManager::AsyncSignIfMember(Consensus::LLMQType llmqType, CSigSharesManager& shareman, const uint256& id,
+                                        const uint256& msgHash, const uint256& quorumHash, bool allowReSign,
+                                        bool allowDiffMsgHashSigning)
 {
+    LogPrintf("CSigningManager::AsyncSignIfMember id=%s\n", id.ToString());
     if (m_mn_activeman == nullptr) return false;
+    LogPrintf("CSigningManager::AsyncSignIfMember id=%s that's mn_activeman\n", id.ToString());
     if (m_mn_activeman->GetProTxHash().IsNull()) return false;
+    LogPrintf("CSigningManager::AsyncSignIfMember id=%s protx=%s\n", id.ToString(), m_mn_activeman->GetProTxHash().ToString());
 
+    LogPrintf("CSigningManager::AsyncSignIfMember id=%s shares=%lld\n", id.ToString(), shareman.CountForSignHash(BuildSignHash(llmqType, quorumHash, id, msgHash)));
+    LogPrintf("CSigningManager::AsyncSignIfMember id=%s msgHash=%s shares=%lld\n", id.ToString(), msgHash.ToString(), shareman.CountForSignHash(BuildSignHash(llmqType, quorumHash, id, msgHash)));
     const CQuorumCPtr quorum = [&]() {
         if (quorumHash.IsNull()) {
             // This might end up giving different results on different members
@@ -902,6 +909,7 @@ bool CSigningManager::AsyncSignIfMember(Consensus::LLMQType llmqType, CSigShares
     }
 
     if (!quorum->IsValidMember(m_mn_activeman->GetProTxHash())) {
+        LogPrintf("CSigningManager::AsyncSignIfMember id=%s not a member of quorum=%s\n", id.ToString(), quorum->qc->quorumHash.ToString());
         return false;
     }
 
@@ -911,9 +919,15 @@ bool CSigningManager::AsyncSignIfMember(Consensus::LLMQType llmqType, CSigShares
             uint256 prevMsgHash;
             db.GetVoteForId(llmqType, id, prevMsgHash);
             if (msgHash != prevMsgHash) {
-                LogPrintf("CSigningManager::%s -- already voted for id=%s and msgHash=%s. Not voting on conflicting msgHash=%s\n", __func__,
-                        id.ToString(), prevMsgHash.ToString(), msgHash.ToString());
-                return false;
+                if (allowDiffMsgHashSigning) {
+                    LogPrintf("CSigningManager::%s -- already voted for id=%s and msgHash=%s. Signing for different msgHash=%s\n",
+                              __func__, id.ToString(), prevMsgHash.ToString(), msgHash.ToString());
+                    hasVoted = false;
+                } else {
+                    LogPrintf("CSigningManager::%s -- already voted for id=%s and msgHash=%s. Not voting on conflicting msgHash=%s\n",
+                              __func__, id.ToString(), prevMsgHash.ToString(), msgHash.ToString());
+                    return false;
+                }
             } else if (allowReSign) {
                 LogPrint(BCLog::LLMQ, "CSigningManager::%s -- already voted for id=%s and msgHash=%s. Resigning!\n", __func__,
                          id.ToString(), prevMsgHash.ToString());
@@ -925,18 +939,22 @@ bool CSigningManager::AsyncSignIfMember(Consensus::LLMQType llmqType, CSigShares
         }
 
         if (db.HasRecoveredSigForId(llmqType, id)) {
+            LogPrintf("CSigningManager::AsyncSignIfMemeber hasRecoveredSig id=%s\n", id.ToString());
             // no need to sign it if we already have a recovered sig
             return true;
         }
         if (!hasVoted) {
             db.WriteVoteForId(llmqType, id, msgHash);
+        } else {
+            LogPrintf("CSigningManager::AsyncSignIfMemeber has voted id=%s\n", id.ToString());
         }
     }
 
     if (allowReSign) {
         // make us re-announce all known shares (other nodes might have run into a timeout)
         shareman.ForceReAnnouncement(quorum, llmqType, id, msgHash);
     }
+    LogPrintf("CSigningManager::AsyncSignIfMemeber call async sign for id=%s msgHash=%s\n", id.ToString(), msgHash.ToString());
     shareman.AsyncSign(quorum, id, msgHash);
 
     return true;

src/llmq/signing.h

@@ -218,7 +218,9 @@ class CSigningManager
     void RegisterRecoveredSigsListener(CRecoveredSigsListener* l);
     void UnregisterRecoveredSigsListener(CRecoveredSigsListener* l);
 
-    bool AsyncSignIfMember(Consensus::LLMQType llmqType, CSigSharesManager& shareman, const uint256& id, const uint256& msgHash, const uint256& quorumHash = uint256(), bool allowReSign = false);
+    bool AsyncSignIfMember(Consensus::LLMQType llmqType, CSigSharesManager& shareman, const uint256& id,
+                           const uint256& msgHash, const uint256& quorumHash = uint256(), bool allowReSign = false,
+                           bool allowDiffMsgHashSigning = false);
     bool HasRecoveredSig(Consensus::LLMQType llmqType, const uint256& id, const uint256& msgHash) const;
     bool HasRecoveredSigForId(Consensus::LLMQType llmqType, const uint256& id) const;
     bool HasRecoveredSigForSession(const uint256& signHash) const;

src/llmq/signing_shares.cpp

@@ -706,6 +706,7 @@ void CSigSharesManager::ProcessSigShare(const CSigShare& sigShare, const CConnma
     }
 
     if (sigman.HasRecoveredSigForId(llmqType, sigShare.getId())) {
+        LogPrintf("CSigSharesManager::ProcessSigShare has recovered sig for id=%s\n", sigShare.getId().ToString());
         return;
     }
 
@@ -735,6 +736,7 @@ void CSigSharesManager::ProcessSigShare(const CSigShare& sigShare, const CConnma
         }
 
         size_t sigShareCount = sigShares.CountForSignHash(sigShare.GetSignHash());
+        LogPrintf("CSigSharesManager::ProcessSigShare sig_id=%s key=%s,%d shares=%lld/%lld\n", sigShare.getId().ToString(), sigShare.GetSignHash().ToString(), sigShare.GetKey().second, sigShareCount, quorum->params.threshold);
         if (sigShareCount >= size_t(quorum->params.threshold)) {
             canTryRecovery = true;
         }

src/llmq/signing_shares.h

@@ -428,6 +428,12 @@ class CSigSharesManager : public CRecoveredSigsListener
 
     void ProcessMessage(const CNode& pnode, const CSporkManager& sporkman, const std::string& msg_type, CDataStream& vRecv);
 
+    int CountForSignHash(const uint256& signHash) {
+        LOCK(cs);
+        return sigShares.CountForSignHash(signHash);
+    }
+
+
     void AsyncSign(const CQuorumCPtr& quorum, const uint256& id, const uint256& msgHash);
     std::optional<CSigShare> CreateSigShare(const CQuorumCPtr& quorum, const uint256& id, const uint256& msgHash) const;
     void ForceReAnnouncement(const CQuorumCPtr& quorum, Consensus::LLMQType llmqType, const uint256& id, const uint256& msgHash);