[Draft] Implement rawchainlocksig and rawtxlocksig (#2930)

contrib/zmq/zmq_sub.py

@@ -11,10 +11,11 @@
 zmqSubSocket = zmqContext.socket(zmq.SUB)
 zmqSubSocket.setsockopt(zmq.SUBSCRIBE, b"hashblock")
 zmqSubSocket.setsockopt(zmq.SUBSCRIBE, b"hashtx")
-zmqSubSocket.setsockopt(zmq.SUBSCRIBE, b"hashtxlock")
 zmqSubSocket.setsockopt(zmq.SUBSCRIBE, b"rawblock")
 zmqSubSocket.setsockopt(zmq.SUBSCRIBE, b"rawtx")
 zmqSubSocket.setsockopt(zmq.SUBSCRIBE, b"rawtxlock")
+zmqSubSocket.setsockopt(zmq.SUBSCRIBE, b"rawchainlock")
+zmqSubSocket.setsockopt(zmq.SUBSCRIBE, b"rawchainlocksig")
 zmqSubSocket.connect("tcp://127.0.0.1:%i" % port)
 
 try:
@@ -25,26 +26,29 @@
         sequence = "Unknown";
 
         if len(msg[-1]) == 4:
-          msgSequence = struct.unpack('<I', msg[-1])[-1]
-          sequence = str(msgSequence)
+            msgSequence = struct.unpack('<I', msg[-1])[-1]
+            sequence = str(msgSequence)
 
         if topic == "hashblock":
             print('- HASH BLOCK ('+sequence+') -')
             print(body.hex())
         elif topic == "hashtx":
-            print ('- HASH TX ('+sequence+') -')
-            print(body.hex())
-        elif topic == "hashtxlock":
-            print('- HASH TX LOCK ('+sequence+') -')
+            print('- HASH TX ('+sequence+') -')
             print(body.hex())
         elif topic == "rawblock":
             print('- RAW BLOCK HEADER ('+sequence+') -')
-            print(body[:80].hex())
-        elif topic == "rawtx":
+            print(binascii.hexlify(body[:80]).decode("utf-8"))
+        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(body.hex())
-        elif topic == "rawtxlock":
-            print('- RAW TX LOCK ('+sequence+') -')
+        elif topic == b"rawtxlock":
+            print('- RAW TX LOCK('+sequence+') -')
             print(body.hex())
 
 except KeyboardInterrupt:

doc/zmq.md

@@ -59,11 +59,11 @@ the command line or in the configuration file.
 Currently, the following notifications are supported:
 
     -zmqpubhashtx=address
-    -zmqpubhashtxlock=address
     -zmqpubhashblock=address
     -zmqpubrawblock=address
+    -zmqpubrawchainlock=address
+    -zmqpubrawchainlocksig=address
     -zmqpubrawtx=address
-    -zmqpubrawtxlock=address
 
 The socket type is PUB and the address must be a valid ZeroMQ socket
 address. The same address can be used in more than one notification.

src/llmq/quorums_chainlocks.cpp

@@ -339,6 +339,20 @@ void CChainLocksHandler::EnforceBestChainLock()
     if (activateNeeded && !ActivateBestChain(state)) {
         LogPrintf("CChainLocksHandler::%s -- ActivateBestChain failed: %s\n", __func__, state.GetRejectReason());
     }
+
+    const CBlockIndex* pindexNotify = nullptr;
+    {
+        LOCK(cs_main);
+        if (lastNotifyChainLockBlockIndex != currentBestChainLockBlockIndex &&
+            chainActive.Tip()->GetAncestor(currentBestChainLockBlockIndex->nHeight) == currentBestChainLockBlockIndex) {
+            lastNotifyChainLockBlockIndex = currentBestChainLockBlockIndex;
+            pindexNotify = currentBestChainLockBlockIndex;
+        }
+    }
+
+    if (pindexNotify) {
+        GetMainSignals().NotifyChainLock(pindexNotify, clsig);
+    }
 }
 
 void CChainLocksHandler::HandleNewRecoveredSig(const llmq::CRecoveredSig& recoveredSig)

src/llmq/quorums_chainlocks.h

@@ -54,6 +54,7 @@ class CChainLocksHandler : public CRecoveredSigsListener
 
     CChainLockSig bestChainLockWithKnownBlock;
     const CBlockIndex* bestChainLockBlockIndex{nullptr};
+    const CBlockIndex* lastNotifyChainLockBlockIndex{nullptr};
 
     int32_t lastSignedHeight{-1};
     uint256 lastSignedRequestId;

src/validationinterface.cpp

@@ -30,6 +30,7 @@ struct ValidationInterfaceConnections {
     boost::signals2::scoped_connection Broadcast;
     boost::signals2::scoped_connection BlockChecked;
     boost::signals2::scoped_connection NotifyMasternodeListChanged;
+    boost::signals2::scoped_connection NotifyChainLock;
 };
 
 struct MainSignalsInstance {
@@ -56,7 +57,8 @@ struct MainSignalsInstance {
     boost::signals2::signal<void (const CBlock&, const CValidationState&)> BlockChecked;
     /** Notifies listeners of updated deterministic masternode list */
     boost::signals2::signal<void (bool undo, const CDeterministicMNList& oldMNList, const CDeterministicMNListDiff& diff)> NotifyMasternodeListChanged;
-
+    /** Notifies listeners of a ChainLock. */
+    boost::signals2::signal<void (const CBlockIndex* pindex, const llmq::CChainLockSig& clsig)> NotifyChainLock;
     std::unordered_map<CValidationInterface*, ValidationInterfaceConnections> m_connMainSignals;
 
     // We are not allowed to assume the scheduler only runs in one thread,
@@ -108,6 +110,7 @@ void RegisterSharedValidationInterface(std::shared_ptr<CValidationInterface> pwa
     conns.Broadcast = g_signals.m_internals->Broadcast.connect(std::bind(&CValidationInterface::ResendWalletTransactions, pwalletIn, std::placeholders::_1));
     conns.BlockChecked = g_signals.m_internals->BlockChecked.connect(std::bind(&CValidationInterface::BlockChecked, pwalletIn, std::placeholders::_1, std::placeholders::_2));
     conns.NotifyMasternodeListChanged = g_signals.m_internals->NotifyMasternodeListChanged.connect(std::bind(&CValidationInterface::NotifyMasternodeListChanged, pwalletIn, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
+    conns.NotifyChainLock = g_signals.m_internals->NotifyChainLock.connect(std::bind(&CValidationInterface::NotifyChainLock, pwalletIn, std::placeholders::_1, std::placeholders::_2));
 }
 void RegisterValidationInterface(CValidationInterface* pwalletIn)
 {
@@ -249,3 +252,8 @@ void CMainSignals::NotifyMasternodeListChanged(bool undo, const CDeterministicMN
               diff.updatedMNs.size(),
               diff.removedMns.size());
 }
+
+void CMainSignals::NotifyChainLock(const CBlockIndex* pindex, const llmq::CChainLockSig& clsig) {
+    m_internals->NotifyChainLock(pindex, clsig);
+    LOG_EVENT("%s: new chain lock pindex: %s", __func__, pindex->GetBlockHash().ToString());
+}

src/validationinterface.h

@@ -26,6 +26,10 @@ class uint256;
 class CScheduler;
 enum class MemPoolRemovalReason;
 
+namespace llmq {
+    class CChainLockSig;
+}
+
 // These functions dispatch to one or all registered wallets
 
 /** Register a wallet to receive updates from core */
@@ -160,6 +164,7 @@ class CValidationInterface {
     friend void ::UnregisterAllValidationInterfaces();
     /** Notifies listeners of updated deterministic masternode list */
     virtual void NotifyMasternodeListChanged(bool undo, const CDeterministicMNList& oldMNList, const CDeterministicMNListDiff& diff) {}
+    virtual void NotifyChainLock(const CBlockIndex* pindex, const llmq::CChainLockSig& clsig) {}
 };
 
 struct MainSignalsInstance;
@@ -192,6 +197,7 @@ class CMainSignals {
     void Broadcast(CConnman* connman);
     void BlockChecked(const CBlock&, const CValidationState&);
     void NotifyMasternodeListChanged(bool undo, const CDeterministicMNList& oldMNList, const CDeterministicMNListDiff& diff);
+    void NotifyChainLock(const CBlockIndex* pindex, const llmq::CChainLockSig& clsig);
 };
 
 CMainSignals& GetMainSignals();

src/zmq/zmqabstractnotifier.cpp

@@ -16,6 +16,11 @@ bool CZMQAbstractNotifier::NotifyBlock(const CBlockIndex * /*CBlockIndex*/)
     return true;
 }
 
+bool CZMQAbstractNotifier::NotifyChainLock(const CBlockIndex * /*CBlockIndex*/, const llmq::CChainLockSig& /*clsig*/)
+{
+    return true;
+}
+
 bool CZMQAbstractNotifier::NotifyTransaction(const CTransaction &/*transaction*/)
 {
     return true;

src/zmq/zmqabstractnotifier.h

@@ -10,6 +10,10 @@
 class CBlockIndex;
 class CZMQAbstractNotifier;
 
+namespace llmq {
+    class CChainLockSig;
+}
+
 typedef CZMQAbstractNotifier* (*CZMQNotifierFactory)();
 
 class CZMQAbstractNotifier
@@ -33,6 +37,7 @@ class CZMQAbstractNotifier
     virtual void Shutdown() = 0;
 
     virtual bool NotifyBlock(const CBlockIndex *pindex);
+    virtual bool NotifyChainLock(const CBlockIndex *pindex, const llmq::CChainLockSig& clsig);
     virtual bool NotifyTransaction(const CTransaction &transaction);
 
 protected:

src/zmq/zmqconfig.h

@@ -19,6 +19,8 @@
 #include "primitives/block.h"
 #include "primitives/transaction.h"
 
+#include "llmq/quorums_chainlocks.h"
+
 void zmqError(const char *str);
 
 #endif // PIVX_ZMQ_ZMQCONFIG_H

src/zmq/zmqnotificationinterface.cpp

@@ -37,6 +37,8 @@ CZMQNotificationInterface* CZMQNotificationInterface::Create()
     factories["pubhashblock"] = CZMQAbstractNotifier::Create<CZMQPublishHashBlockNotifier>;
     factories["pubhashtx"] = CZMQAbstractNotifier::Create<CZMQPublishHashTransactionNotifier>;
     factories["pubrawblock"] = CZMQAbstractNotifier::Create<CZMQPublishRawBlockNotifier>;
+    factories["pubrawchainlock"] = CZMQAbstractNotifier::Create<CZMQPublishRawChainLockNotifier>;
+    factories["pubrawchainlocksig"] = CZMQAbstractNotifier::Create<CZMQPublishRawChainLockSigNotifier>;
     factories["pubrawtx"] = CZMQAbstractNotifier::Create<CZMQPublishRawTransactionNotifier>;
 
     for (const auto& entry : factories)

src/zmq/zmqnotificationinterface.h

@@ -25,10 +25,10 @@ class CZMQNotificationInterface : public CValidationInterface
     void Shutdown();
 
     // CValidationInterface
-    void TransactionAddedToMempool(const CTransactionRef& tx) override;
-    void BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexConnected) override;
-    void BlockDisconnected(const std::shared_ptr<const CBlock>& pblock, const uint256& blockHash, int nBlockHeight, int64_t blockTime) override;
-    void UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) override;
+    void TransactionAddedToMempool(const CTransactionRef& tx);
+    void BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexConnected);
+    void BlockDisconnected(const std::shared_ptr<const CBlock>& pblock, const uint256& blockHash, int nBlockHeight, int64_t blockTime);
+    void UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload);
 
 private:
     CZMQNotificationInterface();

src/zmq/zmqpublishnotifier.cpp

@@ -11,10 +11,13 @@
 
 static std::multimap<std::string, CZMQAbstractPublishNotifier*> mapPublishNotifiers;
 
-static const char *MSG_HASHBLOCK  = "hashblock";
-static const char *MSG_HASHTX     = "hashtx";
-static const char *MSG_RAWBLOCK   = "rawblock";
-static const char *MSG_RAWTX      = "rawtx";
+static const char *MSG_HASHBLOCK     = "hashblock";
+static const char *MSG_HASHCHAINLOCK = "hashchainlock";
+static const char *MSG_HASHTX        = "hashtx";
+static const char *MSG_RAWBLOCK      = "rawblock";
+static const char *MSG_RAWCHAINLOCK  = "rawchainlock";
+static const char *MSG_RAWCLSIG      = "rawchainlocksig";
+static const char *MSG_RAWTX         = "rawtx";
 
 // Internal function to send multipart message
 static int zmq_send_multipart(void *sock, const void* data, size_t size, ...)
@@ -155,6 +158,16 @@ bool CZMQPublishHashBlockNotifier::NotifyBlock(const CBlockIndex *pindex)
     return SendMessage(MSG_HASHBLOCK, data, 32);
 }
 
+bool CZMQPublishHashChainLockNotifier::NotifyChainLock(const CBlockIndex *pindex, const llmq::CChainLockSig& clsig)
+{
+    uint256 hash = pindex->GetBlockHash();
+    LogPrint(BCLog::ZMQ, "zmq: Publish hashchainlock %s\n", hash.GetHex());
+    char data[32];
+    for (unsigned int i = 0; i < 32; i++)
+        data[31 - i] = hash.begin()[i];
+    return SendMessage(MSG_HASHCHAINLOCK, data, 32);
+}
+
 bool CZMQPublishHashTransactionNotifier::NotifyTransaction(const CTransaction &transaction)
 {
     uint256 hash = transaction.GetHash();
@@ -185,6 +198,47 @@ bool CZMQPublishRawBlockNotifier::NotifyBlock(const CBlockIndex *pindex)
     return SendMessage(MSG_RAWBLOCK, &(*ss.begin()), ss.size());
 }
 
+bool CZMQPublishRawChainLockNotifier::NotifyChainLock(const CBlockIndex *pindex, const llmq::CChainLockSig& clsig)
+{
+    LogPrint(BCLog::ZMQ, "zmq: Publish rawchainlock %s\n", pindex->GetBlockHash().GetHex());
+
+    CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
+    {
+        LOCK(cs_main);
+        CBlock block;
+        if(!ReadBlockFromDisk(block, pindex))
+        {
+            zmqError("Can't read block from disk");
+            return false;
+        }
+
+        ss << block;
+    }
+
+    return SendMessage(MSG_RAWCHAINLOCK, &(*ss.begin()), ss.size());
+}
+
+bool CZMQPublishRawChainLockSigNotifier::NotifyChainLock(const CBlockIndex *pindex, const llmq::CChainLockSig& clsig)
+{
+    LogPrint(BCLog::ZMQ, "zmq: Publish rawchainlocksig %s\n", pindex->GetBlockHash().GetHex());
+
+    CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
+    {
+        LOCK(cs_main);
+        CBlock block;
+        if(!ReadBlockFromDisk(block, pindex))
+        {
+            zmqError("Can't read block from disk");
+            return false;
+        }
+
+        ss << block;
+        ss << clsig;
+    }
+
+    return SendMessage(MSG_RAWCLSIG, &(*ss.begin()), ss.size());
+}
+
 bool CZMQPublishRawTransactionNotifier::NotifyTransaction(const CTransaction &transaction)
 {
     uint256 hash = transaction.GetHash();

src/zmq/zmqpublishnotifier.h

@@ -34,6 +34,12 @@ class CZMQPublishHashBlockNotifier : public CZMQAbstractPublishNotifier
     bool NotifyBlock(const CBlockIndex *pindex);
 };
 
+class CZMQPublishHashChainLockNotifier : public CZMQAbstractPublishNotifier
+{
+public:
+    bool NotifyChainLock(const CBlockIndex *pindex, const llmq::CChainLockSig& clsig) override;
+};
+
 class CZMQPublishHashTransactionNotifier : public CZMQAbstractPublishNotifier
 {
 public:
@@ -46,6 +52,18 @@ class CZMQPublishRawBlockNotifier : public CZMQAbstractPublishNotifier
     bool NotifyBlock(const CBlockIndex *pindex);
 };
 
+class CZMQPublishRawChainLockNotifier : public CZMQAbstractPublishNotifier
+{
+public:
+    bool NotifyChainLock(const CBlockIndex *pindex, const llmq::CChainLockSig& clsig) override;
+};
+
+class CZMQPublishRawChainLockSigNotifier : public CZMQAbstractPublishNotifier
+{
+public:
+    bool NotifyChainLock(const CBlockIndex *pindex, const llmq::CChainLockSig& clsig) override;
+};
+
 class CZMQPublishRawTransactionNotifier : public CZMQAbstractPublishNotifier
 {
 public: