mirror of
https://github.com/dashpay/dash.git
synced 2024-12-26 04:22:55 +01:00
Merge #18524: refactor: drop boost::signals2 in validationinterface
d6815a2313158862d448733954a73520f223deb6 refactor: drop boost::signals2 in validationinterface (Russell Yanofsky) Pull request description: Stop using boost::signals2 internally in validationinterface. Replace with std::list and Add/Remove/Clear/Iterate helper functions. Motivation for change is to reduce dependencies and avoid issues happening with boost versions before 1.59: https://github.com/bitcoin/bitcoin/issues/18517, https://github.com/bitcoin/bitcoin/pull/18471 ACKs for top commit: MarcoFalke: ACK d6815a2313158862d448733954a73520f223deb6 laanwj: ACK d6815a2313158862d448733954a73520f223deb6 hebasto: re-ACK d6815a2313158862d448733954a73520f223deb6 promag: ACK d6815a2313158862d448733954a73520f223deb6. Tree-SHA512: 4fc0f14a8446e8616cc142af6c3d36815f3254525d30348ba8e4d4bc74c249a5a8c9bc119bdd1be7ebd7abe0b784bc0c5551a3e156a766890cb2fdd891a95919
This commit is contained in:
Wladimir J. van der Laan
PastaPastaPasta
parent
4f00d45e53
commit
d2bbf03c32
@ -21,56 +21,75 @@
|
||||
#include <unordered_map>
|
||||
#include <utility>
|
||||
|
||||
#include <boost/signals2/signal.hpp>
|
||||
|
||||
struct ValidationInterfaceConnections {
|
||||
boost::signals2::scoped_connection UpdatedBlockTip;
|
||||
boost::signals2::scoped_connection SynchronousUpdatedBlockTip;
|
||||
boost::signals2::scoped_connection TransactionAddedToMempool;
|
||||
boost::signals2::scoped_connection BlockConnected;
|
||||
boost::signals2::scoped_connection BlockDisconnected;
|
||||
boost::signals2::scoped_connection TransactionRemovedFromMempool;
|
||||
boost::signals2::scoped_connection ChainStateFlushed;
|
||||
boost::signals2::scoped_connection BlockChecked;
|
||||
boost::signals2::scoped_connection NewPoWValidBlock;
|
||||
boost::signals2::scoped_connection AcceptedBlockHeader;
|
||||
boost::signals2::scoped_connection NotifyHeaderTip;
|
||||
boost::signals2::scoped_connection NotifyTransactionLock;
|
||||
boost::signals2::scoped_connection NotifyChainLock;
|
||||
boost::signals2::scoped_connection NotifyGovernanceVote;
|
||||
boost::signals2::scoped_connection NotifyGovernanceObject;
|
||||
boost::signals2::scoped_connection NotifyInstantSendDoubleSpendAttempt;
|
||||
boost::signals2::scoped_connection NotifyMasternodeListChanged;
|
||||
boost::signals2::scoped_connection NotifyRecoveredSig;
|
||||
|
||||
};
|
||||
|
||||
//! The MainSignalsInstance manages a list of shared_ptr<CValidationInterface>
|
||||
//! callbacks.
|
||||
//!
|
||||
//! A std::unordered_map is used to track what callbacks are currently
|
||||
//! registered, and a std::list is to used to store the callbacks that are
|
||||
//! currently registered as well as any callbacks that are just unregistered
|
||||
//! and about to be deleted when they are done executing.
|
||||
struct MainSignalsInstance {
|
||||
boost::signals2::signal<void (const CBlockIndex *, const CBlockIndex *, bool fInitialDownload)> UpdatedBlockTip;
|
||||
boost::signals2::signal<void (const CBlockIndex *, const CBlockIndex *, bool fInitialDownload)> SynchronousUpdatedBlockTip;
|
||||
boost::signals2::signal<void (const CTransactionRef &, int64_t)> TransactionAddedToMempool;
|
||||
boost::signals2::signal<void (const std::shared_ptr<const CBlock> &, const CBlockIndex *pindex)> BlockConnected;
|
||||
boost::signals2::signal<void (const std::shared_ptr<const CBlock>&, const CBlockIndex* pindex)> BlockDisconnected;
|
||||
boost::signals2::signal<void (const CTransactionRef &, MemPoolRemovalReason)> TransactionRemovedFromMempool;
|
||||
boost::signals2::signal<void (const CBlockLocator &)> ChainStateFlushed;
|
||||
boost::signals2::signal<void (const CBlock&, const BlockValidationState&)> BlockChecked;
|
||||
boost::signals2::signal<void (const CBlockIndex *, const std::shared_ptr<const CBlock>&)> NewPoWValidBlock;
|
||||
boost::signals2::signal<void (const CBlockIndex *)>AcceptedBlockHeader;
|
||||
boost::signals2::signal<void (const CBlockIndex *, bool)>NotifyHeaderTip;
|
||||
boost::signals2::signal<void (const CTransactionRef& tx, const std::shared_ptr<const llmq::CInstantSendLock>& islock)>NotifyTransactionLock;
|
||||
boost::signals2::signal<void (const CBlockIndex* pindex, const std::shared_ptr<const llmq::CChainLockSig>& clsig)>NotifyChainLock;
|
||||
boost::signals2::signal<void (const std::shared_ptr<const CGovernanceVote>& vote)>NotifyGovernanceVote;
|
||||
boost::signals2::signal<void (const std::shared_ptr<const CGovernanceObject>& object)>NotifyGovernanceObject;
|
||||
boost::signals2::signal<void (const CTransactionRef& currentTx, const CTransactionRef& previousTx)>NotifyInstantSendDoubleSpendAttempt;
|
||||
boost::signals2::signal<void (bool undo, const CDeterministicMNList& oldMNList, const CDeterministicMNListDiff& diff, CConnman& connman)>NotifyMasternodeListChanged;
|
||||
boost::signals2::signal<void (const std::shared_ptr<const llmq::CRecoveredSig>& sig)>NotifyRecoveredSig;
|
||||
private:
|
||||
Mutex m_mutex;
|
||||
//! List entries consist of a callback pointer and reference count. The
|
||||
//! count is equal to the number of current executions of that entry, plus 1
|
||||
//! if it's registered. It cannot be 0 because that would imply it is
|
||||
//! unregistered and also not being executed (so shouldn't exist).
|
||||
struct ListEntry { std::shared_ptr<CValidationInterface> callbacks; int count = 1; };
|
||||
std::list<ListEntry> m_list GUARDED_BY(m_mutex);
|
||||
std::unordered_map<CValidationInterface*, std::list<ListEntry>::iterator> m_map GUARDED_BY(m_mutex);
|
||||
|
||||
public:
|
||||
// We are not allowed to assume the scheduler only runs in one thread,
|
||||
// but must ensure all callbacks happen in-order, so we end up creating
|
||||
// our own queue here :(
|
||||
SingleThreadedSchedulerClient m_schedulerClient;
|
||||
std::unordered_map<CValidationInterface*, ValidationInterfaceConnections> m_connMainSignals;
|
||||
|
||||
explicit MainSignalsInstance(CScheduler *pscheduler) : m_schedulerClient(pscheduler) {}
|
||||
|
||||
void Register(std::shared_ptr<CValidationInterface> callbacks)
|
||||
{
|
||||
LOCK(m_mutex);
|
||||
auto inserted = m_map.emplace(callbacks.get(), m_list.end());
|
||||
if (inserted.second) inserted.first->second = m_list.emplace(m_list.end());
|
||||
inserted.first->second->callbacks = std::move(callbacks);
|
||||
}
|
||||
|
||||
void Unregister(CValidationInterface* callbacks)
|
||||
{
|
||||
LOCK(m_mutex);
|
||||
auto it = m_map.find(callbacks);
|
||||
if (it != m_map.end()) {
|
||||
if (!--it->second->count) m_list.erase(it->second);
|
||||
m_map.erase(it);
|
||||
}
|
||||
}
|
||||
|
||||
//! Clear unregisters every previously registered callback, erasing every
|
||||
//! map entry. After this call, the list may still contain callbacks that
|
||||
//! are currently executing, but it will be cleared when they are done
|
||||
//! executing.
|
||||
void Clear()
|
||||
{
|
||||
LOCK(m_mutex);
|
||||
for (auto it = m_list.begin(); it != m_list.end();) {
|
||||
it = --it->count ? std::next(it) : m_list.erase(it);
|
||||
}
|
||||
m_map.clear();
|
||||
}
|
||||
|
||||
template<typename F> void Iterate(F&& f)
|
||||
{
|
||||
WAIT_LOCK(m_mutex, lock);
|
||||
for (auto it = m_list.begin(); it != m_list.end();) {
|
||||
++it->count;
|
||||
{
|
||||
REVERSE_LOCK(lock);
|
||||
f(*it->callbacks);
|
||||
}
|
||||
it = --it->count ? std::next(it) : m_list.erase(it);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
static CMainSignals g_signals;
|
||||
@ -103,25 +122,7 @@ CMainSignals& GetMainSignals()
|
||||
void RegisterSharedValidationInterface(std::shared_ptr<CValidationInterface> pwalletIn) {
|
||||
// Each connection captures pwalletIn to ensure that each callback is
|
||||
// executed before pwalletIn is destroyed. For more details see #18338.
|
||||
ValidationInterfaceConnections& conns = g_signals.m_internals->m_connMainSignals[pwalletIn.get()];
|
||||
conns.AcceptedBlockHeader = g_signals.m_internals->AcceptedBlockHeader.connect(std::bind(&CValidationInterface::AcceptedBlockHeader, pwalletIn, std::placeholders::_1));
|
||||
conns.NotifyHeaderTip = g_signals.m_internals->NotifyHeaderTip.connect(std::bind(&CValidationInterface::NotifyHeaderTip, pwalletIn, std::placeholders::_1, std::placeholders::_2));
|
||||
conns.UpdatedBlockTip = g_signals.m_internals->UpdatedBlockTip.connect(std::bind(&CValidationInterface::UpdatedBlockTip, pwalletIn, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
|
||||
conns.SynchronousUpdatedBlockTip = g_signals.m_internals->SynchronousUpdatedBlockTip.connect(std::bind(&CValidationInterface::SynchronousUpdatedBlockTip, pwalletIn, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
|
||||
conns.TransactionAddedToMempool = g_signals.m_internals->TransactionAddedToMempool.connect(std::bind(&CValidationInterface::TransactionAddedToMempool, pwalletIn, std::placeholders::_1, std::placeholders::_2));
|
||||
conns.BlockConnected = g_signals.m_internals->BlockConnected.connect(std::bind(&CValidationInterface::BlockConnected, pwalletIn, std::placeholders::_1, std::placeholders::_2));
|
||||
conns.BlockDisconnected = g_signals.m_internals->BlockDisconnected.connect(std::bind(&CValidationInterface::BlockDisconnected, pwalletIn, std::placeholders::_1, std::placeholders::_2));
|
||||
conns.NotifyTransactionLock = g_signals.m_internals->NotifyTransactionLock.connect(std::bind(&CValidationInterface::NotifyTransactionLock, pwalletIn, std::placeholders::_1, std::placeholders::_2));
|
||||
conns.NotifyChainLock = g_signals.m_internals->NotifyChainLock.connect(std::bind(&CValidationInterface::NotifyChainLock, pwalletIn, std::placeholders::_1, std::placeholders::_2));
|
||||
conns.TransactionRemovedFromMempool = g_signals.m_internals->TransactionRemovedFromMempool.connect(std::bind(&CValidationInterface::TransactionRemovedFromMempool, pwalletIn, std::placeholders::_1, std::placeholders::_2));
|
||||
conns.ChainStateFlushed = g_signals.m_internals->ChainStateFlushed.connect(std::bind(&CValidationInterface::ChainStateFlushed, pwalletIn, std::placeholders::_1));
|
||||
conns.BlockChecked = g_signals.m_internals->BlockChecked.connect(std::bind(&CValidationInterface::BlockChecked, pwalletIn, std::placeholders::_1, std::placeholders::_2));
|
||||
conns.NewPoWValidBlock = g_signals.m_internals->NewPoWValidBlock.connect(std::bind(&CValidationInterface::NewPoWValidBlock, pwalletIn, std::placeholders::_1, std::placeholders::_2));
|
||||
conns.NotifyGovernanceObject = g_signals.m_internals->NotifyGovernanceObject.connect(std::bind(&CValidationInterface::NotifyGovernanceObject, pwalletIn, std::placeholders::_1));
|
||||
conns.NotifyGovernanceVote = g_signals.m_internals->NotifyGovernanceVote.connect(std::bind(&CValidationInterface::NotifyGovernanceVote, pwalletIn, std::placeholders::_1));
|
||||
conns.NotifyInstantSendDoubleSpendAttempt = g_signals.m_internals->NotifyInstantSendDoubleSpendAttempt.connect(std::bind(&CValidationInterface::NotifyInstantSendDoubleSpendAttempt, pwalletIn, std::placeholders::_1, std::placeholders::_2));
|
||||
conns.NotifyRecoveredSig = g_signals.m_internals->NotifyRecoveredSig.connect(std::bind(&CValidationInterface::NotifyRecoveredSig, pwalletIn, std::placeholders::_1));
|
||||
conns.NotifyMasternodeListChanged = g_signals.m_internals->NotifyMasternodeListChanged.connect(std::bind(&CValidationInterface::NotifyMasternodeListChanged, pwalletIn, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
|
||||
g_signals.m_internals->Register(std::move(pwalletIn));
|
||||
}
|
||||
|
||||
void RegisterValidationInterface(CValidationInterface* callbacks)
|
||||
@ -138,7 +139,7 @@ void UnregisterSharedValidationInterface(std::shared_ptr<CValidationInterface> c
|
||||
|
||||
void UnregisterValidationInterface(CValidationInterface* pwalletIn) {
|
||||
if (g_signals.m_internals) {
|
||||
g_signals.m_internals->m_connMainSignals.erase(pwalletIn);
|
||||
g_signals.m_internals->Unregister(pwalletIn);
|
||||
}
|
||||
}
|
||||
|
||||
@ -146,7 +147,7 @@ void UnregisterAllValidationInterfaces() {
|
||||
if (!g_signals.m_internals) {
|
||||
return;
|
||||
}
|
||||
g_signals.m_internals->m_connMainSignals.clear();
|
||||
g_signals.m_internals->Clear();
|
||||
}
|
||||
|
||||
void CallFunctionInValidationInterfaceQueue(std::function<void ()> func) {
|
||||
@ -186,7 +187,7 @@ void CMainSignals::UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockInd
|
||||
// in the same critical section where the chain is updated
|
||||
|
||||
auto event = [pindexNew, pindexFork, fInitialDownload, this] {
|
||||
m_internals->UpdatedBlockTip(pindexNew, pindexFork, fInitialDownload);
|
||||
m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.UpdatedBlockTip(pindexNew, pindexFork, fInitialDownload); });
|
||||
};
|
||||
ENQUEUE_AND_LOG_EVENT(event, "%s: new block hash=%s fork block hash=%s (in IBD=%s)", __func__,
|
||||
pindexNew->GetBlockHash().ToString(),
|
||||
@ -195,12 +196,12 @@ void CMainSignals::UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockInd
|
||||
}
|
||||
|
||||
void CMainSignals::SynchronousUpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) {
|
||||
m_internals->SynchronousUpdatedBlockTip(pindexNew, pindexFork, fInitialDownload);
|
||||
m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.SynchronousUpdatedBlockTip(pindexNew, pindexFork, fInitialDownload); });
|
||||
}
|
||||
|
||||
void CMainSignals::TransactionAddedToMempool(const CTransactionRef &ptx, int64_t nAcceptTime) {
|
||||
auto event = [ptx, nAcceptTime, this] {
|
||||
m_internals->TransactionAddedToMempool(ptx, nAcceptTime);
|
||||
m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.TransactionAddedToMempool(ptx, nAcceptTime); });
|
||||
};
|
||||
ENQUEUE_AND_LOG_EVENT(event, "%s: txid=%s", __func__,
|
||||
ptx->GetHash().ToString());
|
||||
@ -208,7 +209,7 @@ void CMainSignals::TransactionAddedToMempool(const CTransactionRef &ptx, int64_t
|
||||
|
||||
void CMainSignals::TransactionRemovedFromMempool(const CTransactionRef &ptx, MemPoolRemovalReason reason) {
|
||||
auto event = [ptx, reason, this] {
|
||||
m_internals->TransactionRemovedFromMempool(ptx, reason);
|
||||
m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.TransactionRemovedFromMempool(ptx, reason); });
|
||||
};
|
||||
ENQUEUE_AND_LOG_EVENT(event, "%s: txid=%s", __func__,
|
||||
ptx->GetHash().ToString());
|
||||
@ -216,7 +217,7 @@ void CMainSignals::TransactionRemovedFromMempool(const CTransactionRef &ptx, Mem
|
||||
|
||||
void CMainSignals::BlockConnected(const std::shared_ptr<const CBlock> &pblock, const CBlockIndex *pindex) {
|
||||
auto event = [pblock, pindex, this] {
|
||||
m_internals->BlockConnected(pblock, pindex);
|
||||
m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.BlockConnected(pblock, pindex); });
|
||||
};
|
||||
ENQUEUE_AND_LOG_EVENT(event, "%s: block hash=%s block height=%d", __func__,
|
||||
pblock->GetHash().ToString(),
|
||||
@ -225,7 +226,7 @@ void CMainSignals::BlockConnected(const std::shared_ptr<const CBlock> &pblock, c
|
||||
|
||||
void CMainSignals::BlockDisconnected(const std::shared_ptr<const CBlock> &pblock, const CBlockIndex* pindex) {
|
||||
auto event = [pblock, pindex, this] {
|
||||
m_internals->BlockDisconnected(pblock, pindex);
|
||||
m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.BlockDisconnected(pblock, pindex); });
|
||||
};
|
||||
ENQUEUE_AND_LOG_EVENT(event, "%s: block hash=%s block height=%d", __func__,
|
||||
pblock->GetHash().ToString(),
|
||||
@ -234,7 +235,7 @@ void CMainSignals::BlockDisconnected(const std::shared_ptr<const CBlock> &pblock
|
||||
|
||||
void CMainSignals::ChainStateFlushed(const CBlockLocator &locator) {
|
||||
auto event = [locator, this] {
|
||||
m_internals->ChainStateFlushed(locator);
|
||||
m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.ChainStateFlushed(locator); });
|
||||
};
|
||||
ENQUEUE_AND_LOG_EVENT(event, "%s: block hash=%s", __func__,
|
||||
locator.IsNull() ? "null" : locator.vHave.front().ToString());
|
||||
@ -243,27 +244,27 @@ void CMainSignals::ChainStateFlushed(const CBlockLocator &locator) {
|
||||
void CMainSignals::BlockChecked(const CBlock& block, const BlockValidationState& state) {
|
||||
LOG_EVENT("%s: block hash=%s state=%s", __func__,
|
||||
block.GetHash().ToString(), state.ToString());
|
||||
m_internals->BlockChecked(block, state);
|
||||
m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.BlockChecked(block, state); });
|
||||
}
|
||||
|
||||
void CMainSignals::NewPoWValidBlock(const CBlockIndex *pindex, const std::shared_ptr<const CBlock> &block) {
|
||||
LOG_EVENT("%s: block hash=%s", __func__, block->GetHash().ToString());
|
||||
m_internals->NewPoWValidBlock(pindex, block);
|
||||
m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.NewPoWValidBlock(pindex, block); });
|
||||
}
|
||||
|
||||
void CMainSignals::AcceptedBlockHeader(const CBlockIndex *pindexNew) {
|
||||
LOG_EVENT("%s: accepted block header hash=%s", __func__, pindexNew->GetBlockHash().ToString());
|
||||
m_internals->AcceptedBlockHeader(pindexNew);
|
||||
m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.AcceptedBlockHeader(pindexNew); });
|
||||
}
|
||||
|
||||
void CMainSignals::NotifyHeaderTip(const CBlockIndex *pindexNew, bool fInitialDownload) {
|
||||
LOG_EVENT("%s: accepted block header hash=%s initial=%d", __func__, pindexNew->GetBlockHash().ToString(), fInitialDownload);
|
||||
m_internals->NotifyHeaderTip(pindexNew, fInitialDownload);
|
||||
m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.NotifyHeaderTip(pindexNew, fInitialDownload); });
|
||||
}
|
||||
|
||||
void CMainSignals::NotifyTransactionLock(const CTransactionRef &tx, const std::shared_ptr<const llmq::CInstantSendLock>& islock) {
|
||||
auto event = [tx, islock, this] {
|
||||
m_internals->NotifyTransactionLock(tx, islock);
|
||||
m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.NotifyTransactionLock(tx, islock); });
|
||||
};
|
||||
ENQUEUE_AND_LOG_EVENT(event, "%s: transaction lock txid=%s", __func__,
|
||||
tx->GetHash().ToString());
|
||||
@ -271,7 +272,7 @@ void CMainSignals::NotifyTransactionLock(const CTransactionRef &tx, const std::s
|
||||
|
||||
void CMainSignals::NotifyChainLock(const CBlockIndex* pindex, const std::shared_ptr<const llmq::CChainLockSig>& clsig) {
|
||||
auto event = [pindex, clsig, this] {
|
||||
m_internals->NotifyChainLock(pindex, clsig);
|
||||
m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.NotifyChainLock(pindex, clsig); });
|
||||
};
|
||||
ENQUEUE_AND_LOG_EVENT(event, "%s: notify chainlock at block=%s cl=%s", __func__,
|
||||
pindex->GetBlockHash().ToString(),
|
||||
@ -280,21 +281,21 @@ void CMainSignals::NotifyChainLock(const CBlockIndex* pindex, const std::shared_
|
||||
|
||||
void CMainSignals::NotifyGovernanceVote(const std::shared_ptr<const CGovernanceVote>& vote) {
|
||||
auto event = [vote, this] {
|
||||
m_internals->NotifyGovernanceVote(vote);
|
||||
m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.NotifyGovernanceVote(vote); });
|
||||
};
|
||||
ENQUEUE_AND_LOG_EVENT(event, "%s: notify governance vote: %s", __func__, vote->GetHash().ToString());
|
||||
}
|
||||
|
||||
void CMainSignals::NotifyGovernanceObject(const std::shared_ptr<const CGovernanceObject>& object) {
|
||||
auto event = [object, this] {
|
||||
m_internals->NotifyGovernanceObject(object);
|
||||
m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.NotifyGovernanceObject(object); });
|
||||
};
|
||||
ENQUEUE_AND_LOG_EVENT(event, "%s: notify governance object: %s", __func__, object->GetHash().ToString());
|
||||
}
|
||||
|
||||
void CMainSignals::NotifyInstantSendDoubleSpendAttempt(const CTransactionRef& currentTx, const CTransactionRef& previousTx) {
|
||||
auto event = [currentTx, previousTx, this] {
|
||||
m_internals->NotifyInstantSendDoubleSpendAttempt(currentTx, previousTx);
|
||||
m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.NotifyInstantSendDoubleSpendAttempt(currentTx, previousTx); });
|
||||
};
|
||||
ENQUEUE_AND_LOG_EVENT(event, "%s: notify instant doublespendattempt currenttxid=%s previoustxid=%s", __func__,
|
||||
currentTx->GetHash().ToString(),
|
||||
@ -303,7 +304,7 @@ void CMainSignals::NotifyInstantSendDoubleSpendAttempt(const CTransactionRef& cu
|
||||
|
||||
void CMainSignals::NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig) {
|
||||
auto event = [sig, this] {
|
||||
m_internals->NotifyRecoveredSig(sig);
|
||||
m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.NotifyRecoveredSig(sig); });
|
||||
};
|
||||
ENQUEUE_AND_LOG_EVENT(event, "%s: notify recoveredsig=%s", __func__,
|
||||
sig->GetHash().ToString());
|
||||
@ -311,5 +312,5 @@ void CMainSignals::NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecover
|
||||
|
||||
void CMainSignals::NotifyMasternodeListChanged(bool undo, const CDeterministicMNList& oldMNList, const CDeterministicMNListDiff& diff, CConnman& connman) {
|
||||
LOG_EVENT("%s: notify mn list changed undo=%d", __func__, undo);
|
||||
m_internals->NotifyMasternodeListChanged(undo, oldMNList, diff, connman);
|
||||
m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.NotifyMasternodeListChanged(undo, oldMNList, diff, connman); });
|
||||
}
|
||||
|
||||
@ -194,9 +194,7 @@ protected:
|
||||
* Notifies listeners that a block which builds directly on our current tip
|
||||
* has been received and connected to the headers tree, though not validated yet */
|
||||
virtual void NewPoWValidBlock(const CBlockIndex *pindex, const std::shared_ptr<const CBlock>& block) {};
|
||||
friend void ::RegisterSharedValidationInterface(std::shared_ptr<CValidationInterface>);
|
||||
friend void ::UnregisterValidationInterface(CValidationInterface*);
|
||||
friend void ::UnregisterAllValidationInterfaces();
|
||||
friend class CMainSignals;
|
||||
};
|
||||
|
||||
struct MainSignalsInstance;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user