scripted-diff: tree-wide: Remove all review-only assertions

dongcarl · dongcarl · commit 6c3b5dc0c13c · 2021-06-10T15:05:24.000-04:00
-BEGIN VERIFY SCRIPT-
find_regex='((assert|CHECK_NONFATAL)\(std::addressof|TODO: REVIEW-ONLY)' \
    &amp;&amp; git grep -l -E "$find_regex" -- . \
        | xargs sed -i -E "/${find_regex}/d"
-END VERIFY SCRIPT-
diff --git a/src/bench/duplicate_inputs.cpp b/src/bench/duplicate_inputs.cpp
@@ -25,7 +25,6 @@ static void DuplicateInputs(benchmark::Bench& bench)
     CMutableTransaction naughtyTx{};
 
     LOCK(cs_main);
-    assert(std::addressof(::ChainActive()) == std::addressof(testing_setup->m_node.chainman->ActiveChain()));
     CBlockIndex* pindexPrev = testing_setup->m_node.chainman->ActiveChain().Tip();
     assert(pindexPrev != nullptr);
     block.nBits = GetNextWorkRequired(pindexPrev, &block, chainparams.GetConsensus());
diff --git a/src/index/base.cpp b/src/index/base.cpp
@@ -340,7 +340,6 @@ void BaseIndex::Interrupt()
 
 bool BaseIndex::Start(CChainState& active_chainstate)
 {
-    assert(std::addressof(::ChainstateActive()) == std::addressof(active_chainstate));
     m_chainstate = &active_chainstate;
     // Need to register this ValidationInterface before running Init(), so that
     // callbacks are not missed if Init sets m_synced to true.
diff --git a/src/init.cpp b/src/init.cpp
@@ -1384,7 +1384,6 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
 
                 // If the loaded chain has a wrong genesis, bail out immediately
                 // (we're likely using a testnet datadir, or the other way around).
-                assert(std::addressof(g_chainman.m_blockman) == std::addressof(chainman.m_blockman));
                 if (!chainman.BlockIndex().empty() &&
                         !chainman.m_blockman.LookupBlockIndex(chainparams.GetConsensus().hashGenesisBlock)) {
                     return InitError(_("Incorrect or no genesis block found. Wrong datadir for network?"));
@@ -1612,7 +1611,6 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     // 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.
     boost::signals2::connection block_notify_genesis_wait_connection;
-    assert(std::addressof(::ChainActive()) == std::addressof(chainman.ActiveChain()));
     if (chainman.ActiveChain().Tip() == nullptr) {
         block_notify_genesis_wait_connection = uiInterface.NotifyBlockTip_connect(std::bind(BlockNotifyGenesisWait, std::placeholders::_2));
     } else {
diff --git a/src/miner.cpp b/src/miner.cpp
@@ -116,7 +116,6 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
     pblocktemplate->vTxSigOpsCost.push_back(-1); // updated at end
 
     LOCK2(cs_main, m_mempool.cs);
-    assert(std::addressof(*::ChainActive().Tip()) == std::addressof(*m_chainstate.m_chain.Tip()));
     CBlockIndex* pindexPrev = m_chainstate.m_chain.Tip();
     assert(pindexPrev != nullptr);
     nHeight = pindexPrev->nHeight + 1;
@@ -176,7 +175,6 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
     pblocktemplate->vTxSigOpsCost[0] = WITNESS_SCALE_FACTOR * GetLegacySigOpCount(*pblock->vtx[0]);
 
     BlockValidationState state;
-    assert(std::addressof(::ChainstateActive()) == std::addressof(m_chainstate));
     if (!TestBlockValidity(state, chainparams, m_chainstate, *pblock, pindexPrev, false, false)) {
         throw std::runtime_error(strprintf("%s: TestBlockValidity failed: %s", __func__, state.ToString()));
     }
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
@@ -1361,7 +1361,6 @@ PeerManagerImpl::PeerManagerImpl(const CChainParams& chainparams, CConnman& conn
       m_stale_tip_check_time(0),
       m_ignore_incoming_txs(ignore_incoming_txs)
 {
-    assert(std::addressof(g_chainman) == std::addressof(m_chainman));
     // Initialize global variables that cannot be constructed at startup.
     recentRejects.reset(new CRollingBloomFilter(120000, 0.000001));
 
diff --git a/src/node/blockstorage.cpp b/src/node/blockstorage.cpp
@@ -248,7 +248,6 @@ bool FindBlockPos(FlatFilePos& pos, unsigned int nAddSize, unsigned int nHeight,
             // when the undo file is keeping up with the block file, we want to flush it explicitly
             // when it is lagging behind (more blocks arrive than are being connected), we let the
             // undo block write case handle it
-            assert(std::addressof(::ChainActive()) == std::addressof(active_chain));
             finalize_undo = (vinfoBlockFile[nFile].nHeightLast == (unsigned int)active_chain.Tip()->nHeight);
             nFile++;
             if (vinfoBlockFile.size() <= nFile) {
diff --git a/src/node/coin.cpp b/src/node/coin.cpp
@@ -13,7 +13,6 @@ void FindCoins(const NodeContext& node, std::map<COutPoint, Coin>& coins)
     assert(node.mempool);
     assert(node.chainman);
     LOCK2(cs_main, node.mempool->cs);
-    assert(std::addressof(::ChainstateActive()) == std::addressof(node.chainman->ActiveChainstate()));
     CCoinsViewCache& chain_view = node.chainman->ActiveChainstate().CoinsTip();
     CCoinsViewMemPool mempool_view(&chain_view, *node.mempool);
     for (auto& coin : coins) {
diff --git a/src/node/coinstats.cpp b/src/node/coinstats.cpp
@@ -97,7 +97,6 @@ static bool GetUTXOStats(CCoinsView* view, BlockManager& blockman, CCoinsStats&
     if (!pindex) {
         {
             LOCK(cs_main);
-            assert(std::addressof(g_chainman.m_blockman) == std::addressof(blockman));
             pindex = blockman.LookupBlockIndex(view->GetBestBlock());
         }
     }
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
@@ -197,7 +197,6 @@ class NodeImpl : public Node
     int getNumBlocks() override
     {
         LOCK(::cs_main);
-        assert(std::addressof(::ChainActive()) == std::addressof(chainman().ActiveChain()));
         return chainman().ActiveChain().Height();
     }
     uint256 getBestBlockHash() override
@@ -208,7 +207,6 @@ class NodeImpl : public Node
     int64_t getLastBlockTime() override
     {
         LOCK(::cs_main);
-        assert(std::addressof(::ChainActive()) == std::addressof(chainman().ActiveChain()));
         if (chainman().ActiveChain().Tip()) {
             return chainman().ActiveChain().Tip()->GetBlockTime();
         }
@@ -219,7 +217,6 @@ class NodeImpl : public Node
         const CBlockIndex* tip;
         {
             LOCK(::cs_main);
-            assert(std::addressof(::ChainActive()) == std::addressof(chainman().ActiveChain()));
             tip = chainman().ActiveChain().Tip();
         }
         return GuessVerificationProgress(Params().TxData(), tip);
@@ -252,7 +249,6 @@ class NodeImpl : public Node
     bool getUnspentOutput(const COutPoint& output, Coin& coin) override
     {
         LOCK(::cs_main);
-        assert(std::addressof(::ChainstateActive()) == std::addressof(chainman().ActiveChainstate()));
         return chainman().ActiveChainstate().CoinsTip().GetCoin(output, coin);
     }
     WalletClient& walletClient() override
@@ -459,14 +455,12 @@ class ChainImpl : public Chain
     bool checkFinalTx(const CTransaction& tx) override
     {
         LOCK(cs_main);
-        assert(std::addressof(::ChainActive()) == std::addressof(chainman().ActiveChain()));
         return CheckFinalTx(chainman().ActiveChain().Tip(), tx);
     }
     std::optional<int> findLocatorFork(const CBlockLocator& locator) override
     {
         LOCK(cs_main);
         const CChain& active = Assert(m_node.chainman)->ActiveChain();
-        assert(std::addressof(g_chainman) == std::addressof(*m_node.chainman));
         if (CBlockIndex* fork = m_node.chainman->m_blockman.FindForkInGlobalIndex(active, locator)) {
             return fork->nHeight;
         }
@@ -476,7 +470,6 @@ class ChainImpl : public Chain
     {
         WAIT_LOCK(cs_main, lock);
         const CChain& active = Assert(m_node.chainman)->ActiveChain();
-        assert(std::addressof(g_chainman) == std::addressof(*m_node.chainman));
         return FillBlock(m_node.chainman->m_blockman.LookupBlockIndex(hash), block, lock, active);
     }
     bool findFirstBlockWithTimeAndHeight(int64_t min_time, int min_height, const FoundBlock& block) override
@@ -489,7 +482,6 @@ class ChainImpl : public Chain
     {
         WAIT_LOCK(cs_main, lock);
         const CChain& active = Assert(m_node.chainman)->ActiveChain();
-        assert(std::addressof(g_chainman) == std::addressof(*m_node.chainman));
         if (const CBlockIndex* block = m_node.chainman->m_blockman.LookupBlockIndex(block_hash)) {
             if (const CBlockIndex* ancestor = block->GetAncestor(ancestor_height)) {
                 return FillBlock(ancestor, ancestor_out, lock, active);
@@ -501,9 +493,7 @@ class ChainImpl : public Chain
     {
         WAIT_LOCK(cs_main, lock);
         const CChain& active = Assert(m_node.chainman)->ActiveChain();
-        assert(std::addressof(g_chainman) == std::addressof(*m_node.chainman));
         const CBlockIndex* block = m_node.chainman->m_blockman.LookupBlockIndex(block_hash);
-        assert(std::addressof(g_chainman) == std::addressof(*m_node.chainman));
         const CBlockIndex* ancestor = m_node.chainman->m_blockman.LookupBlockIndex(ancestor_hash);
         if (block && ancestor && block->GetAncestor(ancestor->nHeight) != ancestor) ancestor = nullptr;
         return FillBlock(ancestor, ancestor_out, lock, active);
@@ -512,9 +502,7 @@ class ChainImpl : public Chain
     {
         WAIT_LOCK(cs_main, lock);
         const CChain& active = Assert(m_node.chainman)->ActiveChain();
-        assert(std::addressof(g_chainman) == std::addressof(*m_node.chainman));
         const CBlockIndex* block1 = m_node.chainman->m_blockman.LookupBlockIndex(block_hash1);
-        assert(std::addressof(g_chainman) == std::addressof(*m_node.chainman));
         const CBlockIndex* block2 = m_node.chainman->m_blockman.LookupBlockIndex(block_hash2);
         const CBlockIndex* ancestor = block1 && block2 ? LastCommonAncestor(block1, block2) : nullptr;
         // Using & instead of && below to avoid short circuiting and leaving
@@ -525,7 +513,6 @@ class ChainImpl : public Chain
     double guessVerificationProgress(const uint256& block_hash) override
     {
         LOCK(cs_main);
-        assert(std::addressof(g_chainman.m_blockman) == std::addressof(chainman().m_blockman));
         return GuessVerificationProgress(Params().TxData(), chainman().m_blockman.LookupBlockIndex(block_hash));
     }
     bool hasBlocks(const uint256& block_hash, int min_height, std::optional<int> max_height) override
@@ -538,7 +525,6 @@ class ChainImpl : public Chain
         // used to limit the range, and passing min_height that's too low or
         // max_height that's too high will not crash or change the result.
         LOCK(::cs_main);
-        assert(std::addressof(g_chainman.m_blockman) == std::addressof(chainman().m_blockman));
         if (CBlockIndex* block = chainman().m_blockman.LookupBlockIndex(block_hash)) {
             if (max_height && block->nHeight >= *max_height) block = block->GetAncestor(*max_height);
             for (; block->nStatus & BLOCK_HAVE_DATA; block = block->pprev) {
diff --git a/src/node/transaction.cpp b/src/node/transaction.cpp
@@ -40,7 +40,6 @@ TransactionError BroadcastTransaction(NodeContext& node, const CTransactionRef t
     { // cs_main scope
     assert(node.chainman);
     LOCK(cs_main);
-    assert(std::addressof(::ChainstateActive()) == std::addressof(node.chainman->ActiveChainstate()));
     // If the transaction is already confirmed in the chain, don't do anything
     // and return early.
     CCoinsViewCache &view = node.chainman->ActiveChainstate().CoinsTip();
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
@@ -84,7 +84,6 @@ ChainstateManager& EnsureChainman(const NodeContext& node)
     if (!node.chainman) {
         throw JSONRPCError(RPC_INTERNAL_ERROR, "Node chainman not found");
     }
-    WITH_LOCK(::cs_main, CHECK_NONFATAL(std::addressof(g_chainman) == std::addressof(*node.chainman)));
     return *node.chainman;
 }
 
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
@@ -114,7 +114,6 @@ static bool GenerateBlock(ChainstateManager& chainman, CBlock& block, uint64_t&
 
     {
         LOCK(cs_main);
-        CHECK_NONFATAL(std::addressof(::ChainActive()) == std::addressof(chainman.ActiveChain()));
         IncrementExtraNonce(&block, chainman.ActiveChain().Tip(), extra_nonce);
     }
 
@@ -147,7 +146,6 @@ static UniValue generateBlocks(ChainstateManager& chainman, const CTxMemPool& me
 
     {   // Don't keep cs_main locked
         LOCK(cs_main);
-        CHECK_NONFATAL(std::addressof(::ChainActive()) == std::addressof(chainman.ActiveChain()));
         nHeight = chainman.ActiveChain().Height();
         nHeightEnd = nHeight+nGenerate;
     }
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
@@ -513,7 +513,6 @@ void CTxMemPool::removeForReorg(CChainState& active_chainstate, int flags)
     for (indexed_transaction_set::const_iterator it = mapTx.begin(); it != mapTx.end(); it++) {
         const CTransaction& tx = it->GetTx();
         LockPoints lp = it->GetLockPoints();
-        assert(std::addressof(::ChainstateActive()) == std::addressof(active_chainstate));
         bool validLP =  TestLockPointValidity(active_chainstate.m_chain, &lp);
         CCoinsViewMemPool view_mempool(&active_chainstate.CoinsTip(), *this);
         if (!CheckFinalTx(active_chainstate.m_chain.Tip(), tx, flags)
@@ -638,10 +637,8 @@ void CTxMemPool::check(CChainState& active_chainstate) const
     uint64_t innerUsage = 0;
 
     CCoinsViewCache& active_coins_tip = active_chainstate.CoinsTip();
-    assert(std::addressof(::ChainstateActive().CoinsTip()) == std::addressof(active_coins_tip)); // TODO: REVIEW-ONLY, REMOVE IN FUTURE COMMIT
     CCoinsViewCache mempoolDuplicate(const_cast<CCoinsViewCache*>(&active_coins_tip));
     const int64_t spendheight = active_chainstate.m_chain.Height() + 1;
-    assert(g_chainman.m_blockman.GetSpendHeight(mempoolDuplicate) == spendheight); // TODO: REVIEW-ONLY, REMOVE IN FUTURE COMMIT
 
     std::list<const CTxMemPoolEntry*> waitingOnDependants;
     for (indexed_transaction_set::const_iterator it = mapTx.begin(); it != mapTx.end(); it++) {
diff --git a/src/validation.cpp b/src/validation.cpp

Original file line number	Diff line number	Diff line change
`@@ -340,7 +340,6 @@ void BaseIndex::Interrupt()`
`340`	`340`
`341`	`341`	`bool BaseIndex::Start(CChainState& active_chainstate)`
`342`	`342`	`{`
`343`		`- assert(std::addressof(::ChainstateActive()) == std::addressof(active_chainstate));`
`344`	`343`	`m_chainstate = &active_chainstate;`
`345`	`344`	`// Need to register this ValidationInterface before running Init(), so that`
`346`	`345`	`// callbacks are not missed if Init sets m_synced to true.`
Original file line number	Diff line number	Diff line change
`@@ -1361,7 +1361,6 @@ PeerManagerImpl::PeerManagerImpl(const CChainParams& chainparams, CConnman& conn`
`1361`	`1361`	`m_stale_tip_check_time(0),`
`1362`	`1362`	`m_ignore_incoming_txs(ignore_incoming_txs)`
`1363`	`1363`	`{`
`1364`		`- assert(std::addressof(g_chainman) == std::addressof(m_chainman));`
`1365`	`1364`	`// Initialize global variables that cannot be constructed at startup.`
`1366`	`1365`	`recentRejects.reset(new CRollingBloomFilter(120000, 0.000001));`
`1367`	`1366`
Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,6 @@ static bool GetUTXOStats(CCoinsView* view, BlockManager& blockman, CCoinsStats&`
`97`	`97`	`if (!pindex) {`
`98`	`98`	`{`
`99`	`99`	`LOCK(cs_main);`
`100`		`- assert(std::addressof(g_chainman.m_blockman) == std::addressof(blockman));`
`101`	`100`	`pindex = blockman.LookupBlockIndex(view->GetBestBlock());`
`102`	`101`	`}`
`103`	`102`	`}`
Original file line number	Diff line number	Diff line change
`@@ -197,7 +197,6 @@ class NodeImpl : public Node`
`197`	`197`	`int getNumBlocks() override`
`198`	`198`	`{`
`199`	`199`	`LOCK(::cs_main);`
`200`		`- assert(std::addressof(::ChainActive()) == std::addressof(chainman().ActiveChain()));`
`201`	`200`	`return chainman().ActiveChain().Height();`
`202`	`201`	`}`
`203`	`202`	`uint256 getBestBlockHash() override`
`@@ -208,7 +207,6 @@ class NodeImpl : public Node`
`208`	`207`	`int64_t getLastBlockTime() override`
`209`	`208`	`{`
`210`	`209`	`LOCK(::cs_main);`
`211`		`- assert(std::addressof(::ChainActive()) == std::addressof(chainman().ActiveChain()));`
`212`	`210`	`if (chainman().ActiveChain().Tip()) {`
`213`	`211`	`return chainman().ActiveChain().Tip()->GetBlockTime();`
`214`	`212`	`}`
`@@ -219,7 +217,6 @@ class NodeImpl : public Node`
`219`	`217`	`const CBlockIndex* tip;`
`220`	`218`	`{`
`221`	`219`	`LOCK(::cs_main);`
`222`		`- assert(std::addressof(::ChainActive()) == std::addressof(chainman().ActiveChain()));`
`223`	`220`	`tip = chainman().ActiveChain().Tip();`
`224`	`221`	`}`
`225`	`222`	`return GuessVerificationProgress(Params().TxData(), tip);`
`@@ -252,7 +249,6 @@ class NodeImpl : public Node`
`252`	`249`	`bool getUnspentOutput(const COutPoint& output, Coin& coin) override`
`253`	`250`	`{`
`254`	`251`	`LOCK(::cs_main);`
`255`		`- assert(std::addressof(::ChainstateActive()) == std::addressof(chainman().ActiveChainstate()));`
`256`	`252`	`return chainman().ActiveChainstate().CoinsTip().GetCoin(output, coin);`
`257`	`253`	`}`
`258`	`254`	`WalletClient& walletClient() override`
`@@ -459,14 +455,12 @@ class ChainImpl : public Chain`
`459`	`455`	`bool checkFinalTx(const CTransaction& tx) override`
`460`	`456`	`{`
`461`	`457`	`LOCK(cs_main);`
`462`		`- assert(std::addressof(::ChainActive()) == std::addressof(chainman().ActiveChain()));`
`463`	`458`	`return CheckFinalTx(chainman().ActiveChain().Tip(), tx);`
`464`	`459`	`}`
`465`	`460`	`std::optional<int> findLocatorFork(const CBlockLocator& locator) override`
`466`	`461`	`{`
`467`	`462`	`LOCK(cs_main);`
`468`	`463`	`const CChain& active = Assert(m_node.chainman)->ActiveChain();`
`469`		`- assert(std::addressof(g_chainman) == std::addressof(*m_node.chainman));`
`470`	`464`	`if (CBlockIndex* fork = m_node.chainman->m_blockman.FindForkInGlobalIndex(active, locator)) {`
`471`	`465`	`return fork->nHeight;`
`472`	`466`	`}`
`@@ -476,7 +470,6 @@ class ChainImpl : public Chain`
`476`	`470`	`{`
`477`	`471`	`WAIT_LOCK(cs_main, lock);`
`478`	`472`	`const CChain& active = Assert(m_node.chainman)->ActiveChain();`
`479`		`- assert(std::addressof(g_chainman) == std::addressof(*m_node.chainman));`
`480`	`473`	`return FillBlock(m_node.chainman->m_blockman.LookupBlockIndex(hash), block, lock, active);`
`481`	`474`	`}`
`482`	`475`	`bool findFirstBlockWithTimeAndHeight(int64_t min_time, int min_height, const FoundBlock& block) override`
`@@ -489,7 +482,6 @@ class ChainImpl : public Chain`
`489`	`482`	`{`
`490`	`483`	`WAIT_LOCK(cs_main, lock);`
`491`	`484`	`const CChain& active = Assert(m_node.chainman)->ActiveChain();`
`492`		`- assert(std::addressof(g_chainman) == std::addressof(*m_node.chainman));`
`493`	`485`	`if (const CBlockIndex* block = m_node.chainman->m_blockman.LookupBlockIndex(block_hash)) {`
`494`	`486`	`if (const CBlockIndex* ancestor = block->GetAncestor(ancestor_height)) {`
`495`	`487`	`return FillBlock(ancestor, ancestor_out, lock, active);`
`@@ -501,9 +493,7 @@ class ChainImpl : public Chain`
`501`	`493`	`{`
`502`	`494`	`WAIT_LOCK(cs_main, lock);`
`503`	`495`	`const CChain& active = Assert(m_node.chainman)->ActiveChain();`
`504`		`- assert(std::addressof(g_chainman) == std::addressof(*m_node.chainman));`
`505`	`496`	`const CBlockIndex* block = m_node.chainman->m_blockman.LookupBlockIndex(block_hash);`
`506`		`- assert(std::addressof(g_chainman) == std::addressof(*m_node.chainman));`
`507`	`497`	`const CBlockIndex* ancestor = m_node.chainman->m_blockman.LookupBlockIndex(ancestor_hash);`
`508`	`498`	`if (block && ancestor && block->GetAncestor(ancestor->nHeight) != ancestor) ancestor = nullptr;`
`509`	`499`	`return FillBlock(ancestor, ancestor_out, lock, active);`
`@@ -512,9 +502,7 @@ class ChainImpl : public Chain`
`512`	`502`	`{`
`513`	`503`	`WAIT_LOCK(cs_main, lock);`
`514`	`504`	`const CChain& active = Assert(m_node.chainman)->ActiveChain();`
`515`		`- assert(std::addressof(g_chainman) == std::addressof(*m_node.chainman));`
`516`	`505`	`const CBlockIndex* block1 = m_node.chainman->m_blockman.LookupBlockIndex(block_hash1);`
`517`		`- assert(std::addressof(g_chainman) == std::addressof(*m_node.chainman));`
`518`	`506`	`const CBlockIndex* block2 = m_node.chainman->m_blockman.LookupBlockIndex(block_hash2);`
`519`	`507`	`const CBlockIndex* ancestor = block1 && block2 ? LastCommonAncestor(block1, block2) : nullptr;`
`520`	`508`	`// Using & instead of && below to avoid short circuiting and leaving`
`@@ -525,7 +513,6 @@ class ChainImpl : public Chain`
`525`	`513`	`double guessVerificationProgress(const uint256& block_hash) override`
`526`	`514`	`{`
`527`	`515`	`LOCK(cs_main);`
`528`		`- assert(std::addressof(g_chainman.m_blockman) == std::addressof(chainman().m_blockman));`
`529`	`516`	`return GuessVerificationProgress(Params().TxData(), chainman().m_blockman.LookupBlockIndex(block_hash));`
`530`	`517`	`}`
`531`	`518`	`bool hasBlocks(const uint256& block_hash, int min_height, std::optional<int> max_height) override`
`@@ -538,7 +525,6 @@ class ChainImpl : public Chain`
`538`	`525`	`// used to limit the range, and passing min_height that's too low or`
`539`	`526`	`// max_height that's too high will not crash or change the result.`
`540`	`527`	`LOCK(::cs_main);`
`541`		`- assert(std::addressof(g_chainman.m_blockman) == std::addressof(chainman().m_blockman));`
`542`	`528`	`if (CBlockIndex* block = chainman().m_blockman.LookupBlockIndex(block_hash)) {`
`543`	`529`	`if (max_height && block->nHeight >= max_height) block = block->GetAncestor(max_height);`
`544`	`530`	`for (; block->nStatus & BLOCK_HAVE_DATA; block = block->pprev) {`