maxmustermann/dogecoin
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

scripted-diff: replace chainActive -> ::ChainActive()

Browse source 
Though at the moment ChainActive() simply references `g_chainstate.m_chain`,
doing this change now clears the way for multiple chainstate usage and allows
us to script the diff.

-BEGIN VERIFY SCRIPT-
git grep -l "chainActive" | grep -E '(h|cpp)$' | xargs sed -i '/chainActive =/b; /extern CChain& chainActive/b; s/\(::\)\{0,1\}chainActive/::ChainActive()/g'
-END VERIFY SCRIPT-
This commit is contained in:
James O'Beirne 2019-03-27 11:14:25 -04:00
parent a3a609079c
commit 631940aab2
27 changed files with 247 additions and 247 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/bench/bench.cpp
View file

@ -114,8 +114,8 @@ void benchmark::BenchRunner::RunAll(Printer& printer, uint64_t num_evals, double
for (const auto& p : benchmarks()) { for (const auto& p : benchmarks()) {
TestingSetup test{CBaseChainParams::REGTEST}; TestingSetup test{CBaseChainParams::REGTEST};
{ {
assert(::chainActive.Height() == 0); assert(::ChainActive().Height() == 0);
const bool witness_enabled{IsWitnessEnabled(::chainActive.Tip(), Params().GetConsensus())}; const bool witness_enabled{IsWitnessEnabled(::ChainActive().Tip(), Params().GetConsensus())};
assert(witness_enabled); assert(witness_enabled);
} }

2
src/bench/duplicate_inputs.cpp
View file

@ -29,7 +29,7 @@ static void DuplicateInputs(benchmark::State& state)
CMutableTransaction coinbaseTx{}; CMutableTransaction coinbaseTx{};
CMutableTransaction naughtyTx{}; CMutableTransaction naughtyTx{};
CBlockIndex* pindexPrev = ::chainActive.Tip(); CBlockIndex* pindexPrev = ::ChainActive().Tip();
assert(pindexPrev != nullptr); assert(pindexPrev != nullptr);
block.nBits = GetNextWorkRequired(pindexPrev, &block, chainparams.GetConsensus()); block.nBits = GetNextWorkRequired(pindexPrev, &block, chainparams.GetConsensus());
block.nNonce = 0; block.nNonce = 0;

16
src/index/base.cpp
View file

@ -63,9 +63,9 @@ bool BaseIndex::Init()
if (locator.IsNull()) { if (locator.IsNull()) {
m_best_block_index = nullptr; m_best_block_index = nullptr;
} else { } else {
m_best_block_index = FindForkInGlobalIndex(chainActive, locator); m_best_block_index = FindForkInGlobalIndex(::ChainActive(), locator);
} }
m_synced = m_best_block_index.load() == chainActive.Tip(); m_synced = m_best_block_index.load() == ::ChainActive().Tip();
return true; return true;
} }
@ -74,15 +74,15 @@ static const CBlockIndex* NextSyncBlock(const CBlockIndex* pindex_prev) EXCLUSIV
AssertLockHeld(cs_main); AssertLockHeld(cs_main);
if (!pindex_prev) { if (!pindex_prev) {
return chainActive.Genesis(); return ::ChainActive().Genesis();
} }
const CBlockIndex* pindex = chainActive.Next(pindex_prev); const CBlockIndex* pindex = ::ChainActive().Next(pindex_prev);
if (pindex) { if (pindex) {
return pindex; return pindex;
} }
return chainActive.Next(chainActive.FindFork(pindex_prev)); return ::ChainActive().Next(::ChainActive().FindFork(pindex_prev));
} }
void BaseIndex::ThreadSync() void BaseIndex::ThreadSync()
@ -168,7 +168,7 @@ bool BaseIndex::Commit()
bool BaseIndex::CommitInternal(CDBBatch& batch) bool BaseIndex::CommitInternal(CDBBatch& batch)
{ {
LOCK(cs_main); LOCK(cs_main);
GetDB().WriteBestBlock(batch, chainActive.GetLocator(m_best_block_index)); GetDB().WriteBestBlock(batch, ::ChainActive().GetLocator(m_best_block_index));
return true; return true;
} }
@ -280,9 +280,9 @@ bool BaseIndex::BlockUntilSyncedToCurrentChain()
{ {
// Skip the queue-draining stuff if we know we're caught up with // Skip the queue-draining stuff if we know we're caught up with
// chainActive.Tip(). // ::ChainActive().Tip().
LOCK(cs_main); LOCK(cs_main);
const CBlockIndex* chain_tip = chainActive.Tip(); const CBlockIndex* chain_tip = ::ChainActive().Tip();
const CBlockIndex* best_block_index = m_best_block_index.load(); const CBlockIndex* best_block_index = m_best_block_index.load();
if (best_block_index->GetAncestor(chain_tip->nHeight) == chain_tip) { if (best_block_index->GetAncestor(chain_tip->nHeight) == chain_tip) {
return true; return true;

2
src/index/txindex.cpp
View file

@ -236,7 +236,7 @@ bool TxIndex::Init()
// Attempt to migrate txindex from the old database to the new one. Even if // Attempt to migrate txindex from the old database to the new one. Even if
// chain_tip is null, the node could be reindexing and we still want to // chain_tip is null, the node could be reindexing and we still want to
// delete txindex records in the old database. // delete txindex records in the old database.
if (!m_db->MigrateData(*pblocktree, chainActive.GetLocator())) { if (!m_db->MigrateData(*pblocktree, ::ChainActive().GetLocator())) {
return false; return false;
} }

14
src/init.cpp
View file

@ -490,7 +490,7 @@ void SetupServerArgs()
"and level 4 tries to reconnect the blocks, " "and level 4 tries to reconnect the blocks, "
"each level includes the checks of the previous levels " "each level includes the checks of the previous levels "
"(0-4, default: %u)", DEFAULT_CHECKLEVEL), true, OptionsCategory::DEBUG_TEST); "(0-4, default: %u)", DEFAULT_CHECKLEVEL), true, OptionsCategory::DEBUG_TEST);
gArgs.AddArg("-checkblockindex", strprintf("Do a full consistency check for mapBlockIndex, setBlockIndexCandidates, chainActive and mapBlocksUnlinked occasionally. (default: %u, regtest: %u)", defaultChainParams->DefaultConsistencyChecks(), regtestChainParams->DefaultConsistencyChecks()), true, OptionsCategory::DEBUG_TEST); gArgs.AddArg("-checkblockindex", strprintf("Do a full consistency check for mapBlockIndex, setBlockIndexCandidates, ::ChainActive() and mapBlocksUnlinked occasionally. (default: %u, regtest: %u)", defaultChainParams->DefaultConsistencyChecks(), regtestChainParams->DefaultConsistencyChecks()), true, OptionsCategory::DEBUG_TEST);
gArgs.AddArg("-checkmempool=<n>", strprintf("Run checks every <n> transactions (default: %u, regtest: %u)", defaultChainParams->DefaultConsistencyChecks(), regtestChainParams->DefaultConsistencyChecks()), true, OptionsCategory::DEBUG_TEST); gArgs.AddArg("-checkmempool=<n>", strprintf("Run checks every <n> transactions (default: %u, regtest: %u)", defaultChainParams->DefaultConsistencyChecks(), regtestChainParams->DefaultConsistencyChecks()), true, OptionsCategory::DEBUG_TEST);
gArgs.AddArg("-checkpoints", strprintf("Disable expensive verification for known chain history (default: %u)", DEFAULT_CHECKPOINTS_ENABLED), true, OptionsCategory::DEBUG_TEST); gArgs.AddArg("-checkpoints", strprintf("Disable expensive verification for known chain history (default: %u)", DEFAULT_CHECKPOINTS_ENABLED), true, OptionsCategory::DEBUG_TEST);
gArgs.AddArg("-deprecatedrpc=<method>", "Allows deprecated RPC method(s) to be used", true, OptionsCategory::DEBUG_TEST); gArgs.AddArg("-deprecatedrpc=<method>", "Allows deprecated RPC method(s) to be used", true, OptionsCategory::DEBUG_TEST);
@ -1572,12 +1572,12 @@ bool AppInitMain(InitInterfaces& interfaces)
is_coinsview_empty = fReset || fReindexChainState || pcoinsTip->GetBestBlock().IsNull(); is_coinsview_empty = fReset || fReindexChainState || pcoinsTip->GetBestBlock().IsNull();
if (!is_coinsview_empty) { if (!is_coinsview_empty) {
// LoadChainTip sets chainActive based on pcoinsTip's best block // LoadChainTip sets ::ChainActive() based on pcoinsTip's best block
if (!LoadChainTip(chainparams)) { if (!LoadChainTip(chainparams)) {
strLoadError = _("Error initializing block database"); strLoadError = _("Error initializing block database");
break; break;
} }
assert(chainActive.Tip() != nullptr); assert(::ChainActive().Tip() != nullptr);
} }
} catch (const std::exception& e) { } catch (const std::exception& e) {
LogPrintf("%s\n", e.what()); LogPrintf("%s\n", e.what());
@ -1587,7 +1587,7 @@ bool AppInitMain(InitInterfaces& interfaces)
if (!fReset) { if (!fReset) {
// Note that RewindBlockIndex MUST run even if we're about to -reindex-chainstate. // Note that RewindBlockIndex MUST run even if we're about to -reindex-chainstate.
// It both disconnects blocks based on chainActive, and drops block data in // It both disconnects blocks based on ::ChainActive(), and drops block data in
// mapBlockIndex based on lack of available witness data. // mapBlockIndex based on lack of available witness data.
uiInterface.InitMessage(_("Rewinding blocks...")); uiInterface.InitMessage(_("Rewinding blocks..."));
if (!RewindBlockIndex(chainparams)) { if (!RewindBlockIndex(chainparams)) {
@ -1605,7 +1605,7 @@ bool AppInitMain(InitInterfaces& interfaces)
MIN_BLOCKS_TO_KEEP); MIN_BLOCKS_TO_KEEP);
} }
CBlockIndex* tip = chainActive.Tip(); CBlockIndex* tip = ::ChainActive().Tip();
RPCNotifyBlockChange(true, tip); RPCNotifyBlockChange(true, tip);
if (tip && tip->nTime > GetAdjustedTime() + 2 * 60 * 60) { if (tip && tip->nTime > GetAdjustedTime() + 2 * 60 * 60) {
strLoadError = _("The block database contains a block which appears to be from the future. " strLoadError = _("The block database contains a block which appears to be from the future. "
@ -1719,7 +1719,7 @@ bool AppInitMain(InitInterfaces& interfaces)
// Either install a handler to notify us when genesis activates, or set fHaveGenesis directly. // Either install a handler to notify us when genesis activates, or set fHaveGenesis directly.
// No locking, as this happens before any background thread is started. // No locking, as this happens before any background thread is started.
boost::signals2::connection block_notify_genesis_wait_connection; boost::signals2::connection block_notify_genesis_wait_connection;
if (chainActive.Tip() == nullptr) { if (::ChainActive().Tip() == nullptr) {
block_notify_genesis_wait_connection = uiInterface.NotifyBlockTip_connect(BlockNotifyGenesisWait); block_notify_genesis_wait_connection = uiInterface.NotifyBlockTip_connect(BlockNotifyGenesisWait);
} else { } else {
fHaveGenesis = true; fHaveGenesis = true;
@ -1759,7 +1759,7 @@ bool AppInitMain(InitInterfaces& interfaces)
{ {
LOCK(cs_main); LOCK(cs_main);
LogPrintf("mapBlockIndex.size() = %u\n", mapBlockIndex.size()); LogPrintf("mapBlockIndex.size() = %u\n", mapBlockIndex.size());
chain_active_height = chainActive.Height(); chain_active_height = ::ChainActive().Height();
} }
LogPrintf("nBestHeight = %d\n", chain_active_height); LogPrintf("nBestHeight = %d\n", chain_active_height);

26
src/interfaces/chain.cpp
View file

@ -41,7 +41,7 @@ class LockImpl : public Chain::Lock
{ {
Optional<int> getHeight() override Optional<int> getHeight() override
{ {
int height = ::chainActive.Height(); int height = ::ChainActive().Height();
if (height >= 0) { if (height >= 0) {
return height; return height;
} }
@ -50,7 +50,7 @@ class LockImpl : public Chain::Lock
Optional<int> getBlockHeight(const uint256& hash) override Optional<int> getBlockHeight(const uint256& hash) override
{ {
CBlockIndex* block = LookupBlockIndex(hash); CBlockIndex* block = LookupBlockIndex(hash);
if (block && ::chainActive.Contains(block)) { if (block && ::ChainActive().Contains(block)) {
return block->nHeight; return block->nHeight;
} }
return nullopt; return nullopt;
@ -63,30 +63,30 @@ class LockImpl : public Chain::Lock
} }
uint256 getBlockHash(int height) override uint256 getBlockHash(int height) override
{ {
CBlockIndex* block = ::chainActive[height]; CBlockIndex* block = ::ChainActive()[height];
assert(block != nullptr); assert(block != nullptr);
return block->GetBlockHash(); return block->GetBlockHash();
} }
int64_t getBlockTime(int height) override int64_t getBlockTime(int height) override
{ {
CBlockIndex* block = ::chainActive[height]; CBlockIndex* block = ::ChainActive()[height];
assert(block != nullptr); assert(block != nullptr);
return block->GetBlockTime(); return block->GetBlockTime();
} }
int64_t getBlockMedianTimePast(int height) override int64_t getBlockMedianTimePast(int height) override
{ {
CBlockIndex* block = ::chainActive[height]; CBlockIndex* block = ::ChainActive()[height];
assert(block != nullptr); assert(block != nullptr);
return block->GetMedianTimePast(); return block->GetMedianTimePast();
} }
bool haveBlockOnDisk(int height) override bool haveBlockOnDisk(int height) override
{ {
CBlockIndex* block = ::chainActive[height]; CBlockIndex* block = ::ChainActive()[height];
return block && ((block->nStatus & BLOCK_HAVE_DATA) != 0) && block->nTx > 0; return block && ((block->nStatus & BLOCK_HAVE_DATA) != 0) && block->nTx > 0;
} }
Optional<int> findFirstBlockWithTimeAndHeight(int64_t time, int height, uint256* hash) override Optional<int> findFirstBlockWithTimeAndHeight(int64_t time, int height, uint256* hash) override
{ {
CBlockIndex* block = ::chainActive.FindEarliestAtLeast(time, height); CBlockIndex* block = ::ChainActive().FindEarliestAtLeast(time, height);
if (block) { if (block) {
if (hash) *hash = block->GetBlockHash(); if (hash) *hash = block->GetBlockHash();
return block->nHeight; return block->nHeight;
@ -96,7 +96,7 @@ class LockImpl : public Chain::Lock
Optional<int> findPruned(int start_height, Optional<int> stop_height) override Optional<int> findPruned(int start_height, Optional<int> stop_height) override
{ {
if (::fPruneMode) { if (::fPruneMode) {
CBlockIndex* block = stop_height ? ::chainActive[*stop_height] : ::chainActive.Tip(); CBlockIndex* block = stop_height ? ::ChainActive()[*stop_height] : ::ChainActive().Tip();
while (block && block->nHeight >= start_height) { while (block && block->nHeight >= start_height) {
if ((block->nStatus & BLOCK_HAVE_DATA) == 0) { if ((block->nStatus & BLOCK_HAVE_DATA) == 0) {
return block->nHeight; return block->nHeight;
@ -109,7 +109,7 @@ class LockImpl : public Chain::Lock
Optional<int> findFork(const uint256& hash, Optional<int>* height) override Optional<int> findFork(const uint256& hash, Optional<int>* height) override
{ {
const CBlockIndex* block = LookupBlockIndex(hash); const CBlockIndex* block = LookupBlockIndex(hash);
const CBlockIndex* fork = block ? ::chainActive.FindFork(block) : nullptr; const CBlockIndex* fork = block ? ::ChainActive().FindFork(block) : nullptr;
if (height) { if (height) {
if (block) { if (block) {
*height = block->nHeight; *height = block->nHeight;
@ -122,11 +122,11 @@ class LockImpl : public Chain::Lock
} }
return nullopt; return nullopt;
} }
CBlockLocator getTipLocator() override { return ::chainActive.GetLocator(); } CBlockLocator getTipLocator() override { return ::ChainActive().GetLocator(); }
Optional<int> findLocatorFork(const CBlockLocator& locator) override Optional<int> findLocatorFork(const CBlockLocator& locator) override
{ {
LockAnnotation lock(::cs_main); LockAnnotation lock(::cs_main);
if (CBlockIndex* fork = FindForkInGlobalIndex(::chainActive, locator)) { if (CBlockIndex* fork = FindForkInGlobalIndex(::ChainActive(), locator)) {
return fork->nHeight; return fork->nHeight;
} }
return nullopt; return nullopt;
@ -341,9 +341,9 @@ public:
{ {
if (!old_tip.IsNull()) { if (!old_tip.IsNull()) {
LOCK(::cs_main); LOCK(::cs_main);
if (old_tip == ::chainActive.Tip()->GetBlockHash()) return; if (old_tip == ::ChainActive().Tip()->GetBlockHash()) return;
CBlockIndex* block = LookupBlockIndex(old_tip); CBlockIndex* block = LookupBlockIndex(old_tip);
if (block && block->GetAncestor(::chainActive.Height()) == ::chainActive.Tip()) return; if (block && block->GetAncestor(::ChainActive().Height()) == ::ChainActive().Tip()) return;
} }
SyncWithValidationInterfaceQueue(); SyncWithValidationInterfaceQueue();
} }

8
src/interfaces/node.cpp
View file

@ -178,13 +178,13 @@ public:
int getNumBlocks() override int getNumBlocks() override
{ {
LOCK(::cs_main); LOCK(::cs_main);
return ::chainActive.Height(); return ::ChainActive().Height();
} }
int64_t getLastBlockTime() override int64_t getLastBlockTime() override
{ {
LOCK(::cs_main); LOCK(::cs_main);
if (::chainActive.Tip()) { if (::ChainActive().Tip()) {
return ::chainActive.Tip()->GetBlockTime(); return ::ChainActive().Tip()->GetBlockTime();
} }
return Params().GenesisBlock().GetBlockTime(); // Genesis block's time of current network return Params().GenesisBlock().GetBlockTime(); // Genesis block's time of current network
} }
@ -193,7 +193,7 @@ public:
const CBlockIndex* tip; const CBlockIndex* tip;
{ {
LOCK(::cs_main); LOCK(::cs_main);
tip = ::chainActive.Tip(); tip = ::ChainActive().Tip();
} }
return GuessVerificationProgress(Params().TxData(), tip); return GuessVerificationProgress(Params().TxData(), tip);
} }

2
src/miner.cpp
View file

@ -109,7 +109,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
pblocktemplate->vTxSigOpsCost.push_back(-1); // updated at end pblocktemplate->vTxSigOpsCost.push_back(-1); // updated at end
LOCK2(cs_main, mempool.cs); LOCK2(cs_main, mempool.cs);
CBlockIndex* pindexPrev = chainActive.Tip(); CBlockIndex* pindexPrev = ::ChainActive().Tip();
assert(pindexPrev != nullptr); assert(pindexPrev != nullptr);
nHeight = pindexPrev->nHeight + 1; nHeight = pindexPrev->nHeight + 1;

90
src/net_processing.cpp
View file

@ -570,7 +570,7 @@ static bool TipMayBeStale(const Consensus::Params &consensusParams) EXCLUSIVE_LO
static bool CanDirectFetch(const Consensus::Params &consensusParams) EXCLUSIVE_LOCKS_REQUIRED(cs_main) static bool CanDirectFetch(const Consensus::Params &consensusParams) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
{ {
return chainActive.Tip()->GetBlockTime() > GetAdjustedTime() - consensusParams.nPowTargetSpacing * 20; return ::ChainActive().Tip()->GetBlockTime() > GetAdjustedTime() - consensusParams.nPowTargetSpacing * 20;
} }
static bool PeerHasHeader(CNodeState *state, const CBlockIndex *pindex) EXCLUSIVE_LOCKS_REQUIRED(cs_main) static bool PeerHasHeader(CNodeState *state, const CBlockIndex *pindex) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
@ -596,7 +596,7 @@ static void FindNextBlocksToDownload(NodeId nodeid, unsigned int count, std::vec
// Make sure pindexBestKnownBlock is up to date, we'll need it. // Make sure pindexBestKnownBlock is up to date, we'll need it.
ProcessBlockAvailability(nodeid); ProcessBlockAvailability(nodeid);
if (state->pindexBestKnownBlock == nullptr || state->pindexBestKnownBlock->nChainWork < chainActive.Tip()->nChainWork || state->pindexBestKnownBlock->nChainWork < nMinimumChainWork) { if (state->pindexBestKnownBlock == nullptr || state->pindexBestKnownBlock->nChainWork < ::ChainActive().Tip()->nChainWork || state->pindexBestKnownBlock->nChainWork < nMinimumChainWork) {
// This peer has nothing interesting. // This peer has nothing interesting.
return; return;
} }
@ -604,7 +604,7 @@ static void FindNextBlocksToDownload(NodeId nodeid, unsigned int count, std::vec
if (state->pindexLastCommonBlock == nullptr) { if (state->pindexLastCommonBlock == nullptr) {
// Bootstrap quickly by guessing a parent of our best tip is the forking point. // Bootstrap quickly by guessing a parent of our best tip is the forking point.
// Guessing wrong in either direction is not a problem. // Guessing wrong in either direction is not a problem.
state->pindexLastCommonBlock = chainActive[std::min(state->pindexBestKnownBlock->nHeight, chainActive.Height())]; state->pindexLastCommonBlock = ::ChainActive()[std::min(state->pindexBestKnownBlock->nHeight, ::ChainActive().Height())];
} }
// If the peer reorganized, our previous pindexLastCommonBlock may not be an ancestor // If the peer reorganized, our previous pindexLastCommonBlock may not be an ancestor
@ -646,7 +646,7 @@ static void FindNextBlocksToDownload(NodeId nodeid, unsigned int count, std::vec
// We wouldn't download this block or its descendants from this peer. // We wouldn't download this block or its descendants from this peer.
return; return;
} }
if (pindex->nStatus & BLOCK_HAVE_DATA || chainActive.Contains(pindex)) { if (pindex->nStatus & BLOCK_HAVE_DATA || ::ChainActive().Contains(pindex)) {
if (pindex->HaveTxsDownloaded()) if (pindex->HaveTxsDownloaded())
state->pindexLastCommonBlock = pindex; state->pindexLastCommonBlock = pindex;
} else if (mapBlocksInFlight.count(pindex->GetBlockHash()) == 0) { } else if (mapBlocksInFlight.count(pindex->GetBlockHash()) == 0) {
@ -978,7 +978,7 @@ void Misbehaving(NodeId pnode, int howmuch, const std::string& message) EXCLUSIV
static bool BlockRequestAllowed(const CBlockIndex* pindex, const Consensus::Params& consensusParams) EXCLUSIVE_LOCKS_REQUIRED(cs_main) static bool BlockRequestAllowed(const CBlockIndex* pindex, const Consensus::Params& consensusParams) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
{ {
AssertLockHeld(cs_main); AssertLockHeld(cs_main);
if (chainActive.Contains(pindex)) return true; if (::ChainActive().Contains(pindex)) return true;
return pindex->IsValid(BLOCK_VALID_SCRIPTS) && (pindexBestHeader != nullptr) && return pindex->IsValid(BLOCK_VALID_SCRIPTS) && (pindexBestHeader != nullptr) &&
(pindexBestHeader->GetBlockTime() - pindex->GetBlockTime() < STALE_RELAY_AGE_LIMIT) && (pindexBestHeader->GetBlockTime() - pindex->GetBlockTime() < STALE_RELAY_AGE_LIMIT) &&
(GetBlockProofEquivalentTime(*pindexBestHeader, *pindex, *pindexBestHeader, consensusParams) < STALE_RELAY_AGE_LIMIT); (GetBlockProofEquivalentTime(*pindexBestHeader, *pindex, *pindexBestHeader, consensusParams) < STALE_RELAY_AGE_LIMIT);
@ -1090,7 +1090,7 @@ void PeerLogicValidation::NewPoWValidBlock(const CBlockIndex *pindex, const std:
/** /**
* Update our best height and announce any block hashes which weren't previously * Update our best height and announce any block hashes which weren't previously
* in chainActive to our peers. * in ::ChainActive() to our peers.
*/ */
void PeerLogicValidation::UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) { void PeerLogicValidation::UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) {
const int nNewHeight = pindexNew->nHeight; const int nNewHeight = pindexNew->nHeight;
@ -1173,13 +1173,13 @@ bool static AlreadyHave(const CInv& inv) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
case MSG_WITNESS_TX: case MSG_WITNESS_TX:
{ {
assert(recentRejects); assert(recentRejects);
if (chainActive.Tip()->GetBlockHash() != hashRecentRejectsChainTip) if (::ChainActive().Tip()->GetBlockHash() != hashRecentRejectsChainTip)
{ {
// If the chain tip has changed previously rejected transactions // If the chain tip has changed previously rejected transactions
// might be now valid, e.g. due to a nLockTime'd tx becoming valid, // might be now valid, e.g. due to a nLockTime'd tx becoming valid,
// or a double-spend. Reset the rejects filter and give those // or a double-spend. Reset the rejects filter and give those
// txs a second chance. // txs a second chance.
hashRecentRejectsChainTip = chainActive.Tip()->GetBlockHash(); hashRecentRejectsChainTip = ::ChainActive().Tip()->GetBlockHash();
recentRejects->reset(); recentRejects->reset();
} }
@ -1304,7 +1304,7 @@ void static ProcessGetBlockData(CNode* pfrom, const CChainParams& chainparams, c
} }
// Avoid leaking prune-height by never sending blocks below the NODE_NETWORK_LIMITED threshold // Avoid leaking prune-height by never sending blocks below the NODE_NETWORK_LIMITED threshold
if (send && !pfrom->fWhitelisted && ( if (send && !pfrom->fWhitelisted && (
(((pfrom->GetLocalServices() & NODE_NETWORK_LIMITED) == NODE_NETWORK_LIMITED) && ((pfrom->GetLocalServices() & NODE_NETWORK) != NODE_NETWORK) && (chainActive.Tip()->nHeight - pindex->nHeight > (int)NODE_NETWORK_LIMITED_MIN_BLOCKS + 2 /* add two blocks buffer extension for possible races */) ) (((pfrom->GetLocalServices() & NODE_NETWORK_LIMITED) == NODE_NETWORK_LIMITED) && ((pfrom->GetLocalServices() & NODE_NETWORK) != NODE_NETWORK) && (::ChainActive().Tip()->nHeight - pindex->nHeight > (int)NODE_NETWORK_LIMITED_MIN_BLOCKS + 2 /* add two blocks buffer extension for possible races */) )
)) { )) {
LogPrint(BCLog::NET, "Ignore block request below NODE_NETWORK_LIMITED threshold from peer=%d\n", pfrom->GetId()); LogPrint(BCLog::NET, "Ignore block request below NODE_NETWORK_LIMITED threshold from peer=%d\n", pfrom->GetId());
@ -1374,7 +1374,7 @@ void static ProcessGetBlockData(CNode* pfrom, const CChainParams& chainparams, c
// instead we respond with the full, non-compact block. // instead we respond with the full, non-compact block.
bool fPeerWantsWitness = State(pfrom->GetId())->fWantsCmpctWitness; bool fPeerWantsWitness = State(pfrom->GetId())->fWantsCmpctWitness;
int nSendFlags = fPeerWantsWitness ? 0 : SERIALIZE_TRANSACTION_NO_WITNESS; int nSendFlags = fPeerWantsWitness ? 0 : SERIALIZE_TRANSACTION_NO_WITNESS;
if (CanDirectFetch(consensusParams) && pindex->nHeight >= chainActive.Height() - MAX_CMPCTBLOCK_DEPTH) { if (CanDirectFetch(consensusParams) && pindex->nHeight >= ::ChainActive().Height() - MAX_CMPCTBLOCK_DEPTH) {
if ((fPeerWantsWitness || !fWitnessesPresentInARecentCompactBlock) && a_recent_compact_block && a_recent_compact_block->header.GetHash() == pindex->GetBlockHash()) { if ((fPeerWantsWitness || !fWitnessesPresentInARecentCompactBlock) && a_recent_compact_block && a_recent_compact_block->header.GetHash() == pindex->GetBlockHash()) {
connman->PushMessage(pfrom, msgMaker.Make(nSendFlags, NetMsgType::CMPCTBLOCK, *a_recent_compact_block)); connman->PushMessage(pfrom, msgMaker.Make(nSendFlags, NetMsgType::CMPCTBLOCK, *a_recent_compact_block));
} else { } else {
@ -1394,7 +1394,7 @@ void static ProcessGetBlockData(CNode* pfrom, const CChainParams& chainparams, c
// and we want it right after the last block so they don't // and we want it right after the last block so they don't
// wait for other stuff first. // wait for other stuff first.
std::vector<CInv> vInv; std::vector<CInv> vInv;
vInv.push_back(CInv(MSG_BLOCK, chainActive.Tip()->GetBlockHash())); vInv.push_back(CInv(MSG_BLOCK, ::ChainActive().Tip()->GetBlockHash()));
connman->PushMessage(pfrom, msgMaker.Make(NetMsgType::INV, vInv)); connman->PushMessage(pfrom, msgMaker.Make(NetMsgType::INV, vInv));
pfrom->hashContinue.SetNull(); pfrom->hashContinue.SetNull();
} }
@ -1515,7 +1515,7 @@ bool static ProcessHeadersMessage(CNode *pfrom, CConnman *connman, const std::ve
// nUnconnectingHeaders gets reset back to 0. // nUnconnectingHeaders gets reset back to 0.
if (!LookupBlockIndex(headers[0].hashPrevBlock) && nCount < MAX_BLOCKS_TO_ANNOUNCE) { if (!LookupBlockIndex(headers[0].hashPrevBlock) && nCount < MAX_BLOCKS_TO_ANNOUNCE) {
nodestate->nUnconnectingHeaders++; nodestate->nUnconnectingHeaders++;
connman->PushMessage(pfrom, msgMaker.Make(NetMsgType::GETHEADERS, chainActive.GetLocator(pindexBestHeader), uint256())); connman->PushMessage(pfrom, msgMaker.Make(NetMsgType::GETHEADERS, ::ChainActive().GetLocator(pindexBestHeader), uint256()));
LogPrint(BCLog::NET, "received header %s: missing prev block %s, sending getheaders (%d) to end (peer=%d, nUnconnectingHeaders=%d)\n", LogPrint(BCLog::NET, "received header %s: missing prev block %s, sending getheaders (%d) to end (peer=%d, nUnconnectingHeaders=%d)\n",
headers[0].GetHash().ToString(), headers[0].GetHash().ToString(),
headers[0].hashPrevBlock.ToString(), headers[0].hashPrevBlock.ToString(),
@ -1612,26 +1612,26 @@ bool static ProcessHeadersMessage(CNode *pfrom, CConnman *connman, const std::ve
// because it is set in UpdateBlockAvailability. Some nullptr checks // because it is set in UpdateBlockAvailability. Some nullptr checks
// are still present, however, as belt-and-suspenders. // are still present, however, as belt-and-suspenders.
if (received_new_header && pindexLast->nChainWork > chainActive.Tip()->nChainWork) { if (received_new_header && pindexLast->nChainWork > ::ChainActive().Tip()->nChainWork) {
nodestate->m_last_block_announcement = GetTime(); nodestate->m_last_block_announcement = GetTime();
} }
if (nCount == MAX_HEADERS_RESULTS) { if (nCount == MAX_HEADERS_RESULTS) {
// Headers message had its maximum size; the peer may have more headers. // Headers message had its maximum size; the peer may have more headers.
// TODO: optimize: if pindexLast is an ancestor of chainActive.Tip or pindexBestHeader, continue // TODO: optimize: if pindexLast is an ancestor of ::ChainActive().Tip or pindexBestHeader, continue
// from there instead. // from there instead.
LogPrint(BCLog::NET, "more getheaders (%d) to end to peer=%d (startheight:%d)\n", pindexLast->nHeight, pfrom->GetId(), pfrom->nStartingHeight); LogPrint(BCLog::NET, "more getheaders (%d) to end to peer=%d (startheight:%d)\n", pindexLast->nHeight, pfrom->GetId(), pfrom->nStartingHeight);
connman->PushMessage(pfrom, msgMaker.Make(NetMsgType::GETHEADERS, chainActive.GetLocator(pindexLast), uint256())); connman->PushMessage(pfrom, msgMaker.Make(NetMsgType::GETHEADERS, ::ChainActive().GetLocator(pindexLast), uint256()));
} }
bool fCanDirectFetch = CanDirectFetch(chainparams.GetConsensus()); bool fCanDirectFetch = CanDirectFetch(chainparams.GetConsensus());
// If this set of headers is valid and ends in a block with at least as // If this set of headers is valid and ends in a block with at least as
// much work as our tip, download as much as possible. // much work as our tip, download as much as possible.
if (fCanDirectFetch && pindexLast->IsValid(BLOCK_VALID_TREE) && chainActive.Tip()->nChainWork <= pindexLast->nChainWork) { if (fCanDirectFetch && pindexLast->IsValid(BLOCK_VALID_TREE) && ::ChainActive().Tip()->nChainWork <= pindexLast->nChainWork) {
std::vector<const CBlockIndex*> vToFetch; std::vector<const CBlockIndex*> vToFetch;
const CBlockIndex *pindexWalk = pindexLast; const CBlockIndex *pindexWalk = pindexLast;
// Calculate all the blocks we'd need to switch to pindexLast, up to a limit. // Calculate all the blocks we'd need to switch to pindexLast, up to a limit.
while (pindexWalk && !chainActive.Contains(pindexWalk) && vToFetch.size() <= MAX_BLOCKS_IN_TRANSIT_PER_PEER) { while (pindexWalk && !::ChainActive().Contains(pindexWalk) && vToFetch.size() <= MAX_BLOCKS_IN_TRANSIT_PER_PEER) {
if (!(pindexWalk->nStatus & BLOCK_HAVE_DATA) && if (!(pindexWalk->nStatus & BLOCK_HAVE_DATA) &&
!mapBlocksInFlight.count(pindexWalk->GetBlockHash()) && !mapBlocksInFlight.count(pindexWalk->GetBlockHash()) &&
(!IsWitnessEnabled(pindexWalk->pprev, chainparams.GetConsensus()) || State(pfrom->GetId())->fHaveWitness)) { (!IsWitnessEnabled(pindexWalk->pprev, chainparams.GetConsensus()) || State(pfrom->GetId())->fHaveWitness)) {
@ -1644,7 +1644,7 @@ bool static ProcessHeadersMessage(CNode *pfrom, CConnman *connman, const std::ve
// very large reorg at a time we think we're close to caught up to // very large reorg at a time we think we're close to caught up to
// the main chain -- this shouldn't really happen. Bail out on the // the main chain -- this shouldn't really happen. Bail out on the
// direct fetch and rely on parallel download instead. // direct fetch and rely on parallel download instead.
if (!chainActive.Contains(pindexWalk)) { if (!::ChainActive().Contains(pindexWalk)) {
LogPrint(BCLog::NET, "Large reorg, won't direct fetch to %s (%d)\n", LogPrint(BCLog::NET, "Large reorg, won't direct fetch to %s (%d)\n",
pindexLast->GetBlockHash().ToString(), pindexLast->GetBlockHash().ToString(),
pindexLast->nHeight); pindexLast->nHeight);
@ -1685,7 +1685,7 @@ bool static ProcessHeadersMessage(CNode *pfrom, CConnman *connman, const std::ve
// us sync -- disconnect if using an outbound slot (unless // us sync -- disconnect if using an outbound slot (unless
// whitelisted or addnode). // whitelisted or addnode).
// Note: We compare their tip to nMinimumChainWork (rather than // Note: We compare their tip to nMinimumChainWork (rather than
// chainActive.Tip()) because we won't start block download // ::ChainActive().Tip()) because we won't start block download
// until we have a headers chain that has at least // until we have a headers chain that has at least
// nMinimumChainWork, even if a peer has a chain past our tip, // nMinimumChainWork, even if a peer has a chain past our tip,
// as an anti-DoS measure. // as an anti-DoS measure.
@ -1699,7 +1699,7 @@ bool static ProcessHeadersMessage(CNode *pfrom, CConnman *connman, const std::ve
if (!pfrom->fDisconnect && IsOutboundDisconnectionCandidate(pfrom) && nodestate->pindexBestKnownBlock != nullptr) { if (!pfrom->fDisconnect && IsOutboundDisconnectionCandidate(pfrom) && nodestate->pindexBestKnownBlock != nullptr) {
// If this is an outbound peer, check to see if we should protect // If this is an outbound peer, check to see if we should protect
// it from the bad/lagging chain logic. // it from the bad/lagging chain logic.
if (g_outbound_peers_with_protect_from_disconnect < MAX_OUTBOUND_PEERS_TO_PROTECT_FROM_DISCONNECT && nodestate->pindexBestKnownBlock->nChainWork >= chainActive.Tip()->nChainWork && !nodestate->m_chain_sync.m_protect) { if (g_outbound_peers_with_protect_from_disconnect < MAX_OUTBOUND_PEERS_TO_PROTECT_FROM_DISCONNECT && nodestate->pindexBestKnownBlock->nChainWork >= ::ChainActive().Tip()->nChainWork && !nodestate->m_chain_sync.m_protect) {
LogPrint(BCLog::NET, "Protecting outbound peer=%d from eviction\n", pfrom->GetId()); LogPrint(BCLog::NET, "Protecting outbound peer=%d from eviction\n", pfrom->GetId());
nodestate->m_chain_sync.m_protect = true; nodestate->m_chain_sync.m_protect = true;
++g_outbound_peers_with_protect_from_disconnect; ++g_outbound_peers_with_protect_from_disconnect;
@ -2168,7 +2168,7 @@ bool static ProcessMessage(CNode* pfrom, const std::string& strCommand, CDataStr
// fell back to inv we probably have a reorg which we should get the headers for first, // fell back to inv we probably have a reorg which we should get the headers for first,
// we now only provide a getheaders response here. When we receive the headers, we will // we now only provide a getheaders response here. When we receive the headers, we will
// then ask for the blocks we need. // then ask for the blocks we need.
connman->PushMessage(pfrom, msgMaker.Make(NetMsgType::GETHEADERS, chainActive.GetLocator(pindexBestHeader), inv.hash)); connman->PushMessage(pfrom, msgMaker.Make(NetMsgType::GETHEADERS, ::ChainActive().GetLocator(pindexBestHeader), inv.hash));
LogPrint(BCLog::NET, "getheaders (%d) %s to peer=%d\n", pindexBestHeader->nHeight, inv.hash.ToString(), pfrom->GetId()); LogPrint(BCLog::NET, "getheaders (%d) %s to peer=%d\n", pindexBestHeader->nHeight, inv.hash.ToString(), pfrom->GetId());
} }
} }
@ -2239,14 +2239,14 @@ bool static ProcessMessage(CNode* pfrom, const std::string& strCommand, CDataStr
LOCK(cs_main); LOCK(cs_main);
// Find the last block the caller has in the main chain // Find the last block the caller has in the main chain
const CBlockIndex* pindex = FindForkInGlobalIndex(chainActive, locator); const CBlockIndex* pindex = FindForkInGlobalIndex(::ChainActive(), locator);
// Send the rest of the chain // Send the rest of the chain
if (pindex) if (pindex)
pindex = chainActive.Next(pindex); pindex = ::ChainActive().Next(pindex);
int nLimit = 500; int nLimit = 500;
LogPrint(BCLog::NET, "getblocks %d to %s limit %d from peer=%d\n", (pindex ? pindex->nHeight : -1), hashStop.IsNull() ? "end" : hashStop.ToString(), nLimit, pfrom->GetId()); LogPrint(BCLog::NET, "getblocks %d to %s limit %d from peer=%d\n", (pindex ? pindex->nHeight : -1), hashStop.IsNull() ? "end" : hashStop.ToString(), nLimit, pfrom->GetId());
for (; pindex; pindex = chainActive.Next(pindex)) for (; pindex; pindex = ::ChainActive().Next(pindex))
{ {
if (pindex->GetBlockHash() == hashStop) if (pindex->GetBlockHash() == hashStop)
{ {
@ -2256,7 +2256,7 @@ bool static ProcessMessage(CNode* pfrom, const std::string& strCommand, CDataStr
// If pruning, don't inv blocks unless we have on disk and are likely to still have // If pruning, don't inv blocks unless we have on disk and are likely to still have
// for some reasonable time window (1 hour) that block relay might require. // for some reasonable time window (1 hour) that block relay might require.
const int nPrunedBlocksLikelyToHave = MIN_BLOCKS_TO_KEEP - 3600 / chainparams.GetConsensus().nPowTargetSpacing; const int nPrunedBlocksLikelyToHave = MIN_BLOCKS_TO_KEEP - 3600 / chainparams.GetConsensus().nPowTargetSpacing;
if (fPruneMode && (!(pindex->nStatus & BLOCK_HAVE_DATA) || pindex->nHeight <= chainActive.Tip()->nHeight - nPrunedBlocksLikelyToHave)) if (fPruneMode && (!(pindex->nStatus & BLOCK_HAVE_DATA) || pindex->nHeight <= ::ChainActive().Tip()->nHeight - nPrunedBlocksLikelyToHave))
{ {
LogPrint(BCLog::NET, " getblocks stopping, pruned or too old block at %d %s\n", pindex->nHeight, pindex->GetBlockHash().ToString()); LogPrint(BCLog::NET, " getblocks stopping, pruned or too old block at %d %s\n", pindex->nHeight, pindex->GetBlockHash().ToString());
break; break;
@ -2298,7 +2298,7 @@ bool static ProcessMessage(CNode* pfrom, const std::string& strCommand, CDataStr
return true; return true;
} }
if (pindex->nHeight < chainActive.Height() - MAX_BLOCKTXN_DEPTH) { if (pindex->nHeight < ::ChainActive().Height() - MAX_BLOCKTXN_DEPTH) {
// If an older block is requested (should never happen in practice, // If an older block is requested (should never happen in practice,
// but can happen in tests) send a block response instead of a // but can happen in tests) send a block response instead of a
// blocktxn response. Sending a full block response instead of a // blocktxn response. Sending a full block response instead of a
@ -2358,23 +2358,23 @@ bool static ProcessMessage(CNode* pfrom, const std::string& strCommand, CDataStr
else else
{ {
// Find the last block the caller has in the main chain // Find the last block the caller has in the main chain
pindex = FindForkInGlobalIndex(chainActive, locator); pindex = FindForkInGlobalIndex(::ChainActive(), locator);
if (pindex) if (pindex)
pindex = chainActive.Next(pindex); pindex = ::ChainActive().Next(pindex);
} }
// we must use CBlocks, as CBlockHeaders won't include the 0x00 nTx count at the end // we must use CBlocks, as CBlockHeaders won't include the 0x00 nTx count at the end
std::vector<CBlock> vHeaders; std::vector<CBlock> vHeaders;
int nLimit = MAX_HEADERS_RESULTS; int nLimit = MAX_HEADERS_RESULTS;
LogPrint(BCLog::NET, "getheaders %d to %s from peer=%d\n", (pindex ? pindex->nHeight : -1), hashStop.IsNull() ? "end" : hashStop.ToString(), pfrom->GetId()); LogPrint(BCLog::NET, "getheaders %d to %s from peer=%d\n", (pindex ? pindex->nHeight : -1), hashStop.IsNull() ? "end" : hashStop.ToString(), pfrom->GetId());
for (; pindex; pindex = chainActive.Next(pindex)) for (; pindex; pindex = ::ChainActive().Next(pindex))
{ {
vHeaders.push_back(pindex->GetBlockHeader()); vHeaders.push_back(pindex->GetBlockHeader());
if (--nLimit <= 0 || pindex->GetBlockHash() == hashStop) if (--nLimit <= 0 || pindex->GetBlockHash() == hashStop)
break; break;
} }
// pindex can be nullptr either if we sent chainActive.Tip() OR // pindex can be nullptr either if we sent ::ChainActive().Tip() OR
// if our peer has chainActive.Tip() (and thus we are sending an empty // if our peer has ::ChainActive().Tip() (and thus we are sending an empty
// headers message). In both cases it's safe to update // headers message). In both cases it's safe to update
// pindexBestHeaderSent to be our tip. // pindexBestHeaderSent to be our tip.
// //
@ -2385,7 +2385,7 @@ bool static ProcessMessage(CNode* pfrom, const std::string& strCommand, CDataStr
// without the new block. By resetting the BestHeaderSent, we ensure we // without the new block. By resetting the BestHeaderSent, we ensure we
// will re-announce the new block via headers (or compact blocks again) // will re-announce the new block via headers (or compact blocks again)
// in the SendMessages logic. // in the SendMessages logic.
nodestate->pindexBestHeaderSent = pindex ? pindex : chainActive.Tip(); nodestate->pindexBestHeaderSent = pindex ? pindex : ::ChainActive().Tip();
connman->PushMessage(pfrom, msgMaker.Make(NetMsgType::HEADERS, vHeaders)); connman->PushMessage(pfrom, msgMaker.Make(NetMsgType::HEADERS, vHeaders));
return true; return true;
} }
@ -2562,7 +2562,7 @@ bool static ProcessMessage(CNode* pfrom, const std::string& strCommand, CDataStr
if (!LookupBlockIndex(cmpctblock.header.hashPrevBlock)) { if (!LookupBlockIndex(cmpctblock.header.hashPrevBlock)) {
// Doesn't connect (or is genesis), instead of DoSing in AcceptBlockHeader, request deeper headers // Doesn't connect (or is genesis), instead of DoSing in AcceptBlockHeader, request deeper headers
if (!IsInitialBlockDownload()) if (!IsInitialBlockDownload())
connman->PushMessage(pfrom, msgMaker.Make(NetMsgType::GETHEADERS, chainActive.GetLocator(pindexBestHeader), uint256())); connman->PushMessage(pfrom, msgMaker.Make(NetMsgType::GETHEADERS, ::ChainActive().GetLocator(pindexBestHeader), uint256()));
return true; return true;
} }
@ -2612,7 +2612,7 @@ bool static ProcessMessage(CNode* pfrom, const std::string& strCommand, CDataStr
// If this was a new header with more work than our tip, update the // If this was a new header with more work than our tip, update the
// peer's last block announcement time // peer's last block announcement time
if (received_new_header && pindex->nChainWork > chainActive.Tip()->nChainWork) { if (received_new_header && pindex->nChainWork > ::ChainActive().Tip()->nChainWork) {
nodestate->m_last_block_announcement = GetTime(); nodestate->m_last_block_announcement = GetTime();
} }
@ -2622,7 +2622,7 @@ bool static ProcessMessage(CNode* pfrom, const std::string& strCommand, CDataStr
if (pindex->nStatus & BLOCK_HAVE_DATA) // Nothing to do here if (pindex->nStatus & BLOCK_HAVE_DATA) // Nothing to do here
return true; return true;
if (pindex->nChainWork <= chainActive.Tip()->nChainWork || // We know something better if (pindex->nChainWork <= ::ChainActive().Tip()->nChainWork || // We know something better
pindex->nTx != 0) { // We had this block at some point, but pruned it pindex->nTx != 0) { // We had this block at some point, but pruned it
if (fAlreadyInFlight) { if (fAlreadyInFlight) {
// We requested this block for some reason, but our mempool will probably be useless // We requested this block for some reason, but our mempool will probably be useless
@ -2646,7 +2646,7 @@ bool static ProcessMessage(CNode* pfrom, const std::string& strCommand, CDataStr
// We want to be a bit conservative just to be extra careful about DoS // We want to be a bit conservative just to be extra careful about DoS
// possibilities in compact block processing... // possibilities in compact block processing...
if (pindex->nHeight <= chainActive.Height() + 2) { if (pindex->nHeight <= ::ChainActive().Height() + 2) {
if ((!fAlreadyInFlight && nodestate->nBlocksInFlight < MAX_BLOCKS_IN_TRANSIT_PER_PEER) || if ((!fAlreadyInFlight && nodestate->nBlocksInFlight < MAX_BLOCKS_IN_TRANSIT_PER_PEER) ||
(fAlreadyInFlight && blockInFlightIt->second.first == pfrom->GetId())) { (fAlreadyInFlight && blockInFlightIt->second.first == pfrom->GetId())) {
std::list<QueuedBlock>::iterator* queuedBlockIt = nullptr; std::list<QueuedBlock>::iterator* queuedBlockIt = nullptr;
@ -3301,7 +3301,7 @@ void PeerLogicValidation::ConsiderEviction(CNode *pto, int64_t time_in_seconds)
// their chain has more work than ours, we should sync to it, // their chain has more work than ours, we should sync to it,
// unless it's invalid, in which case we should find that out and // unless it's invalid, in which case we should find that out and
// disconnect from them elsewhere). // disconnect from them elsewhere).
if (state.pindexBestKnownBlock != nullptr && state.pindexBestKnownBlock->nChainWork >= chainActive.Tip()->nChainWork) { if (state.pindexBestKnownBlock != nullptr && state.pindexBestKnownBlock->nChainWork >= ::ChainActive().Tip()->nChainWork) {
if (state.m_chain_sync.m_timeout != 0) { if (state.m_chain_sync.m_timeout != 0) {
state.m_chain_sync.m_timeout = 0; state.m_chain_sync.m_timeout = 0;
state.m_chain_sync.m_work_header = nullptr; state.m_chain_sync.m_work_header = nullptr;
@ -3313,7 +3313,7 @@ void PeerLogicValidation::ConsiderEviction(CNode *pto, int64_t time_in_seconds)
// where we checked against our tip. // where we checked against our tip.
// Either way, set a new timeout based on current tip. // Either way, set a new timeout based on current tip.
state.m_chain_sync.m_timeout = time_in_seconds + CHAIN_SYNC_TIMEOUT; state.m_chain_sync.m_timeout = time_in_seconds + CHAIN_SYNC_TIMEOUT;
state.m_chain_sync.m_work_header = chainActive.Tip(); state.m_chain_sync.m_work_header = ::ChainActive().Tip();
state.m_chain_sync.m_sent_getheaders = false; state.m_chain_sync.m_sent_getheaders = false;
} else if (state.m_chain_sync.m_timeout > 0 && time_in_seconds > state.m_chain_sync.m_timeout) { } else if (state.m_chain_sync.m_timeout > 0 && time_in_seconds > state.m_chain_sync.m_timeout) {
// No evidence yet that our peer has synced to a chain with work equal to that // No evidence yet that our peer has synced to a chain with work equal to that
@ -3326,7 +3326,7 @@ void PeerLogicValidation::ConsiderEviction(CNode *pto, int64_t time_in_seconds)
} else { } else {
assert(state.m_chain_sync.m_work_header); assert(state.m_chain_sync.m_work_header);
LogPrint(BCLog::NET, "sending getheaders to outbound peer=%d to verify chain work (current best known block:%s, benchmark blockhash: %s)\n", pto->GetId(), state.pindexBestKnownBlock != nullptr ? state.pindexBestKnownBlock->GetBlockHash().ToString() : "<none>", state.m_chain_sync.m_work_header->GetBlockHash().ToString()); LogPrint(BCLog::NET, "sending getheaders to outbound peer=%d to verify chain work (current best known block:%s, benchmark blockhash: %s)\n", pto->GetId(), state.pindexBestKnownBlock != nullptr ? state.pindexBestKnownBlock->GetBlockHash().ToString() : "<none>", state.m_chain_sync.m_work_header->GetBlockHash().ToString());
connman->PushMessage(pto, msgMaker.Make(NetMsgType::GETHEADERS, chainActive.GetLocator(state.m_chain_sync.m_work_header->pprev), uint256())); connman->PushMessage(pto, msgMaker.Make(NetMsgType::GETHEADERS, ::ChainActive().GetLocator(state.m_chain_sync.m_work_header->pprev), uint256()));
state.m_chain_sync.m_sent_getheaders = true; state.m_chain_sync.m_sent_getheaders = true;
constexpr int64_t HEADERS_RESPONSE_TIME = 120; // 2 minutes constexpr int64_t HEADERS_RESPONSE_TIME = 120; // 2 minutes
// Bump the timeout to allow a response, which could clear the timeout // Bump the timeout to allow a response, which could clear the timeout
@ -3524,7 +3524,7 @@ bool PeerLogicValidation::SendMessages(CNode* pto)
// Start block sync // Start block sync
if (pindexBestHeader == nullptr) if (pindexBestHeader == nullptr)
pindexBestHeader = chainActive.Tip(); pindexBestHeader = ::ChainActive().Tip();
bool fFetch = state.fPreferredDownload || (nPreferredDownload == 0 && !pto->fClient && !pto->fOneShot); // Download if this is a nice peer, or we have no nice peers and this one might do. bool fFetch = state.fPreferredDownload || (nPreferredDownload == 0 && !pto->fClient && !pto->fOneShot); // Download if this is a nice peer, or we have no nice peers and this one might do.
if (!state.fSyncStarted && !pto->fClient && !fImporting && !fReindex) { if (!state.fSyncStarted && !pto->fClient && !fImporting && !fReindex) {
// Only actively request headers from a single peer, unless we're close to today. // Only actively request headers from a single peer, unless we're close to today.
@ -3543,7 +3543,7 @@ bool PeerLogicValidation::SendMessages(CNode* pto)
if (pindexStart->pprev) if (pindexStart->pprev)
pindexStart = pindexStart->pprev; pindexStart = pindexStart->pprev;
LogPrint(BCLog::NET, "initial getheaders (%d) to peer=%d (startheight:%d)\n", pindexStart->nHeight, pto->GetId(), pto->nStartingHeight); LogPrint(BCLog::NET, "initial getheaders (%d) to peer=%d (startheight:%d)\n", pindexStart->nHeight, pto->GetId(), pto->nStartingHeight);
connman->PushMessage(pto, msgMaker.Make(NetMsgType::GETHEADERS, chainActive.GetLocator(pindexStart), uint256())); connman->PushMessage(pto, msgMaker.Make(NetMsgType::GETHEADERS, ::ChainActive().GetLocator(pindexStart), uint256()));
} }
} }
@ -3570,11 +3570,11 @@ bool PeerLogicValidation::SendMessages(CNode* pto)
bool fFoundStartingHeader = false; bool fFoundStartingHeader = false;
// Try to find first header that our peer doesn't have, and // Try to find first header that our peer doesn't have, and
// then send all headers past that one. If we come across any // then send all headers past that one. If we come across any
// headers that aren't on chainActive, give up. // headers that aren't on ::ChainActive(), give up.
for (const uint256 &hash : pto->vBlockHashesToAnnounce) { for (const uint256 &hash : pto->vBlockHashesToAnnounce) {
const CBlockIndex* pindex = LookupBlockIndex(hash); const CBlockIndex* pindex = LookupBlockIndex(hash);
assert(pindex); assert(pindex);
if (chainActive[pindex->nHeight] != pindex) { if (::ChainActive()[pindex->nHeight] != pindex) {
// Bail out if we reorged away from this block // Bail out if we reorged away from this block
fRevertToInv = true; fRevertToInv = true;
break; break;
@ -3670,9 +3670,9 @@ bool PeerLogicValidation::SendMessages(CNode* pto)
// Warn if we're announcing a block that is not on the main chain. // Warn if we're announcing a block that is not on the main chain.
// This should be very rare and could be optimized out. // This should be very rare and could be optimized out.
// Just log for now. // Just log for now.
if (chainActive[pindex->nHeight] != pindex) { if (::ChainActive()[pindex->nHeight] != pindex) {
LogPrint(BCLog::NET, "Announcing block %s not on main chain (tip=%s)\n", LogPrint(BCLog::NET, "Announcing block %s not on main chain (tip=%s)\n",
hashToAnnounce.ToString(), chainActive.Tip()->GetBlockHash().ToString()); hashToAnnounce.ToString(), ::ChainActive().Tip()->GetBlockHash().ToString());
} }
// If the peer's chain has this block, don't inv it back. // If the peer's chain has this block, don't inv it back.

2
src/policy/fees.cpp
View file

@ -526,7 +526,7 @@ void CBlockPolicyEstimator::processTransaction(const CTxMemPoolEntry& entry, boo
if (txHeight != nBestSeenHeight) { if (txHeight != nBestSeenHeight) {
// Ignore side chains and re-orgs; assuming they are random they don't // Ignore side chains and re-orgs; assuming they are random they don't
// affect the estimate. We'll potentially double count transactions in 1-block reorgs. // affect the estimate. We'll potentially double count transactions in 1-block reorgs.
// Ignore txs if BlockPolicyEstimator is not in sync with chainActive.Tip(). // Ignore txs if BlockPolicyEstimator is not in sync with ::ChainActive().Tip().
// It will be synced next time a block is processed. // It will be synced next time a block is processed.
return; return;
} }

2
src/qt/test/wallettests.cpp
View file

@ -149,7 +149,7 @@ void TestGUI()
reserver.reserve(); reserver.reserve();
CWallet::ScanResult result = wallet->ScanForWalletTransactions(locked_chain->getBlockHash(0), {} /* stop_block */, reserver, true /* fUpdate */); CWallet::ScanResult result = wallet->ScanForWalletTransactions(locked_chain->getBlockHash(0), {} /* stop_block */, reserver, true /* fUpdate */);
QCOMPARE(result.status, CWallet::ScanResult::SUCCESS); QCOMPARE(result.status, CWallet::ScanResult::SUCCESS);
QCOMPARE(result.last_scanned_block, chainActive.Tip()->GetBlockHash()); QCOMPARE(result.last_scanned_block, ::ChainActive().Tip()->GetBlockHash());
QVERIFY(result.last_failed_block.IsNull()); QVERIFY(result.last_failed_block.IsNull());
} }
wallet->SetBroadcastTransactions(true); wallet->SetBroadcastTransactions(true);

20
src/rest.cpp
View file

@ -141,13 +141,13 @@ static bool rest_headers(HTTPRequest* req,
headers.reserve(count); headers.reserve(count);
{ {
LOCK(cs_main); LOCK(cs_main);
tip = chainActive.Tip(); tip = ::ChainActive().Tip();
const CBlockIndex* pindex = LookupBlockIndex(hash); const CBlockIndex* pindex = LookupBlockIndex(hash);
while (pindex != nullptr && chainActive.Contains(pindex)) { while (pindex != nullptr && ::ChainActive().Contains(pindex)) {
headers.push_back(pindex); headers.push_back(pindex);
if (headers.size() == (unsigned long)count) if (headers.size() == (unsigned long)count)
break; break;
pindex = chainActive.Next(pindex); pindex = ::ChainActive().Next(pindex);
} }
} }
@ -209,7 +209,7 @@ static bool rest_block(HTTPRequest* req,
CBlockIndex* tip = nullptr; CBlockIndex* tip = nullptr;
{ {
LOCK(cs_main); LOCK(cs_main);
tip = chainActive.Tip(); tip = ::ChainActive().Tip();
pblockindex = LookupBlockIndex(hash); pblockindex = LookupBlockIndex(hash);
if (!pblockindex) { if (!pblockindex) {
return RESTERR(req, HTTP_NOT_FOUND, hashStr + " not found"); return RESTERR(req, HTTP_NOT_FOUND, hashStr + " not found");
@ -522,7 +522,7 @@ static bool rest_getutxos(HTTPRequest* req, const std::string& strURIPart)
// serialize data // serialize data
// use exact same output as mentioned in Bip64 // use exact same output as mentioned in Bip64
CDataStream ssGetUTXOResponse(SER_NETWORK, PROTOCOL_VERSION); CDataStream ssGetUTXOResponse(SER_NETWORK, PROTOCOL_VERSION);
ssGetUTXOResponse << chainActive.Height() << chainActive.Tip()->GetBlockHash() << bitmap << outs; ssGetUTXOResponse << ::ChainActive().Height() << ::ChainActive().Tip()->GetBlockHash() << bitmap << outs;
std::string ssGetUTXOResponseString = ssGetUTXOResponse.str(); std::string ssGetUTXOResponseString = ssGetUTXOResponse.str();
req->WriteHeader("Content-Type", "application/octet-stream"); req->WriteHeader("Content-Type", "application/octet-stream");
@ -532,7 +532,7 @@ static bool rest_getutxos(HTTPRequest* req, const std::string& strURIPart)
case RetFormat::HEX: { case RetFormat::HEX: {
CDataStream ssGetUTXOResponse(SER_NETWORK, PROTOCOL_VERSION); CDataStream ssGetUTXOResponse(SER_NETWORK, PROTOCOL_VERSION);
ssGetUTXOResponse << chainActive.Height() << chainActive.Tip()->GetBlockHash() << bitmap << outs; ssGetUTXOResponse << ::ChainActive().Height() << ::ChainActive().Tip()->GetBlockHash() << bitmap << outs;
std::string strHex = HexStr(ssGetUTXOResponse.begin(), ssGetUTXOResponse.end()) + "\n"; std::string strHex = HexStr(ssGetUTXOResponse.begin(), ssGetUTXOResponse.end()) + "\n";
req->WriteHeader("Content-Type", "text/plain"); req->WriteHeader("Content-Type", "text/plain");
@ -545,8 +545,8 @@ static bool rest_getutxos(HTTPRequest* req, const std::string& strURIPart)
// pack in some essentials // pack in some essentials
// use more or less the same output as mentioned in Bip64 // use more or less the same output as mentioned in Bip64
objGetUTXOResponse.pushKV("chainHeight", chainActive.Height()); objGetUTXOResponse.pushKV("chainHeight", ::ChainActive().Height());
objGetUTXOResponse.pushKV("chaintipHash", chainActive.Tip()->GetBlockHash().GetHex()); objGetUTXOResponse.pushKV("chaintipHash", ::ChainActive().Tip()->GetBlockHash().GetHex());
objGetUTXOResponse.pushKV("bitmap", bitmapStringRepresentation); objGetUTXOResponse.pushKV("bitmap", bitmapStringRepresentation);
UniValue utxos(UniValue::VARR); UniValue utxos(UniValue::VARR);
@ -590,10 +590,10 @@ static bool rest_blockhash_by_height(HTTPRequest* req,
CBlockIndex* pblockindex = nullptr; CBlockIndex* pblockindex = nullptr;
{ {
LOCK(cs_main); LOCK(cs_main);
if (blockheight > chainActive.Height()) { if (blockheight > ::ChainActive().Height()) {
return RESTERR(req, HTTP_NOT_FOUND, "Block height out of range"); return RESTERR(req, HTTP_NOT_FOUND, "Block height out of range");
} }
pblockindex = chainActive[blockheight]; pblockindex = ::ChainActive()[blockheight];
} }
switch (rf) { switch (rf) {
case RetFormat::BINARY: { case RetFormat::BINARY: {

44
src/rpc/blockchain.cpp
View file

@ -182,7 +182,7 @@ static UniValue getblockcount(const JSONRPCRequest& request)
}.ToString()); }.ToString());
LOCK(cs_main); LOCK(cs_main);
return chainActive.Height(); return ::ChainActive().Height();
} }
static UniValue getbestblockhash(const JSONRPCRequest& request) static UniValue getbestblockhash(const JSONRPCRequest& request)
@ -202,7 +202,7 @@ static UniValue getbestblockhash(const JSONRPCRequest& request)
}.ToString()); }.ToString());
LOCK(cs_main); LOCK(cs_main);
return chainActive.Tip()->GetBlockHash().GetHex(); return ::ChainActive().Tip()->GetBlockHash().GetHex();
} }
void RPCNotifyBlockChange(bool ibd, const CBlockIndex * pindex) void RPCNotifyBlockChange(bool ibd, const CBlockIndex * pindex)
@ -381,7 +381,7 @@ static UniValue getdifficulty(const JSONRPCRequest& request)
}.ToString()); }.ToString());
LOCK(cs_main); LOCK(cs_main);
return GetDifficulty(chainActive.Tip()); return GetDifficulty(::ChainActive().Tip());
} }
static std::string EntryDescriptionString() static std::string EntryDescriptionString()
@ -732,10 +732,10 @@ static UniValue getblockhash(const JSONRPCRequest& request)
LOCK(cs_main); LOCK(cs_main);
int nHeight = request.params[0].get_int(); int nHeight = request.params[0].get_int();
if (nHeight < 0 || nHeight > chainActive.Height()) if (nHeight < 0 || nHeight > ::ChainActive().Height())
throw JSONRPCError(RPC_INVALID_PARAMETER, "Block height out of range"); throw JSONRPCError(RPC_INVALID_PARAMETER, "Block height out of range");
CBlockIndex* pblockindex = chainActive[nHeight]; CBlockIndex* pblockindex = ::ChainActive()[nHeight];
return pblockindex->GetBlockHash().GetHex(); return pblockindex->GetBlockHash().GetHex();
} }
@ -791,7 +791,7 @@ static UniValue getblockheader(const JSONRPCRequest& request)
{ {
LOCK(cs_main); LOCK(cs_main);
pblockindex = LookupBlockIndex(hash); pblockindex = LookupBlockIndex(hash);
tip = chainActive.Tip(); tip = ::ChainActive().Tip();
} }
if (!pblockindex) { if (!pblockindex) {
@ -904,7 +904,7 @@ static UniValue getblock(const JSONRPCRequest& request)
{ {
LOCK(cs_main); LOCK(cs_main);
pblockindex = LookupBlockIndex(hash); pblockindex = LookupBlockIndex(hash);
tip = chainActive.Tip(); tip = ::ChainActive().Tip();
if (!pblockindex) { if (!pblockindex) {
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found"); throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
@ -1026,7 +1026,7 @@ static UniValue pruneblockchain(const JSONRPCRequest& request)
// too low to be a block time (corresponds to timestamp from Sep 2001). // too low to be a block time (corresponds to timestamp from Sep 2001).
if (heightParam > 1000000000) { if (heightParam > 1000000000) {
// Add a 2 hour buffer to include blocks which might have had old timestamps // Add a 2 hour buffer to include blocks which might have had old timestamps
CBlockIndex* pindex = chainActive.FindEarliestAtLeast(heightParam - TIMESTAMP_WINDOW, 0); CBlockIndex* pindex = ::ChainActive().FindEarliestAtLeast(heightParam - TIMESTAMP_WINDOW, 0);
if (!pindex) { if (!pindex) {
throw JSONRPCError(RPC_INVALID_PARAMETER, "Could not find block with at least the specified timestamp."); throw JSONRPCError(RPC_INVALID_PARAMETER, "Could not find block with at least the specified timestamp.");
} }
@ -1034,7 +1034,7 @@ static UniValue pruneblockchain(const JSONRPCRequest& request)
} }
unsigned int height = (unsigned int) heightParam; unsigned int height = (unsigned int) heightParam;
unsigned int chainHeight = (unsigned int) chainActive.Height(); unsigned int chainHeight = (unsigned int) ::ChainActive().Height();
if (chainHeight < Params().PruneAfterHeight()) if (chainHeight < Params().PruneAfterHeight())
throw JSONRPCError(RPC_MISC_ERROR, "Blockchain is too short for pruning."); throw JSONRPCError(RPC_MISC_ERROR, "Blockchain is too short for pruning.");
else if (height > chainHeight) else if (height > chainHeight)
@ -1333,10 +1333,10 @@ UniValue getblockchaininfo(const JSONRPCRequest& request)
LOCK(cs_main); LOCK(cs_main);
const CBlockIndex* tip = chainActive.Tip(); const CBlockIndex* tip = ::ChainActive().Tip();
UniValue obj(UniValue::VOBJ); UniValue obj(UniValue::VOBJ);
obj.pushKV("chain", Params().NetworkIDString()); obj.pushKV("chain", Params().NetworkIDString());
obj.pushKV("blocks", (int)chainActive.Height()); obj.pushKV("blocks", (int)::ChainActive().Height());
obj.pushKV("headers", pindexBestHeader ? pindexBestHeader->nHeight : -1); obj.pushKV("headers", pindexBestHeader ? pindexBestHeader->nHeight : -1);
obj.pushKV("bestblockhash", tip->GetBlockHash().GetHex()); obj.pushKV("bestblockhash", tip->GetBlockHash().GetHex());
obj.pushKV("difficulty", (double)GetDifficulty(tip)); obj.pushKV("difficulty", (double)GetDifficulty(tip));
@ -1433,11 +1433,11 @@ static UniValue getchaintips(const JSONRPCRequest& request)
LOCK(cs_main); LOCK(cs_main);
/* /*
* Idea: the set of chain tips is chainActive.tip, plus orphan blocks which do not have another orphan building off of them. * Idea: the set of chain tips is ::ChainActive().tip, plus orphan blocks which do not have another orphan building off of them.
* Algorithm: * Algorithm:
* - Make one pass through mapBlockIndex, picking out the orphan blocks, and also storing a set of the orphan block's pprev pointers. * - Make one pass through mapBlockIndex, picking out the orphan blocks, and also storing a set of the orphan block's pprev pointers.
* - Iterate through the orphan blocks. If the block isn't pointed to by another orphan, it is a chain tip. * - Iterate through the orphan blocks. If the block isn't pointed to by another orphan, it is a chain tip.
* - add chainActive.Tip() * - add ::ChainActive().Tip()
*/ */
std::set<const CBlockIndex*, CompareBlocksByHeight> setTips; std::set<const CBlockIndex*, CompareBlocksByHeight> setTips;
std::set<const CBlockIndex*> setOrphans; std::set<const CBlockIndex*> setOrphans;
@ -1445,7 +1445,7 @@ static UniValue getchaintips(const JSONRPCRequest& request)
for (const std::pair<const uint256, CBlockIndex*>& item : mapBlockIndex) for (const std::pair<const uint256, CBlockIndex*>& item : mapBlockIndex)
{ {
if (!chainActive.Contains(item.second)) { if (!::ChainActive().Contains(item.second)) {
setOrphans.insert(item.second); setOrphans.insert(item.second);
setPrevs.insert(item.second->pprev); setPrevs.insert(item.second->pprev);
} }
@ -1459,7 +1459,7 @@ static UniValue getchaintips(const JSONRPCRequest& request)
} }
// Always report the currently active tip. // Always report the currently active tip.
setTips.insert(chainActive.Tip()); setTips.insert(::ChainActive().Tip());
/* Construct the output array. */ /* Construct the output array. */
UniValue res(UniValue::VARR); UniValue res(UniValue::VARR);
@ -1469,11 +1469,11 @@ static UniValue getchaintips(const JSONRPCRequest& request)
obj.pushKV("height", block->nHeight); obj.pushKV("height", block->nHeight);
obj.pushKV("hash", block->phashBlock->GetHex()); obj.pushKV("hash", block->phashBlock->GetHex());
const int branchLen = block->nHeight - chainActive.FindFork(block)->nHeight; const int branchLen = block->nHeight - ::ChainActive().FindFork(block)->nHeight;
obj.pushKV("branchlen", branchLen); obj.pushKV("branchlen", branchLen);
std::string status; std::string status;
if (chainActive.Contains(block)) { if (::ChainActive().Contains(block)) {
// This block is part of the currently active chain. // This block is part of the currently active chain.
status = "active"; status = "active";
} else if (block->nStatus & BLOCK_FAILED_MASK) { } else if (block->nStatus & BLOCK_FAILED_MASK) {
@ -1694,7 +1694,7 @@ static UniValue getchaintxstats(const JSONRPCRequest& request)
if (request.params[1].isNull()) { if (request.params[1].isNull()) {
LOCK(cs_main); LOCK(cs_main);
pindex = chainActive.Tip(); pindex = ::ChainActive().Tip();
} else { } else {
uint256 hash(ParseHashV(request.params[1], "blockhash")); uint256 hash(ParseHashV(request.params[1], "blockhash"));
LOCK(cs_main); LOCK(cs_main);
@ -1702,7 +1702,7 @@ static UniValue getchaintxstats(const JSONRPCRequest& request)
if (!pindex) { if (!pindex) {
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found"); throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
} }
if (!chainActive.Contains(pindex)) { if (!::ChainActive().Contains(pindex)) {
throw JSONRPCError(RPC_INVALID_PARAMETER, "Block is not in main chain"); throw JSONRPCError(RPC_INVALID_PARAMETER, "Block is not in main chain");
} }
} }
@ -1863,7 +1863,7 @@ static UniValue getblockstats(const JSONRPCRequest& request)
CBlockIndex* pindex; CBlockIndex* pindex;
if (request.params[0].isNum()) { if (request.params[0].isNum()) {
const int height = request.params[0].get_int(); const int height = request.params[0].get_int();
const int current_tip = chainActive.Height(); const int current_tip = ::ChainActive().Height();
if (height < 0) { if (height < 0) {
throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Target block height %d is negative", height)); throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Target block height %d is negative", height));
} }
@ -1871,14 +1871,14 @@ static UniValue getblockstats(const JSONRPCRequest& request)
throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Target block height %d after current tip %d", height, current_tip)); throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Target block height %d after current tip %d", height, current_tip));
} }
pindex = chainActive[height]; pindex = ::ChainActive()[height];
} else { } else {
const uint256 hash(ParseHashV(request.params[0], "hash_or_height")); const uint256 hash(ParseHashV(request.params[0], "hash_or_height"));
pindex = LookupBlockIndex(hash); pindex = LookupBlockIndex(hash);
if (!pindex) { if (!pindex) {
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found"); throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
} }
if (!chainActive.Contains(pindex)) { if (!::ChainActive().Contains(pindex)) {
throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Block is not in chain %s", Params().NetworkIDString())); throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Block is not in chain %s", Params().NetworkIDString()));
} }
} }

24
src/rpc/mining.cpp
View file

@ -40,10 +40,10 @@
* If 'height' is nonnegative, compute the estimate at the time when a given block was found. * If 'height' is nonnegative, compute the estimate at the time when a given block was found.
*/ */
static UniValue GetNetworkHashPS(int lookup, int height) { static UniValue GetNetworkHashPS(int lookup, int height) {
CBlockIndex *pb = chainActive.Tip(); CBlockIndex *pb = ::ChainActive().Tip();
if (height >= 0 && height < chainActive.Height()) if (height >= 0 && height < ::ChainActive().Height())
pb = chainActive[height]; pb = ::ChainActive()[height];
if (pb == nullptr || !pb->nHeight) if (pb == nullptr || !pb->nHeight)
return 0; return 0;
@ -109,7 +109,7 @@ static UniValue generateBlocks(const CScript& coinbase_script, int nGenerate, ui
{ // Don't keep cs_main locked { // Don't keep cs_main locked
LOCK(cs_main); LOCK(cs_main);
nHeight = chainActive.Height(); nHeight = ::ChainActive().Height();
nHeightEnd = nHeight+nGenerate; nHeightEnd = nHeight+nGenerate;
} }
unsigned int nExtraNonce = 0; unsigned int nExtraNonce = 0;
@ -122,7 +122,7 @@ static UniValue generateBlocks(const CScript& coinbase_script, int nGenerate, ui
CBlock *pblock = &pblocktemplate->block; CBlock *pblock = &pblocktemplate->block;
{ {
LOCK(cs_main); LOCK(cs_main);
IncrementExtraNonce(pblock, chainActive.Tip(), nExtraNonce); IncrementExtraNonce(pblock, ::ChainActive().Tip(), nExtraNonce);
} }
while (nMaxTries > 0 && pblock->nNonce < nInnerLoopCount && !CheckProofOfWork(pblock->GetHash(), pblock->nBits, Params().GetConsensus())) { while (nMaxTries > 0 && pblock->nNonce < nInnerLoopCount && !CheckProofOfWork(pblock->GetHash(), pblock->nBits, Params().GetConsensus())) {
++pblock->nNonce; ++pblock->nNonce;
@ -210,10 +210,10 @@ static UniValue getmininginfo(const JSONRPCRequest& request)
LOCK(cs_main); LOCK(cs_main);
UniValue obj(UniValue::VOBJ); UniValue obj(UniValue::VOBJ);
obj.pushKV("blocks", (int)chainActive.Height()); obj.pushKV("blocks", (int)::ChainActive().Height());
if (BlockAssembler::m_last_block_weight) obj.pushKV("currentblockweight", *BlockAssembler::m_last_block_weight); if (BlockAssembler::m_last_block_weight) obj.pushKV("currentblockweight", *BlockAssembler::m_last_block_weight);
if (BlockAssembler::m_last_block_num_txs) obj.pushKV("currentblocktx", *BlockAssembler::m_last_block_num_txs); if (BlockAssembler::m_last_block_num_txs) obj.pushKV("currentblocktx", *BlockAssembler::m_last_block_num_txs);
obj.pushKV("difficulty", (double)GetDifficulty(chainActive.Tip())); obj.pushKV("difficulty", (double)GetDifficulty(::ChainActive().Tip()));
obj.pushKV("networkhashps", getnetworkhashps(request)); obj.pushKV("networkhashps", getnetworkhashps(request));
obj.pushKV("pooledtx", (uint64_t)mempool.size()); obj.pushKV("pooledtx", (uint64_t)mempool.size());
obj.pushKV("chain", Params().NetworkIDString()); obj.pushKV("chain", Params().NetworkIDString());
@ -409,7 +409,7 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
return "duplicate-inconclusive"; return "duplicate-inconclusive";
} }
CBlockIndex* const pindexPrev = chainActive.Tip(); CBlockIndex* const pindexPrev = ::ChainActive().Tip();
// TestBlockValidity only supports blocks built on the current Tip // TestBlockValidity only supports blocks built on the current Tip
if (block.hashPrevBlock != pindexPrev->GetBlockHash()) if (block.hashPrevBlock != pindexPrev->GetBlockHash())
return "inconclusive-not-best-prevblk"; return "inconclusive-not-best-prevblk";
@ -465,7 +465,7 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
else else
{ {
// NOTE: Spec does not specify behaviour for non-string longpollid, but this makes testing easier // NOTE: Spec does not specify behaviour for non-string longpollid, but this makes testing easier
hashWatchedChain = chainActive.Tip()->GetBlockHash(); hashWatchedChain = ::ChainActive().Tip()->GetBlockHash();
nTransactionsUpdatedLastLP = nTransactionsUpdatedLast; nTransactionsUpdatedLastLP = nTransactionsUpdatedLast;
} }
@ -503,7 +503,7 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
static CBlockIndex* pindexPrev; static CBlockIndex* pindexPrev;
static int64_t nStart; static int64_t nStart;
static std::unique_ptr<CBlockTemplate> pblocktemplate; static std::unique_ptr<CBlockTemplate> pblocktemplate;
if (pindexPrev != chainActive.Tip() || if (pindexPrev != ::ChainActive().Tip() ||
(mempool.GetTransactionsUpdated() != nTransactionsUpdatedLast && GetTime() - nStart > 5)) (mempool.GetTransactionsUpdated() != nTransactionsUpdatedLast && GetTime() - nStart > 5))
{ {
// Clear pindexPrev so future calls make a new block, despite any failures from here on // Clear pindexPrev so future calls make a new block, despite any failures from here on
@ -511,7 +511,7 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
// Store the pindexBest used before CreateNewBlock, to avoid races // Store the pindexBest used before CreateNewBlock, to avoid races
nTransactionsUpdatedLast = mempool.GetTransactionsUpdated(); nTransactionsUpdatedLast = mempool.GetTransactionsUpdated();
CBlockIndex* pindexPrevNew = chainActive.Tip(); CBlockIndex* pindexPrevNew = ::ChainActive().Tip();
nStart = GetTime(); nStart = GetTime();
// Create new block // Create new block
@ -646,7 +646,7 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
result.pushKV("transactions", transactions); result.pushKV("transactions", transactions);
result.pushKV("coinbaseaux", aux); result.pushKV("coinbaseaux", aux);
result.pushKV("coinbasevalue", (int64_t)pblock->vtx[0]->vout[0].nValue); result.pushKV("coinbasevalue", (int64_t)pblock->vtx[0]->vout[0].nValue);
result.pushKV("longpollid", chainActive.Tip()->GetBlockHash().GetHex() + i64tostr(nTransactionsUpdatedLast)); result.pushKV("longpollid", ::ChainActive().Tip()->GetBlockHash().GetHex() + i64tostr(nTransactionsUpdatedLast));
result.pushKV("target", hashTarget.GetHex()); result.pushKV("target", hashTarget.GetHex());
result.pushKV("mintime", (int64_t)pindexPrev->GetMedianTimePast()+1); result.pushKV("mintime", (int64_t)pindexPrev->GetMedianTimePast()+1);
result.pushKV("mutable", aMutable); result.pushKV("mutable", aMutable);

10
src/rpc/rawtransaction.cpp
View file

@ -64,8 +64,8 @@ static void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue&
entry.pushKV("blockhash", hashBlock.GetHex()); entry.pushKV("blockhash", hashBlock.GetHex());
CBlockIndex* pindex = LookupBlockIndex(hashBlock); CBlockIndex* pindex = LookupBlockIndex(hashBlock);
if (pindex) { if (pindex) {
if (chainActive.Contains(pindex)) { if (::ChainActive().Contains(pindex)) {
entry.pushKV("confirmations", 1 + chainActive.Height() - pindex->nHeight); entry.pushKV("confirmations", 1 + ::ChainActive().Height() - pindex->nHeight);
entry.pushKV("time", pindex->GetBlockTime()); entry.pushKV("time", pindex->GetBlockTime());
entry.pushKV("blocktime", pindex->GetBlockTime()); entry.pushKV("blocktime", pindex->GetBlockTime());
} }
@ -184,7 +184,7 @@ static UniValue getrawtransaction(const JSONRPCRequest& request)
if (!blockindex) { if (!blockindex) {
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block hash not found"); throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block hash not found");
} }
in_active_chain = chainActive.Contains(blockindex); in_active_chain = ::ChainActive().Contains(blockindex);
} }
bool f_txindex_ready = false; bool f_txindex_ready = false;
@ -274,7 +274,7 @@ static UniValue gettxoutproof(const JSONRPCRequest& request)
for (const auto& tx : setTxids) { for (const auto& tx : setTxids) {
const Coin& coin = AccessByTxid(*pcoinsTip, tx); const Coin& coin = AccessByTxid(*pcoinsTip, tx);
if (!coin.IsSpent()) { if (!coin.IsSpent()) {
pblockindex = chainActive[coin.nHeight]; pblockindex = ::ChainActive()[coin.nHeight];
break; break;
} }
} }
@ -348,7 +348,7 @@ static UniValue verifytxoutproof(const JSONRPCRequest& request)
LOCK(cs_main); LOCK(cs_main);
const CBlockIndex* pindex = LookupBlockIndex(merkleBlock.header.GetHash()); const CBlockIndex* pindex = LookupBlockIndex(merkleBlock.header.GetHash());
if (!pindex || !chainActive.Contains(pindex) || pindex->nTx == 0) { if (!pindex || !::ChainActive().Contains(pindex) || pindex->nTx == 0) {
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found in chain"); throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found in chain");
} }

12
src/test/blockfilter_index_tests.cpp
View file

@ -125,9 +125,9 @@ BOOST_FIXTURE_TEST_CASE(blockfilter_index_initial_sync, TestChain100Setup)
std::vector<BlockFilter> filters; std::vector<BlockFilter> filters;
std::vector<uint256> filter_hashes; std::vector<uint256> filter_hashes;
for (const CBlockIndex* block_index = chainActive.Genesis(); for (const CBlockIndex* block_index = ::ChainActive().Genesis();
block_index != nullptr; block_index != nullptr;
block_index = chainActive.Next(block_index)) { block_index = ::ChainActive().Next(block_index)) {
BOOST_CHECK(!filter_index.LookupFilter(block_index, filter)); BOOST_CHECK(!filter_index.LookupFilter(block_index, filter));
BOOST_CHECK(!filter_index.LookupFilterHeader(block_index, filter_header)); BOOST_CHECK(!filter_index.LookupFilterHeader(block_index, filter_header));
BOOST_CHECK(!filter_index.LookupFilterRange(block_index->nHeight, block_index, filters)); BOOST_CHECK(!filter_index.LookupFilterRange(block_index->nHeight, block_index, filters));
@ -153,9 +153,9 @@ BOOST_FIXTURE_TEST_CASE(blockfilter_index_initial_sync, TestChain100Setup)
{ {
LOCK(cs_main); LOCK(cs_main);
const CBlockIndex* block_index; const CBlockIndex* block_index;
for (block_index = chainActive.Genesis(); for (block_index = ::ChainActive().Genesis();
block_index != nullptr; block_index != nullptr;
block_index = chainActive.Next(block_index)) { block_index = ::ChainActive().Next(block_index)) {
CheckFilterLookups(filter_index, block_index, last_header); CheckFilterLookups(filter_index, block_index, last_header);
} }
} }
@ -164,7 +164,7 @@ BOOST_FIXTURE_TEST_CASE(blockfilter_index_initial_sync, TestChain100Setup)
const CBlockIndex* tip; const CBlockIndex* tip;
{ {
LOCK(cs_main); LOCK(cs_main);
tip = chainActive.Tip(); tip = ::ChainActive().Tip();
} }
CScript coinbase_script_pub_key = GetScriptForDestination(coinbaseKey.GetPubKey().GetID()); CScript coinbase_script_pub_key = GetScriptForDestination(coinbaseKey.GetPubKey().GetID());
std::vector<std::shared_ptr<CBlock>> chainA, chainB; std::vector<std::shared_ptr<CBlock>> chainA, chainB;
@ -250,7 +250,7 @@ BOOST_FIXTURE_TEST_CASE(blockfilter_index_initial_sync, TestChain100Setup)
{ {
LOCK(cs_main); LOCK(cs_main);
tip = chainActive.Tip(); tip = ::ChainActive().Tip();
} }
BOOST_CHECK(filter_index.LookupFilterRange(0, tip, filters)); BOOST_CHECK(filter_index.LookupFilterRange(0, tip, filters));
BOOST_CHECK(filter_index.LookupFilterHashRange(0, tip, filter_hashes)); BOOST_CHECK(filter_index.LookupFilterHashRange(0, tip, filter_hashes));

4
src/test/denialofservice_tests.cpp
View file

@ -90,8 +90,8 @@ BOOST_AUTO_TEST_CASE(outbound_slow_chain_eviction)
// This test requires that we have a chain with non-zero work. // This test requires that we have a chain with non-zero work.
{ {
LOCK(cs_main); LOCK(cs_main);
BOOST_CHECK(chainActive.Tip() != nullptr); BOOST_CHECK(::ChainActive().Tip() != nullptr);
BOOST_CHECK(chainActive.Tip()->nChainWork > 0); BOOST_CHECK(::ChainActive().Tip()->nChainWork > 0);
} }
// Test starts here // Test starts here

60
src/test/miner_tests.cpp
View file

@ -86,7 +86,7 @@ static CBlockIndex CreateBlockIndex(int nHeight)
{ {
CBlockIndex index; CBlockIndex index;
index.nHeight = nHeight; index.nHeight = nHeight;
index.pprev = chainActive.Tip(); index.pprev = ::ChainActive().Tip();
return index; return index;
} }
@ -231,17 +231,17 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
{ {
LOCK(cs_main); LOCK(cs_main);
pblock->nVersion = 1; pblock->nVersion = 1;
pblock->nTime = chainActive.Tip()->GetMedianTimePast()+1; pblock->nTime = ::ChainActive().Tip()->GetMedianTimePast()+1;
CMutableTransaction txCoinbase(*pblock->vtx[0]); CMutableTransaction txCoinbase(*pblock->vtx[0]);
txCoinbase.nVersion = 1; txCoinbase.nVersion = 1;
txCoinbase.vin[0].scriptSig = CScript(); txCoinbase.vin[0].scriptSig = CScript();
txCoinbase.vin[0].scriptSig.push_back(blockinfo[i].extranonce); txCoinbase.vin[0].scriptSig.push_back(blockinfo[i].extranonce);
txCoinbase.vin[0].scriptSig.push_back(chainActive.Height()); txCoinbase.vin[0].scriptSig.push_back(::ChainActive().Height());
txCoinbase.vout.resize(1); // Ignore the (optional) segwit commitment added by CreateNewBlock (as the hardcoded nonces don't account for this) txCoinbase.vout.resize(1); // Ignore the (optional) segwit commitment added by CreateNewBlock (as the hardcoded nonces don't account for this)
txCoinbase.vout[0].scriptPubKey = CScript(); txCoinbase.vout[0].scriptPubKey = CScript();
pblock->vtx[0] = MakeTransactionRef(std::move(txCoinbase)); pblock->vtx[0] = MakeTransactionRef(std::move(txCoinbase));
if (txFirst.size() == 0) if (txFirst.size() == 0)
baseheight = chainActive.Height(); baseheight = ::ChainActive().Height();
if (txFirst.size() < 4) if (txFirst.size() < 4)
txFirst.push_back(pblock->vtx[0]); txFirst.push_back(pblock->vtx[0]);
pblock->hashMerkleRoot = BlockMerkleRoot(*pblock); pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);
@ -367,29 +367,29 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
mempool.clear(); mempool.clear();
// subsidy changing // subsidy changing
int nHeight = chainActive.Height(); int nHeight = ::ChainActive().Height();
// Create an actual 209999-long block chain (without valid blocks). // Create an actual 209999-long block chain (without valid blocks).
while (chainActive.Tip()->nHeight < 209999) { while (::ChainActive().Tip()->nHeight < 209999) {
CBlockIndex* prev = chainActive.Tip(); CBlockIndex* prev = ::ChainActive().Tip();
CBlockIndex* next = new CBlockIndex(); CBlockIndex* next = new CBlockIndex();
next->phashBlock = new uint256(InsecureRand256()); next->phashBlock = new uint256(InsecureRand256());
pcoinsTip->SetBestBlock(next->GetBlockHash()); pcoinsTip->SetBestBlock(next->GetBlockHash());
next->pprev = prev; next->pprev = prev;
next->nHeight = prev->nHeight + 1; next->nHeight = prev->nHeight + 1;
next->BuildSkip(); next->BuildSkip();
chainActive.SetTip(next); ::ChainActive().SetTip(next);
} }
BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey)); BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
// Extend to a 210000-long block chain. // Extend to a 210000-long block chain.
while (chainActive.Tip()->nHeight < 210000) { while (::ChainActive().Tip()->nHeight < 210000) {
CBlockIndex* prev = chainActive.Tip(); CBlockIndex* prev = ::ChainActive().Tip();
CBlockIndex* next = new CBlockIndex(); CBlockIndex* next = new CBlockIndex();
next->phashBlock = new uint256(InsecureRand256()); next->phashBlock = new uint256(InsecureRand256());
pcoinsTip->SetBestBlock(next->GetBlockHash()); pcoinsTip->SetBestBlock(next->GetBlockHash());
next->pprev = prev; next->pprev = prev;
next->nHeight = prev->nHeight + 1; next->nHeight = prev->nHeight + 1;
next->BuildSkip(); next->BuildSkip();
chainActive.SetTip(next); ::ChainActive().SetTip(next);
} }
BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey)); BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
@ -412,16 +412,16 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
mempool.clear(); mempool.clear();
// Delete the dummy blocks again. // Delete the dummy blocks again.
while (chainActive.Tip()->nHeight > nHeight) { while (::ChainActive().Tip()->nHeight > nHeight) {
CBlockIndex* del = chainActive.Tip(); CBlockIndex* del = ::ChainActive().Tip();
chainActive.SetTip(del->pprev); ::ChainActive().SetTip(del->pprev);
pcoinsTip->SetBestBlock(del->pprev->GetBlockHash()); pcoinsTip->SetBestBlock(del->pprev->GetBlockHash());
delete del->phashBlock; delete del->phashBlock;
delete del; delete del;
} }
// non-final txs in mempool // non-final txs in mempool
SetMockTime(chainActive.Tip()->GetMedianTimePast()+1); SetMockTime(::ChainActive().Tip()->GetMedianTimePast()+1);
int flags = LOCKTIME_VERIFY_SEQUENCE|LOCKTIME_MEDIAN_TIME_PAST; int flags = LOCKTIME_VERIFY_SEQUENCE|LOCKTIME_MEDIAN_TIME_PAST;
// height map // height map
std::vector<int> prevheights; std::vector<int> prevheights;
@ -433,7 +433,7 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
tx.vin[0].prevout.hash = txFirst[0]->GetHash(); // only 1 transaction tx.vin[0].prevout.hash = txFirst[0]->GetHash(); // only 1 transaction
tx.vin[0].prevout.n = 0; tx.vin[0].prevout.n = 0;
tx.vin[0].scriptSig = CScript() << OP_1; tx.vin[0].scriptSig = CScript() << OP_1;
tx.vin[0].nSequence = chainActive.Tip()->nHeight + 1; // txFirst[0] is the 2nd block tx.vin[0].nSequence = ::ChainActive().Tip()->nHeight + 1; // txFirst[0] is the 2nd block
prevheights[0] = baseheight + 1; prevheights[0] = baseheight + 1;
tx.vout.resize(1); tx.vout.resize(1);
tx.vout[0].nValue = BLOCKSUBSIDY-HIGHFEE; tx.vout[0].nValue = BLOCKSUBSIDY-HIGHFEE;
@ -443,11 +443,11 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
mempool.addUnchecked(entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx)); mempool.addUnchecked(entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
BOOST_CHECK(CheckFinalTx(CTransaction(tx), flags)); // Locktime passes BOOST_CHECK(CheckFinalTx(CTransaction(tx), flags)); // Locktime passes
BOOST_CHECK(!TestSequenceLocks(CTransaction(tx), flags)); // Sequence locks fail BOOST_CHECK(!TestSequenceLocks(CTransaction(tx), flags)); // Sequence locks fail
BOOST_CHECK(SequenceLocks(CTransaction(tx), flags, &prevheights, CreateBlockIndex(chainActive.Tip()->nHeight + 2))); // Sequence locks pass on 2nd block BOOST_CHECK(SequenceLocks(CTransaction(tx), flags, &prevheights, CreateBlockIndex(::ChainActive().Tip()->nHeight + 2))); // Sequence locks pass on 2nd block
// relative time locked // relative time locked
tx.vin[0].prevout.hash = txFirst[1]->GetHash(); tx.vin[0].prevout.hash = txFirst[1]->GetHash();
tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | (((chainActive.Tip()->GetMedianTimePast()+1-chainActive[1]->GetMedianTimePast()) >> CTxIn::SEQUENCE_LOCKTIME_GRANULARITY) + 1); // txFirst[1] is the 3rd block tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | (((::ChainActive().Tip()->GetMedianTimePast()+1-::ChainActive()[1]->GetMedianTimePast()) >> CTxIn::SEQUENCE_LOCKTIME_GRANULARITY) + 1); // txFirst[1] is the 3rd block
prevheights[0] = baseheight + 2; prevheights[0] = baseheight + 2;
hash = tx.GetHash(); hash = tx.GetHash();
mempool.addUnchecked(entry.Time(GetTime()).FromTx(tx)); mempool.addUnchecked(entry.Time(GetTime()).FromTx(tx));
@ -455,36 +455,36 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
BOOST_CHECK(!TestSequenceLocks(CTransaction(tx), flags)); // Sequence locks fail BOOST_CHECK(!TestSequenceLocks(CTransaction(tx), flags)); // Sequence locks fail
for (int i = 0; i < CBlockIndex::nMedianTimeSpan; i++) for (int i = 0; i < CBlockIndex::nMedianTimeSpan; i++)
chainActive.Tip()->GetAncestor(chainActive.Tip()->nHeight - i)->nTime += 512; //Trick the MedianTimePast ::ChainActive().Tip()->GetAncestor(::ChainActive().Tip()->nHeight - i)->nTime += 512; //Trick the MedianTimePast
BOOST_CHECK(SequenceLocks(CTransaction(tx), flags, &prevheights, CreateBlockIndex(chainActive.Tip()->nHeight + 1))); // Sequence locks pass 512 seconds later BOOST_CHECK(SequenceLocks(CTransaction(tx), flags, &prevheights, CreateBlockIndex(::ChainActive().Tip()->nHeight + 1))); // Sequence locks pass 512 seconds later
for (int i = 0; i < CBlockIndex::nMedianTimeSpan; i++) for (int i = 0; i < CBlockIndex::nMedianTimeSpan; i++)
chainActive.Tip()->GetAncestor(chainActive.Tip()->nHeight - i)->nTime -= 512; //undo tricked MTP ::ChainActive().Tip()->GetAncestor(::ChainActive().Tip()->nHeight - i)->nTime -= 512; //undo tricked MTP
// absolute height locked // absolute height locked
tx.vin[0].prevout.hash = txFirst[2]->GetHash(); tx.vin[0].prevout.hash = txFirst[2]->GetHash();
tx.vin[0].nSequence = CTxIn::SEQUENCE_FINAL - 1; tx.vin[0].nSequence = CTxIn::SEQUENCE_FINAL - 1;
prevheights[0] = baseheight + 3; prevheights[0] = baseheight + 3;
tx.nLockTime = chainActive.Tip()->nHeight + 1; tx.nLockTime = ::ChainActive().Tip()->nHeight + 1;
hash = tx.GetHash(); hash = tx.GetHash();
mempool.addUnchecked(entry.Time(GetTime()).FromTx(tx)); mempool.addUnchecked(entry.Time(GetTime()).FromTx(tx));
BOOST_CHECK(!CheckFinalTx(CTransaction(tx), flags)); // Locktime fails BOOST_CHECK(!CheckFinalTx(CTransaction(tx), flags)); // Locktime fails
BOOST_CHECK(TestSequenceLocks(CTransaction(tx), flags)); // Sequence locks pass BOOST_CHECK(TestSequenceLocks(CTransaction(tx), flags)); // Sequence locks pass
BOOST_CHECK(IsFinalTx(CTransaction(tx), chainActive.Tip()->nHeight + 2, chainActive.Tip()->GetMedianTimePast())); // Locktime passes on 2nd block BOOST_CHECK(IsFinalTx(CTransaction(tx), ::ChainActive().Tip()->nHeight + 2, ::ChainActive().Tip()->GetMedianTimePast())); // Locktime passes on 2nd block
// absolute time locked // absolute time locked
tx.vin[0].prevout.hash = txFirst[3]->GetHash(); tx.vin[0].prevout.hash = txFirst[3]->GetHash();
tx.nLockTime = chainActive.Tip()->GetMedianTimePast(); tx.nLockTime = ::ChainActive().Tip()->GetMedianTimePast();
prevheights.resize(1); prevheights.resize(1);
prevheights[0] = baseheight + 4; prevheights[0] = baseheight + 4;
hash = tx.GetHash(); hash = tx.GetHash();
mempool.addUnchecked(entry.Time(GetTime()).FromTx(tx)); mempool.addUnchecked(entry.Time(GetTime()).FromTx(tx));
BOOST_CHECK(!CheckFinalTx(CTransaction(tx), flags)); // Locktime fails BOOST_CHECK(!CheckFinalTx(CTransaction(tx), flags)); // Locktime fails
BOOST_CHECK(TestSequenceLocks(CTransaction(tx), flags)); // Sequence locks pass BOOST_CHECK(TestSequenceLocks(CTransaction(tx), flags)); // Sequence locks pass
BOOST_CHECK(IsFinalTx(CTransaction(tx), chainActive.Tip()->nHeight + 2, chainActive.Tip()->GetMedianTimePast() + 1)); // Locktime passes 1 second later BOOST_CHECK(IsFinalTx(CTransaction(tx), ::ChainActive().Tip()->nHeight + 2, ::ChainActive().Tip()->GetMedianTimePast() + 1)); // Locktime passes 1 second later
// mempool-dependent transactions (not added) // mempool-dependent transactions (not added)
tx.vin[0].prevout.hash = hash; tx.vin[0].prevout.hash = hash;
prevheights[0] = chainActive.Tip()->nHeight + 1; prevheights[0] = ::ChainActive().Tip()->nHeight + 1;
tx.nLockTime = 0; tx.nLockTime = 0;
tx.vin[0].nSequence = 0; tx.vin[0].nSequence = 0;
BOOST_CHECK(CheckFinalTx(CTransaction(tx), flags)); // Locktime passes BOOST_CHECK(CheckFinalTx(CTransaction(tx), flags)); // Locktime passes
@ -505,14 +505,14 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
BOOST_CHECK_EQUAL(pblocktemplate->block.vtx.size(), 3U); BOOST_CHECK_EQUAL(pblocktemplate->block.vtx.size(), 3U);
// However if we advance height by 1 and time by 512, all of them should be mined // However if we advance height by 1 and time by 512, all of them should be mined
for (int i = 0; i < CBlockIndex::nMedianTimeSpan; i++) for (int i = 0; i < CBlockIndex::nMedianTimeSpan; i++)
chainActive.Tip()->GetAncestor(chainActive.Tip()->nHeight - i)->nTime += 512; //Trick the MedianTimePast ::ChainActive().Tip()->GetAncestor(::ChainActive().Tip()->nHeight - i)->nTime += 512; //Trick the MedianTimePast
chainActive.Tip()->nHeight++; ::ChainActive().Tip()->nHeight++;
SetMockTime(chainActive.Tip()->GetMedianTimePast() + 1); SetMockTime(::ChainActive().Tip()->GetMedianTimePast() + 1);
BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey)); BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
BOOST_CHECK_EQUAL(pblocktemplate->block.vtx.size(), 5U); BOOST_CHECK_EQUAL(pblocktemplate->block.vtx.size(), 5U);
chainActive.Tip()->nHeight--; ::ChainActive().Tip()->nHeight--;
SetMockTime(0); SetMockTime(0);
mempool.clear(); mempool.clear();

2
src/test/setup_common.cpp
View file

@ -151,7 +151,7 @@ TestChain100Setup::CreateAndProcessBlock(const std::vector<CMutableTransaction>&
{ {
LOCK(cs_main); LOCK(cs_main);
unsigned int extraNonce = 0; unsigned int extraNonce = 0;
IncrementExtraNonce(&block, chainActive.Tip(), extraNonce); IncrementExtraNonce(&block, ::ChainActive().Tip(), extraNonce);
} }
while (!CheckProofOfWork(block.GetHash(), block.nBits, chainparams.GetConsensus())) ++block.nNonce; while (!CheckProofOfWork(block.GetHash(), block.nBits, chainparams.GetConsensus())) ++block.nNonce;

10
src/test/txvalidationcache_tests.cpp
View file

@ -66,18 +66,18 @@ BOOST_FIXTURE_TEST_CASE(tx_mempool_block_doublespend, TestChain100Setup)
// Test 1: block with both of those transactions should be rejected. // Test 1: block with both of those transactions should be rejected.
block = CreateAndProcessBlock(spends, scriptPubKey); block = CreateAndProcessBlock(spends, scriptPubKey);
BOOST_CHECK(chainActive.Tip()->GetBlockHash() != block.GetHash()); BOOST_CHECK(::ChainActive().Tip()->GetBlockHash() != block.GetHash());
// Test 2: ... and should be rejected if spend1 is in the memory pool // Test 2: ... and should be rejected if spend1 is in the memory pool
BOOST_CHECK(ToMemPool(spends[0])); BOOST_CHECK(ToMemPool(spends[0]));
block = CreateAndProcessBlock(spends, scriptPubKey); block = CreateAndProcessBlock(spends, scriptPubKey);
BOOST_CHECK(chainActive.Tip()->GetBlockHash() != block.GetHash()); BOOST_CHECK(::ChainActive().Tip()->GetBlockHash() != block.GetHash());
mempool.clear(); mempool.clear();
// Test 3: ... and should be rejected if spend2 is in the memory pool // Test 3: ... and should be rejected if spend2 is in the memory pool
BOOST_CHECK(ToMemPool(spends[1])); BOOST_CHECK(ToMemPool(spends[1]));
block = CreateAndProcessBlock(spends, scriptPubKey); block = CreateAndProcessBlock(spends, scriptPubKey);
BOOST_CHECK(chainActive.Tip()->GetBlockHash() != block.GetHash()); BOOST_CHECK(::ChainActive().Tip()->GetBlockHash() != block.GetHash());
mempool.clear(); mempool.clear();
// Final sanity test: first spend in mempool, second in block, that's OK: // Final sanity test: first spend in mempool, second in block, that's OK:
@ -85,7 +85,7 @@ BOOST_FIXTURE_TEST_CASE(tx_mempool_block_doublespend, TestChain100Setup)
oneSpend.push_back(spends[0]); oneSpend.push_back(spends[0]);
BOOST_CHECK(ToMemPool(spends[1])); BOOST_CHECK(ToMemPool(spends[1]));
block = CreateAndProcessBlock(oneSpend, scriptPubKey); block = CreateAndProcessBlock(oneSpend, scriptPubKey);
BOOST_CHECK(chainActive.Tip()->GetBlockHash() == block.GetHash()); BOOST_CHECK(::ChainActive().Tip()->GetBlockHash() == block.GetHash());
// spends[1] should have been removed from the mempool when the // spends[1] should have been removed from the mempool when the
// block with spends[0] is accepted: // block with spends[0] is accepted:
BOOST_CHECK_EQUAL(mempool.size(), 0U); BOOST_CHECK_EQUAL(mempool.size(), 0U);
@ -220,7 +220,7 @@ BOOST_FIXTURE_TEST_CASE(checkinputs_test, TestChain100Setup)
block = CreateAndProcessBlock({spend_tx}, p2pk_scriptPubKey); block = CreateAndProcessBlock({spend_tx}, p2pk_scriptPubKey);
LOCK(cs_main); LOCK(cs_main);
BOOST_CHECK(chainActive.Tip()->GetBlockHash() == block.GetHash()); BOOST_CHECK(::ChainActive().Tip()->GetBlockHash() == block.GetHash());
BOOST_CHECK(pcoinsTip->GetBestBlock() == block.GetHash()); BOOST_CHECK(pcoinsTip->GetBestBlock() == block.GetHash());
// Test P2SH: construct a transaction that is valid without P2SH, and // Test P2SH: construct a transaction that is valid without P2SH, and

2
src/test/util.cpp
View file

@ -84,7 +84,7 @@ std::shared_ptr<CBlock> PrepareBlock(const CScript& coinbase_scriptPubKey)
.CreateNewBlock(coinbase_scriptPubKey) .CreateNewBlock(coinbase_scriptPubKey)
->block); ->block);
block->nTime = ::chainActive.Tip()->GetMedianTimePast() + 1; block->nTime = ::ChainActive().Tip()->GetMedianTimePast() + 1;
block->hashMerkleRoot = BlockMerkleRoot(*block); block->hashMerkleRoot = BlockMerkleRoot(*block);
return block; return block;

4
src/test/validation_block_tests.cpp
View file

@ -144,7 +144,7 @@ BOOST_AUTO_TEST_CASE(processnewblock_signals_ordering)
const CBlockIndex* initial_tip = nullptr; const CBlockIndex* initial_tip = nullptr;
{ {
LOCK(cs_main); LOCK(cs_main);
initial_tip = chainActive.Tip(); initial_tip = ::ChainActive().Tip();
} }
TestSubscriber sub(initial_tip->GetBlockHash()); TestSubscriber sub(initial_tip->GetBlockHash());
RegisterValidationInterface(&sub); RegisterValidationInterface(&sub);
@ -181,7 +181,7 @@ BOOST_AUTO_TEST_CASE(processnewblock_signals_ordering)
UnregisterValidationInterface(&sub); UnregisterValidationInterface(&sub);
BOOST_CHECK_EQUAL(sub.m_expected_tip, chainActive.Tip()->GetBlockHash()); BOOST_CHECK_EQUAL(sub.m_expected_tip, ::ChainActive().Tip()->GetBlockHash());
} }
BOOST_AUTO_TEST_SUITE_END() BOOST_AUTO_TEST_SUITE_END()

2
src/txmempool.h
View file

@ -496,7 +496,7 @@ public:
* By design, it is guaranteed that: * By design, it is guaranteed that:
* *
* 1. Locking both `cs_main` and `mempool.cs` will give a view of mempool * 1. Locking both `cs_main` and `mempool.cs` will give a view of mempool
* that is consistent with current chain tip (`chainActive` and * that is consistent with current chain tip (`::ChainActive()` and
* `pcoinsTip`) and is fully populated. Fully populated means that if the * `pcoinsTip`) and is fully populated. Fully populated means that if the
* current active chain is missing transactions that were present in a * current active chain is missing transactions that were present in a
* previously active chain, all the missing transactions will have been * previously active chain, all the missing transactions will have been

108
src/validation.cpp
View file

@ -340,13 +340,13 @@ bool CheckFinalTx(const CTransaction &tx, int flags)
// scheduled, so no flags are set. // scheduled, so no flags are set.
flags = std::max(flags, 0); flags = std::max(flags, 0);
// CheckFinalTx() uses chainActive.Height()+1 to evaluate // CheckFinalTx() uses ::ChainActive().Height()+1 to evaluate
// nLockTime because when IsFinalTx() is called within // nLockTime because when IsFinalTx() is called within
// CBlock::AcceptBlock(), the height of the block *being* // CBlock::AcceptBlock(), the height of the block *being*
// evaluated is what is used. Thus if we want to know if a // evaluated is what is used. Thus if we want to know if a
// transaction can be part of the *next* block, we need to call // transaction can be part of the *next* block, we need to call
// IsFinalTx() with one more than chainActive.Height(). // IsFinalTx() with one more than ::ChainActive().Height().
const int nBlockHeight = chainActive.Height() + 1; const int nBlockHeight = ::ChainActive().Height() + 1;
// BIP113 requires that time-locked transactions have nLockTime set to // BIP113 requires that time-locked transactions have nLockTime set to
// less than the median time of the previous block they're contained in. // less than the median time of the previous block they're contained in.
@ -354,7 +354,7 @@ bool CheckFinalTx(const CTransaction &tx, int flags)
// chain tip, so we use that to calculate the median time passed to // chain tip, so we use that to calculate the median time passed to
// IsFinalTx() if LOCKTIME_MEDIAN_TIME_PAST is set. // IsFinalTx() if LOCKTIME_MEDIAN_TIME_PAST is set.
const int64_t nBlockTime = (flags & LOCKTIME_MEDIAN_TIME_PAST) const int64_t nBlockTime = (flags & LOCKTIME_MEDIAN_TIME_PAST)
? chainActive.Tip()->GetMedianTimePast() ? ::ChainActive().Tip()->GetMedianTimePast()
: GetAdjustedTime(); : GetAdjustedTime();
return IsFinalTx(tx, nBlockHeight, nBlockTime); return IsFinalTx(tx, nBlockHeight, nBlockTime);
@ -367,9 +367,9 @@ bool TestLockPointValidity(const LockPoints* lp)
// If there are relative lock times then the maxInputBlock will be set // If there are relative lock times then the maxInputBlock will be set
// If there are no relative lock times, the LockPoints don't depend on the chain // If there are no relative lock times, the LockPoints don't depend on the chain
if (lp->maxInputBlock) { if (lp->maxInputBlock) {
// Check whether chainActive is an extension of the block at which the LockPoints // Check whether ::ChainActive() is an extension of the block at which the LockPoints
// calculation was valid. If not LockPoints are no longer valid // calculation was valid. If not LockPoints are no longer valid
if (!chainActive.Contains(lp->maxInputBlock)) { if (!::ChainActive().Contains(lp->maxInputBlock)) {
return false; return false;
} }
} }
@ -383,17 +383,17 @@ bool CheckSequenceLocks(const CTxMemPool& pool, const CTransaction& tx, int flag
AssertLockHeld(cs_main); AssertLockHeld(cs_main);
AssertLockHeld(pool.cs); AssertLockHeld(pool.cs);
CBlockIndex* tip = chainActive.Tip(); CBlockIndex* tip = ::ChainActive().Tip();
assert(tip != nullptr); assert(tip != nullptr);
CBlockIndex index; CBlockIndex index;
index.pprev = tip; index.pprev = tip;
// CheckSequenceLocks() uses chainActive.Height()+1 to evaluate // CheckSequenceLocks() uses ::ChainActive().Height()+1 to evaluate
// height based locks because when SequenceLocks() is called within // height based locks because when SequenceLocks() is called within
// ConnectBlock(), the height of the block *being* // ConnectBlock(), the height of the block *being*
// evaluated is what is used. // evaluated is what is used.
// Thus if we want to know if a transaction can be part of the // Thus if we want to know if a transaction can be part of the
// *next* block, we need to use one more than chainActive.Height() // *next* block, we need to use one more than ::ChainActive().Height()
index.nHeight = tip->nHeight + 1; index.nHeight = tip->nHeight + 1;
std::pair<int, int64_t> lockPair; std::pair<int, int64_t> lockPair;
@ -403,7 +403,7 @@ bool CheckSequenceLocks(const CTxMemPool& pool, const CTransaction& tx, int flag
lockPair.second = lp->time; lockPair.second = lp->time;
} }
else { else {
// pcoinsTip contains the UTXO set for chainActive.Tip() // pcoinsTip contains the UTXO set for ::ChainActive().Tip()
CCoinsViewMemPool viewMemPool(pcoinsTip.get(), pool); CCoinsViewMemPool viewMemPool(pcoinsTip.get(), pool);
std::vector<int> prevheights; std::vector<int> prevheights;
prevheights.resize(tx.vin.size()); prevheights.resize(tx.vin.size());
@ -470,9 +470,9 @@ static bool IsCurrentForFeeEstimation() EXCLUSIVE_LOCKS_REQUIRED(cs_main)
AssertLockHeld(cs_main); AssertLockHeld(cs_main);
if (IsInitialBlockDownload()) if (IsInitialBlockDownload())
return false; return false;
if (chainActive.Tip()->GetBlockTime() < (GetTime() - MAX_FEE_ESTIMATION_TIP_AGE)) if (::ChainActive().Tip()->GetBlockTime() < (GetTime() - MAX_FEE_ESTIMATION_TIP_AGE))
return false; return false;
if (chainActive.Height() < pindexBestHeader->nHeight - 1) if (::ChainActive().Height() < pindexBestHeader->nHeight - 1)
return false; return false;
return true; return true;
} }
@ -524,7 +524,7 @@ static void UpdateMempoolForReorg(DisconnectedBlockTransactions &disconnectpool,
mempool.UpdateTransactionsFromBlock(vHashUpdate); mempool.UpdateTransactionsFromBlock(vHashUpdate);
// We also need to remove any now-immature transactions // We also need to remove any now-immature transactions
mempool.removeForReorg(pcoinsTip.get(), chainActive.Tip()->nHeight + 1, STANDARD_LOCKTIME_VERIFY_FLAGS); mempool.removeForReorg(pcoinsTip.get(), ::ChainActive().Tip()->nHeight + 1, STANDARD_LOCKTIME_VERIFY_FLAGS);
// Re-limit mempool size, in case we added any transactions // Re-limit mempool size, in case we added any transactions
LimitMempoolSize(mempool, gArgs.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000, gArgs.GetArg("-mempoolexpiry", DEFAULT_MEMPOOL_EXPIRY) * 60 * 60); LimitMempoolSize(mempool, gArgs.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000, gArgs.GetArg("-mempoolexpiry", DEFAULT_MEMPOOL_EXPIRY) * 60 * 60);
} }
@ -731,7 +731,7 @@ static bool AcceptToMemoryPoolWorker(const CChainParams& chainparams, CTxMemPool
} }
} }
CTxMemPoolEntry entry(ptx, nFees, nAcceptTime, chainActive.Height(), CTxMemPoolEntry entry(ptx, nFees, nAcceptTime, ::ChainActive().Height(),
fSpendsCoinbase, nSigOpsCost, lp); fSpendsCoinbase, nSigOpsCost, lp);
unsigned int nSize = entry.GetTxSize(); unsigned int nSize = entry.GetTxSize();
@ -937,7 +937,7 @@ static bool AcceptToMemoryPoolWorker(const CChainParams& chainparams, CTxMemPool
// There is a similar check in CreateNewBlock() to prevent creating // There is a similar check in CreateNewBlock() to prevent creating
// invalid blocks (using TestBlockValidity), however allowing such // invalid blocks (using TestBlockValidity), however allowing such
// transactions into the mempool can be exploited as a DoS attack. // transactions into the mempool can be exploited as a DoS attack.
unsigned int currentBlockScriptVerifyFlags = GetBlockScriptFlags(chainActive.Tip(), chainparams.GetConsensus()); unsigned int currentBlockScriptVerifyFlags = GetBlockScriptFlags(::ChainActive().Tip(), chainparams.GetConsensus());
if (!CheckInputsFromMempoolAndCache(tx, state, view, pool, currentBlockScriptVerifyFlags, true, txdata)) { if (!CheckInputsFromMempoolAndCache(tx, state, view, pool, currentBlockScriptVerifyFlags, true, txdata)) {
return error("%s: BUG! PLEASE REPORT THIS! CheckInputs failed against latest-block but not STANDARD flags %s, %s", return error("%s: BUG! PLEASE REPORT THIS! CheckInputs failed against latest-block but not STANDARD flags %s, %s",
__func__, hash.ToString(), FormatStateMessage(state)); __func__, hash.ToString(), FormatStateMessage(state));
@ -1191,11 +1191,11 @@ bool IsInitialBlockDownload()
return false; return false;
if (fImporting || fReindex) if (fImporting || fReindex)
return true; return true;
if (chainActive.Tip() == nullptr) if (::ChainActive().Tip() == nullptr)
return true; return true;
if (chainActive.Tip()->nChainWork < nMinimumChainWork) if (::ChainActive().Tip()->nChainWork < nMinimumChainWork)
return true; return true;
if (chainActive.Tip()->GetBlockTime() < (GetTime() - nMaxTipAge)) if (::ChainActive().Tip()->GetBlockTime() < (GetTime() - nMaxTipAge))
return true; return true;
LogPrintf("Leaving InitialBlockDownload (latching to false)\n"); LogPrintf("Leaving InitialBlockDownload (latching to false)\n");
latchToFalse.store(true, std::memory_order_relaxed); latchToFalse.store(true, std::memory_order_relaxed);
@ -1232,10 +1232,10 @@ static void CheckForkWarningConditions() EXCLUSIVE_LOCKS_REQUIRED(cs_main)
// If our best fork is no longer within 72 blocks (+/- 12 hours if no one mines it) // If our best fork is no longer within 72 blocks (+/- 12 hours if no one mines it)
// of our head, drop it // of our head, drop it
if (pindexBestForkTip && chainActive.Height() - pindexBestForkTip->nHeight >= 72) if (pindexBestForkTip && ::ChainActive().Height() - pindexBestForkTip->nHeight >= 72)
pindexBestForkTip = nullptr; pindexBestForkTip = nullptr;
if (pindexBestForkTip || (pindexBestInvalid && pindexBestInvalid->nChainWork > chainActive.Tip()->nChainWork + (GetBlockProof(*chainActive.Tip()) * 6))) if (pindexBestForkTip || (pindexBestInvalid && pindexBestInvalid->nChainWork > ::ChainActive().Tip()->nChainWork + (GetBlockProof(*::ChainActive().Tip()) * 6)))
{ {
if (!GetfLargeWorkForkFound() && pindexBestForkBase) if (!GetfLargeWorkForkFound() && pindexBestForkBase)
{ {
@ -1268,7 +1268,7 @@ static void CheckForkWarningConditionsOnNewFork(CBlockIndex* pindexNewForkTip) E
AssertLockHeld(cs_main); AssertLockHeld(cs_main);
// If we are on a fork that is sufficiently large, set a warning flag // If we are on a fork that is sufficiently large, set a warning flag
CBlockIndex* pfork = pindexNewForkTip; CBlockIndex* pfork = pindexNewForkTip;
CBlockIndex* plonger = chainActive.Tip(); CBlockIndex* plonger = ::ChainActive().Tip();
while (pfork && pfork != plonger) while (pfork && pfork != plonger)
{ {
while (plonger && plonger->nHeight > pfork->nHeight) while (plonger && plonger->nHeight > pfork->nHeight)
@ -1287,7 +1287,7 @@ static void CheckForkWarningConditionsOnNewFork(CBlockIndex* pindexNewForkTip) E
// the 7-block condition and from this always have the most-likely-to-cause-warning fork // the 7-block condition and from this always have the most-likely-to-cause-warning fork
if (pfork && (!pindexBestForkTip || pindexNewForkTip->nHeight > pindexBestForkTip->nHeight) && if (pfork && (!pindexBestForkTip || pindexNewForkTip->nHeight > pindexBestForkTip->nHeight) &&
pindexNewForkTip->nChainWork - pfork->nChainWork > (GetBlockProof(*pfork) * 7) && pindexNewForkTip->nChainWork - pfork->nChainWork > (GetBlockProof(*pfork) * 7) &&
chainActive.Height() - pindexNewForkTip->nHeight < 72) ::ChainActive().Height() - pindexNewForkTip->nHeight < 72)
{ {
pindexBestForkTip = pindexNewForkTip; pindexBestForkTip = pindexNewForkTip;
pindexBestForkBase = pfork; pindexBestForkBase = pfork;
@ -1304,10 +1304,10 @@ void static InvalidChainFound(CBlockIndex* pindexNew) EXCLUSIVE_LOCKS_REQUIRED(c
LogPrintf("%s: invalid block=%s height=%d log2_work=%.8g date=%s\n", __func__, LogPrintf("%s: invalid block=%s height=%d log2_work=%.8g date=%s\n", __func__,
pindexNew->GetBlockHash().ToString(), pindexNew->nHeight, pindexNew->GetBlockHash().ToString(), pindexNew->nHeight,
log(pindexNew->nChainWork.getdouble())/log(2.0), FormatISO8601DateTime(pindexNew->GetBlockTime())); log(pindexNew->nChainWork.getdouble())/log(2.0), FormatISO8601DateTime(pindexNew->GetBlockTime()));
CBlockIndex *tip = chainActive.Tip(); CBlockIndex *tip = ::ChainActive().Tip();
assert (tip); assert (tip);
LogPrintf("%s: current best=%s height=%d log2_work=%.8g date=%s\n", __func__, LogPrintf("%s: current best=%s height=%d log2_work=%.8g date=%s\n", __func__,
tip->GetBlockHash().ToString(), chainActive.Height(), log(tip->nChainWork.getdouble())/log(2.0), tip->GetBlockHash().ToString(), ::ChainActive().Height(), log(tip->nChainWork.getdouble())/log(2.0),
FormatISO8601DateTime(tip->GetBlockTime())); FormatISO8601DateTime(tip->GetBlockTime()));
CheckForkWarningConditions(); CheckForkWarningConditions();
} }
@ -2180,7 +2180,7 @@ bool static FlushStateToDisk(const CChainParams& chainparams, CValidationState &
} }
if (full_flush_completed) { if (full_flush_completed) {
// Update best block in wallet (so we can detect restored wallets). // Update best block in wallet (so we can detect restored wallets).
GetMainSignals().ChainStateFlushed(chainActive.GetLocator()); GetMainSignals().ChainStateFlushed(::ChainActive().GetLocator());
} }
} catch (const std::runtime_error& e) { } catch (const std::runtime_error& e) {
return AbortNode(state, std::string("System error while flushing: ") + e.what()); return AbortNode(state, std::string("System error while flushing: ") + e.what());
@ -3598,7 +3598,7 @@ bool ProcessNewBlock(const CChainParams& chainparams, const std::shared_ptr<cons
bool TestBlockValidity(CValidationState& state, const CChainParams& chainparams, const CBlock& block, CBlockIndex* pindexPrev, bool fCheckPOW, bool fCheckMerkleRoot) bool TestBlockValidity(CValidationState& state, const CChainParams& chainparams, const CBlock& block, CBlockIndex* pindexPrev, bool fCheckPOW, bool fCheckMerkleRoot)
{ {
AssertLockHeld(cs_main); AssertLockHeld(cs_main);
assert(pindexPrev && pindexPrev == chainActive.Tip()); assert(pindexPrev && pindexPrev == ::ChainActive().Tip());
CCoinsViewCache viewNew(pcoinsTip.get()); CCoinsViewCache viewNew(pcoinsTip.get());
uint256 block_hash(block.GetHash()); uint256 block_hash(block.GetHash());
CBlockIndex indexDummy(block); CBlockIndex indexDummy(block);
@ -3687,11 +3687,11 @@ static void FindFilesToPruneManual(std::set<int>& setFilesToPrune, int nManualPr
assert(fPruneMode && nManualPruneHeight > 0); assert(fPruneMode && nManualPruneHeight > 0);
LOCK2(cs_main, cs_LastBlockFile); LOCK2(cs_main, cs_LastBlockFile);
if (chainActive.Tip() == nullptr) if (::ChainActive().Tip() == nullptr)
return; return;
// last block to prune is the lesser of (user-specified height, MIN_BLOCKS_TO_KEEP from the tip) // last block to prune is the lesser of (user-specified height, MIN_BLOCKS_TO_KEEP from the tip)
unsigned int nLastBlockWeCanPrune = std::min((unsigned)nManualPruneHeight, chainActive.Tip()->nHeight - MIN_BLOCKS_TO_KEEP); unsigned int nLastBlockWeCanPrune = std::min((unsigned)nManualPruneHeight, ::ChainActive().Tip()->nHeight - MIN_BLOCKS_TO_KEEP);
int count=0; int count=0;
for (int fileNumber = 0; fileNumber < nLastBlockFile; fileNumber++) { for (int fileNumber = 0; fileNumber < nLastBlockFile; fileNumber++) {
if (vinfoBlockFile[fileNumber].nSize == 0 || vinfoBlockFile[fileNumber].nHeightLast > nLastBlockWeCanPrune) if (vinfoBlockFile[fileNumber].nSize == 0 || vinfoBlockFile[fileNumber].nHeightLast > nLastBlockWeCanPrune)
@ -3731,14 +3731,14 @@ void PruneBlockFilesManual(int nManualPruneHeight)
static void FindFilesToPrune(std::set<int>& setFilesToPrune, uint64_t nPruneAfterHeight) static void FindFilesToPrune(std::set<int>& setFilesToPrune, uint64_t nPruneAfterHeight)
{ {
LOCK2(cs_main, cs_LastBlockFile); LOCK2(cs_main, cs_LastBlockFile);
if (chainActive.Tip() == nullptr || nPruneTarget == 0) { if (::ChainActive().Tip() == nullptr || nPruneTarget == 0) {
return; return;
} }
if ((uint64_t)chainActive.Tip()->nHeight <= nPruneAfterHeight) { if ((uint64_t)::ChainActive().Tip()->nHeight <= nPruneAfterHeight) {
return; return;
} }
unsigned int nLastBlockWeCanPrune = chainActive.Tip()->nHeight - MIN_BLOCKS_TO_KEEP; unsigned int nLastBlockWeCanPrune = ::ChainActive().Tip()->nHeight - MIN_BLOCKS_TO_KEEP;
uint64_t nCurrentUsage = CalculateCurrentUsage(); uint64_t nCurrentUsage = CalculateCurrentUsage();
// We don't check to prune until after we've allocated new space for files // We don't check to prune until after we've allocated new space for files
// So we should leave a buffer under our target to account for another allocation // So we should leave a buffer under our target to account for another allocation
@ -3935,11 +3935,11 @@ bool LoadChainTip(const CChainParams& chainparams)
{ {
AssertLockHeld(cs_main); AssertLockHeld(cs_main);
if (chainActive.Tip() && chainActive.Tip()->GetBlockHash() == pcoinsTip->GetBestBlock()) return true; if (::ChainActive().Tip() && ::ChainActive().Tip()->GetBlockHash() == pcoinsTip->GetBestBlock()) return true;
if (pcoinsTip->GetBestBlock().IsNull() && mapBlockIndex.size() == 1) { if (pcoinsTip->GetBestBlock().IsNull() && mapBlockIndex.size() == 1) {
// In case we just added the genesis block, connect it now, so // In case we just added the genesis block, connect it now, so
// that we always have a chainActive.Tip() when we return. // that we always have a ::ChainActive().Tip() when we return.
LogPrintf("%s: Connecting genesis block...\n", __func__); LogPrintf("%s: Connecting genesis block...\n", __func__);
CValidationState state; CValidationState state;
if (!ActivateBestChain(state, chainparams)) { if (!ActivateBestChain(state, chainparams)) {
@ -3953,14 +3953,14 @@ bool LoadChainTip(const CChainParams& chainparams)
if (!pindex) { if (!pindex) {
return false; return false;
} }
chainActive.SetTip(pindex); ::ChainActive().SetTip(pindex);
g_chainstate.PruneBlockIndexCandidates(); g_chainstate.PruneBlockIndexCandidates();
LogPrintf("Loaded best chain: hashBestChain=%s height=%d date=%s progress=%f\n", LogPrintf("Loaded best chain: hashBestChain=%s height=%d date=%s progress=%f\n",
chainActive.Tip()->GetBlockHash().ToString(), chainActive.Height(), ::ChainActive().Tip()->GetBlockHash().ToString(), ::ChainActive().Height(),
FormatISO8601DateTime(chainActive.Tip()->GetBlockTime()), FormatISO8601DateTime(::ChainActive().Tip()->GetBlockTime()),
GuessVerificationProgress(chainparams.TxData(), chainActive.Tip())); GuessVerificationProgress(chainparams.TxData(), ::ChainActive().Tip()));
return true; return true;
} }
@ -3977,12 +3977,12 @@ CVerifyDB::~CVerifyDB()
bool CVerifyDB::VerifyDB(const CChainParams& chainparams, CCoinsView *coinsview, int nCheckLevel, int nCheckDepth) bool CVerifyDB::VerifyDB(const CChainParams& chainparams, CCoinsView *coinsview, int nCheckLevel, int nCheckDepth)
{ {
LOCK(cs_main); LOCK(cs_main);
if (chainActive.Tip() == nullptr || chainActive.Tip()->pprev == nullptr) if (::ChainActive().Tip() == nullptr || ::ChainActive().Tip()->pprev == nullptr)
return true; return true;
// Verify blocks in the best chain // Verify blocks in the best chain
if (nCheckDepth <= 0 || nCheckDepth > chainActive.Height()) if (nCheckDepth <= 0 || nCheckDepth > ::ChainActive().Height())
nCheckDepth = chainActive.Height(); nCheckDepth = ::ChainActive().Height();
nCheckLevel = std::max(0, std::min(4, nCheckLevel)); nCheckLevel = std::max(0, std::min(4, nCheckLevel));
LogPrintf("Verifying last %i blocks at level %i\n", nCheckDepth, nCheckLevel); LogPrintf("Verifying last %i blocks at level %i\n", nCheckDepth, nCheckLevel);
CCoinsViewCache coins(coinsview); CCoinsViewCache coins(coinsview);
@ -3992,16 +3992,16 @@ bool CVerifyDB::VerifyDB(const CChainParams& chainparams, CCoinsView *coinsview,
CValidationState state; CValidationState state;
int reportDone = 0; int reportDone = 0;
LogPrintf("[0%%]..."); /* Continued */ LogPrintf("[0%%]..."); /* Continued */
for (pindex = chainActive.Tip(); pindex && pindex->pprev; pindex = pindex->pprev) { for (pindex = ::ChainActive().Tip(); pindex && pindex->pprev; pindex = pindex->pprev) {
boost::this_thread::interruption_point(); boost::this_thread::interruption_point();
const int percentageDone = std::max(1, std::min(99, (int)(((double)(chainActive.Height() - pindex->nHeight)) / (double)nCheckDepth * (nCheckLevel >= 4 ? 50 : 100)))); const int percentageDone = std::max(1, std::min(99, (int)(((double)(::ChainActive().Height() - pindex->nHeight)) / (double)nCheckDepth * (nCheckLevel >= 4 ? 50 : 100))));
if (reportDone < percentageDone/10) { if (reportDone < percentageDone/10) {
// report every 10% step // report every 10% step
LogPrintf("[%d%%]...", percentageDone); /* Continued */ LogPrintf("[%d%%]...", percentageDone); /* Continued */
reportDone = percentageDone/10; reportDone = percentageDone/10;
} }
uiInterface.ShowProgress(_("Verifying blocks..."), percentageDone, false); uiInterface.ShowProgress(_("Verifying blocks..."), percentageDone, false);
if (pindex->nHeight <= chainActive.Height()-nCheckDepth) if (pindex->nHeight <= ::ChainActive().Height()-nCheckDepth)
break; break;
if (fPruneMode && !(pindex->nStatus & BLOCK_HAVE_DATA)) { if (fPruneMode && !(pindex->nStatus & BLOCK_HAVE_DATA)) {
// If pruning, only go back as far as we have data. // If pruning, only go back as far as we have data.
@ -4043,23 +4043,23 @@ bool CVerifyDB::VerifyDB(const CChainParams& chainparams, CCoinsView *coinsview,
return true; return true;
} }
if (pindexFailure) if (pindexFailure)
return error("VerifyDB(): *** coin database inconsistencies found (last %i blocks, %i good transactions before that)\n", chainActive.Height() - pindexFailure->nHeight + 1, nGoodTransactions); return error("VerifyDB(): *** coin database inconsistencies found (last %i blocks, %i good transactions before that)\n", ::ChainActive().Height() - pindexFailure->nHeight + 1, nGoodTransactions);
// store block count as we move pindex at check level >= 4 // store block count as we move pindex at check level >= 4
int block_count = chainActive.Height() - pindex->nHeight; int block_count = ::ChainActive().Height() - pindex->nHeight;
// check level 4: try reconnecting blocks // check level 4: try reconnecting blocks
if (nCheckLevel >= 4) { if (nCheckLevel >= 4) {
while (pindex != chainActive.Tip()) { while (pindex != ::ChainActive().Tip()) {
boost::this_thread::interruption_point(); boost::this_thread::interruption_point();
const int percentageDone = std::max(1, std::min(99, 100 - (int)(((double)(chainActive.Height() - pindex->nHeight)) / (double)nCheckDepth * 50))); const int percentageDone = std::max(1, std::min(99, 100 - (int)(((double)(::ChainActive().Height() - pindex->nHeight)) / (double)nCheckDepth * 50)));
if (reportDone < percentageDone/10) { if (reportDone < percentageDone/10) {
// report every 10% step // report every 10% step
LogPrintf("[%d%%]...", percentageDone); /* Continued */ LogPrintf("[%d%%]...", percentageDone); /* Continued */
reportDone = percentageDone/10; reportDone = percentageDone/10;
} }
uiInterface.ShowProgress(_("Verifying blocks..."), percentageDone, false); uiInterface.ShowProgress(_("Verifying blocks..."), percentageDone, false);
pindex = chainActive.Next(pindex); pindex = ::ChainActive().Next(pindex);
CBlock block; CBlock block;
if (!ReadBlockFromDisk(block, pindex, chainparams.GetConsensus())) if (!ReadBlockFromDisk(block, pindex, chainparams.GetConsensus()))
return error("VerifyDB(): *** ReadBlockFromDisk failed at %d, hash=%s", pindex->nHeight, pindex->GetBlockHash().ToString()); return error("VerifyDB(): *** ReadBlockFromDisk failed at %d, hash=%s", pindex->nHeight, pindex->GetBlockHash().ToString());
@ -4299,8 +4299,8 @@ bool RewindBlockIndex(const CChainParams& params) {
return false; return false;
} }
if (chainActive.Tip() != nullptr) { if (::ChainActive().Tip() != nullptr) {
// FlushStateToDisk can possibly read chainActive. Be conservative // FlushStateToDisk can possibly read ::ChainActive(). Be conservative
// and skip it here, we're about to -reindex-chainstate anyway, so // and skip it here, we're about to -reindex-chainstate anyway, so
// it'll get called a bunch real soon. // it'll get called a bunch real soon.
CValidationState state; CValidationState state;
@ -4325,7 +4325,7 @@ void CChainState::UnloadBlockIndex() {
void UnloadBlockIndex() void UnloadBlockIndex()
{ {
LOCK(cs_main); LOCK(cs_main);
chainActive.SetTip(nullptr); ::ChainActive().SetTip(nullptr);
pindexBestInvalid = nullptr; pindexBestInvalid = nullptr;
pindexBestHeader = nullptr; pindexBestHeader = nullptr;
mempool.clear(); mempool.clear();
@ -4721,19 +4721,19 @@ CBlockFileInfo* GetBlockFileInfo(size_t n)
ThresholdState VersionBitsTipState(const Consensus::Params& params, Consensus::DeploymentPos pos) ThresholdState VersionBitsTipState(const Consensus::Params& params, Consensus::DeploymentPos pos)
{ {
LOCK(cs_main); LOCK(cs_main);
return VersionBitsState(chainActive.Tip(), params, pos, versionbitscache); return VersionBitsState(::ChainActive().Tip(), params, pos, versionbitscache);
} }
BIP9Stats VersionBitsTipStatistics(const Consensus::Params& params, Consensus::DeploymentPos pos) BIP9Stats VersionBitsTipStatistics(const Consensus::Params& params, Consensus::DeploymentPos pos)
{ {
LOCK(cs_main); LOCK(cs_main);
return VersionBitsStatistics(chainActive.Tip(), params, pos); return VersionBitsStatistics(::ChainActive().Tip(), params, pos);
} }
int VersionBitsTipStateSinceHeight(const Consensus::Params& params, Consensus::DeploymentPos pos) int VersionBitsTipStateSinceHeight(const Consensus::Params& params, Consensus::DeploymentPos pos)
{ {
LOCK(cs_main); LOCK(cs_main);
return VersionBitsStateSinceHeight(chainActive.Tip(), params, pos, versionbitscache); return VersionBitsStateSinceHeight(::ChainActive().Tip(), params, pos, versionbitscache);
} }
static const uint64_t MEMPOOL_DUMP_VERSION = 1; static const uint64_t MEMPOOL_DUMP_VERSION = 1;

2
src/validation.h
View file

@ -176,7 +176,7 @@ extern bool fHavePruned;
extern bool fPruneMode; extern bool fPruneMode;
/** Number of MiB of block files that we're trying to stay below. */ /** Number of MiB of block files that we're trying to stay below. */
extern uint64_t nPruneTarget; extern uint64_t nPruneTarget;
/** Block files containing a block-height within MIN_BLOCKS_TO_KEEP of chainActive.Tip() will not be pruned. */ /** Block files containing a block-height within MIN_BLOCKS_TO_KEEP of ::ChainActive().Tip() will not be pruned. */
static const unsigned int MIN_BLOCKS_TO_KEEP = 288; static const unsigned int MIN_BLOCKS_TO_KEEP = 288;
/** Minimum blocks required to signal NODE_NETWORK_LIMITED */ /** Minimum blocks required to signal NODE_NETWORK_LIMITED */
static const unsigned int NODE_NETWORK_LIMITED_MIN_BLOCKS = 288; static const unsigned int NODE_NETWORK_LIMITED_MIN_BLOCKS = 288;

20
src/wallet/test/wallet_tests.cpp
View file

@ -39,10 +39,10 @@ BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions, TestChain100Setup)
auto chain = interfaces::MakeChain(); auto chain = interfaces::MakeChain();
// Cap last block file size, and mine new block in a new block file. // Cap last block file size, and mine new block in a new block file.
CBlockIndex* oldTip = chainActive.Tip(); CBlockIndex* oldTip = ::ChainActive().Tip();
GetBlockFileInfo(oldTip->GetBlockPos().nFile)->nSize = MAX_BLOCKFILE_SIZE; GetBlockFileInfo(oldTip->GetBlockPos().nFile)->nSize = MAX_BLOCKFILE_SIZE;
CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())); CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
CBlockIndex* newTip = chainActive.Tip(); CBlockIndex* newTip = ::ChainActive().Tip();
LockAnnotation lock(::cs_main); LockAnnotation lock(::cs_main);
auto locked_chain = chain->lock(); auto locked_chain = chain->lock();
@ -119,10 +119,10 @@ BOOST_FIXTURE_TEST_CASE(importmulti_rescan, TestChain100Setup)
auto chain = interfaces::MakeChain(); auto chain = interfaces::MakeChain();
// Cap last block file size, and mine new block in a new block file. // Cap last block file size, and mine new block in a new block file.
CBlockIndex* oldTip = chainActive.Tip(); CBlockIndex* oldTip = ::ChainActive().Tip();
GetBlockFileInfo(oldTip->GetBlockPos().nFile)->nSize = MAX_BLOCKFILE_SIZE; GetBlockFileInfo(oldTip->GetBlockPos().nFile)->nSize = MAX_BLOCKFILE_SIZE;
CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())); CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
CBlockIndex* newTip = chainActive.Tip(); CBlockIndex* newTip = ::ChainActive().Tip();
LockAnnotation lock(::cs_main); LockAnnotation lock(::cs_main);
auto locked_chain = chain->lock(); auto locked_chain = chain->lock();
@ -181,7 +181,7 @@ BOOST_FIXTURE_TEST_CASE(importwallet_rescan, TestChain100Setup)
// Create two blocks with same timestamp to verify that importwallet rescan // Create two blocks with same timestamp to verify that importwallet rescan
// will pick up both blocks, not just the first. // will pick up both blocks, not just the first.
const int64_t BLOCK_TIME = chainActive.Tip()->GetBlockTimeMax() + 5; const int64_t BLOCK_TIME = ::ChainActive().Tip()->GetBlockTimeMax() + 5;
SetMockTime(BLOCK_TIME); SetMockTime(BLOCK_TIME);
m_coinbase_txns.emplace_back(CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]); m_coinbase_txns.emplace_back(CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]);
m_coinbase_txns.emplace_back(CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]); m_coinbase_txns.emplace_back(CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]);
@ -249,7 +249,7 @@ BOOST_FIXTURE_TEST_CASE(coin_mark_dirty_immature_credit, TestChain100Setup)
CWalletTx wtx(&wallet, m_coinbase_txns.back()); CWalletTx wtx(&wallet, m_coinbase_txns.back());
auto locked_chain = chain->lock(); auto locked_chain = chain->lock();
LOCK(wallet.cs_wallet); LOCK(wallet.cs_wallet);
wtx.hashBlock = chainActive.Tip()->GetBlockHash(); wtx.hashBlock = ::ChainActive().Tip()->GetBlockHash();
wtx.nIndex = 0; wtx.nIndex = 0;
// Call GetImmatureCredit() once before adding the key to the wallet to // Call GetImmatureCredit() once before adding the key to the wallet to
@ -346,10 +346,10 @@ public:
AddKey(*wallet, coinbaseKey); AddKey(*wallet, coinbaseKey);
WalletRescanReserver reserver(wallet.get()); WalletRescanReserver reserver(wallet.get());
reserver.reserve(); reserver.reserve();
CWallet::ScanResult result = wallet->ScanForWalletTransactions(chainActive.Genesis()->GetBlockHash(), {} /* stop_block */, reserver, false /* update */); CWallet::ScanResult result = wallet->ScanForWalletTransactions(::ChainActive().Genesis()->GetBlockHash(), {} /* stop_block */, reserver, false /* update */);
BOOST_CHECK_EQUAL(result.status, CWallet::ScanResult::SUCCESS); BOOST_CHECK_EQUAL(result.status, CWallet::ScanResult::SUCCESS);
BOOST_CHECK_EQUAL(result.last_scanned_block, chainActive.Tip()->GetBlockHash()); BOOST_CHECK_EQUAL(result.last_scanned_block, ::ChainActive().Tip()->GetBlockHash());
BOOST_CHECK_EQUAL(*result.last_scanned_height, chainActive.Height()); BOOST_CHECK_EQUAL(*result.last_scanned_height, ::ChainActive().Height());
BOOST_CHECK(result.last_failed_block.IsNull()); BOOST_CHECK(result.last_failed_block.IsNull());
} }
@ -378,7 +378,7 @@ public:
LOCK(wallet->cs_wallet); LOCK(wallet->cs_wallet);
auto it = wallet->mapWallet.find(tx->GetHash()); auto it = wallet->mapWallet.find(tx->GetHash());
BOOST_CHECK(it != wallet->mapWallet.end()); BOOST_CHECK(it != wallet->mapWallet.end());
it->second.SetMerkleBranch(chainActive.Tip()->GetBlockHash(), 1); it->second.SetMerkleBranch(::ChainActive().Tip()->GetBlockHash(), 1);
return it->second; return it->second;
} }

2
src/wallet/wallet.cpp
View file

@ -1288,7 +1288,7 @@ void CWallet::UpdatedBlockTip()
void CWallet::BlockUntilSyncedToCurrentChain() { void CWallet::BlockUntilSyncedToCurrentChain() {
AssertLockNotHeld(cs_wallet); AssertLockNotHeld(cs_wallet);
// Skip the queue-draining stuff if we know we're caught up with // Skip the queue-draining stuff if we know we're caught up with
// chainActive.Tip(), otherwise put a callback in the validation interface queue and wait // ::ChainActive().Tip(), otherwise put a callback in the validation interface queue and wait
// for the queue to drain enough to execute it (indicating we are caught up // for the queue to drain enough to execute it (indicating we are caught up
// at least with the time we entered this function). // at least with the time we entered this function).
uint256 last_block_hash = WITH_LOCK(cs_wallet, return m_last_block_processed); uint256 last_block_hash = WITH_LOCK(cs_wallet, return m_last_block_processed);