Merge #9725: CValidationInterface Cleanups
b1a6d4cTake a CTransactionRef in AddToWalletIfInvolvingMe to avoid a copy (Matt Corallo)1c95e2fUse std::shared_ptr instead of boost::shared_ptr in ScriptForMining (Matt Corallo)91f1e6cRemove dead-code tracking of requests for blocks we generated (Matt Corallo)acad82fAdd override to functions using CValidationInterface methods (Matt Corallo)e6d5e6cHold cs_wallet for whole block [dis]connection processing (Matt Corallo)461e49fSyncTransaction->TxAddedToMempool/BlockConnected/Disconnected (Matt Corallo)f404334Handle SyncTransaction in ActivateBestChain instead of ConnectTrace (Matt Corallo)a147687Keep conflictedTxs in ConnectTrace per-block (Matt Corallo)d3167baHandle conflicted transactions directly in ConnectTrace (Matt Corallo)29e6e23Make ConnectTrace::blocksConnected private, hide behind accessors (Matt Corallo)822000cAdd pblock to connectTrace at the end of ConnectTip, not start (Matt Corallo)f5e9a01Include missing #include in zmqnotificationinterface.h (Matt Corallo) Tree-SHA512: 8893d47559da3b28d2ef7359768547cba8a4b43b6f891d80f5848f995a84b1517bfb0f706fdc8cd43f09a1350349eb440d9724a59363ab517dfcc4fcb31b2018
This commit is contained in:
Wladimir J. van der Laan
commit
67023e9004
|
|
@ -744,21 +744,23 @@ PeerLogicValidation::PeerLogicValidation(CConnman* connmanIn) : connman(connmanI
|
|||
recentRejects.reset(new CRollingBloomFilter(120000, 0.000001));
|
||||
}
|
||||
|
||||
void PeerLogicValidation::SyncTransaction(const CTransaction& tx, const CBlockIndex* pindex, int nPosInBlock) {
|
||||
if (nPosInBlock == CMainSignals::SYNC_TRANSACTION_NOT_IN_BLOCK)
|
||||
return;
|
||||
|
||||
void PeerLogicValidation::BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex, const std::vector<CTransactionRef>& vtxConflicted) {
|
||||
LOCK(cs_main);
|
||||
|
||||
std::vector<uint256> vOrphanErase;
|
||||
// Which orphan pool entries must we evict?
|
||||
for (size_t j = 0; j < tx.vin.size(); j++) {
|
||||
auto itByPrev = mapOrphanTransactionsByPrev.find(tx.vin[j].prevout);
|
||||
if (itByPrev == mapOrphanTransactionsByPrev.end()) continue;
|
||||
for (auto mi = itByPrev->second.begin(); mi != itByPrev->second.end(); ++mi) {
|
||||
const CTransaction& orphanTx = *(*mi)->second.tx;
|
||||
const uint256& orphanHash = orphanTx.GetHash();
|
||||
vOrphanErase.push_back(orphanHash);
|
||||
|
||||
for (const CTransactionRef& ptx : pblock->vtx) {
|
||||
const CTransaction& tx = *ptx;
|
||||
|
||||
// Which orphan pool entries must we evict?
|
||||
for (size_t j = 0; j < tx.vin.size(); j++) {
|
||||
auto itByPrev = mapOrphanTransactionsByPrev.find(tx.vin[j].prevout);
|
||||
if (itByPrev == mapOrphanTransactionsByPrev.end()) continue;
|
||||
for (auto mi = itByPrev->second.begin(); mi != itByPrev->second.end(); ++mi) {
|
||||
const CTransaction& orphanTx = *(*mi)->second.tx;
|
||||
const uint256& orphanHash = orphanTx.GetHash();
|
||||
vOrphanErase.push_back(orphanHash);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -30,10 +30,10 @@ private:
|
|||
public:
|
||||
PeerLogicValidation(CConnman* connmanIn);
|
||||
|
||||
virtual void SyncTransaction(const CTransaction& tx, const CBlockIndex* pindex, int nPosInBlock);
|
||||
virtual void UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload);
|
||||
virtual void BlockChecked(const CBlock& block, const CValidationState& state);
|
||||
virtual void NewPoWValidBlock(const CBlockIndex *pindex, const std::shared_ptr<const CBlock>& pblock);
|
||||
void BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexConnected, const std::vector<CTransactionRef>& vtxConflicted) override;
|
||||
void UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) override;
|
||||
void BlockChecked(const CBlock& block, const CValidationState& state) override;
|
||||
void NewPoWValidBlock(const CBlockIndex *pindex, const std::shared_ptr<const CBlock>& pblock) override;
|
||||
};
|
||||
|
||||
struct CNodeStateStats {
|
||||
|
|
|
|||
|
|
@ -27,7 +27,6 @@
|
|||
#include <stdint.h>
|
||||
|
||||
#include <boost/assign/list_of.hpp>
|
||||
#include <boost/shared_ptr.hpp>
|
||||
|
||||
#include <univalue.h>
|
||||
|
||||
|
|
@ -95,7 +94,7 @@ UniValue getnetworkhashps(const JSONRPCRequest& request)
|
|||
return GetNetworkHashPS(request.params.size() > 0 ? request.params[0].get_int() : 120, request.params.size() > 1 ? request.params[1].get_int() : -1);
|
||||
}
|
||||
|
||||
UniValue generateBlocks(boost::shared_ptr<CReserveScript> coinbaseScript, int nGenerate, uint64_t nMaxTries, bool keepScript)
|
||||
UniValue generateBlocks(std::shared_ptr<CReserveScript> coinbaseScript, int nGenerate, uint64_t nMaxTries, bool keepScript)
|
||||
{
|
||||
static const int nInnerLoopCount = 0x10000;
|
||||
int nHeightStart = 0;
|
||||
|
|
@ -167,7 +166,7 @@ UniValue generate(const JSONRPCRequest& request)
|
|||
nMaxTries = request.params[1].get_int();
|
||||
}
|
||||
|
||||
boost::shared_ptr<CReserveScript> coinbaseScript;
|
||||
std::shared_ptr<CReserveScript> coinbaseScript;
|
||||
GetMainSignals().ScriptForMining(coinbaseScript);
|
||||
|
||||
// If the keypool is exhausted, no script is returned at all. Catch this.
|
||||
|
|
@ -208,7 +207,7 @@ UniValue generatetoaddress(const JSONRPCRequest& request)
|
|||
if (!address.IsValid())
|
||||
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Error: Invalid address");
|
||||
|
||||
boost::shared_ptr<CReserveScript> coinbaseScript(new CReserveScript());
|
||||
std::shared_ptr<CReserveScript> coinbaseScript = std::make_shared<CReserveScript>();
|
||||
coinbaseScript->reserveScript = GetScriptForDestination(address.Get());
|
||||
|
||||
return generateBlocks(coinbaseScript, nGenerate, nMaxTries, false);
|
||||
|
|
@ -710,7 +709,7 @@ public:
|
|||
submitblock_StateCatcher(const uint256 &hashIn) : hash(hashIn), found(false), state() {}
|
||||
|
||||
protected:
|
||||
virtual void BlockChecked(const CBlock& block, const CValidationState& stateIn) {
|
||||
void BlockChecked(const CBlock& block, const CValidationState& stateIn) override {
|
||||
if (block.GetHash() != hash)
|
||||
return;
|
||||
found = true;
|
||||
|
|
|
|||
|
|
@ -154,39 +154,6 @@ namespace {
|
|||
std::set<int> setDirtyFileInfo;
|
||||
} // anon namespace
|
||||
|
||||
/* Use this class to start tracking transactions that are removed from the
|
||||
* mempool and pass all those transactions through SyncTransaction when the
|
||||
* object goes out of scope. This is currently only used to call SyncTransaction
|
||||
* on conflicts removed from the mempool during block connection. Applied in
|
||||
* ActivateBestChain around ActivateBestStep which in turn calls:
|
||||
* ConnectTip->removeForBlock->removeConflicts
|
||||
*/
|
||||
class MemPoolConflictRemovalTracker
|
||||
{
|
||||
private:
|
||||
std::vector<CTransactionRef> conflictedTxs;
|
||||
CTxMemPool &pool;
|
||||
|
||||
public:
|
||||
MemPoolConflictRemovalTracker(CTxMemPool &_pool) : pool(_pool) {
|
||||
pool.NotifyEntryRemoved.connect(boost::bind(&MemPoolConflictRemovalTracker::NotifyEntryRemoved, this, _1, _2));
|
||||
}
|
||||
|
||||
void NotifyEntryRemoved(CTransactionRef txRemoved, MemPoolRemovalReason reason) {
|
||||
if (reason == MemPoolRemovalReason::CONFLICT) {
|
||||
conflictedTxs.push_back(txRemoved);
|
||||
}
|
||||
}
|
||||
|
||||
~MemPoolConflictRemovalTracker() {
|
||||
pool.NotifyEntryRemoved.disconnect(boost::bind(&MemPoolConflictRemovalTracker::NotifyEntryRemoved, this, _1, _2));
|
||||
for (const auto& tx : conflictedTxs) {
|
||||
GetMainSignals().SyncTransaction(*tx, NULL, CMainSignals::SYNC_TRANSACTION_NOT_IN_BLOCK);
|
||||
}
|
||||
conflictedTxs.clear();
|
||||
}
|
||||
};
|
||||
|
||||
CBlockIndex* FindForkInGlobalIndex(const CChain& chain, const CBlockLocator& locator)
|
||||
{
|
||||
// Find the first block the caller has in the main chain
|
||||
|
|
@ -982,7 +949,7 @@ bool AcceptToMemoryPoolWorker(CTxMemPool& pool, CValidationState& state, const C
|
|||
}
|
||||
}
|
||||
|
||||
GetMainSignals().SyncTransaction(tx, NULL, CMainSignals::SYNC_TRANSACTION_NOT_IN_BLOCK);
|
||||
GetMainSignals().TransactionAddedToMempool(ptx);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
|
@ -2153,7 +2120,8 @@ bool static DisconnectTip(CValidationState& state, const CChainParams& chainpara
|
|||
CBlockIndex *pindexDelete = chainActive.Tip();
|
||||
assert(pindexDelete);
|
||||
// Read block from disk.
|
||||
CBlock block;
|
||||
std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>();
|
||||
CBlock& block = *pblock;
|
||||
if (!ReadBlockFromDisk(block, pindexDelete, chainparams.GetConsensus()))
|
||||
return AbortNode(state, "Failed to read block");
|
||||
// Apply the block atomically to the chain state.
|
||||
|
|
@ -2195,9 +2163,7 @@ bool static DisconnectTip(CValidationState& state, const CChainParams& chainpara
|
|||
UpdateTip(pindexDelete->pprev, chainparams);
|
||||
// Let wallets know transactions went from 1-confirmed to
|
||||
// 0-confirmed or conflicted:
|
||||
for (const auto& tx : block.vtx) {
|
||||
GetMainSignals().SyncTransaction(*tx, pindexDelete->pprev, CMainSignals::SYNC_TRANSACTION_NOT_IN_BLOCK);
|
||||
}
|
||||
GetMainSignals().BlockDisconnected(pblock);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -2207,36 +2173,92 @@ static int64_t nTimeFlush = 0;
|
|||
static int64_t nTimeChainState = 0;
|
||||
static int64_t nTimePostConnect = 0;
|
||||
|
||||
struct PerBlockConnectTrace {
|
||||
CBlockIndex* pindex = NULL;
|
||||
std::shared_ptr<const CBlock> pblock;
|
||||
std::shared_ptr<std::vector<CTransactionRef>> conflictedTxs;
|
||||
PerBlockConnectTrace() : conflictedTxs(std::make_shared<std::vector<CTransactionRef>>()) {}
|
||||
};
|
||||
/**
|
||||
* Used to track blocks whose transactions were applied to the UTXO state as a
|
||||
* part of a single ActivateBestChainStep call.
|
||||
*
|
||||
* This class also tracks transactions that are removed from the mempool as
|
||||
* conflicts (per block) and can be used to pass all those transactions
|
||||
* through SyncTransaction.
|
||||
*
|
||||
* This class assumes (and asserts) that the conflicted transactions for a given
|
||||
* block are added via mempool callbacks prior to the BlockConnected() associated
|
||||
* with those transactions. If any transactions are marked conflicted, it is
|
||||
* assumed that an associated block will always be added.
|
||||
*
|
||||
* This class is single-use, once you call GetBlocksConnected() you have to throw
|
||||
* it away and make a new one.
|
||||
*/
|
||||
struct ConnectTrace {
|
||||
std::vector<std::pair<CBlockIndex*, std::shared_ptr<const CBlock> > > blocksConnected;
|
||||
class ConnectTrace {
|
||||
private:
|
||||
std::vector<PerBlockConnectTrace> blocksConnected;
|
||||
CTxMemPool &pool;
|
||||
|
||||
public:
|
||||
ConnectTrace(CTxMemPool &_pool) : blocksConnected(1), pool(_pool) {
|
||||
pool.NotifyEntryRemoved.connect(boost::bind(&ConnectTrace::NotifyEntryRemoved, this, _1, _2));
|
||||
}
|
||||
|
||||
~ConnectTrace() {
|
||||
pool.NotifyEntryRemoved.disconnect(boost::bind(&ConnectTrace::NotifyEntryRemoved, this, _1, _2));
|
||||
}
|
||||
|
||||
void BlockConnected(CBlockIndex* pindex, std::shared_ptr<const CBlock> pblock) {
|
||||
assert(!blocksConnected.back().pindex);
|
||||
assert(pindex);
|
||||
assert(pblock);
|
||||
blocksConnected.back().pindex = pindex;
|
||||
blocksConnected.back().pblock = std::move(pblock);
|
||||
blocksConnected.emplace_back();
|
||||
}
|
||||
|
||||
std::vector<PerBlockConnectTrace>& GetBlocksConnected() {
|
||||
// We always keep one extra block at the end of our list because
|
||||
// blocks are added after all the conflicted transactions have
|
||||
// been filled in. Thus, the last entry should always be an empty
|
||||
// one waiting for the transactions from the next block. We pop
|
||||
// the last entry here to make sure the list we return is sane.
|
||||
assert(!blocksConnected.back().pindex);
|
||||
assert(blocksConnected.back().conflictedTxs->empty());
|
||||
blocksConnected.pop_back();
|
||||
return blocksConnected;
|
||||
}
|
||||
|
||||
void NotifyEntryRemoved(CTransactionRef txRemoved, MemPoolRemovalReason reason) {
|
||||
assert(!blocksConnected.back().pindex);
|
||||
if (reason == MemPoolRemovalReason::CONFLICT) {
|
||||
blocksConnected.back().conflictedTxs->emplace_back(std::move(txRemoved));
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Connect a new block to chainActive. pblock is either NULL or a pointer to a CBlock
|
||||
* corresponding to pindexNew, to bypass loading it again from disk.
|
||||
*
|
||||
* The block is always added to connectTrace (either after loading from disk or by copying
|
||||
* pblock) - if that is not intended, care must be taken to remove the last entry in
|
||||
* blocksConnected in case of failure.
|
||||
* The block is added to connectTrace if connection succeeds.
|
||||
*/
|
||||
bool static ConnectTip(CValidationState& state, const CChainParams& chainparams, CBlockIndex* pindexNew, const std::shared_ptr<const CBlock>& pblock, ConnectTrace& connectTrace)
|
||||
{
|
||||
assert(pindexNew->pprev == chainActive.Tip());
|
||||
// Read block from disk.
|
||||
int64_t nTime1 = GetTimeMicros();
|
||||
std::shared_ptr<const CBlock> pthisBlock;
|
||||
if (!pblock) {
|
||||
std::shared_ptr<CBlock> pblockNew = std::make_shared<CBlock>();
|
||||
connectTrace.blocksConnected.emplace_back(pindexNew, pblockNew);
|
||||
if (!ReadBlockFromDisk(*pblockNew, pindexNew, chainparams.GetConsensus()))
|
||||
return AbortNode(state, "Failed to read block");
|
||||
pthisBlock = pblockNew;
|
||||
} else {
|
||||
connectTrace.blocksConnected.emplace_back(pindexNew, pblock);
|
||||
pthisBlock = pblock;
|
||||
}
|
||||
const CBlock& blockConnecting = *connectTrace.blocksConnected.back().second;
|
||||
const CBlock& blockConnecting = *pthisBlock;
|
||||
// Apply the block atomically to the chain state.
|
||||
int64_t nTime2 = GetTimeMicros(); nTimeReadFromDisk += nTime2 - nTime1;
|
||||
int64_t nTime3;
|
||||
|
|
@ -2270,6 +2292,8 @@ bool static ConnectTip(CValidationState& state, const CChainParams& chainparams,
|
|||
int64_t nTime6 = GetTimeMicros(); nTimePostConnect += nTime6 - nTime5; nTimeTotal += nTime6 - nTime1;
|
||||
LogPrint(BCLog::BENCH, " - Connect postprocess: %.2fms [%.2fs]\n", (nTime6 - nTime5) * 0.001, nTimePostConnect * 0.000001);
|
||||
LogPrint(BCLog::BENCH, "- Connect block: %.2fms [%.2fs]\n", (nTime6 - nTime1) * 0.001, nTimeTotal * 0.000001);
|
||||
|
||||
connectTrace.BlockConnected(pindexNew, std::move(pthisBlock));
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -2388,8 +2412,6 @@ static bool ActivateBestChainStep(CValidationState& state, const CChainParams& c
|
|||
state = CValidationState();
|
||||
fInvalidFound = true;
|
||||
fContinue = false;
|
||||
// If we didn't actually connect the block, don't notify listeners about it
|
||||
connectTrace.blocksConnected.pop_back();
|
||||
break;
|
||||
} else {
|
||||
// A system error occurred (disk space, database error, ...).
|
||||
|
|
@ -2461,18 +2483,11 @@ bool ActivateBestChain(CValidationState &state, const CChainParams& chainparams,
|
|||
break;
|
||||
|
||||
const CBlockIndex *pindexFork;
|
||||
ConnectTrace connectTrace;
|
||||
bool fInitialDownload;
|
||||
{
|
||||
LOCK(cs_main);
|
||||
{ // TODO: Temporarily ensure that mempool removals are notified before
|
||||
// connected transactions. This shouldn't matter, but the abandoned
|
||||
// state of transactions in our wallet is currently cleared when we
|
||||
// receive another notification and there is a race condition where
|
||||
// notification of a connected conflict might cause an outside process
|
||||
// to abandon a transaction and then have it inadvertently cleared by
|
||||
// the notification that the conflicted transaction was evicted.
|
||||
MemPoolConflictRemovalTracker mrt(mempool);
|
||||
ConnectTrace connectTrace(mempool); // Destructed before cs_main is unlocked
|
||||
|
||||
CBlockIndex *pindexOldTip = chainActive.Tip();
|
||||
if (pindexMostWork == NULL) {
|
||||
pindexMostWork = FindMostWorkChain();
|
||||
|
|
@ -2495,16 +2510,9 @@ bool ActivateBestChain(CValidationState &state, const CChainParams& chainparams,
|
|||
pindexFork = chainActive.FindFork(pindexOldTip);
|
||||
fInitialDownload = IsInitialBlockDownload();
|
||||
|
||||
// throw all transactions though the signal-interface
|
||||
|
||||
} // MemPoolConflictRemovalTracker destroyed and conflict evictions are notified
|
||||
|
||||
// Transactions in the connected block are notified
|
||||
for (const auto& pair : connectTrace.blocksConnected) {
|
||||
assert(pair.second);
|
||||
const CBlock& block = *(pair.second);
|
||||
for (unsigned int i = 0; i < block.vtx.size(); i++)
|
||||
GetMainSignals().SyncTransaction(*block.vtx[i], pair.first, i);
|
||||
for (const PerBlockConnectTrace& trace : connectTrace.GetBlocksConnected()) {
|
||||
assert(trace.pblock && trace.pindex);
|
||||
GetMainSignals().BlockConnected(trace.pblock, trace.pindex, *trace.conflictedTxs);
|
||||
}
|
||||
}
|
||||
// When we reach this point, we switched to a new tip (stored in pindexNewTip).
|
||||
|
|
|
|||
|
|
@ -14,39 +14,42 @@ CMainSignals& GetMainSignals()
|
|||
|
||||
void RegisterValidationInterface(CValidationInterface* pwalletIn) {
|
||||
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.TransactionAddedToMempool.connect(boost::bind(&CValidationInterface::TransactionAddedToMempool, pwalletIn, _1));
|
||||
g_signals.BlockConnected.connect(boost::bind(&CValidationInterface::BlockConnected, pwalletIn, _1, _2, _3));
|
||||
g_signals.BlockDisconnected.connect(boost::bind(&CValidationInterface::BlockDisconnected, pwalletIn, _1));
|
||||
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));
|
||||
g_signals.Broadcast.connect(boost::bind(&CValidationInterface::ResendWalletTransactions, pwalletIn, _1, _2));
|
||||
g_signals.BlockChecked.connect(boost::bind(&CValidationInterface::BlockChecked, pwalletIn, _1, _2));
|
||||
g_signals.ScriptForMining.connect(boost::bind(&CValidationInterface::GetScriptForMining, pwalletIn, _1));
|
||||
g_signals.BlockFound.connect(boost::bind(&CValidationInterface::ResetRequestCount, pwalletIn, _1));
|
||||
g_signals.NewPoWValidBlock.connect(boost::bind(&CValidationInterface::NewPoWValidBlock, pwalletIn, _1, _2));
|
||||
}
|
||||
|
||||
void UnregisterValidationInterface(CValidationInterface* pwalletIn) {
|
||||
g_signals.BlockFound.disconnect(boost::bind(&CValidationInterface::ResetRequestCount, pwalletIn, _1));
|
||||
g_signals.ScriptForMining.disconnect(boost::bind(&CValidationInterface::GetScriptForMining, pwalletIn, _1));
|
||||
g_signals.BlockChecked.disconnect(boost::bind(&CValidationInterface::BlockChecked, pwalletIn, _1, _2));
|
||||
g_signals.Broadcast.disconnect(boost::bind(&CValidationInterface::ResendWalletTransactions, pwalletIn, _1, _2));
|
||||
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.SyncTransaction.disconnect(boost::bind(&CValidationInterface::SyncTransaction, pwalletIn, _1, _2, _3));
|
||||
g_signals.TransactionAddedToMempool.disconnect(boost::bind(&CValidationInterface::TransactionAddedToMempool, pwalletIn, _1));
|
||||
g_signals.BlockConnected.disconnect(boost::bind(&CValidationInterface::BlockConnected, pwalletIn, _1, _2, _3));
|
||||
g_signals.BlockDisconnected.disconnect(boost::bind(&CValidationInterface::BlockDisconnected, pwalletIn, _1));
|
||||
g_signals.UpdatedBlockTip.disconnect(boost::bind(&CValidationInterface::UpdatedBlockTip, pwalletIn, _1, _2, _3));
|
||||
g_signals.NewPoWValidBlock.disconnect(boost::bind(&CValidationInterface::NewPoWValidBlock, pwalletIn, _1, _2));
|
||||
}
|
||||
|
||||
void UnregisterAllValidationInterfaces() {
|
||||
g_signals.BlockFound.disconnect_all_slots();
|
||||
g_signals.ScriptForMining.disconnect_all_slots();
|
||||
g_signals.BlockChecked.disconnect_all_slots();
|
||||
g_signals.Broadcast.disconnect_all_slots();
|
||||
g_signals.Inventory.disconnect_all_slots();
|
||||
g_signals.SetBestChain.disconnect_all_slots();
|
||||
g_signals.UpdatedTransaction.disconnect_all_slots();
|
||||
g_signals.SyncTransaction.disconnect_all_slots();
|
||||
g_signals.TransactionAddedToMempool.disconnect_all_slots();
|
||||
g_signals.BlockConnected.disconnect_all_slots();
|
||||
g_signals.BlockDisconnected.disconnect_all_slots();
|
||||
g_signals.UpdatedBlockTip.disconnect_all_slots();
|
||||
g_signals.NewPoWValidBlock.disconnect_all_slots();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,16 +7,16 @@
|
|||
#define BITCOIN_VALIDATIONINTERFACE_H
|
||||
|
||||
#include <boost/signals2/signal.hpp>
|
||||
#include <boost/shared_ptr.hpp>
|
||||
#include <memory>
|
||||
|
||||
#include "primitives/transaction.h" // CTransaction(Ref)
|
||||
|
||||
class CBlock;
|
||||
class CBlockIndex;
|
||||
struct CBlockLocator;
|
||||
class CBlockIndex;
|
||||
class CConnman;
|
||||
class CReserveScript;
|
||||
class CTransaction;
|
||||
class CValidationInterface;
|
||||
class CValidationState;
|
||||
class uint256;
|
||||
|
|
@ -33,14 +33,15 @@ void UnregisterAllValidationInterfaces();
|
|||
class CValidationInterface {
|
||||
protected:
|
||||
virtual void UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) {}
|
||||
virtual void SyncTransaction(const CTransaction &tx, const CBlockIndex *pindex, int posInBlock) {}
|
||||
virtual void TransactionAddedToMempool(const CTransactionRef &ptxn) {}
|
||||
virtual void BlockConnected(const std::shared_ptr<const CBlock> &block, const CBlockIndex *pindex, const std::vector<CTransactionRef> &txnConflicted) {}
|
||||
virtual void BlockDisconnected(const std::shared_ptr<const CBlock> &block) {}
|
||||
virtual void SetBestChain(const CBlockLocator &locator) {}
|
||||
virtual void UpdatedTransaction(const uint256 &hash) {}
|
||||
virtual void Inventory(const uint256 &hash) {}
|
||||
virtual void ResendWalletTransactions(int64_t nBestBlockTime, CConnman* connman) {}
|
||||
virtual void BlockChecked(const CBlock&, const CValidationState&) {}
|
||||
virtual void GetScriptForMining(boost::shared_ptr<CReserveScript>&) {};
|
||||
virtual void ResetRequestCount(const uint256 &hash) {};
|
||||
virtual void GetScriptForMining(std::shared_ptr<CReserveScript>&) {};
|
||||
virtual void NewPoWValidBlock(const CBlockIndex *pindex, const std::shared_ptr<const CBlock>& block) {};
|
||||
friend void ::RegisterValidationInterface(CValidationInterface*);
|
||||
friend void ::UnregisterValidationInterface(CValidationInterface*);
|
||||
|
|
@ -50,17 +51,15 @@ protected:
|
|||
struct CMainSignals {
|
||||
/** Notifies listeners of updated block chain tip */
|
||||
boost::signals2::signal<void (const CBlockIndex *, const CBlockIndex *, bool fInitialDownload)> UpdatedBlockTip;
|
||||
/** A posInBlock value for SyncTransaction calls for transactions not
|
||||
* included in connected blocks such as transactions removed from mempool,
|
||||
* accepted to mempool or appearing in disconnected blocks.*/
|
||||
static const int SYNC_TRANSACTION_NOT_IN_BLOCK = -1;
|
||||
/** Notifies listeners of updated transaction data (transaction, and
|
||||
* optionally the block it is found in). Called with block data when
|
||||
* transaction is included in a connected block, and without block data when
|
||||
* transaction was accepted to mempool, removed from mempool (only when
|
||||
* removal was due to conflict from connected block), or appeared in a
|
||||
* disconnected block.*/
|
||||
boost::signals2::signal<void (const CTransaction &, const CBlockIndex *pindex, int posInBlock)> SyncTransaction;
|
||||
/** Notifies listeners of a transaction having been added to mempool. */
|
||||
boost::signals2::signal<void (const CTransactionRef &)> TransactionAddedToMempool;
|
||||
/**
|
||||
* Notifies listeners of a block being connected.
|
||||
* Provides a vector of transactions evicted from the mempool as a result.
|
||||
*/
|
||||
boost::signals2::signal<void (const std::shared_ptr<const CBlock> &, const CBlockIndex *pindex, const std::vector<CTransactionRef> &)> BlockConnected;
|
||||
/** Notifies listeners of a block being disconnected */
|
||||
boost::signals2::signal<void (const std::shared_ptr<const CBlock> &)> BlockDisconnected;
|
||||
/** Notifies listeners of an updated transaction without new data (for now: a coinbase potentially becoming visible). */
|
||||
boost::signals2::signal<void (const uint256 &)> UpdatedTransaction;
|
||||
/** Notifies listeners of a new active block chain. */
|
||||
|
|
@ -77,9 +76,7 @@ struct CMainSignals {
|
|||
*/
|
||||
boost::signals2::signal<void (const CBlock&, const CValidationState&)> BlockChecked;
|
||||
/** Notifies listeners that a key for mining is required (coinbase) */
|
||||
boost::signals2::signal<void (boost::shared_ptr<CReserveScript>&)> ScriptForMining;
|
||||
/** Notifies listeners that a block has been successfully mined */
|
||||
boost::signals2::signal<void (const uint256 &)> BlockFound;
|
||||
boost::signals2::signal<void (std::shared_ptr<CReserveScript>&)> ScriptForMining;
|
||||
/**
|
||||
* 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 */
|
||||
|
|
|
|||
|
|
@ -967,8 +967,9 @@ bool CWallet::LoadToWallet(const CWalletTx& wtxIn)
|
|||
* Abandoned state should probably be more carefully tracked via different
|
||||
* posInBlock signals or by checking mempool presence when necessary.
|
||||
*/
|
||||
bool CWallet::AddToWalletIfInvolvingMe(const CTransaction& tx, const CBlockIndex* pIndex, int posInBlock, bool fUpdate)
|
||||
bool CWallet::AddToWalletIfInvolvingMe(const CTransactionRef& ptx, const CBlockIndex* pIndex, int posInBlock, bool fUpdate)
|
||||
{
|
||||
const CTransaction& tx = *ptx;
|
||||
{
|
||||
AssertLockHeld(cs_wallet);
|
||||
|
||||
|
|
@ -989,7 +990,7 @@ bool CWallet::AddToWalletIfInvolvingMe(const CTransaction& tx, const CBlockIndex
|
|||
if (fExisted && !fUpdate) return false;
|
||||
if (fExisted || IsMine(tx) || IsFromMe(tx))
|
||||
{
|
||||
CWalletTx wtx(this, MakeTransactionRef(tx));
|
||||
CWalletTx wtx(this, ptx);
|
||||
|
||||
// Get merkle branch if transaction was found in a block
|
||||
if (posInBlock != -1)
|
||||
|
|
@ -1117,11 +1118,10 @@ void CWallet::MarkConflicted(const uint256& hashBlock, const uint256& hashTx)
|
|||
}
|
||||
}
|
||||
|
||||
void CWallet::SyncTransaction(const CTransaction& tx, const CBlockIndex *pindex, int posInBlock)
|
||||
{
|
||||
LOCK2(cs_main, cs_wallet);
|
||||
void CWallet::SyncTransaction(const CTransactionRef& ptx, const CBlockIndex *pindexBlockConnected, int posInBlock) {
|
||||
const CTransaction& tx = *ptx;
|
||||
|
||||
if (!AddToWalletIfInvolvingMe(tx, pindex, posInBlock, true))
|
||||
if (!AddToWalletIfInvolvingMe(ptx, pindexBlockConnected, posInBlock, true))
|
||||
return; // Not one of ours
|
||||
|
||||
// If a transaction changes 'conflicted' state, that changes the balance
|
||||
|
|
@ -1134,6 +1134,38 @@ void CWallet::SyncTransaction(const CTransaction& tx, const CBlockIndex *pindex,
|
|||
}
|
||||
}
|
||||
|
||||
void CWallet::TransactionAddedToMempool(const CTransactionRef& ptx) {
|
||||
LOCK2(cs_main, cs_wallet);
|
||||
SyncTransaction(ptx, NULL, -1);
|
||||
}
|
||||
|
||||
void CWallet::BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex *pindex, const std::vector<CTransactionRef>& vtxConflicted) {
|
||||
LOCK2(cs_main, cs_wallet);
|
||||
// TODO: Tempoarily ensure that mempool removals are notified before
|
||||
// connected transactions. This shouldn't matter, but the abandoned
|
||||
// state of transactions in our wallet is currently cleared when we
|
||||
// receive another notification and there is a race condition where
|
||||
// notification of a connected conflict might cause an outside process
|
||||
// to abandon a transaction and then have it inadvertantly cleared by
|
||||
// the notification that the conflicted transaction was evicted.
|
||||
|
||||
for (const CTransactionRef& ptx : vtxConflicted) {
|
||||
SyncTransaction(ptx, NULL, -1);
|
||||
}
|
||||
for (size_t i = 0; i < pblock->vtx.size(); i++) {
|
||||
SyncTransaction(pblock->vtx[i], pindex, i);
|
||||
}
|
||||
}
|
||||
|
||||
void CWallet::BlockDisconnected(const std::shared_ptr<const CBlock>& pblock) {
|
||||
LOCK2(cs_main, cs_wallet);
|
||||
|
||||
for (const CTransactionRef& ptx : pblock->vtx) {
|
||||
SyncTransaction(ptx, NULL, -1);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
isminetype CWallet::IsMine(const CTxIn &txin) const
|
||||
{
|
||||
|
|
@ -1512,7 +1544,7 @@ CBlockIndex* CWallet::ScanForWalletTransactions(CBlockIndex* pindexStart, bool f
|
|||
CBlock block;
|
||||
if (ReadBlockFromDisk(block, pindex, Params().GetConsensus())) {
|
||||
for (size_t posInBlock = 0; posInBlock < block.vtx.size(); ++posInBlock) {
|
||||
AddToWalletIfInvolvingMe(*block.vtx[posInBlock], pindex, posInBlock, fUpdate);
|
||||
AddToWalletIfInvolvingMe(block.vtx[posInBlock], pindex, posInBlock, fUpdate);
|
||||
}
|
||||
if (!ret) {
|
||||
ret = pindex;
|
||||
|
|
@ -3365,9 +3397,9 @@ void CWallet::UpdatedTransaction(const uint256 &hashTx)
|
|||
}
|
||||
}
|
||||
|
||||
void CWallet::GetScriptForMining(boost::shared_ptr<CReserveScript> &script)
|
||||
void CWallet::GetScriptForMining(std::shared_ptr<CReserveScript> &script)
|
||||
{
|
||||
boost::shared_ptr<CReserveKey> rKey(new CReserveKey(this));
|
||||
std::shared_ptr<CReserveKey> rKey = std::make_shared<CReserveKey>(this);
|
||||
CPubKey pubkey;
|
||||
if (!rKey->GetReservedKey(pubkey))
|
||||
return;
|
||||
|
|
|
|||
|
|
@ -28,8 +28,6 @@
|
|||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#include <boost/shared_ptr.hpp>
|
||||
|
||||
extern CWallet* pwalletMain;
|
||||
|
||||
/**
|
||||
|
|
@ -661,6 +659,9 @@ private:
|
|||
|
||||
void SyncMetaData(std::pair<TxSpends::iterator, TxSpends::iterator>);
|
||||
|
||||
/* Used by TransactionAddedToMemorypool/BlockConnected/Disconnected */
|
||||
void SyncTransaction(const CTransactionRef& tx, const CBlockIndex *pindexBlockConnected, int posInBlock);
|
||||
|
||||
/* the HD chain data model (external chain counters) */
|
||||
CHDChain hdChain;
|
||||
|
||||
|
|
@ -849,8 +850,10 @@ public:
|
|||
void MarkDirty();
|
||||
bool AddToWallet(const CWalletTx& wtxIn, bool fFlushOnClose=true);
|
||||
bool LoadToWallet(const CWalletTx& wtxIn);
|
||||
void SyncTransaction(const CTransaction& tx, const CBlockIndex *pindex, int posInBlock) override;
|
||||
bool AddToWalletIfInvolvingMe(const CTransaction& tx, const CBlockIndex* pIndex, int posInBlock, bool fUpdate);
|
||||
void TransactionAddedToMempool(const CTransactionRef& tx) override;
|
||||
void BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex *pindex, const std::vector<CTransactionRef>& vtxConflicted) override;
|
||||
void BlockDisconnected(const std::shared_ptr<const CBlock>& pblock) override;
|
||||
bool AddToWalletIfInvolvingMe(const CTransactionRef& tx, const CBlockIndex* pIndex, int posInBlock, bool fUpdate);
|
||||
CBlockIndex* ScanForWalletTransactions(CBlockIndex* pindexStart, bool fUpdate = false);
|
||||
void ReacceptWalletTransactions();
|
||||
void ResendWalletTransactions(int64_t nBestBlockTime, CConnman* connman) override;
|
||||
|
|
@ -959,12 +962,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
void GetScriptForMining(boost::shared_ptr<CReserveScript> &script) override;
|
||||
void ResetRequestCount(const uint256 &hash) override
|
||||
{
|
||||
LOCK(cs_wallet);
|
||||
mapRequestCount[hash] = 0;
|
||||
};
|
||||
void GetScriptForMining(std::shared_ptr<CReserveScript> &script) override;
|
||||
|
||||
unsigned int GetKeyPoolSize()
|
||||
{
|
||||
|
|
|
|||
|
|
@ -144,8 +144,12 @@ void CZMQNotificationInterface::UpdatedBlockTip(const CBlockIndex *pindexNew, co
|
|||
}
|
||||
}
|
||||
|
||||
void CZMQNotificationInterface::SyncTransaction(const CTransaction& tx, const CBlockIndex* pindex, int posInBlock)
|
||||
void CZMQNotificationInterface::TransactionAddedToMempool(const CTransactionRef& ptx)
|
||||
{
|
||||
// Used by BlockConnected and BlockDisconnected as well, because they're
|
||||
// all the same external callback.
|
||||
const CTransaction& tx = *ptx;
|
||||
|
||||
for (std::list<CZMQAbstractNotifier*>::iterator i = notifiers.begin(); i!=notifiers.end(); )
|
||||
{
|
||||
CZMQAbstractNotifier *notifier = *i;
|
||||
|
|
@ -160,3 +164,19 @@ void CZMQNotificationInterface::SyncTransaction(const CTransaction& tx, const CB
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
void CZMQNotificationInterface::BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexConnected, const std::vector<CTransactionRef>& vtxConflicted)
|
||||
{
|
||||
for (const CTransactionRef& ptx : pblock->vtx) {
|
||||
// Do a normal notify for each transaction added in the block
|
||||
TransactionAddedToMempool(ptx);
|
||||
}
|
||||
}
|
||||
|
||||
void CZMQNotificationInterface::BlockDisconnected(const std::shared_ptr<const CBlock>& pblock)
|
||||
{
|
||||
for (const CTransactionRef& ptx : pblock->vtx) {
|
||||
// Do a normal notify for each transaction removed in block disconnection
|
||||
TransactionAddedToMempool(ptx);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@
|
|||
#include "validationinterface.h"
|
||||
#include <string>
|
||||
#include <map>
|
||||
#include <list>
|
||||
|
||||
class CBlockIndex;
|
||||
class CZMQAbstractNotifier;
|
||||
|
|
@ -24,8 +25,10 @@ protected:
|
|||
void Shutdown();
|
||||
|
||||
// CValidationInterface
|
||||
void SyncTransaction(const CTransaction& tx, const CBlockIndex *pindex, int posInBlock);
|
||||
void UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload);
|
||||
void TransactionAddedToMempool(const CTransactionRef& tx) override;
|
||||
void BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexConnected, const std::vector<CTransactionRef>& vtxConflicted) override;
|
||||
void BlockDisconnected(const std::shared_ptr<const CBlock>& pblock) override;
|
||||
void UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) override;
|
||||
|
||||
private:
|
||||
CZMQNotificationInterface();
|
||||
|
|
|
|||
Loading…
Reference in a new issue