Implement rawchainlocksig and rawtxlocksig (#2930)

UdjinM6 · web-flow · commit 428f304506a0 · 2019-05-23T12:13:58.000+03:00
* Pass is-lock into `CInstantSendManager::UpdateWalletTransaction()`

* Implement `rawtxlocksig` which pushes tx+islock

* Implement `rawchainlocksig` which pushes block+clsig

* fix log category
diff --git a/contrib/zmq/zmq_sub.py b/contrib/zmq/zmq_sub.py
@@ -51,8 +51,10 @@ def __init__(self):
         self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "hashinstantsenddoublespend")
         self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "rawblock")
         self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "rawchainlock")
+        self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "rawchainlocksig")
         self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "rawtx")
         self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "rawtxlock")
+        self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "rawtxlocksig")
         self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "rawgovernancevote")
         self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "rawgovernanceobject")
         self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "rawinstantsenddoublespend")
@@ -95,12 +97,18 @@ async def handle(self) :
         elif topic == b"rawchainlock":
             print('- RAW CHAINLOCK ('+sequence+') -')
             print(binascii.hexlify(body[:80]).decode("utf-8"))
+        elif topic == b"rawchainlocksig":
+            print('- RAW CHAINLOCK SIG ('+sequence+') -')
+            print(binascii.hexlify(body[:80]).decode("utf-8"))
         elif topic == b"rawtx":
             print('- RAW TX ('+sequence+') -')
             print(binascii.hexlify(body).decode("utf-8"))
         elif topic == b"rawtxlock":
             print('- RAW TX LOCK ('+sequence+') -')
             print(binascii.hexlify(body).decode("utf-8"))
+        elif topic == b"rawtxlocksig":
+            print('- RAW TX LOCK SIG ('+sequence+') -')
+            print(binascii.hexlify(body).decode("utf-8"))
         elif topic == b"rawgovernancevote":
             print('- RAW GOVERNANCE VOTE ('+sequence+') -')
             print(binascii.hexlify(body).decode("utf-8"))
diff --git a/contrib/zmq/zmq_sub3.4.py b/contrib/zmq/zmq_sub3.4.py
@@ -55,8 +55,10 @@ def __init__(self):
         self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "hashinstantsenddoublespend")
         self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "rawblock")
         self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "rawchainlock")
+        self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "rawchainlocksig")
         self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "rawtx")
         self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "rawtxlock")
+        self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "rawtxlocksig")
         self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "rawgovernancevote")
         self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "rawgovernanceobject")
         self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "rawinstantsenddoublespend")
@@ -98,12 +100,18 @@ def handle(self) :
         elif topic == b"rawchainlock":
             print('- RAW CHAINLOCK ('+sequence+') -')
             print(binascii.hexlify(body[:80]).decode("utf-8"))
+        elif topic == b"rawchainlocksig":
+            print('- RAW CHAINLOCK SIG ('+sequence+') -')
+            print(binascii.hexlify(body[:80]).decode("utf-8"))
         elif topic == b"rawtx":
             print('- RAW TX ('+sequence+') -')
             print(binascii.hexlify(body).decode("utf-8"))
         elif topic == b"rawtxlock":
             print('- RAW TX LOCK ('+sequence+') -')
             print(binascii.hexlify(body).decode("utf-8"))
+        elif topic == b"rawtxlocksig":
+            print('- RAW TX LOCK SIG ('+sequence+') -')
+            print(binascii.hexlify(body).decode("utf-8"))
         elif topic == b"rawgovernancevote":
             print('- RAW GOVERNANCE VOTE ('+sequence+') -')
             print(binascii.hexlify(body).decode("utf-8"))
diff --git a/doc/zmq.md b/doc/zmq.md
@@ -65,8 +65,10 @@ Currently, the following notifications are supported:
     -zmqpubhashinstantsenddoublespend=address
     -zmqpubrawblock=address
     -zmqpubrawchainlock=address
+    -zmqpubrawchainlocksig=address
     -zmqpubrawtx=address
     -zmqpubrawtxlock=address
+    -zmqpubrawtxlocksig=address
     -zmqpubrawgovernancevote=address
     -zmqpubrawgovernanceobject=address
     -zmqpubrawinstantsenddoublespend=address
diff --git a/src/dsnotificationinterface.cpp b/src/dsnotificationinterface.cpp
@@ -88,7 +88,7 @@ void CDSNotificationInterface::NotifyMasternodeListChanged(bool undo, const CDet
     governance.UpdateCachesAndClean();
 }
 
-void CDSNotificationInterface::NotifyChainLock(const CBlockIndex* pindex)
+void CDSNotificationInterface::NotifyChainLock(const CBlockIndex* pindex, const llmq::CChainLockSig& clsig)
 {
     llmq::quorumInstantSendManager->NotifyChainLock(pindex);
 }
diff --git a/src/dsnotificationinterface.h b/src/dsnotificationinterface.h
@@ -23,7 +23,7 @@ class CDSNotificationInterface : public CValidationInterface
     void UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) override;
     void SyncTransaction(const CTransaction &tx, const CBlockIndex *pindex, int posInBlock) override;
     void NotifyMasternodeListChanged(bool undo, const CDeterministicMNList& oldMNList, const CDeterministicMNListDiff& diff) override;
-    void NotifyChainLock(const CBlockIndex* pindex) override;
+    void NotifyChainLock(const CBlockIndex* pindex, const llmq::CChainLockSig& clsig) override;
 
 private:
     CConnman& connman;
diff --git a/src/instantsend.cpp b/src/instantsend.cpp
@@ -539,7 +539,8 @@ void CInstantSend::UpdateLockedTransaction(const CTxLockCandidate& txLockCandida
     }
 #endif
 
-    GetMainSignals().NotifyTransactionLock(*txLockCandidate.txLockRequest.tx);
+    llmq::CInstantSendLock islock;
+    GetMainSignals().NotifyTransactionLock(*txLockCandidate.txLockRequest.tx, islock);
 
     LogPrint(BCLog::INSTANTSEND, "CInstantSend::UpdateLockedTransaction -- done, txid=%s\n", txHash.ToString());
 }
diff --git a/src/llmq/quorums_chainlocks.cpp b/src/llmq/quorums_chainlocks.cpp
@@ -526,7 +526,7 @@ void CChainLocksHandler::EnforceBestChainLock()
     }
 
     if (pindexNotify) {
-        GetMainSignals().NotifyChainLock(pindexNotify);
+        GetMainSignals().NotifyChainLock(pindexNotify, clsig);
     }
 }
 
diff --git a/src/llmq/quorums_instantsend.cpp b/src/llmq/quorums_instantsend.cpp
@@ -920,31 +920,33 @@ void CInstantSendManager::ProcessInstantSendLock(NodeId from, const uint256& has
 
     RemoveMempoolConflictsForLock(hash, islock);
     ResolveBlockConflicts(hash, islock);
-    UpdateWalletTransaction(islock.txid, tx);
+    UpdateWalletTransaction(tx, islock);
 }
 
-void CInstantSendManager::UpdateWalletTransaction(const uint256& txid, const CTransactionRef& tx)
+void CInstantSendManager::UpdateWalletTransaction(const CTransactionRef& tx, const CInstantSendLock& islock)
 {
+    if (tx == nullptr) {
+        return;
+    }
+
 #ifdef ENABLE_WALLET
     if (!pwalletMain) {
         return;
     }
 
-    if (pwalletMain->UpdatedTransaction(txid)) {
+    if (pwalletMain->UpdatedTransaction(tx->GetHash())) {
         // notify an external script once threshold is reached
         std::string strCmd = GetArg("-instantsendnotify", "");
         if (!strCmd.empty()) {
-            boost::replace_all(strCmd, "%s", txid.GetHex());
+            boost::replace_all(strCmd, "%s", tx->GetHash().GetHex());
             boost::thread t(runCommand, strCmd); // thread runs free
         }
     }
 #endif
 
-    if (tx) {
-        GetMainSignals().NotifyTransactionLock(*tx);
-        // bump mempool counter to make sure newly mined txes are picked up by getblocktemplate
-        mempool.AddTransactionsUpdated(1);
-    }
+    GetMainSignals().NotifyTransactionLock(*tx, islock);
+    // bump mempool counter to make sure newly mined txes are picked up by getblocktemplate
+    mempool.AddTransactionsUpdated(1);
 }
 
 void CInstantSendManager::SyncTransaction(const CTransaction& tx, const CBlockIndex* pindex, int posInBlock)
diff --git a/src/llmq/quorums_instantsend.h b/src/llmq/quorums_instantsend.h
@@ -139,7 +139,7 @@ class CInstantSendManager : public CRecoveredSigsListener
     bool PreVerifyInstantSendLock(NodeId nodeId, const CInstantSendLock& islock, bool& retBan);
     bool ProcessPendingInstantSendLocks();
     void ProcessInstantSendLock(NodeId from, const uint256& hash, const CInstantSendLock& islock);
-    void UpdateWalletTransaction(const uint256& txid, const CTransactionRef& tx);
+    void UpdateWalletTransaction(const CTransactionRef& tx, const CInstantSendLock& islock);
 
     void SyncTransaction(const CTransaction &tx, const CBlockIndex *pindex, int posInBlock);
     void AddNonLockedTx(const CTransactionRef& tx);
diff --git a/src/validationinterface.cpp b/src/validationinterface.cpp
@@ -17,8 +17,8 @@ void RegisterValidationInterface(CValidationInterface* pwalletIn) {
     g_signals.NotifyHeaderTip.connect(boost::bind(&CValidationInterface::NotifyHeaderTip, pwalletIn, _1, _2));
     g_signals.UpdatedBlockTip.connect(boost::bind(&CValidationInterface::UpdatedBlockTip, pwalletIn, _1, _2, _3));
     g_signals.SyncTransaction.connect(boost::bind(&CValidationInterface::SyncTransaction, pwalletIn, _1, _2, _3));
-    g_signals.NotifyTransactionLock.connect(boost::bind(&CValidationInterface::NotifyTransactionLock, pwalletIn, _1));
-    g_signals.NotifyChainLock.connect(boost::bind(&CValidationInterface::NotifyChainLock, pwalletIn, _1));
+    g_signals.NotifyTransactionLock.connect(boost::bind(&CValidationInterface::NotifyTransactionLock, pwalletIn, _1, _2));
+    g_signals.NotifyChainLock.connect(boost::bind(&CValidationInterface::NotifyChainLock, pwalletIn, _1, _2));
     g_signals.UpdatedTransaction.connect(boost::bind(&CValidationInterface::UpdatedTransaction, pwalletIn, _1));
     g_signals.SetBestChain.connect(boost::bind(&CValidationInterface::SetBestChain, pwalletIn, _1));
     g_signals.Inventory.connect(boost::bind(&CValidationInterface::Inventory, pwalletIn, _1));
@@ -41,8 +41,8 @@ void UnregisterValidationInterface(CValidationInterface* pwalletIn) {
     g_signals.Inventory.disconnect(boost::bind(&CValidationInterface::Inventory, pwalletIn, _1));
     g_signals.SetBestChain.disconnect(boost::bind(&CValidationInterface::SetBestChain, pwalletIn, _1));
     g_signals.UpdatedTransaction.disconnect(boost::bind(&CValidationInterface::UpdatedTransaction, pwalletIn, _1));
-    g_signals.NotifyChainLock.disconnect(boost::bind(&CValidationInterface::NotifyChainLock, pwalletIn, _1));
-    g_signals.NotifyTransactionLock.disconnect(boost::bind(&CValidationInterface::NotifyTransactionLock, pwalletIn, _1));
+    g_signals.NotifyChainLock.disconnect(boost::bind(&CValidationInterface::NotifyChainLock, pwalletIn, _1, _2));
+    g_signals.NotifyTransactionLock.disconnect(boost::bind(&CValidationInterface::NotifyTransactionLock, pwalletIn, _1, _2));
     g_signals.SyncTransaction.disconnect(boost::bind(&CValidationInterface::SyncTransaction, pwalletIn, _1, _2, _3));
     g_signals.UpdatedBlockTip.disconnect(boost::bind(&CValidationInterface::UpdatedBlockTip, pwalletIn, _1, _2, _3));
     g_signals.NewPoWValidBlock.disconnect(boost::bind(&CValidationInterface::NewPoWValidBlock, pwalletIn, _1, _2));
diff --git a/src/validationinterface.h b/src/validationinterface.h
@@ -24,6 +24,11 @@ class CDeterministicMNList;
 class CDeterministicMNListDiff;
 class uint256;
 
+namespace llmq {
+    class CChainLockSig;
+    class CInstantSendLock;
+}
+
 // These functions dispatch to one or all registered wallets
 
 /** Register a wallet to receive updates from core */
@@ -39,8 +44,8 @@ class CValidationInterface {
     virtual void NotifyHeaderTip(const CBlockIndex *pindexNew, bool fInitialDownload) {}
     virtual void UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) {}
     virtual void SyncTransaction(const CTransaction &tx, const CBlockIndex *pindex, int posInBlock) {}
-    virtual void NotifyTransactionLock(const CTransaction &tx) {}
-    virtual void NotifyChainLock(const CBlockIndex* pindex) {}
+    virtual void NotifyTransactionLock(const CTransaction &tx, const llmq::CInstantSendLock& islock) {}
+    virtual void NotifyChainLock(const CBlockIndex* pindex, const llmq::CChainLockSig& clsig) {}
     virtual void NotifyGovernanceVote(const CGovernanceVote &vote) {}
     virtual void NotifyGovernanceObject(const CGovernanceObject &object) {}
     virtual void NotifyInstantSendDoubleSpendAttempt(const CTransaction &currentTx, const CTransaction &previousTx) {}
@@ -77,9 +82,9 @@ struct CMainSignals {
      * disconnected block.*/
     boost::signals2::signal<void (const CTransaction &, const CBlockIndex *pindex, int posInBlock)> SyncTransaction;
     /** Notifies listeners of an updated transaction lock without new data. */
-    boost::signals2::signal<void (const CTransaction &)> NotifyTransactionLock;
+    boost::signals2::signal<void (const CTransaction &, const llmq::CInstantSendLock& islock)> NotifyTransactionLock;
     /** Notifies listeners of a ChainLock. */
-    boost::signals2::signal<void (const CBlockIndex* pindex)> NotifyChainLock;
+    boost::signals2::signal<void (const CBlockIndex* pindex, const llmq::CChainLockSig& clsig)> NotifyChainLock;
     /** Notifies listeners of a new governance vote. */
     boost::signals2::signal<void (const CGovernanceVote &)> NotifyGovernanceVote;
     /** Notifies listeners of a new governance object. */
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
@@ -5319,7 +5319,7 @@ bool AutoBackupWallet(CWallet* wallet, const std::string& strWalletFile_, std::s
     return true;
 }
 
-void CWallet::NotifyTransactionLock(const CTransaction &tx)
+void CWallet::NotifyTransactionLock(const CTransaction &tx, const llmq::CInstantSendLock& islock)
 {
     LOCK(cs_wallet);
     // Only notify UI if this transaction is in this wallet
@@ -5329,7 +5329,7 @@ void CWallet::NotifyTransactionLock(const CTransaction &tx)
     }
 }
 
-void CWallet::NotifyChainLock(const CBlockIndex* pindexChainLock)
+void CWallet::NotifyChainLock(const CBlockIndex* pindexChainLock, const llmq::CChainLockSig& clsig)
 {
     NotifyChainLockReceived(pindexChainLock->nHeight);
 }
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
@@ -1172,8 +1172,8 @@ class CWallet : public CCryptoKeyStore, public CValidationInterface
     bool SetCryptedHDChain(const CHDChain& chain, bool memonly);
     bool GetDecryptedHDChain(CHDChain& hdChainRet);
 
-    void NotifyTransactionLock(const CTransaction &tx) override;
-    void NotifyChainLock(const CBlockIndex* pindexChainLock) override;
+    void NotifyTransactionLock(const CTransaction &tx, const llmq::CInstantSendLock& islock) override;
+    void NotifyChainLock(const CBlockIndex* pindexChainLock, const llmq::CChainLockSig& clsig) override;
 };
 
 /** A key allocated from the key pool. */
diff --git a/src/zmq/zmqabstractnotifier.cpp b/src/zmq/zmqabstractnotifier.cpp
@@ -16,7 +16,7 @@ bool CZMQAbstractNotifier::NotifyBlock(const CBlockIndex * /*CBlockIndex*/)
     return true;
 }
 
-bool CZMQAbstractNotifier::NotifyChainLock(const CBlockIndex * /*CBlockIndex*/)
+bool CZMQAbstractNotifier::NotifyChainLock(const CBlockIndex * /*CBlockIndex*/, const llmq::CChainLockSig& /*clsig*/)
 {
     return true;
 }
@@ -26,7 +26,7 @@ bool CZMQAbstractNotifier::NotifyTransaction(const CTransaction &/*transaction*/
     return true;
 }
 
-bool CZMQAbstractNotifier::NotifyTransactionLock(const CTransaction &/*transaction*/)
+bool CZMQAbstractNotifier::NotifyTransactionLock(const CTransaction &/*transaction*/, const llmq::CInstantSendLock& /*islock*/)
 {
     return true;
 }
diff --git a/src/zmq/zmqabstractnotifier.h b/src/zmq/zmqabstractnotifier.h
@@ -12,6 +12,11 @@ class CGovernanceObject;
 class CGovernanceVote;
 class CZMQAbstractNotifier;
 
+namespace llmq {
+    class CChainLockSig;
+    class CInstantSendLock;
+}
+
 typedef CZMQAbstractNotifier* (*CZMQNotifierFactory)();
 
 class CZMQAbstractNotifier
@@ -35,9 +40,9 @@ class CZMQAbstractNotifier
     virtual void Shutdown() = 0;
 
     virtual bool NotifyBlock(const CBlockIndex *pindex);
-    virtual bool NotifyChainLock(const CBlockIndex *pindex);
+    virtual bool NotifyChainLock(const CBlockIndex *pindex, const llmq::CChainLockSig& clsig);
     virtual bool NotifyTransaction(const CTransaction &transaction);
-    virtual bool NotifyTransactionLock(const CTransaction &transaction);
+    virtual bool NotifyTransactionLock(const CTransaction &transaction, const llmq::CInstantSendLock& islock);
     virtual bool NotifyGovernanceVote(const CGovernanceVote &vote);
     virtual bool NotifyGovernanceObject(const CGovernanceObject &object);
     virtual bool NotifyInstantSendDoubleSpendAttempt(const CTransaction &currentTx, const CTransaction &previousTx);
diff --git a/src/zmq/zmqconfig.h b/src/zmq/zmqconfig.h
@@ -24,6 +24,9 @@
 
 #include "instantsend.h"
 
+#include "llmq/quorums_chainlocks.h"
+#include "llmq/quorums_instantsend.h"
+
 void zmqError(const char *str);
 
 #endif // BITCOIN_ZMQ_ZMQCONFIG_H
diff --git a/src/zmq/zmqnotificationinterface.cpp b/src/zmq/zmqnotificationinterface.cpp
@@ -44,8 +44,10 @@ CZMQNotificationInterface* CZMQNotificationInterface::Create()
     factories["pubhashinstantsenddoublespend"] = CZMQAbstractNotifier::Create<CZMQPublishHashInstantSendDoubleSpendNotifier>;
     factories["pubrawblock"] = CZMQAbstractNotifier::Create<CZMQPublishRawBlockNotifier>;
     factories["pubrawchainlock"] = CZMQAbstractNotifier::Create<CZMQPublishRawChainLockNotifier>;
+    factories["pubrawchainlocksig"] = CZMQAbstractNotifier::Create<CZMQPublishRawChainLockSigNotifier>;
     factories["pubrawtx"] = CZMQAbstractNotifier::Create<CZMQPublishRawTransactionNotifier>;
     factories["pubrawtxlock"] = CZMQAbstractNotifier::Create<CZMQPublishRawTransactionLockNotifier>;
+    factories["pubrawtxlocksig"] = CZMQAbstractNotifier::Create<CZMQPublishRawTransactionLockSigNotifier>;
     factories["pubrawgovernancevote"] = CZMQAbstractNotifier::Create<CZMQPublishRawGovernanceVoteNotifier>;
     factories["pubrawgovernanceobject"] = CZMQAbstractNotifier::Create<CZMQPublishRawGovernanceObjectNotifier>;
     factories["pubrawinstantsenddoublespend"] = CZMQAbstractNotifier::Create<CZMQPublishRawInstantSendDoubleSpendNotifier>;
@@ -154,12 +156,12 @@ void CZMQNotificationInterface::UpdatedBlockTip(const CBlockIndex *pindexNew, co
     }
 }
 
-void CZMQNotificationInterface::NotifyChainLock(const CBlockIndex *pindex)
+void CZMQNotificationInterface::NotifyChainLock(const CBlockIndex *pindex, const llmq::CChainLockSig& clsig)
 {
     for (std::list<CZMQAbstractNotifier*>::iterator i = notifiers.begin(); i!=notifiers.end(); )
     {
         CZMQAbstractNotifier *notifier = *i;
-        if (notifier->NotifyChainLock(pindex))
+        if (notifier->NotifyChainLock(pindex, clsig))
         {
             i++;
         }
@@ -188,12 +190,12 @@ void CZMQNotificationInterface::SyncTransaction(const CTransaction& tx, const CB
     }
 }
 
-void CZMQNotificationInterface::NotifyTransactionLock(const CTransaction &tx)
+void CZMQNotificationInterface::NotifyTransactionLock(const CTransaction &tx, const llmq::CInstantSendLock& islock)
 {
     for (std::list<CZMQAbstractNotifier*>::iterator i = notifiers.begin(); i!=notifiers.end(); )
     {
         CZMQAbstractNotifier *notifier = *i;
-        if (notifier->NotifyTransactionLock(tx))
+        if (notifier->NotifyTransactionLock(tx, islock))
         {
             i++;
         }
diff --git a/src/zmq/zmqnotificationinterface.h b/src/zmq/zmqnotificationinterface.h
@@ -26,8 +26,8 @@ class CZMQNotificationInterface : public CValidationInterface
     // CValidationInterface
     void SyncTransaction(const CTransaction& tx, const CBlockIndex *pindex, int posInBlock) override;
     void UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) override;
-    void NotifyChainLock(const CBlockIndex *pindex) override;
-    void NotifyTransactionLock(const CTransaction &tx) override;
+    void NotifyChainLock(const CBlockIndex *pindex, const llmq::CChainLockSig& clsig) override;
+    void NotifyTransactionLock(const CTransaction &tx, const llmq::CInstantSendLock& islock) override;
     void NotifyGovernanceVote(const CGovernanceVote& vote) override;
     void NotifyGovernanceObject(const CGovernanceObject& object) override;
     void NotifyInstantSendDoubleSpendAttempt(const CTransaction &currentTx, const CTransaction &previousTx) override;
diff --git a/src/zmq/zmqpublishnotifier.cpp b/src/zmq/zmqpublishnotifier.cpp
diff --git a/src/zmq/zmqpublishnotifier.h b/src/zmq/zmqpublishnotifier.h

Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ void CDSNotificationInterface::NotifyMasternodeListChanged(bool undo, const CDet`
`88`	`88`	`governance.UpdateCachesAndClean();`
`89`	`89`	`}`
`90`	`90`
`91`		`-void CDSNotificationInterface::NotifyChainLock(const CBlockIndex* pindex)`
	`91`	`+void CDSNotificationInterface::NotifyChainLock(const CBlockIndex* pindex, const llmq::CChainLockSig& clsig)`
`92`	`92`	`{`
`93`	`93`	`llmq::quorumInstantSendManager->NotifyChainLock(pindex);`
`94`	`94`	`}`
Original file line number	Diff line number	Diff line change
`@@ -539,7 +539,8 @@ void CInstantSend::UpdateLockedTransaction(const CTxLockCandidate& txLockCandida`
`539`	`539`	`}`
`540`	`540`	`#endif`
`541`	`541`
`542`		`- GetMainSignals().NotifyTransactionLock(*txLockCandidate.txLockRequest.tx);`
	`542`	`+ llmq::CInstantSendLock islock;`
	`543`	`+ GetMainSignals().NotifyTransactionLock(*txLockCandidate.txLockRequest.tx, islock);`
`543`	`544`
`544`	`545`	`LogPrint(BCLog::INSTANTSEND, "CInstantSend::UpdateLockedTransaction -- done, txid=%s\n", txHash.ToString());`
`545`	`546`	`}`
Original file line number	Diff line number	Diff line change
`@@ -526,7 +526,7 @@ void CChainLocksHandler::EnforceBestChainLock()`
`526`	`526`	`}`
`527`	`527`
`528`	`528`	`if (pindexNotify) {`
`529`		`- GetMainSignals().NotifyChainLock(pindexNotify);`
	`529`	`+ GetMainSignals().NotifyChainLock(pindexNotify, clsig);`
`530`	`530`	`}`
`531`	`531`	`}`
`532`	`532`