Line data    Source code

       1             : // Copyright (c) 2025 The Dash Core developers
       2             : // Distributed under the MIT software license, see the accompanying
       3             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       4             : 
       5             : #ifndef BITCOIN_INSTANTSEND_NET_INSTANTSEND_H
       6             : #define BITCOIN_INSTANTSEND_NET_INSTANTSEND_H
       7             : 
       8             : #include <net_processing.h>
       9             : #include <util/threadinterrupt.h>
      10             : #include <validationinterface.h>
      11             : 
      12             : #include <memory>
      13             : #include <optional>
      14             : #include <thread>
      15             : #include <vector>
      16             : 
      17             : class CChainState;
      18             : 
      19             : namespace Consensus {
      20             : struct LLMQParams;
      21             : } // namespace Consensus
      22             : 
      23             : namespace chainlock {
      24             : class Chainlocks;
      25             : } // namespace chainlock
      26             : 
      27             : class CMasternodeSync;
      28             : class CTxMemPool;
      29             : 
      30             : namespace instantsend {
      31             : struct InstantSendLock;
      32             : using InstantSendLockPtr = std::shared_ptr<InstantSendLock>;
      33             : struct PendingISLockEntry;
      34             : class InstantSendSigner;
      35             : } // namespace instantsend
      36             : namespace llmq {
      37             : class CSigningManager;
      38             : class CInstantSendManager;
      39             : class CQuorumManager;
      40             : } // namespace llmq
      41             : 
      42             : class NetInstantSend final : public NetHandler, public CValidationInterface
      43             : {
      44             : public:
      45       11428 :     NetInstantSend(PeerManagerInternal* peer_manager, llmq::CInstantSendManager& is_manager,
      46             :                    instantsend::InstantSendSigner* signer, llmq::CSigningManager& sigman, llmq::CQuorumManager& qman,
      47             :                    const chainlock::Chainlocks& chainlocks, CChainState& chainstate, CTxMemPool& mempool,
      48             :                    const CMasternodeSync& mn_sync) :
      49        2857 :         NetHandler(peer_manager),
      50        2857 :         m_is_manager{is_manager},
      51        2857 :         m_signer{signer},
      52        2857 :         m_sigman{sigman},
      53        2857 :         m_qman(qman),
      54        2857 :         m_chainlocks{chainlocks},
      55        2857 :         m_chainstate{chainstate},
      56        2857 :         m_mempool{mempool},
      57        2857 :         m_mn_sync{mn_sync}
      58        8571 :     {
      59        2857 :         workInterrupt.reset();
      60        5714 :     }
      61             :     void ProcessMessage(CNode& pfrom, const std::string& msg_type, CDataStream& vRecv) override;
      62             : 
      63             :     void Start() override;
      64             :     void Stop() override;
      65        5714 :     void Interrupt() override { workInterrupt(); };
      66             : 
      67             :     void WorkThreadMain();
      68             : 
      69             : protected:
      70             :     // -- CValidationInterface
      71             :     void SynchronousUpdatedBlockTip(const CBlockIndex* pindexNew, const CBlockIndex* pindexFork,
      72             :                                     bool fInitialDownload) override;
      73             :     void UpdatedBlockTip(const CBlockIndex* pindexNew, const CBlockIndex* pindexFork, bool fInitialDownload) override;
      74             :     void TransactionAddedToMempool(const CTransactionRef&, int64_t, uint64_t mempool_sequence) override;
      75             :     void TransactionRemovedFromMempool(const CTransactionRef& ptx, MemPoolRemovalReason reason,
      76             :                                        uint64_t mempool_sequence) override;
      77             :     void BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex) override;
      78             :     void BlockDisconnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexDisconnected) override;
      79             :     void NotifyChainLock(const CBlockIndex* pindex, const std::shared_ptr<const chainlock::ChainLockSig>& clsig) override;
      80             : 
      81             : private:
      82             :     struct BatchVerificationData;
      83             : 
      84             :     bool ValidateIncomingISLock(const instantsend::InstantSendLock& islock, NodeId node_id);
      85             :     std::optional<int> ResolveCycleHeight(const uint256& cycle_hash);
      86             :     bool ValidateDeterministicCycleHeight(int cycle_height, const Consensus::LLMQParams& llmq_params, NodeId node_id);
      87             : 
      88             :     std::unique_ptr<BatchVerificationData> BuildVerificationBatch(
      89             :         const Consensus::LLMQParams& llmq_params, int signOffset,
      90             :         const std::vector<instantsend::PendingISLockEntry>& pend);
      91             :     Uint256HashSet ApplyVerificationResults(
      92             :         const Consensus::LLMQParams& llmq_params, bool ban,
      93             :         BatchVerificationData& data,
      94             :         const std::vector<instantsend::PendingISLockEntry>& pend);
      95             : 
      96             :     void ProcessPendingISLocks(std::vector<instantsend::PendingISLockEntry>&& locks_to_process);
      97             :     void ProcessInstantSendLock(NodeId from, const uint256& hash, const instantsend::InstantSendLockPtr& islock);
      98             :     void RemoveMempoolConflictsForLock(const uint256& hash, const instantsend::InstantSendLock& islock);
      99             : 
     100             :     Uint256HashSet ProcessPendingInstantSendLocks(
     101             :         const Consensus::LLMQParams& llmq_params, int signOffset, bool ban,
     102             :         const std::vector<instantsend::PendingISLockEntry>& pend);
     103             : 
     104             :     void ResolveBlockConflicts(const uint256& islockHash, const instantsend::InstantSendLock& islock);
     105             : 
     106             :     void TruncateRecoveredSigsForInputs(const instantsend::InstantSendLock& islock);
     107             : 
     108             :     void HandleFullyConfirmedBlock(const CBlockIndex* pindex);
     109             :     void ClearConflicting(const Uint256HashMap<CTransactionRef>& to_delete);
     110             : 
     111             :     llmq::CInstantSendManager& m_is_manager;
     112             :     instantsend::InstantSendSigner* m_signer; // non-null only for masternode
     113             :     llmq::CSigningManager& m_sigman;
     114             :     llmq::CQuorumManager& m_qman;
     115             :     const chainlock::Chainlocks& m_chainlocks;
     116             :     CChainState& m_chainstate;
     117             :     CTxMemPool& m_mempool;
     118             :     const CMasternodeSync& m_mn_sync;
     119             : 
     120             :     std::thread workThread;
     121             :     CThreadInterrupt workInterrupt;
     122             : };
     123             : 
     124             : #endif // BITCOIN_INSTANTSEND_NET_INSTANTSEND_H