diff --git a/src/test/blockfilter_index_tests.cpp b/src/test/blockfilter_index_tests.cpp
index 395e9eb30..ff8d1dd92 100644
--- a/src/test/blockfilter_index_tests.cpp
+++ b/src/test/blockfilter_index_tests.cpp
@@ -1,338 +1,341 @@
 // Copyright (c) 2017-2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <blockfilter.h>
 #include <chainparams.h>
 #include <config.h>
 #include <consensus/validation.h>
 #include <index/blockfilterindex.h>
 #include <miner.h>
 #include <pow/pow.h>
 #include <script/standard.h>
 #include <test/util/blockfilter.h>
 #include <test/util/setup_common.h>
 #include <validation.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_AUTO_TEST_SUITE(blockfilter_index_tests)
 
 struct BuildChainTestingSetup : public TestChain100Setup {
     CBlock CreateBlock(const CBlockIndex *prev,
                        const std::vector<CMutableTransaction> &txns,
                        const CScript &scriptPubKey);
     bool BuildChain(const CBlockIndex *pindex,
                     const CScript &coinbase_script_pub_key, size_t length,
                     std::vector<std::shared_ptr<CBlock>> &chain);
 };
 
 static bool CheckFilterLookups(BlockFilterIndex &filter_index,
                                const CBlockIndex *block_index,
                                uint256 &last_header) {
     BlockFilter expected_filter;
     if (!ComputeFilter(filter_index.GetFilterType(), block_index,
                        expected_filter)) {
         BOOST_ERROR("ComputeFilter failed on block " << block_index->nHeight);
         return false;
     }
 
     BlockFilter filter;
     uint256 filter_header;
     std::vector<BlockFilter> filters;
     std::vector<uint256> filter_hashes;
 
     BOOST_CHECK(filter_index.LookupFilter(block_index, filter));
     BOOST_CHECK(filter_index.LookupFilterHeader(block_index, filter_header));
     BOOST_CHECK(filter_index.LookupFilterRange(block_index->nHeight,
                                                block_index, filters));
     BOOST_CHECK(filter_index.LookupFilterHashRange(block_index->nHeight,
                                                    block_index, filter_hashes));
 
     BOOST_CHECK_EQUAL(filters.size(), 1U);
     BOOST_CHECK_EQUAL(filter_hashes.size(), 1U);
 
     BOOST_CHECK_EQUAL(filter.GetHash(), expected_filter.GetHash());
     BOOST_CHECK_EQUAL(filter_header,
                       expected_filter.ComputeHeader(last_header));
     BOOST_CHECK_EQUAL(filters[0].GetHash(), expected_filter.GetHash());
     BOOST_CHECK_EQUAL(filter_hashes[0], expected_filter.GetHash());
 
     filters.clear();
     filter_hashes.clear();
     last_header = filter_header;
     return true;
 }
 
 CBlock BuildChainTestingSetup::CreateBlock(
     const CBlockIndex *prev, const std::vector<CMutableTransaction> &txns,
     const CScript &scriptPubKey) {
     const Config &config = GetConfig();
     std::unique_ptr<CBlockTemplate> pblocktemplate =
-        BlockAssembler(config, ::ChainstateActive(), *m_node.mempool)
+        BlockAssembler(config, m_node.chainman->ActiveChainstate(),
+                       *m_node.mempool)
             .CreateNewBlock(scriptPubKey);
     CBlock &block = pblocktemplate->block;
     block.hashPrevBlock = prev->GetBlockHash();
     block.nTime = prev->nTime + 1;
 
     // Replace mempool-selected txns with just coinbase plus passed-in txns:
     block.vtx.resize(1);
     for (const CMutableTransaction &tx : txns) {
         block.vtx.push_back(MakeTransactionRef(tx));
     }
     // IncrementExtraNonce creates a valid coinbase and merkleRoot
     unsigned int extraNonce = 0;
     IncrementExtraNonce(&block, prev, config.GetMaxBlockSize(), extraNonce);
 
     while (!CheckProofOfWork(block.GetHash(), block.nBits,
                              config.GetChainParams().GetConsensus())) {
         ++block.nNonce;
     }
 
     return block;
 }
 
 bool BuildChainTestingSetup::BuildChain(
     const CBlockIndex *pindex, const CScript &coinbase_script_pub_key,
     size_t length, std::vector<std::shared_ptr<CBlock>> &chain) {
     std::vector<CMutableTransaction> no_txns;
 
     chain.resize(length);
     for (auto &block : chain) {
         block = std::make_shared<CBlock>(
             CreateBlock(pindex, no_txns, coinbase_script_pub_key));
         CBlockHeader header = block->GetBlockHeader();
 
         BlockValidationState state;
         if (!Assert(m_node.chainman)
                  ->ProcessNewBlockHeaders(GetConfig(), {header}, state,
                                           &pindex)) {
             return false;
         }
     }
 
     return true;
 }
 
 BOOST_FIXTURE_TEST_CASE(blockfilter_index_initial_sync,
                         BuildChainTestingSetup) {
     BlockFilterIndex filter_index(BlockFilterType::BASIC, 1 << 20, true);
 
     uint256 last_header;
 
     // Filter should not be found in the index before it is started.
     {
         LOCK(cs_main);
 
         BlockFilter filter;
         uint256 filter_header;
         std::vector<BlockFilter> filters;
         std::vector<uint256> filter_hashes;
 
-        for (const CBlockIndex *block_index = ::ChainActive().Genesis();
+        for (const CBlockIndex *block_index =
+                 m_node.chainman->ActiveChain().Genesis();
              block_index != nullptr;
-             block_index = ::ChainActive().Next(block_index)) {
+             block_index = m_node.chainman->ActiveChain().Next(block_index)) {
             BOOST_CHECK(!filter_index.LookupFilter(block_index, filter));
             BOOST_CHECK(
                 !filter_index.LookupFilterHeader(block_index, filter_header));
             BOOST_CHECK(!filter_index.LookupFilterRange(block_index->nHeight,
                                                         block_index, filters));
             BOOST_CHECK(!filter_index.LookupFilterHashRange(
                 block_index->nHeight, block_index, filter_hashes));
         }
     }
 
     // BlockUntilSyncedToCurrentChain should return false before index is
     // started.
     BOOST_CHECK(!filter_index.BlockUntilSyncedToCurrentChain());
 
-    filter_index.Start(::ChainstateActive());
+    filter_index.Start(m_node.chainman->ActiveChainstate());
 
     // Allow filter index to catch up with the block index.
     constexpr int64_t timeout_ms = 10 * 1000;
     int64_t time_start = GetTimeMillis();
     while (!filter_index.BlockUntilSyncedToCurrentChain()) {
         BOOST_REQUIRE(time_start + timeout_ms > GetTimeMillis());
         UninterruptibleSleep(std::chrono::milliseconds{100});
     }
 
     // Check that filter index has all blocks that were in the chain before it
     // started.
     {
         LOCK(cs_main);
         const CBlockIndex *block_index;
-        for (block_index = ::ChainActive().Genesis(); block_index != nullptr;
-             block_index = ::ChainActive().Next(block_index)) {
+        for (block_index = m_node.chainman->ActiveChain().Genesis();
+             block_index != nullptr;
+             block_index = m_node.chainman->ActiveChain().Next(block_index)) {
             CheckFilterLookups(filter_index, block_index, last_header);
         }
     }
 
     // Create two forks.
     const CBlockIndex *tip;
     {
         LOCK(cs_main);
-        tip = ::ChainActive().Tip();
+        tip = m_node.chainman->ActiveTip();
     }
 
     // Make sure we disable reorg protection.
     gArgs.ForceSetArg("-parkdeepreorg", "false");
 
     CKey coinbase_key_A, coinbase_key_B;
     coinbase_key_A.MakeNewKey(true);
     coinbase_key_B.MakeNewKey(true);
     CScript coinbase_script_pub_key_A =
         GetScriptForDestination(PKHash(coinbase_key_A.GetPubKey()));
     CScript coinbase_script_pub_key_B =
         GetScriptForDestination(PKHash(coinbase_key_B.GetPubKey()));
     std::vector<std::shared_ptr<CBlock>> chainA, chainB;
     BOOST_REQUIRE(BuildChain(tip, coinbase_script_pub_key_A, 10, chainA));
     BOOST_REQUIRE(BuildChain(tip, coinbase_script_pub_key_B, 10, chainB));
 
     // Check that new blocks on chain A get indexed.
     uint256 chainA_last_header = last_header;
     for (size_t i = 0; i < 2; i++) {
         const auto &block = chainA[i];
         BOOST_REQUIRE(Assert(m_node.chainman)
                           ->ProcessNewBlock(GetConfig(), block, true, nullptr));
     }
     for (size_t i = 0; i < 2; i++) {
         const auto &block = chainA[i];
         const CBlockIndex *block_index;
         {
             LOCK(cs_main);
             block_index =
-                g_chainman.m_blockman.LookupBlockIndex(block->GetHash());
+                m_node.chainman->m_blockman.LookupBlockIndex(block->GetHash());
         }
 
         BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
         CheckFilterLookups(filter_index, block_index, chainA_last_header);
     }
 
     // Reorg to chain B.
     uint256 chainB_last_header = last_header;
     for (size_t i = 0; i < 3; i++) {
         const auto &block = chainB[i];
         BOOST_REQUIRE(Assert(m_node.chainman)
                           ->ProcessNewBlock(GetConfig(), block, true, nullptr));
     }
     for (size_t i = 0; i < 3; i++) {
         const auto &block = chainB[i];
         const CBlockIndex *block_index;
         {
             LOCK(cs_main);
             block_index =
-                g_chainman.m_blockman.LookupBlockIndex(block->GetHash());
+                m_node.chainman->m_blockman.LookupBlockIndex(block->GetHash());
         }
 
         BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
         CheckFilterLookups(filter_index, block_index, chainB_last_header);
     }
 
     // Check that filters for stale blocks on A can be retrieved.
     chainA_last_header = last_header;
     for (size_t i = 0; i < 2; i++) {
         const auto &block = chainA[i];
         const CBlockIndex *block_index;
         {
             LOCK(cs_main);
             block_index =
-                g_chainman.m_blockman.LookupBlockIndex(block->GetHash());
+                m_node.chainman->m_blockman.LookupBlockIndex(block->GetHash());
         }
 
         BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
         CheckFilterLookups(filter_index, block_index, chainA_last_header);
     }
 
     // Reorg back to chain A.
     for (size_t i = 2; i < 4; i++) {
         const auto &block = chainA[i];
         BOOST_REQUIRE(Assert(m_node.chainman)
                           ->ProcessNewBlock(GetConfig(), block, true, nullptr));
     }
 
     // Check that chain A and B blocks can be retrieved.
     chainA_last_header = last_header;
     chainB_last_header = last_header;
     for (size_t i = 0; i < 3; i++) {
         const CBlockIndex *block_index;
 
         {
             LOCK(cs_main);
-            block_index =
-                g_chainman.m_blockman.LookupBlockIndex(chainA[i]->GetHash());
+            block_index = m_node.chainman->m_blockman.LookupBlockIndex(
+                chainA[i]->GetHash());
         }
         BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
         CheckFilterLookups(filter_index, block_index, chainA_last_header);
 
         {
             LOCK(cs_main);
-            block_index =
-                g_chainman.m_blockman.LookupBlockIndex(chainB[i]->GetHash());
+            block_index = m_node.chainman->m_blockman.LookupBlockIndex(
+                chainB[i]->GetHash());
         }
         BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
         CheckFilterLookups(filter_index, block_index, chainB_last_header);
     }
 
     // Test lookups for a range of filters/hashes.
     std::vector<BlockFilter> filters;
     std::vector<uint256> filter_hashes;
 
     {
         LOCK(cs_main);
-        tip = ::ChainActive().Tip();
+        tip = m_node.chainman->ActiveTip();
     }
     BOOST_CHECK(filter_index.LookupFilterRange(0, tip, filters));
     BOOST_CHECK(filter_index.LookupFilterHashRange(0, tip, filter_hashes));
 
     BOOST_CHECK(tip->nHeight >= 0);
     BOOST_CHECK_EQUAL(filters.size(), tip->nHeight + 1U);
     BOOST_CHECK_EQUAL(filter_hashes.size(), tip->nHeight + 1U);
 
     filters.clear();
     filter_hashes.clear();
 
     filter_index.Interrupt();
     filter_index.Stop();
 }
 
 BOOST_FIXTURE_TEST_CASE(blockfilter_index_init_destroy, BasicTestingSetup) {
     BlockFilterIndex *filter_index;
 
     filter_index = GetBlockFilterIndex(BlockFilterType::BASIC);
     BOOST_CHECK(filter_index == nullptr);
 
     BOOST_CHECK(
         InitBlockFilterIndex(BlockFilterType::BASIC, 1 << 20, true, false));
 
     filter_index = GetBlockFilterIndex(BlockFilterType::BASIC);
     BOOST_CHECK(filter_index != nullptr);
     BOOST_CHECK(filter_index->GetFilterType() == BlockFilterType::BASIC);
 
     // Initialize returns false if index already exists.
     BOOST_CHECK(
         !InitBlockFilterIndex(BlockFilterType::BASIC, 1 << 20, true, false));
 
     int iter_count = 0;
     ForEachBlockFilterIndex(
         [&iter_count](BlockFilterIndex &_index) { iter_count++; });
     BOOST_CHECK_EQUAL(iter_count, 1);
 
     BOOST_CHECK(DestroyBlockFilterIndex(BlockFilterType::BASIC));
 
     // Destroy returns false because index was already destroyed.
     BOOST_CHECK(!DestroyBlockFilterIndex(BlockFilterType::BASIC));
 
     filter_index = GetBlockFilterIndex(BlockFilterType::BASIC);
     BOOST_CHECK(filter_index == nullptr);
 
     // Reinitialize index.
     BOOST_CHECK(
         InitBlockFilterIndex(BlockFilterType::BASIC, 1 << 20, true, false));
 
     DestroyAllBlockFilterIndexes();
 
     filter_index = GetBlockFilterIndex(BlockFilterType::BASIC);
     BOOST_CHECK(filter_index == nullptr);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/checkpoints_tests.cpp b/src/test/checkpoints_tests.cpp
index c13d627d9..33be1f9f5 100644
--- a/src/test/checkpoints_tests.cpp
+++ b/src/test/checkpoints_tests.cpp
@@ -1,215 +1,215 @@
 // Copyright (c) 2011-2015 The Bitcoin Core developers
 // Copyright (c) 2018-2019 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 //
 // Unit tests for block-chain checkpoints
 //
 
 #include <checkpoints.h>
 
 #include <chain.h>
 #include <chainparams.h>
 #include <config.h>
 #include <consensus/validation.h>
 #include <streams.h>
 #include <uint256.h>
 #include <util/strencodings.h>
 #include <validation.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <memory>
 
 BOOST_FIXTURE_TEST_SUITE(checkpoints_tests, TestingSetup)
 
 BOOST_AUTO_TEST_CASE(sanity) {
     const auto params = CreateChainParams(CBaseChainParams::MAIN);
     const CCheckpointData &checkpoints = params->Checkpoints();
     BlockHash p11111 = BlockHash::fromHex(
         "0000000069e244f73d78e8fd29ba2fd2ed618bd6fa2ee92559f542fdb26e7c1d");
     BlockHash p134444 = BlockHash::fromHex(
         "00000000000005b12ffd4cd315cd34ffd4a594f430ac814c91184a0d42d2b0fe");
     BOOST_CHECK(Checkpoints::CheckBlock(checkpoints, 11111, p11111));
     BOOST_CHECK(Checkpoints::CheckBlock(checkpoints, 134444, p134444));
 
     // Wrong hashes at checkpoints should fail:
     BOOST_CHECK(!Checkpoints::CheckBlock(checkpoints, 11111, p134444));
     BOOST_CHECK(!Checkpoints::CheckBlock(checkpoints, 134444, p11111));
 
     // ... but any hash not at a checkpoint should succeed:
     BOOST_CHECK(Checkpoints::CheckBlock(checkpoints, 11111 + 1, p134444));
     BOOST_CHECK(Checkpoints::CheckBlock(checkpoints, 134444 + 1, p11111));
 }
 
 class ChainParamsWithCheckpoints : public CChainParams {
 public:
     ChainParamsWithCheckpoints(const CChainParams &chainParams,
                                CCheckpointData &checkpoints)
         : CChainParams(chainParams) {
         checkpointData = checkpoints;
     }
 };
 
 class MainnetConfigWithTestCheckpoints : public DummyConfig {
 public:
     MainnetConfigWithTestCheckpoints() : DummyConfig(createChainParams()) {}
 
     static std::unique_ptr<CChainParams> createChainParams() {
         CCheckpointData checkpoints = {
             .mapCheckpoints = {
                 {2, BlockHash::fromHex("000000006a625f06636b8bb6ac7b960a8d03705"
                                        "d1ace08b1a19da3fdcc99ddbd")},
             }};
         const auto mainParams = CreateChainParams(CBaseChainParams::MAIN);
         return std::make_unique<ChainParamsWithCheckpoints>(*mainParams,
                                                             checkpoints);
     }
 };
 
 /**
  * This test has 4 precomputed blocks mined ontop of the genesis block:
  *  G ---> A ---> AA (checkpointed)
  *   \       \
  *    \--> B  \-> AB
  * After the node has accepted only A and AA, these rejects should occur:
  *  * B should be rejected for forking prior to an accepted checkpoint
  *  * AB should be rejected for forking at an accepted checkpoint
  */
 BOOST_AUTO_TEST_CASE(ban_fork_prior_to_and_at_checkpoints) {
     MainnetConfigWithTestCheckpoints config;
     const CBlockIndex *pindex = nullptr;
 
     // Start with mainnet genesis block
     CBlockHeader headerG = config.GetChainParams().GenesisBlock();
     BOOST_CHECK(headerG.GetHash() ==
                 uint256S("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f"
                          "1b60a8ce26f"));
 
     {
         BlockValidationState state;
         BOOST_CHECK(
             Assert(m_node.chainman)
                 ->ProcessNewBlockHeaders(config, {headerG}, state, &pindex));
         pindex = nullptr;
     }
 
     CBlockHeader headerA, headerB, headerAA, headerAB;
     CDataStream stream = CDataStream(
         ParseHex(
             "010000006fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000"
             "000000982051fd1e4ba744bbbe680e1fee14677ba1a3c3540bf7b1cdb606e85723"
             "3e0e61bc6649ffff001d01e3629901010000000100000000000000000000000000"
             "00000000000000000000000000000000000000ffffffff0704ffff001d0104ffff"
             "ffff0100f2052a0100000043410496b538e853519c726a2c91e61ec11600ae1390"
             "813a627c66fb8be7947be63c52da7589379515d4e0a604f8141781e62294721166"
             "bf621e73a82cbf2342c858eeac00000000"),
         SER_NETWORK, PROTOCOL_VERSION);
     stream >> headerA;
     BOOST_CHECK(headerA.GetHash() ==
                 uint256S("00000000839a8e6886ab5951d76f411475428afc90947ee320161"
                          "bbf18eb6048"));
     BOOST_CHECK(headerA.hashPrevBlock == headerG.GetHash());
 
     stream = CDataStream(
         ParseHex(
             "010000004860eb18bf1b1620e37e9490fc8a427514416fd75159ab86688e9a8300"
             "000000d5fdcc541e25de1c7a5addedf24858b8bb665c9f36ef744ee42c316022c9"
             "0f9bb0bc6649ffff001d08d2bd6101010000000100000000000000000000000000"
             "00000000000000000000000000000000000000ffffffff0704ffff001d010bffff"
             "ffff0100f2052a010000004341047211a824f55b505228e4c3d5194c1fcfaa15a4"
             "56abdf37f9b9d97a4040afc073dee6c89064984f03385237d92167c13e236446b4"
             "17ab79a0fcae412ae3316b77ac00000000"),
         SER_NETWORK, PROTOCOL_VERSION);
     stream >> headerAA;
     BOOST_CHECK(headerAA.GetHash() ==
                 uint256S("000000006a625f06636b8bb6ac7b960a8d03705d1ace08b1a19da"
                          "3fdcc99ddbd"));
     BOOST_CHECK(headerAA.hashPrevBlock == headerA.GetHash());
 
     stream = CDataStream(
         ParseHex(
             "000000206fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000"
             "000000bff4e0fd76ec3e9c8853811dec34dda8d5debb24d4113d94235fd4b24bb2"
             "92981b70995cffff001d4e6e050001020000000100000000000000000000000000"
             "00000000000000000000000000000000000000ffffffff0d51026302082f454233"
             "322e302fffffffff0100f2052a01000000232103c91f2fa16c94c92d08629eeb8f"
             "d681658d49f2b3016b13336d67d79f858dbc71ac000000001"),
         SER_NETWORK, PROTOCOL_VERSION);
     stream >> headerB;
     BOOST_CHECK(headerB.hashPrevBlock == headerG.GetHash());
 
     stream = CDataStream(
         ParseHex(
             "000000204860eb18bf1b1620e37e9490fc8a427514416fd75159ab86688e9a8300"
             "0000003800b1dd09f3f1a1c9e62ce8dca6d1e6caacc9a02d178ef6ad95527b49ff"
             "863f8282995cffff001d2cc70f0001020000000100000000000000000000000000"
             "00000000000000000000000000000000000000ffffffff0d52024902082f454233"
             "322e302fffffffff0100f2052a010000002321020a56690eb0e2454c1f362d3599"
             "89198a0b23505578be4164a65521ee7751eb1dac00000000"),
         SER_NETWORK, PROTOCOL_VERSION);
     stream >> headerAB;
     BOOST_CHECK(headerAB.hashPrevBlock == headerA.GetHash());
 
     // Headers A and AA should be accepted
     {
         BlockValidationState state;
         BOOST_CHECK(
             Assert(m_node.chainman)
                 ->ProcessNewBlockHeaders(config, {headerA}, state, &pindex));
         BOOST_CHECK(state.IsValid());
         BOOST_CHECK(pindex != nullptr);
         pindex = nullptr;
     }
 
     {
         BlockValidationState state;
         BOOST_CHECK(
             Assert(m_node.chainman)
                 ->ProcessNewBlockHeaders(config, {headerAA}, state, &pindex));
         BOOST_CHECK(state.IsValid());
         BOOST_CHECK(pindex != nullptr);
         pindex = nullptr;
     }
 
     // Header B should be rejected
     {
         BlockValidationState state;
         BOOST_CHECK(
             !Assert(m_node.chainman)
                  ->ProcessNewBlockHeaders(config, {headerB}, state, &pindex));
         BOOST_CHECK(state.IsInvalid());
         BOOST_CHECK(state.GetRejectReason() == "bad-fork-prior-to-checkpoint");
         BOOST_CHECK(pindex == nullptr);
     }
 
     // Sanity check to ensure header was not saved in memory
     {
         LOCK(cs_main);
-        BOOST_CHECK(g_chainman.m_blockman.LookupBlockIndex(headerB.GetHash()) ==
-                    nullptr);
+        BOOST_CHECK(m_node.chainman->m_blockman.LookupBlockIndex(
+                        headerB.GetHash()) == nullptr);
     }
 
     // Header AB should be rejected
     {
         BlockValidationState state;
         BOOST_CHECK(
             !Assert(m_node.chainman)
                  ->ProcessNewBlockHeaders(config, {headerAB}, state, &pindex));
         BOOST_CHECK(state.IsInvalid());
         BOOST_CHECK(state.GetRejectReason() == "checkpoint mismatch");
         BOOST_CHECK(pindex == nullptr);
     }
 
     // Sanity check to ensure header was not saved in memory
     {
         LOCK(cs_main);
-        BOOST_CHECK(g_chainman.m_blockman.LookupBlockIndex(
+        BOOST_CHECK(m_node.chainman->m_blockman.LookupBlockIndex(
                         headerAB.GetHash()) == nullptr);
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/coinstatsindex_tests.cpp b/src/test/coinstatsindex_tests.cpp
index 4e1c26064..d27028cc1 100644
--- a/src/test/coinstatsindex_tests.cpp
+++ b/src/test/coinstatsindex_tests.cpp
@@ -1,78 +1,78 @@
 // Copyright (c) 2020 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <index/coinstatsindex.h>
 #include <test/util/setup_common.h>
 #include <util/time.h>
 #include <validation.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <chrono>
 
 BOOST_AUTO_TEST_SUITE(coinstatsindex_tests)
 
 BOOST_FIXTURE_TEST_CASE(coinstatsindex_initial_sync, TestChain100Setup) {
     CoinStatsIndex coin_stats_index{1 << 20, true};
 
     CCoinsStats coin_stats{CoinStatsHashType::MUHASH};
     const CBlockIndex *block_index;
     {
         LOCK(cs_main);
-        block_index = ChainActive().Tip();
+        block_index = m_node.chainman->ActiveTip();
     }
 
     // CoinStatsIndex should not be found before it is started.
     BOOST_CHECK(!coin_stats_index.LookUpStats(block_index, coin_stats));
 
     // BlockUntilSyncedToCurrentChain should return false before CoinStatsIndex
     // is started.
     BOOST_CHECK(!coin_stats_index.BlockUntilSyncedToCurrentChain());
 
-    coin_stats_index.Start(::ChainstateActive());
+    coin_stats_index.Start(m_node.chainman->ActiveChainstate());
 
     // Allow the CoinStatsIndex to catch up with the block index that is syncing
     // in a background thread.
     const auto timeout = GetTime<std::chrono::seconds>() + 120s;
     while (!coin_stats_index.BlockUntilSyncedToCurrentChain()) {
         BOOST_REQUIRE(timeout > GetTime<std::chrono::milliseconds>());
         UninterruptibleSleep(100ms);
     }
 
     // Check that CoinStatsIndex works for genesis block.
     const CBlockIndex *genesis_block_index;
     {
         LOCK(cs_main);
-        genesis_block_index = ChainActive().Genesis();
+        genesis_block_index = m_node.chainman->ActiveChain().Genesis();
     }
     BOOST_CHECK(coin_stats_index.LookUpStats(genesis_block_index, coin_stats));
 
     // Check that CoinStatsIndex updates with new blocks.
     coin_stats_index.LookUpStats(block_index, coin_stats);
 
     const CScript script_pub_key{
         CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG};
     std::vector<CMutableTransaction> noTxns;
     CreateAndProcessBlock(noTxns, script_pub_key);
 
     // Let the CoinStatsIndex to catch up again.
     BOOST_CHECK(coin_stats_index.BlockUntilSyncedToCurrentChain());
 
     CCoinsStats new_coin_stats{CoinStatsHashType::MUHASH};
     const CBlockIndex *new_block_index;
     {
         LOCK(cs_main);
-        new_block_index = ChainActive().Tip();
+        new_block_index = m_node.chainman->ActiveTip();
     }
     coin_stats_index.LookUpStats(new_block_index, new_coin_stats);
 
     BOOST_CHECK(block_index != new_block_index);
 
     // Shutdown sequence (c.f. Shutdown() in init.cpp)
     coin_stats_index.Stop();
 
     // Rest of shutdown sequence and destructors happen in ~TestingSetup()
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/denialofservice_tests.cpp b/src/test/denialofservice_tests.cpp
index f45407221..bd156fa33 100644
--- a/src/test/denialofservice_tests.cpp
+++ b/src/test/denialofservice_tests.cpp
@@ -1,433 +1,433 @@
 // Copyright (c) 2011-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 // Unit tests for denial-of-service detection/prevention code
 
 #include <banman.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <config.h>
 #include <net.h>
 #include <net_processing.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
 #include <script/standard.h>
 #include <serialize.h>
 #include <txorphanage.h>
 #include <util/system.h>
 #include <util/time.h>
 #include <validation.h>
 
 #include <test/util/net.h>
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <cstdint>
 
 namespace {
 struct CConnmanTest : public CConnman {
     using CConnman::CConnman;
     void AddNode(CNode &node) {
         LOCK(cs_vNodes);
         vNodes.push_back(&node);
     }
     void ClearNodes() {
         LOCK(cs_vNodes);
         for (CNode *node : vNodes) {
             delete node;
         }
         vNodes.clear();
     }
 };
 } // namespace
 
 static CService ip(uint32_t i) {
     struct in_addr s;
     s.s_addr = i;
     return CService(CNetAddr(s), Params().GetDefaultPort());
 }
 
 static NodeId id = 0;
 
 void UpdateLastBlockAnnounceTime(NodeId node, int64_t time_in_seconds);
 
 BOOST_FIXTURE_TEST_SUITE(denialofservice_tests, TestingSetup)
 
 // Test eviction of an outbound peer whose chain never advances
 // Mock a node connection, and use mocktime to simulate a peer which never sends
 // any headers messages. PeerLogic should decide to evict that outbound peer,
 // after the appropriate timeouts.
 // Note that we protect 4 outbound nodes from being subject to this logic; this
 // test takes advantage of that protection only being applied to nodes which
 // send headers with sufficient work.
 BOOST_AUTO_TEST_CASE(outbound_slow_chain_eviction) {
     const Config &config = GetConfig();
 
     auto connman = std::make_unique<CConnman>(config, 0x1337, 0x1337);
     // Disable inactivity checks for this test to avoid interference
     static_cast<ConnmanTestMsg *>(connman.get())->SetPeerConnectTimeout(99999s);
     auto peerLogic = PeerManager::make(
         config.GetChainParams(), *connman, nullptr, *m_node.scheduler,
         *m_node.chainman, *m_node.mempool, false);
 
     // Mock an outbound peer
     CAddress addr1(ip(0xa0b0c001), NODE_NONE);
     CNode dummyNode1(id++, ServiceFlags(NODE_NETWORK), INVALID_SOCKET, addr1,
                      /* nKeyedNetGroupIn */ 0, /* nLocalHostNonceIn */ 0,
                      /* nLocalExtraEntropyIn */ 0, CAddress(), /* pszDest */ "",
                      ConnectionType::OUTBOUND_FULL_RELAY,
                      /* inbound_onion */ false);
     dummyNode1.SetCommonVersion(PROTOCOL_VERSION);
 
     peerLogic->InitializeNode(config, &dummyNode1);
     dummyNode1.fSuccessfullyConnected = true;
 
     // This test requires that we have a chain with non-zero work.
     {
         LOCK(cs_main);
-        BOOST_CHECK(::ChainActive().Tip() != nullptr);
-        BOOST_CHECK(::ChainActive().Tip()->nChainWork > 0);
+        BOOST_CHECK(m_node.chainman->ActiveTip() != nullptr);
+        BOOST_CHECK(m_node.chainman->ActiveTip()->nChainWork > 0);
     }
 
     // Test starts here
     {
         LOCK(dummyNode1.cs_sendProcessing);
         // should result in getheaders
         BOOST_CHECK(peerLogic->SendMessages(config, &dummyNode1));
     }
     {
         LOCK(dummyNode1.cs_vSend);
         BOOST_CHECK(dummyNode1.vSendMsg.size() > 0);
         dummyNode1.vSendMsg.clear();
     }
 
     int64_t nStartTime = GetTime();
     // Wait 21 minutes
     SetMockTime(nStartTime + 21 * 60);
     {
         LOCK(dummyNode1.cs_sendProcessing);
         // should result in getheaders
         BOOST_CHECK(peerLogic->SendMessages(config, &dummyNode1));
     }
     {
         LOCK(dummyNode1.cs_vSend);
         BOOST_CHECK(dummyNode1.vSendMsg.size() > 0);
     }
     // Wait 3 more minutes
     SetMockTime(nStartTime + 24 * 60);
     {
         LOCK(dummyNode1.cs_sendProcessing);
         // should result in disconnect
         BOOST_CHECK(peerLogic->SendMessages(config, &dummyNode1));
     }
     BOOST_CHECK(dummyNode1.fDisconnect == true);
     SetMockTime(0);
 
     bool dummy;
     peerLogic->FinalizeNode(config, dummyNode1, dummy);
 }
 
 static void AddRandomOutboundPeer(const Config &config,
                                   std::vector<CNode *> &vNodes,
                                   PeerManager &peerLogic,
                                   CConnmanTest *connman) {
     CAddress addr(ip(g_insecure_rand_ctx.randbits(32)), NODE_NONE);
     vNodes.emplace_back(
         new CNode(id++, ServiceFlags(NODE_NETWORK), INVALID_SOCKET, addr,
                   /* nKeyedNetGroupIn */ 0,
                   /* nLocalHostNonceIn */ 0,
                   /* nLocalExtraEntropyIn */ 0, CAddress(),
                   /* pszDest */ "", ConnectionType::OUTBOUND_FULL_RELAY,
                   /* inbound_onion */ false));
     CNode &node = *vNodes.back();
     node.SetCommonVersion(PROTOCOL_VERSION);
 
     peerLogic.InitializeNode(config, &node);
     node.fSuccessfullyConnected = true;
 
     connman->AddNode(node);
 }
 
 BOOST_AUTO_TEST_CASE(stale_tip_peer_management) {
     const Config &config = GetConfig();
 
     auto connman = std::make_unique<CConnmanTest>(config, 0x1337, 0x1337);
     auto peerLogic = PeerManager::make(
         config.GetChainParams(), *connman, nullptr, *m_node.scheduler,
         *m_node.chainman, *m_node.mempool, false);
 
     const Consensus::Params &consensusParams =
         config.GetChainParams().GetConsensus();
     constexpr int max_outbound_full_relay = MAX_OUTBOUND_FULL_RELAY_CONNECTIONS;
     CConnman::Options options;
     options.nMaxConnections = DEFAULT_MAX_PEER_CONNECTIONS;
     options.m_max_outbound_full_relay = max_outbound_full_relay;
     options.nMaxFeeler = MAX_FEELER_CONNECTIONS;
 
     const auto time_init{GetTime<std::chrono::seconds>()};
     SetMockTime(time_init.count());
     const auto time_later{
         time_init +
         3 * std::chrono::seconds{consensusParams.nPowTargetSpacing} + 1s};
     connman->Init(options);
     std::vector<CNode *> vNodes;
 
     // Mock some outbound peers
     for (int i = 0; i < max_outbound_full_relay; ++i) {
         AddRandomOutboundPeer(config, vNodes, *peerLogic, connman.get());
     }
 
     peerLogic->CheckForStaleTipAndEvictPeers();
 
     // No nodes should be marked for disconnection while we have no extra peers
     for (const CNode *node : vNodes) {
         BOOST_CHECK(node->fDisconnect == false);
     }
 
     SetMockTime(time_later.count());
 
     // Now tip should definitely be stale, and we should look for an extra
     // outbound peer
     peerLogic->CheckForStaleTipAndEvictPeers();
     BOOST_CHECK(connman->GetTryNewOutboundPeer());
 
     // Still no peers should be marked for disconnection
     for (const CNode *node : vNodes) {
         BOOST_CHECK(node->fDisconnect == false);
     }
 
     // If we add one more peer, something should get marked for eviction
     // on the next check (since we're mocking the time to be in the future, the
     // required time connected check should be satisfied).
     SetMockTime(time_init.count());
     AddRandomOutboundPeer(config, vNodes, *peerLogic, connman.get());
     SetMockTime(time_later.count());
 
     peerLogic->CheckForStaleTipAndEvictPeers();
     for (int i = 0; i < max_outbound_full_relay; ++i) {
         BOOST_CHECK(vNodes[i]->fDisconnect == false);
     }
     // Last added node should get marked for eviction
     BOOST_CHECK(vNodes.back()->fDisconnect == true);
 
     vNodes.back()->fDisconnect = false;
 
     // Update the last announced block time for the last
     // peer, and check that the next newest node gets evicted.
     UpdateLastBlockAnnounceTime(vNodes.back()->GetId(), GetTime());
 
     peerLogic->CheckForStaleTipAndEvictPeers();
     for (int i = 0; i < max_outbound_full_relay - 1; ++i) {
         BOOST_CHECK(vNodes[i]->fDisconnect == false);
     }
     BOOST_CHECK(vNodes[max_outbound_full_relay - 1]->fDisconnect == true);
     BOOST_CHECK(vNodes.back()->fDisconnect == false);
 
     bool dummy;
     for (const CNode *node : vNodes) {
         peerLogic->FinalizeNode(config, *node, dummy);
     }
 
     connman->ClearNodes();
 }
 
 BOOST_AUTO_TEST_CASE(peer_discouragement) {
     const Config &config = GetConfig();
 
     auto banman = std::make_unique<BanMan>(
         m_args.GetDataDirPath() / "banlist.dat", config.GetChainParams(),
         nullptr, DEFAULT_MISBEHAVING_BANTIME);
     auto connman = std::make_unique<CConnman>(config, 0x1337, 0x1337);
     auto peerLogic = PeerManager::make(
         config.GetChainParams(), *connman, banman.get(), *m_node.scheduler,
         *m_node.chainman, *m_node.mempool, false);
 
     banman->ClearBanned();
     CAddress addr1(ip(0xa0b0c001), NODE_NONE);
     CNode dummyNode1(id++, NODE_NETWORK, INVALID_SOCKET, addr1,
                      /* nKeyedNetGroupIn */ 0, /* nLocalHostNonceIn */ 0,
                      /* nLocalExtraEntropyIn */ 0, CAddress(), /* pszDest */ "",
                      ConnectionType::INBOUND, /* inbound_onion */ false);
     dummyNode1.SetCommonVersion(PROTOCOL_VERSION);
     peerLogic->InitializeNode(config, &dummyNode1);
     dummyNode1.fSuccessfullyConnected = true;
     // Should be discouraged
     peerLogic->Misbehaving(dummyNode1.GetId(), DISCOURAGEMENT_THRESHOLD,
                            /* message */ "");
     {
         LOCK(dummyNode1.cs_sendProcessing);
         BOOST_CHECK(peerLogic->SendMessages(config, &dummyNode1));
     }
     BOOST_CHECK(banman->IsDiscouraged(addr1));
     // Different IP, not discouraged
     BOOST_CHECK(!banman->IsDiscouraged(ip(0xa0b0c001 | 0x0000ff00)));
 
     CAddress addr2(ip(0xa0b0c002), NODE_NONE);
     CNode dummyNode2(id++, NODE_NETWORK, INVALID_SOCKET, addr2,
                      /* nKeyedNetGroupIn */ 1, /* nLocalHostNonceIn */ 1,
                      /* nLocalExtraEntropyIn */ 1, CAddress(),
                      /* pszDest */ "", ConnectionType::INBOUND,
                      /* inbound_onion */ false);
     dummyNode2.SetCommonVersion(PROTOCOL_VERSION);
     peerLogic->InitializeNode(config, &dummyNode2);
     dummyNode2.fSuccessfullyConnected = true;
     peerLogic->Misbehaving(dummyNode2.GetId(), DISCOURAGEMENT_THRESHOLD - 1,
                            /* message */ "");
     {
         LOCK(dummyNode2.cs_sendProcessing);
         BOOST_CHECK(peerLogic->SendMessages(config, &dummyNode2));
     }
     // 2 not discouraged yet...
     BOOST_CHECK(!banman->IsDiscouraged(addr2));
     // ... but 1 still should be
     BOOST_CHECK(banman->IsDiscouraged(addr1));
     // 2 reaches discouragement threshold
     peerLogic->Misbehaving(dummyNode2.GetId(), 1, /* message */ "");
     {
         LOCK(dummyNode2.cs_sendProcessing);
         BOOST_CHECK(peerLogic->SendMessages(config, &dummyNode2));
     }
     BOOST_CHECK(banman->IsDiscouraged(addr1)); // Expect both 1 and 2
     BOOST_CHECK(banman->IsDiscouraged(addr2)); // to be discouraged now
 
     bool dummy;
     peerLogic->FinalizeNode(config, dummyNode1, dummy);
     peerLogic->FinalizeNode(config, dummyNode2, dummy);
 }
 
 BOOST_AUTO_TEST_CASE(DoS_bantime) {
     const Config &config = GetConfig();
 
     auto banman = std::make_unique<BanMan>(
         m_args.GetDataDirPath() / "banlist.dat", config.GetChainParams(),
         nullptr, DEFAULT_MISBEHAVING_BANTIME);
     auto connman = std::make_unique<CConnman>(config, 0x1337, 0x1337);
     auto peerLogic = PeerManager::make(
         config.GetChainParams(), *connman, banman.get(), *m_node.scheduler,
         *m_node.chainman, *m_node.mempool, false);
 
     banman->ClearBanned();
     int64_t nStartTime = GetTime();
     // Overrides future calls to GetTime()
     SetMockTime(nStartTime);
 
     CAddress addr(ip(0xa0b0c001), NODE_NONE);
     CNode dummyNode(id++, NODE_NETWORK, INVALID_SOCKET, addr,
                     /* nKeyedNetGroupIn */ 4, /* nLocalHostNonceIn */ 4,
                     /* nLocalExtraEntropyIn */ 4, CAddress(), /* pszDest */ "",
                     ConnectionType::INBOUND, /* inbound_onion */ false);
     dummyNode.SetCommonVersion(PROTOCOL_VERSION);
     peerLogic->InitializeNode(config, &dummyNode);
     dummyNode.fSuccessfullyConnected = true;
 
     peerLogic->Misbehaving(dummyNode.GetId(), DISCOURAGEMENT_THRESHOLD,
                            /* message */ "");
     {
         LOCK(dummyNode.cs_sendProcessing);
         BOOST_CHECK(peerLogic->SendMessages(config, &dummyNode));
     }
     BOOST_CHECK(banman->IsDiscouraged(addr));
 
     bool dummy;
     peerLogic->FinalizeNode(config, dummyNode, dummy);
 }
 
 class TxOrphanageTest : public TxOrphanage {
 public:
     inline size_t CountOrphans() const EXCLUSIVE_LOCKS_REQUIRED(g_cs_orphans) {
         return m_orphans.size();
     }
 
     CTransactionRef RandomOrphan() EXCLUSIVE_LOCKS_REQUIRED(g_cs_orphans) {
         std::map<TxId, OrphanTx>::iterator it;
         it = m_orphans.lower_bound(TxId{InsecureRand256()});
         if (it == m_orphans.end()) {
             it = m_orphans.begin();
         }
         return it->second.tx;
     }
 };
 
 BOOST_AUTO_TEST_CASE(DoS_mapOrphans) {
     TxOrphanageTest orphanage;
     CKey key;
     key.MakeNewKey(true);
     FillableSigningProvider keystore;
     BOOST_CHECK(keystore.AddKey(key));
 
     LOCK(g_cs_orphans);
 
     // 50 orphan transactions:
     for (int i = 0; i < 50; i++) {
         CMutableTransaction tx;
         tx.vin.resize(1);
         tx.vin[0].prevout = COutPoint(TxId(InsecureRand256()), 0);
         tx.vin[0].scriptSig << OP_1;
         tx.vout.resize(1);
         tx.vout[0].nValue = 1 * CENT;
         tx.vout[0].scriptPubKey =
             GetScriptForDestination(PKHash(key.GetPubKey()));
 
         orphanage.AddTx(MakeTransactionRef(tx), i);
     }
 
     // ... and 50 that depend on other orphans:
     for (int i = 0; i < 50; i++) {
         CTransactionRef txPrev = orphanage.RandomOrphan();
 
         CMutableTransaction tx;
         tx.vin.resize(1);
         tx.vin[0].prevout = COutPoint(txPrev->GetId(), 0);
         tx.vout.resize(1);
         tx.vout[0].nValue = 1 * CENT;
         tx.vout[0].scriptPubKey =
             GetScriptForDestination(PKHash(key.GetPubKey()));
         BOOST_CHECK(SignSignature(keystore, *txPrev, tx, 0,
                                   SigHashType().withForkId()));
 
         orphanage.AddTx(MakeTransactionRef(tx), i);
     }
 
     // This really-big orphan should be ignored:
     for (int i = 0; i < 10; i++) {
         CTransactionRef txPrev = orphanage.RandomOrphan();
 
         CMutableTransaction tx;
         tx.vout.resize(1);
         tx.vout[0].nValue = 1 * CENT;
         tx.vout[0].scriptPubKey =
             GetScriptForDestination(PKHash(key.GetPubKey()));
         tx.vin.resize(2777);
         for (size_t j = 0; j < tx.vin.size(); j++) {
             tx.vin[j].prevout = COutPoint(txPrev->GetId(), j);
         }
         BOOST_CHECK(SignSignature(keystore, *txPrev, tx, 0,
                                   SigHashType().withForkId()));
         // Re-use same signature for other inputs
         // (they don't have to be valid for this test)
         for (unsigned int j = 1; j < tx.vin.size(); j++) {
             tx.vin[j].scriptSig = tx.vin[0].scriptSig;
         }
 
         BOOST_CHECK(!orphanage.AddTx(MakeTransactionRef(tx), i));
     }
 
     // Test EraseOrphansFor:
     for (NodeId i = 0; i < 3; i++) {
         size_t sizeBefore = orphanage.CountOrphans();
         orphanage.EraseForPeer(i);
         BOOST_CHECK(orphanage.CountOrphans() < sizeBefore);
     }
 
     // Test LimitOrphanTxSize() function:
     orphanage.LimitOrphans(40);
     BOOST_CHECK(orphanage.CountOrphans() <= 40);
     orphanage.LimitOrphans(10);
     BOOST_CHECK(orphanage.CountOrphans() <= 10);
     orphanage.LimitOrphans(0);
     BOOST_CHECK(orphanage.CountOrphans() == 0);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/finalization_tests.cpp b/src/test/finalization_tests.cpp
index 86c4109b2..28c18494b 100644
--- a/src/test/finalization_tests.cpp
+++ b/src/test/finalization_tests.cpp
@@ -1,96 +1,101 @@
 // Copyright (c) 2018-2019 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chain.h>
 #include <chainparams.h>
 #include <config.h>
 #include <util/time.h>
 #include <validation.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_FIXTURE_TEST_SUITE(finalization_tests, TestChain100Setup)
 
 BOOST_AUTO_TEST_CASE(finalizationDelay) {
     CScript p2pk_scriptPubKey =
         CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
     CBlock block;
 
     {
         LOCK(cs_main);
         // We should have no finalized block because the 100 blocks generated by
         // the test setup are too close to "now";
-        BOOST_CHECK_MESSAGE(::ChainstateActive().GetFinalizedBlock() == nullptr,
-                            "No block finalized (tip at height "
-                                << ::ChainActive().Tip()->nHeight << ")");
+        BOOST_CHECK_MESSAGE(
+            m_node.chainman->ActiveChainstate().GetFinalizedBlock() == nullptr,
+            "No block finalized (tip at height "
+                << m_node.chainman->ActiveHeight() << ")");
     }
 
     // Create maxreorgdepth blocks. Auto-finalization will not occur because
     // the delay is not expired
     int64_t mockedTime = GetTime();
     for (uint32_t i = 0; i < DEFAULT_MAX_REORG_DEPTH; i++) {
         block = CreateAndProcessBlock({}, p2pk_scriptPubKey);
         LOCK(cs_main);
         // These blocks are too recent.
-        BOOST_CHECK_MESSAGE(::ChainstateActive().GetFinalizedBlock() == nullptr,
-                            "No block finalized (tip at height "
-                                << ::ChainActive().Tip()->nHeight << ")");
+        BOOST_CHECK_MESSAGE(
+            m_node.chainman->ActiveChainstate().GetFinalizedBlock() == nullptr,
+            "No block finalized (tip at height "
+                << m_node.chainman->ActiveHeight() << ")");
     }
 
     // Make the finalization time to expire
     mockedTime += DEFAULT_MIN_FINALIZATION_DELAY + 1;
     SetMockTime(mockedTime);
 
     // Next maxreorgdepth blocks should cause auto-finalization
-    CBlockIndex *blockToFinalize = ::ChainActive().Tip()->GetAncestor(
-        ::ChainActive().Tip()->nHeight - DEFAULT_MAX_REORG_DEPTH);
+    CBlockIndex *blockToFinalize = m_node.chainman->ActiveTip()->GetAncestor(
+        m_node.chainman->ActiveHeight() - DEFAULT_MAX_REORG_DEPTH);
 
     for (uint32_t i = 0; i < DEFAULT_MAX_REORG_DEPTH; i++) {
-        blockToFinalize = ::ChainActive().Next(blockToFinalize);
+        blockToFinalize = m_node.chainman->ActiveChain().Next(blockToFinalize);
         block = CreateAndProcessBlock({}, p2pk_scriptPubKey);
         LOCK(cs_main);
         BOOST_CHECK_MESSAGE(
-            ::ChainstateActive().GetFinalizedBlock() == blockToFinalize,
+            m_node.chainman->ActiveChainstate().GetFinalizedBlock() ==
+                blockToFinalize,
             "Block finalized at height "
                 << blockToFinalize->nHeight << " (tip at height "
-                << ::ChainActive().Tip()->nHeight << ")");
+                << m_node.chainman->ActiveHeight() << ")");
     }
 
     // Next blocks won't cause auto-finalization because the delay is not
     // expired
     for (uint32_t i = 0; i < DEFAULT_MAX_REORG_DEPTH; i++) {
         block = CreateAndProcessBlock({}, p2pk_scriptPubKey);
         LOCK(cs_main);
         // These blocks are finalized.
         BOOST_CHECK_MESSAGE(
-            ::ChainstateActive().GetFinalizedBlock() == blockToFinalize,
+            m_node.chainman->ActiveChainstate().GetFinalizedBlock() ==
+                blockToFinalize,
             "Finalized block remains unchanged at height "
                 << blockToFinalize->nHeight << " (tip at height "
-                << ::ChainActive().Tip()->nHeight << ")");
+                << m_node.chainman->ActiveHeight() << ")");
     }
 
     // Make the finalization time to expire
     mockedTime += DEFAULT_MIN_FINALIZATION_DELAY + 1;
     SetMockTime(mockedTime);
 
-    blockToFinalize = ::ChainActive().Tip()->GetAncestor(
-        ::ChainActive().Tip()->nHeight - DEFAULT_MAX_REORG_DEPTH);
+    blockToFinalize = m_node.chainman->ActiveTip()->GetAncestor(
+        m_node.chainman->ActiveHeight() - DEFAULT_MAX_REORG_DEPTH);
 
     // Create some more blocks.
     // Finalization should start moving again.
     for (uint32_t i = 0; i < DEFAULT_MAX_REORG_DEPTH; i++) {
-        blockToFinalize = ::ChainActive().Next(blockToFinalize);
+        blockToFinalize = m_node.chainman->ActiveChain().Next(blockToFinalize);
         block = CreateAndProcessBlock({}, p2pk_scriptPubKey);
         LOCK(cs_main);
         BOOST_CHECK_MESSAGE(
-            ::ChainstateActive().GetFinalizedBlock() == blockToFinalize,
+            m_node.chainman->ActiveChainstate().GetFinalizedBlock() ==
+                blockToFinalize,
             "Block finalized at height "
                 << blockToFinalize->nHeight << " (tip at height "
-                << ::ChainActive().Tip()->nHeight << ")");
+                << m_node.chainman->ActiveHeight() << ")");
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/interfaces_tests.cpp b/src/test/interfaces_tests.cpp
index ccf15f1f0..04891311c 100644
--- a/src/test/interfaces_tests.cpp
+++ b/src/test/interfaces_tests.cpp
@@ -1,186 +1,187 @@
 // Copyright (c) 2020 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chainparams.h>
 #include <config.h>
 #include <consensus/validation.h>
 #include <interfaces/chain.h>
 #include <script/standard.h>
 #include <test/util/setup_common.h>
 #include <validation.h>
 
 #include <boost/test/unit_test.hpp>
 
 using interfaces::FoundBlock;
 
 BOOST_FIXTURE_TEST_SUITE(interfaces_tests, TestChain100Setup)
 
 BOOST_AUTO_TEST_CASE(findBlock) {
     auto &chain = m_node.chain;
     const CChain &active = Assert(m_node.chainman)->ActiveChain();
 
     BlockHash hash;
     BOOST_CHECK(
         chain->findBlock(active[10]->GetBlockHash(), FoundBlock().hash(hash)));
     BOOST_CHECK_EQUAL(hash, active[10]->GetBlockHash());
 
     int height = -1;
     BOOST_CHECK(chain->findBlock(active[20]->GetBlockHash(),
                                  FoundBlock().height(height)));
     BOOST_CHECK_EQUAL(height, active[20]->nHeight);
 
     CBlock data;
     BOOST_CHECK(
         chain->findBlock(active[30]->GetBlockHash(), FoundBlock().data(data)));
     BOOST_CHECK_EQUAL(data.GetHash(), active[30]->GetBlockHash());
 
     int64_t time = -1;
     BOOST_CHECK(
         chain->findBlock(active[40]->GetBlockHash(), FoundBlock().time(time)));
     BOOST_CHECK_EQUAL(time, active[40]->GetBlockTime());
 
     int64_t max_time = -1;
     BOOST_CHECK(chain->findBlock(active[50]->GetBlockHash(),
                                  FoundBlock().maxTime(max_time)));
     BOOST_CHECK_EQUAL(max_time, active[50]->GetBlockTimeMax());
 
     int64_t mtp_time = -1;
     BOOST_CHECK(chain->findBlock(active[60]->GetBlockHash(),
                                  FoundBlock().mtpTime(mtp_time)));
     BOOST_CHECK_EQUAL(mtp_time, active[60]->GetMedianTimePast());
 
     bool cur_active{false}, next_active{false};
     BlockHash next_hash;
     BOOST_CHECK_EQUAL(active.Height(), 100);
     BOOST_CHECK(chain->findBlock(
         active[99]->GetBlockHash(),
         FoundBlock()
             .inActiveChain(cur_active)
             .nextBlock(
                 FoundBlock().inActiveChain(next_active).hash(next_hash))));
     BOOST_CHECK(cur_active);
     BOOST_CHECK(next_active);
     BOOST_CHECK_EQUAL(next_hash, active[100]->GetBlockHash());
     cur_active = next_active = false;
     BOOST_CHECK(chain->findBlock(
         active[100]->GetBlockHash(),
         FoundBlock()
             .inActiveChain(cur_active)
             .nextBlock(FoundBlock().inActiveChain(next_active))));
     BOOST_CHECK(cur_active);
     BOOST_CHECK(!next_active);
 
     BOOST_CHECK(!chain->findBlock(BlockHash(), FoundBlock()));
 }
 
 BOOST_AUTO_TEST_CASE(findFirstBlockWithTimeAndHeight) {
     auto &chain = m_node.chain;
     const CChain &active = Assert(m_node.chainman)->ActiveChain();
     BlockHash hash;
     int height;
     BOOST_CHECK(chain->findFirstBlockWithTimeAndHeight(
         /* min_time= */ 0, /* min_height= */ 5,
         FoundBlock().hash(hash).height(height)));
     BOOST_CHECK_EQUAL(hash, active[5]->GetBlockHash());
     BOOST_CHECK_EQUAL(height, 5);
     BOOST_CHECK(!chain->findFirstBlockWithTimeAndHeight(
         /* min_time= */ active.Tip()->GetBlockTimeMax() + 1,
         /* min_height= */ 0));
 }
 
 BOOST_AUTO_TEST_CASE(findAncestorByHeight) {
     auto &chain = m_node.chain;
     const CChain &active = Assert(m_node.chainman)->ActiveChain();
     BlockHash hash;
     BOOST_CHECK(chain->findAncestorByHeight(active[20]->GetBlockHash(), 10,
                                             FoundBlock().hash(hash)));
     BOOST_CHECK_EQUAL(hash, active[10]->GetBlockHash());
     BOOST_CHECK(!chain->findAncestorByHeight(active[10]->GetBlockHash(), 20));
 }
 
 BOOST_AUTO_TEST_CASE(findAncestorByHash) {
     auto &chain = m_node.chain;
     const CChain &active = Assert(m_node.chainman)->ActiveChain();
     int height = -1;
     BOOST_CHECK(chain->findAncestorByHash(active[20]->GetBlockHash(),
                                           active[10]->GetBlockHash(),
                                           FoundBlock().height(height)));
     BOOST_CHECK_EQUAL(height, 10);
     BOOST_CHECK(!chain->findAncestorByHash(active[10]->GetBlockHash(),
                                            active[20]->GetBlockHash()));
 }
 
 BOOST_AUTO_TEST_CASE(findCommonAncestor) {
     auto &chain = m_node.chain;
     const CChain &active = Assert(m_node.chainman)->ActiveChain();
     auto *orig_tip = active.Tip();
     for (int i = 0; i < 10; ++i) {
         BlockValidationState state;
-        ChainstateActive().InvalidateBlock(GetConfig(), state, active.Tip());
+        m_node.chainman->ActiveChainstate().InvalidateBlock(GetConfig(), state,
+                                                            active.Tip());
     }
     BOOST_CHECK_EQUAL(active.Height(), orig_tip->nHeight - 10);
     coinbaseKey.MakeNewKey(true);
     for (int i = 0; i < 20; ++i) {
         CreateAndProcessBlock({},
                               GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
     }
     BOOST_CHECK_EQUAL(active.Height(), orig_tip->nHeight + 10);
     BlockHash fork_hash;
     int fork_height;
     int orig_height;
     BOOST_CHECK(chain->findCommonAncestor(
         orig_tip->GetBlockHash(), active.Tip()->GetBlockHash(),
         FoundBlock().height(fork_height).hash(fork_hash),
         FoundBlock().height(orig_height)));
     BOOST_CHECK_EQUAL(orig_height, orig_tip->nHeight);
     BOOST_CHECK_EQUAL(fork_height, orig_tip->nHeight - 10);
     BOOST_CHECK_EQUAL(fork_hash, active[fork_height]->GetBlockHash());
 
     BlockHash active_hash, orig_hash;
     BOOST_CHECK(!chain->findCommonAncestor(active.Tip()->GetBlockHash(),
                                            BlockHash(), {},
                                            FoundBlock().hash(active_hash), {}));
     BOOST_CHECK(!chain->findCommonAncestor(BlockHash(),
                                            orig_tip->GetBlockHash(), {}, {},
                                            FoundBlock().hash(orig_hash)));
     BOOST_CHECK_EQUAL(active_hash, active.Tip()->GetBlockHash());
     BOOST_CHECK_EQUAL(orig_hash, orig_tip->GetBlockHash());
 }
 
 BOOST_AUTO_TEST_CASE(hasBlocks) {
     auto &chain = m_node.chain;
     const CChain &active = Assert(m_node.chainman)->ActiveChain();
 
     // Test ranges
     BOOST_CHECK(chain->hasBlocks(active.Tip()->GetBlockHash(), 10, 90));
     BOOST_CHECK(chain->hasBlocks(active.Tip()->GetBlockHash(), 10, {}));
     BOOST_CHECK(chain->hasBlocks(active.Tip()->GetBlockHash(), 0, 90));
     BOOST_CHECK(chain->hasBlocks(active.Tip()->GetBlockHash(), 0, {}));
     BOOST_CHECK(chain->hasBlocks(active.Tip()->GetBlockHash(), -1000, 1000));
     active[5]->nStatus = active[5]->nStatus.withData(false);
     BOOST_CHECK(chain->hasBlocks(active.Tip()->GetBlockHash(), 10, 90));
     BOOST_CHECK(chain->hasBlocks(active.Tip()->GetBlockHash(), 10, {}));
     BOOST_CHECK(!chain->hasBlocks(active.Tip()->GetBlockHash(), 0, 90));
     BOOST_CHECK(!chain->hasBlocks(active.Tip()->GetBlockHash(), 0, {}));
     BOOST_CHECK(!chain->hasBlocks(active.Tip()->GetBlockHash(), -1000, 1000));
     active[95]->nStatus = active[95]->nStatus.withData(false);
     BOOST_CHECK(chain->hasBlocks(active.Tip()->GetBlockHash(), 10, 90));
     BOOST_CHECK(!chain->hasBlocks(active.Tip()->GetBlockHash(), 10, {}));
     BOOST_CHECK(!chain->hasBlocks(active.Tip()->GetBlockHash(), 0, 90));
     BOOST_CHECK(!chain->hasBlocks(active.Tip()->GetBlockHash(), 0, {}));
     BOOST_CHECK(!chain->hasBlocks(active.Tip()->GetBlockHash(), -1000, 1000));
     active[50]->nStatus = active[50]->nStatus.withData(false);
     BOOST_CHECK(!chain->hasBlocks(active.Tip()->GetBlockHash(), 10, 90));
     BOOST_CHECK(!chain->hasBlocks(active.Tip()->GetBlockHash(), 10, {}));
     BOOST_CHECK(!chain->hasBlocks(active.Tip()->GetBlockHash(), 0, 90));
     BOOST_CHECK(!chain->hasBlocks(active.Tip()->GetBlockHash(), 0, {}));
     BOOST_CHECK(!chain->hasBlocks(active.Tip()->GetBlockHash(), -1000, 1000));
 
     // Test edge cases
     BOOST_CHECK(chain->hasBlocks(active.Tip()->GetBlockHash(), 6, 49));
     BOOST_CHECK(!chain->hasBlocks(active.Tip()->GetBlockHash(), 5, 49));
     BOOST_CHECK(!chain->hasBlocks(active.Tip()->GetBlockHash(), 6, 50));
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/miner_tests.cpp b/src/test/miner_tests.cpp
index 268d811c5..d798ed29d 100644
--- a/src/test/miner_tests.cpp
+++ b/src/test/miner_tests.cpp
@@ -1,759 +1,773 @@
 // Copyright (c) 2011-2019 The Bitcoin Core developers
 // Copyright (c) 2017-2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <miner.h>
 
 #include <chain.h>
 #include <chainparams.h>
 #include <coins.h>
 #include <config.h>
 #include <consensus/consensus.h>
 #include <consensus/merkle.h>
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
 #include <policy/policy.h>
 #include <script/standard.h>
 #include <txmempool.h>
 #include <uint256.h>
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <util/system.h>
 #include <util/time.h>
 #include <validation.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <memory>
 
 namespace miner_tests {
 struct MinerTestingSetup : public TestingSetup {
     void TestPackageSelection(const CChainParams &chainparams,
                               const CScript &scriptPubKey,
                               const std::vector<CTransactionRef> &txFirst)
         EXCLUSIVE_LOCKS_REQUIRED(::cs_main, m_node.mempool->cs);
     bool TestSequenceLocks(const CTransaction &tx, int flags)
         EXCLUSIVE_LOCKS_REQUIRED(::cs_main, m_node.mempool->cs) {
-        return CheckSequenceLocks(::ChainstateActive(), *m_node.mempool, tx,
-                                  flags);
+        return CheckSequenceLocks(m_node.chainman->ActiveChainstate(),
+                                  *m_node.mempool, tx, flags);
     }
     BlockAssembler AssemblerForTest(const CChainParams &params);
 };
 } // namespace miner_tests
 
 BOOST_FIXTURE_TEST_SUITE(miner_tests, MinerTestingSetup)
 
 static CFeeRate blockMinFeeRate = CFeeRate(DEFAULT_BLOCK_MIN_TX_FEE_PER_KB);
 
 BlockAssembler MinerTestingSetup::AssemblerForTest(const CChainParams &params) {
     BlockAssembler::Options options;
     options.blockMinFeeRate = blockMinFeeRate;
-    return BlockAssembler(::ChainstateActive(), params, *m_node.mempool,
-                          options);
+    return BlockAssembler(m_node.chainman->ActiveChainstate(), params,
+                          *m_node.mempool, options);
 }
 
 constexpr static struct {
     uint8_t extranonce;
     uint32_t nonce;
 } blockinfo[] = {
     {4, 0xa4a3e223}, {2, 0x15c32f9e}, {1, 0x0375b547}, {1, 0x7004a8a5},
     {2, 0xce440296}, {2, 0x52cfe198}, {1, 0x77a72cd0}, {2, 0xbb5d6f84},
     {2, 0x83f30c2c}, {1, 0x48a73d5b}, {1, 0xef7dcd01}, {2, 0x6809c6c4},
     {2, 0x0883ab3c}, {1, 0x087bbbe2}, {2, 0x2104a814}, {2, 0xdffb6daa},
     {1, 0xee8a0a08}, {2, 0xba4237c1}, {1, 0xa70349dc}, {1, 0x344722bb},
     {3, 0xd6294733}, {2, 0xec9f5c94}, {2, 0xca2fbc28}, {1, 0x6ba4f406},
     {2, 0x015d4532}, {1, 0x6e119b7c}, {2, 0x43e8f314}, {2, 0x27962f38},
     {2, 0xb571b51b}, {2, 0xb36bee23}, {2, 0xd17924a8}, {2, 0x6bc212d9},
     {1, 0x630d4948}, {2, 0x9a4c4ebb}, {2, 0x554be537}, {1, 0xd63ddfc7},
     {2, 0xa10acc11}, {1, 0x759a8363}, {2, 0xfb73090d}, {1, 0xe82c6a34},
     {1, 0xe33e92d7}, {3, 0x658ef5cb}, {2, 0xba32ff22}, {5, 0x0227a10c},
     {1, 0xa9a70155}, {5, 0xd096d809}, {1, 0x37176174}, {1, 0x830b8d0f},
     {1, 0xc6e3910e}, {2, 0x823f3ca8}, {1, 0x99850849}, {1, 0x7521fb81},
     {1, 0xaacaabab}, {1, 0xd645a2eb}, {5, 0x7aea1781}, {5, 0x9d6e4b78},
     {1, 0x4ce90fd8}, {1, 0xabdc832d}, {6, 0x4a34f32a}, {2, 0xf2524c1c},
     {2, 0x1bbeb08a}, {1, 0xad47f480}, {1, 0x9f026aeb}, {1, 0x15a95049},
     {2, 0xd1cb95b2}, {2, 0xf84bbda5}, {1, 0x0fa62cd1}, {1, 0xe05f9169},
     {1, 0x78d194a9}, {5, 0x3e38147b}, {5, 0x737ba0d4}, {1, 0x63378e10},
     {1, 0x6d5f91cf}, {2, 0x88612eb8}, {2, 0xe9639484}, {1, 0xb7fabc9d},
     {2, 0x19b01592}, {1, 0x5a90dd31}, {2, 0x5bd7e028}, {2, 0x94d00323},
     {1, 0xa9b9c01a}, {1, 0x3a40de61}, {1, 0x56e7eec7}, {5, 0x859f7ef6},
     {1, 0xfd8e5630}, {1, 0x2b0c9f7f}, {1, 0xba700e26}, {1, 0x7170a408},
     {1, 0x70de86a8}, {1, 0x74d64cd5}, {1, 0x49e738a1}, {2, 0x6910b602},
     {0, 0x643c565f}, {1, 0x54264b3f}, {2, 0x97ea6396}, {2, 0x55174459},
     {2, 0x03e8779a}, {1, 0x98f34d8f}, {1, 0xc07b2b07}, {1, 0xdfe29668},
     {1, 0x3141c7c1}, {1, 0xb3b595f4}, {1, 0x735abf08}, {5, 0x623bfbce},
     {2, 0xd351e722}, {1, 0xf4ca48c9}, {1, 0x5b19c670}, {1, 0xa164bf0e},
     {2, 0xbbbeb305}, {2, 0xfe1c810a},
 };
 
 static CBlockIndex CreateBlockIndex(int nHeight, CBlockIndex *active_chain_tip)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     CBlockIndex index;
     index.nHeight = nHeight;
     index.pprev = active_chain_tip;
     return index;
 }
 
 // Test suite for ancestor feerate transaction selection.
 // Implemented as an additional function, rather than a separate test case,
 // to allow reusing the blockchain created in CreateNewBlock_validity.
 void MinerTestingSetup::TestPackageSelection(
     const CChainParams &chainparams, const CScript &scriptPubKey,
     const std::vector<CTransactionRef> &txFirst) {
     // Test the ancestor feerate transaction selection.
     TestMemPoolEntryHelper entry;
 
     // Test that a medium fee transaction will be selected after a higher fee
     // rate package with a low fee rate parent.
     CMutableTransaction tx;
     tx.vin.resize(1);
     tx.vin[0].scriptSig = CScript() << OP_1;
     tx.vin[0].prevout = COutPoint(txFirst[0]->GetId(), 0);
     tx.vout.resize(1);
     tx.vout[0].nValue = int64_t(5000000000LL - 1000) * SATOSHI;
     // This tx has a low fee: 1000 satoshis.
     // Save this txid for later use.
     TxId parentTxId = tx.GetId();
     m_node.mempool->addUnchecked(entry.Fee(1000 * SATOSHI)
                                      .Time(GetTime())
                                      .SpendsCoinbase(true)
                                      .FromTx(tx));
 
     // This tx has a medium fee: 10000 satoshis.
     tx.vin[0].prevout = COutPoint(txFirst[1]->GetId(), 0);
     tx.vout[0].nValue = int64_t(5000000000LL - 10000) * SATOSHI;
     TxId mediumFeeTxId = tx.GetId();
     m_node.mempool->addUnchecked(entry.Fee(10000 * SATOSHI)
                                      .Time(GetTime())
                                      .SpendsCoinbase(true)
                                      .FromTx(tx));
 
     // This tx has a high fee, but depends on the first transaction.
     tx.vin[0].prevout = COutPoint(parentTxId, 0);
     // 50k satoshi fee.
     tx.vout[0].nValue = int64_t(5000000000LL - 1000 - 50000) * SATOSHI;
     TxId highFeeTxId = tx.GetId();
     m_node.mempool->addUnchecked(entry.Fee(50000 * SATOSHI)
                                      .Time(GetTime())
                                      .SpendsCoinbase(false)
                                      .FromTx(tx));
 
     std::unique_ptr<CBlockTemplate> pblocktemplate =
         AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
     BOOST_CHECK(pblocktemplate->block.vtx[1]->GetId() == parentTxId);
     BOOST_CHECK(pblocktemplate->block.vtx[2]->GetId() == highFeeTxId);
     BOOST_CHECK(pblocktemplate->block.vtx[3]->GetId() == mediumFeeTxId);
 
     // Test that a package below the block min tx fee doesn't get included
     tx.vin[0].prevout = COutPoint(highFeeTxId, 0);
     // 0 fee.
     tx.vout[0].nValue = int64_t(5000000000LL - 1000 - 50000) * SATOSHI;
     TxId freeTxId = tx.GetId();
     m_node.mempool->addUnchecked(entry.Fee(Amount::zero()).FromTx(tx));
     size_t freeTxSize = GetSerializeSize(tx, PROTOCOL_VERSION);
 
     // Calculate a fee on child transaction that will put the package just
     // below the block min tx fee (assuming 1 child tx of the same size).
     Amount feeToUse = blockMinFeeRate.GetFee(2 * freeTxSize) - SATOSHI;
 
     tx.vin[0].prevout = COutPoint(freeTxId, 0);
     tx.vout[0].nValue =
         int64_t(5000000000LL - 1000 - 50000) * SATOSHI - feeToUse;
     TxId lowFeeTxId = tx.GetId();
     m_node.mempool->addUnchecked(entry.Fee(feeToUse).FromTx(tx));
     pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
     // Verify that the free tx and the low fee tx didn't get selected.
     for (const auto &txn : pblocktemplate->block.vtx) {
         BOOST_CHECK(txn->GetId() != freeTxId);
         BOOST_CHECK(txn->GetId() != lowFeeTxId);
     }
 
     // Test that packages above the min relay fee do get included, even if one
     // of the transactions is below the min relay fee. Remove the low fee
     // transaction and replace with a higher fee transaction
     m_node.mempool->removeRecursive(CTransaction(tx),
                                     MemPoolRemovalReason::REPLACED);
     // Now we should be just over the min relay fee.
     tx.vout[0].nValue -= 2 * SATOSHI;
     lowFeeTxId = tx.GetId();
     m_node.mempool->addUnchecked(entry.Fee(feeToUse + 2 * SATOSHI).FromTx(tx));
     pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
     BOOST_CHECK(pblocktemplate->block.vtx[4]->GetId() == freeTxId);
     BOOST_CHECK(pblocktemplate->block.vtx[5]->GetId() == lowFeeTxId);
 
     // Test that transaction selection properly updates ancestor fee
     // calculations as ancestor transactions get included in a block. Add a
     // 0-fee transaction that has 2 outputs.
     tx.vin[0].prevout = COutPoint(txFirst[2]->GetId(), 0);
     tx.vout.resize(2);
     tx.vout[0].nValue = int64_t(5000000000LL - 100000000) * SATOSHI;
     // 1BCC output.
     tx.vout[1].nValue = 100000000 * SATOSHI;
     TxId freeTxId2 = tx.GetId();
     m_node.mempool->addUnchecked(
         entry.Fee(Amount::zero()).SpendsCoinbase(true).FromTx(tx));
 
     // This tx can't be mined by itself.
     tx.vin[0].prevout = COutPoint(freeTxId2, 0);
     tx.vout.resize(1);
     feeToUse = blockMinFeeRate.GetFee(freeTxSize);
     tx.vout[0].nValue = int64_t(5000000000LL - 100000000) * SATOSHI - feeToUse;
     TxId lowFeeTxId2 = tx.GetId();
     m_node.mempool->addUnchecked(
         entry.Fee(feeToUse).SpendsCoinbase(false).FromTx(tx));
     pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
 
     // Verify that this tx isn't selected.
     for (const auto &txn : pblocktemplate->block.vtx) {
         BOOST_CHECK(txn->GetId() != freeTxId2);
         BOOST_CHECK(txn->GetId() != lowFeeTxId2);
     }
 
     // This tx will be mineable, and should cause lowFeeTxId2 to be selected as
     // well.
     tx.vin[0].prevout = COutPoint(freeTxId2, 1);
     // 10k satoshi fee.
     tx.vout[0].nValue = (100000000 - 10000) * SATOSHI;
     m_node.mempool->addUnchecked(entry.Fee(10000 * SATOSHI).FromTx(tx));
     pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
     BOOST_CHECK(pblocktemplate->block.vtx[8]->GetId() == lowFeeTxId2);
 }
 
 static void TestCoinbaseMessageEB(uint64_t eb, std::string cbmsg,
                                   const CTxMemPool &mempool,
                                   const ChainstateManager &chainman) {
     GlobalConfig config;
     config.SetMaxBlockSize(eb);
 
     CScript scriptPubKey =
         CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909"
                               "a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112"
                               "de5c384df7ba0b8d578a4c702b6bf11d5f")
                   << OP_CHECKSIG;
 
     std::unique_ptr<CBlockTemplate> pblocktemplate =
         BlockAssembler(config, chainman.ActiveChainstate(), mempool)
             .CreateNewBlock(scriptPubKey);
 
     CBlock *pblock = &pblocktemplate->block;
 
     // IncrementExtraNonce creates a valid coinbase and merkleRoot
     unsigned int extraNonce = 0;
-    CBlockIndex *active_chain_tip = chainman.ActiveChain().Tip();
+    CBlockIndex *active_chain_tip = chainman.ActiveTip();
     IncrementExtraNonce(pblock, active_chain_tip, config.GetMaxBlockSize(),
                         extraNonce);
     unsigned int nHeight = active_chain_tip->nHeight + 1;
     std::vector<uint8_t> vec(cbmsg.begin(), cbmsg.end());
     BOOST_CHECK(pblock->vtx[0]->vin[0].scriptSig ==
                 (CScript() << nHeight << CScriptNum(extraNonce) << vec));
 }
 
 // Coinbase scriptSig has to contains the correct EB value
 // converted to MB, rounded down to the first decimal
 BOOST_AUTO_TEST_CASE(CheckCoinbase_EB) {
     TestCoinbaseMessageEB(1000001, "/EB1.0/", *m_node.mempool,
                           *m_node.chainman);
     TestCoinbaseMessageEB(2000000, "/EB2.0/", *m_node.mempool,
                           *m_node.chainman);
     TestCoinbaseMessageEB(8000000, "/EB8.0/", *m_node.mempool,
                           *m_node.chainman);
     TestCoinbaseMessageEB(8320000, "/EB8.3/", *m_node.mempool,
                           *m_node.chainman);
 }
 
 // NOTE: These tests rely on CreateNewBlock doing its own self-validation!
 BOOST_AUTO_TEST_CASE(CreateNewBlock_validity) {
     // Note that by default, these tests run with size accounting enabled.
     GlobalConfig config;
     const CChainParams &chainparams = config.GetChainParams();
     CScript scriptPubKey =
         CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909"
                               "a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112"
                               "de5c384df7ba0b8d578a4c702b6bf11d5f")
                   << OP_CHECKSIG;
     std::unique_ptr<CBlockTemplate> pblocktemplate;
     CMutableTransaction tx;
     CScript script;
     TestMemPoolEntryHelper entry;
     entry.nFee = 11 * SATOSHI;
     entry.nHeight = 11;
 
     fCheckpointsEnabled = false;
 
     // Simple block creation, nothing special yet:
     BOOST_CHECK(pblocktemplate =
                     AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
 
     // We can't make transactions until we have inputs.
     // Therefore, load 110 blocks :)
     static_assert(std::size(blockinfo) == 110,
                   "Should have 110 blocks to import");
     int baseheight = 0;
     std::vector<CTransactionRef> txFirst;
     for (const auto &bi : blockinfo) {
         // pointer for convenience
         CBlock *pblock = &pblocktemplate->block;
         {
             LOCK(cs_main);
             pblock->nVersion = 1;
-            pblock->nTime = ::ChainActive().Tip()->GetMedianTimePast() + 1;
+            pblock->nTime =
+                m_node.chainman->ActiveTip()->GetMedianTimePast() + 1;
             CMutableTransaction txCoinbase(*pblock->vtx[0]);
             txCoinbase.nVersion = 1;
             txCoinbase.vin[0].scriptSig = CScript();
             txCoinbase.vin[0].scriptSig.push_back(bi.extranonce);
-            txCoinbase.vin[0].scriptSig.push_back(::ChainActive().Height());
+            txCoinbase.vin[0].scriptSig.push_back(
+                m_node.chainman->ActiveHeight());
             txCoinbase.vout.resize(1);
             txCoinbase.vout[0].scriptPubKey = CScript();
             pblock->vtx[0] = MakeTransactionRef(std::move(txCoinbase));
             if (txFirst.size() == 0) {
-                baseheight = ::ChainActive().Height();
+                baseheight = m_node.chainman->ActiveHeight();
             }
             if (txFirst.size() < 4) {
                 txFirst.push_back(pblock->vtx[0]);
             }
             pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);
             pblock->nNonce = bi.nonce;
         }
         std::shared_ptr<const CBlock> shared_pblock =
             std::make_shared<const CBlock>(*pblock);
         BOOST_CHECK(
             Assert(m_node.chainman)
                 ->ProcessNewBlock(config, shared_pblock, true, nullptr));
         pblock->hashPrevBlock = pblock->GetHash();
     }
 
     LOCK(cs_main);
     LOCK(m_node.mempool->cs);
 
     // Just to make sure we can still make simple blocks.
     BOOST_CHECK(pblocktemplate =
                     AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
 
     const Amount BLOCKSUBSIDY = 50 * COIN;
     const Amount LOWFEE = CENT;
     const Amount HIGHFEE = COIN;
     const Amount HIGHERFEE = 4 * COIN;
 
     // block size > limit
     tx.vin.resize(1);
     tx.vin[0].scriptSig = CScript();
     // 18 * (520char + DROP) + OP_1 = 9433 bytes
     std::vector<uint8_t> vchData(520);
     for (unsigned int i = 0; i < 18; ++i) {
         tx.vin[0].scriptSig << vchData << OP_DROP;
     }
 
     tx.vin[0].scriptSig << OP_1;
     tx.vin[0].prevout = COutPoint(txFirst[0]->GetId(), 0);
     tx.vout.resize(1);
     tx.vout[0].nValue = BLOCKSUBSIDY;
     for (unsigned int i = 0; i < 128; ++i) {
         tx.vout[0].nValue -= LOWFEE;
         const TxId txid = tx.GetId();
         // Only first tx spends coinbase.
         bool spendsCoinbase = i == 0;
         m_node.mempool->addUnchecked(entry.Fee(LOWFEE)
                                          .Time(GetTime())
                                          .SpendsCoinbase(spendsCoinbase)
                                          .FromTx(tx));
         tx.vin[0].prevout = COutPoint(txid, 0);
     }
 
     BOOST_CHECK(pblocktemplate =
                     AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
     m_node.mempool->clear();
 
     // Orphan in mempool, template creation fails.
     m_node.mempool->addUnchecked(entry.Fee(LOWFEE).Time(GetTime()).FromTx(tx));
     BOOST_CHECK_EXCEPTION(
         AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey),
         std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));
     m_node.mempool->clear();
 
     // Child with higher priority than parent.
     tx.vin[0].scriptSig = CScript() << OP_1;
     tx.vin[0].prevout = COutPoint(txFirst[1]->GetId(), 0);
     tx.vout[0].nValue = BLOCKSUBSIDY - HIGHFEE;
     TxId txid = tx.GetId();
     m_node.mempool->addUnchecked(
         entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
     tx.vin[0].prevout = COutPoint(txid, 0);
     tx.vin.resize(2);
     tx.vin[1].scriptSig = CScript() << OP_1;
     tx.vin[1].prevout = COutPoint(txFirst[0]->GetId(), 0);
     // First txn output + fresh coinbase - new txn fee.
     tx.vout[0].nValue = tx.vout[0].nValue + BLOCKSUBSIDY - HIGHERFEE;
     txid = tx.GetId();
     m_node.mempool->addUnchecked(
         entry.Fee(HIGHERFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
     BOOST_CHECK(pblocktemplate =
                     AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
     m_node.mempool->clear();
 
     // Coinbase in mempool, template creation fails.
     tx.vin.resize(1);
     tx.vin[0].prevout = COutPoint();
     tx.vin[0].scriptSig = CScript() << OP_0 << OP_1;
     tx.vout[0].nValue = Amount::zero();
     txid = tx.GetId();
     // Give it a fee so it'll get mined.
     m_node.mempool->addUnchecked(
         entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(false).FromTx(tx));
     // Should throw bad-tx-coinbase
     BOOST_CHECK_EXCEPTION(
         AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey),
         std::runtime_error, HasReason("bad-tx-coinbase"));
     m_node.mempool->clear();
 
     // Double spend txn pair in mempool, template creation fails.
     tx.vin[0].prevout = COutPoint(txFirst[0]->GetId(), 0);
     tx.vin[0].scriptSig = CScript() << OP_1;
     tx.vout[0].nValue = BLOCKSUBSIDY - HIGHFEE;
     tx.vout[0].scriptPubKey = CScript() << OP_1;
     txid = tx.GetId();
     m_node.mempool->addUnchecked(
         entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
     tx.vout[0].scriptPubKey = CScript() << OP_2;
     txid = tx.GetId();
     m_node.mempool->addUnchecked(
         entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
     BOOST_CHECK_EXCEPTION(
         AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey),
         std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));
     m_node.mempool->clear();
 
     // Subsidy changing.
-    int nHeight = ::ChainActive().Height();
+    int nHeight = m_node.chainman->ActiveHeight();
     // Create an actual 209999-long block chain (without valid blocks).
-    while (::ChainActive().Tip()->nHeight < 209999) {
-        CBlockIndex *prev = ::ChainActive().Tip();
+    while (m_node.chainman->ActiveHeight() < 209999) {
+        CBlockIndex *prev = m_node.chainman->ActiveTip();
         CBlockIndex *next = new CBlockIndex();
         next->phashBlock = new BlockHash(InsecureRand256());
-        ::ChainstateActive().CoinsTip().SetBestBlock(next->GetBlockHash());
+        m_node.chainman->ActiveChainstate().CoinsTip().SetBestBlock(
+            next->GetBlockHash());
         next->pprev = prev;
         next->nHeight = prev->nHeight + 1;
         next->BuildSkip();
-        ::ChainActive().SetTip(next);
+        m_node.chainman->ActiveChain().SetTip(next);
     }
     BOOST_CHECK(pblocktemplate =
                     AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
     // Extend to a 210000-long block chain.
-    while (::ChainActive().Tip()->nHeight < 210000) {
-        CBlockIndex *prev = ::ChainActive().Tip();
+    while (m_node.chainman->ActiveHeight() < 210000) {
+        CBlockIndex *prev = m_node.chainman->ActiveTip();
         CBlockIndex *next = new CBlockIndex();
         next->phashBlock = new BlockHash(InsecureRand256());
-        ::ChainstateActive().CoinsTip().SetBestBlock(next->GetBlockHash());
+        m_node.chainman->ActiveChainstate().CoinsTip().SetBestBlock(
+            next->GetBlockHash());
         next->pprev = prev;
         next->nHeight = prev->nHeight + 1;
         next->BuildSkip();
-        ::ChainActive().SetTip(next);
+        m_node.chainman->ActiveChain().SetTip(next);
     }
 
     BOOST_CHECK(pblocktemplate =
                     AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
 
     // Invalid p2sh txn in mempool, template creation fails
     tx.vin[0].prevout = COutPoint(txFirst[0]->GetId(), 0);
     tx.vin[0].scriptSig = CScript() << OP_1;
     tx.vout[0].nValue = BLOCKSUBSIDY - LOWFEE;
     script = CScript() << OP_0;
     tx.vout[0].scriptPubKey = GetScriptForDestination(ScriptHash(script));
     txid = tx.GetId();
     m_node.mempool->addUnchecked(
         entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
     tx.vin[0].prevout = COutPoint(txid, 0);
     tx.vin[0].scriptSig = CScript()
                           << std::vector<uint8_t>(script.begin(), script.end());
     tx.vout[0].nValue -= LOWFEE;
     txid = tx.GetId();
     m_node.mempool->addUnchecked(
         entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(false).FromTx(tx));
     // Should throw blk-bad-inputs
     BOOST_CHECK_EXCEPTION(
         AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey),
         std::runtime_error, HasReason("blk-bad-inputs"));
     m_node.mempool->clear();
 
     // Delete the dummy blocks again.
-    while (::ChainActive().Tip()->nHeight > nHeight) {
-        CBlockIndex *del = ::ChainActive().Tip();
-        ::ChainActive().SetTip(del->pprev);
-        ::ChainstateActive().CoinsTip().SetBestBlock(
+    while (m_node.chainman->ActiveHeight() > nHeight) {
+        CBlockIndex *del = m_node.chainman->ActiveTip();
+        m_node.chainman->ActiveChain().SetTip(del->pprev);
+        m_node.chainman->ActiveChainstate().CoinsTip().SetBestBlock(
             del->pprev->GetBlockHash());
         delete del->phashBlock;
         delete del;
     }
 
     // non-final txs in mempool
-    SetMockTime(::ChainActive().Tip()->GetMedianTimePast() + 1);
+    SetMockTime(m_node.chainman->ActiveTip()->GetMedianTimePast() + 1);
     uint32_t flags = LOCKTIME_VERIFY_SEQUENCE | LOCKTIME_MEDIAN_TIME_PAST;
     // height map
     std::vector<int> prevheights;
 
     // Relative height locked.
     tx.nVersion = 2;
     tx.vin.resize(1);
     prevheights.resize(1);
     // Only 1 transaction.
     tx.vin[0].prevout = COutPoint(txFirst[0]->GetId(), 0);
     tx.vin[0].scriptSig = CScript() << OP_1;
     // txFirst[0] is the 2nd block
-    tx.vin[0].nSequence = ::ChainActive().Tip()->nHeight + 1;
+    tx.vin[0].nSequence = m_node.chainman->ActiveHeight() + 1;
     prevheights[0] = baseheight + 1;
     tx.vout.resize(1);
     tx.vout[0].nValue = BLOCKSUBSIDY - HIGHFEE;
     tx.vout[0].scriptPubKey = CScript() << OP_1;
     tx.nLockTime = 0;
     txid = tx.GetId();
     m_node.mempool->addUnchecked(
         entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
 
     const Consensus::Params &params = chainparams.GetConsensus();
 
     {
         // Locktime passes.
         TxValidationState state;
         BOOST_CHECK(ContextualCheckTransactionForCurrentBlock(
-            ::ChainActive().Tip(), params, CTransaction(tx), state, flags));
+            m_node.chainman->ActiveTip(), params, CTransaction(tx), state,
+            flags));
     }
 
     // Sequence locks fail.
     BOOST_CHECK(!TestSequenceLocks(CTransaction(tx), flags));
 
     // Sequence locks pass on 2nd block.
     BOOST_CHECK(
         SequenceLocks(CTransaction(tx), flags, prevheights,
                       CreateBlockIndex(m_node.chainman->ActiveHeight() + 2,
                                        m_node.chainman->ActiveTip())));
 
     // Relative time locked.
     tx.vin[0].prevout = COutPoint(txFirst[1]->GetId(), 0);
     // 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);
+    tx.vin[0].nSequence =
+        CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG |
+        (((m_node.chainman->ActiveTip()->GetMedianTimePast() + 1 -
+           m_node.chainman->ActiveChain()[1]->GetMedianTimePast()) >>
+          CTxIn::SEQUENCE_LOCKTIME_GRANULARITY) +
+         1);
     prevheights[0] = baseheight + 2;
     txid = tx.GetId();
     m_node.mempool->addUnchecked(entry.Time(GetTime()).FromTx(tx));
 
     {
         // Locktime passes.
         TxValidationState state;
         BOOST_CHECK(ContextualCheckTransactionForCurrentBlock(
-            ::ChainActive().Tip(), params, CTransaction(tx), state, flags));
+            m_node.chainman->ActiveTip(), params, CTransaction(tx), state,
+            flags));
     }
 
     // Sequence locks fail.
     BOOST_CHECK(!TestSequenceLocks(CTransaction(tx), flags));
 
     for (int i = 0; i < CBlockIndex::nMedianTimeSpan; i++) {
         // Trick the MedianTimePast.
         m_node.chainman->ActiveTip()
             ->GetAncestor(m_node.chainman->ActiveHeight() - i)
             ->nTime += 512;
     }
 
     // Sequence locks pass 512 seconds later.
     BOOST_CHECK(
         SequenceLocks(CTransaction(tx), flags, prevheights,
                       CreateBlockIndex(m_node.chainman->ActiveHeight() + 1,
                                        m_node.chainman->ActiveTip())));
 
     for (int i = 0; i < CBlockIndex::nMedianTimeSpan; i++) {
         // Undo tricked MTP.
-        ::ChainActive()
+        m_node.chainman->ActiveChain()
             .Tip()
-            ->GetAncestor(::ChainActive().Tip()->nHeight - i)
+            ->GetAncestor(m_node.chainman->ActiveHeight() - i)
             ->nTime -= 512;
     }
 
     // Absolute height locked.
     tx.vin[0].prevout = COutPoint(txFirst[2]->GetId(), 0);
     tx.vin[0].nSequence = CTxIn::SEQUENCE_FINAL - 1;
     prevheights[0] = baseheight + 3;
-    tx.nLockTime = ::ChainActive().Tip()->nHeight + 1;
+    tx.nLockTime = m_node.chainman->ActiveHeight() + 1;
     txid = tx.GetId();
     m_node.mempool->addUnchecked(entry.Time(GetTime()).FromTx(tx));
 
     {
         // Locktime fails.
         TxValidationState state;
         BOOST_CHECK(!ContextualCheckTransactionForCurrentBlock(
-            ::ChainActive().Tip(), params, CTransaction(tx), state, flags));
+            m_node.chainman->ActiveTip(), params, CTransaction(tx), state,
+            flags));
         BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-txns-nonfinal");
     }
 
     // Sequence locks pass.
     BOOST_CHECK(TestSequenceLocks(CTransaction(tx), flags));
 
     {
         // Locktime passes on 2nd block.
         TxValidationState state;
-        int64_t nMedianTimePast = ::ChainActive().Tip()->GetMedianTimePast();
-        BOOST_CHECK(ContextualCheckTransaction(
-            params, CTransaction(tx), state, ::ChainActive().Tip()->nHeight + 2,
-            nMedianTimePast, nMedianTimePast));
+        int64_t nMedianTimePast =
+            m_node.chainman->ActiveTip()->GetMedianTimePast();
+        BOOST_CHECK(
+            ContextualCheckTransaction(params, CTransaction(tx), state,
+                                       m_node.chainman->ActiveHeight() + 2,
+                                       nMedianTimePast, nMedianTimePast));
     }
 
     // Absolute time locked.
     tx.vin[0].prevout = COutPoint(txFirst[3]->GetId(), 0);
-    tx.nLockTime = ::ChainActive().Tip()->GetMedianTimePast();
+    tx.nLockTime = m_node.chainman->ActiveTip()->GetMedianTimePast();
     prevheights.resize(1);
     prevheights[0] = baseheight + 4;
     txid = tx.GetId();
     m_node.mempool->addUnchecked(entry.Time(GetTime()).FromTx(tx));
 
     {
         // Locktime fails.
         TxValidationState state;
         BOOST_CHECK(!ContextualCheckTransactionForCurrentBlock(
-            ::ChainActive().Tip(), params, CTransaction(tx), state, flags));
+            m_node.chainman->ActiveTip(), params, CTransaction(tx), state,
+            flags));
         BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-txns-nonfinal");
     }
 
     // Sequence locks pass.
     BOOST_CHECK(TestSequenceLocks(CTransaction(tx), flags));
 
     {
         // Locktime passes 1 second later.
         TxValidationState state;
         int64_t nMedianTimePast =
-            ::ChainActive().Tip()->GetMedianTimePast() + 1;
-        BOOST_CHECK(ContextualCheckTransaction(
-            params, CTransaction(tx), state, ::ChainActive().Tip()->nHeight + 1,
-            nMedianTimePast, nMedianTimePast));
+            m_node.chainman->ActiveTip()->GetMedianTimePast() + 1;
+        BOOST_CHECK(
+            ContextualCheckTransaction(params, CTransaction(tx), state,
+                                       m_node.chainman->ActiveHeight() + 1,
+                                       nMedianTimePast, nMedianTimePast));
     }
 
     // mempool-dependent transactions (not added)
     tx.vin[0].prevout = COutPoint(txid, 0);
-    prevheights[0] = ::ChainActive().Tip()->nHeight + 1;
+    prevheights[0] = m_node.chainman->ActiveHeight() + 1;
     tx.nLockTime = 0;
     tx.vin[0].nSequence = 0;
 
     {
         // Locktime passes.
         TxValidationState state;
         BOOST_CHECK(ContextualCheckTransactionForCurrentBlock(
-            ::ChainActive().Tip(), params, CTransaction(tx), state, flags));
+            m_node.chainman->ActiveTip(), params, CTransaction(tx), state,
+            flags));
     }
 
     // Sequence locks pass.
     BOOST_CHECK(TestSequenceLocks(CTransaction(tx), flags));
     tx.vin[0].nSequence = 1;
     // Sequence locks fail.
     BOOST_CHECK(!TestSequenceLocks(CTransaction(tx), flags));
     tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG;
     // Sequence locks pass.
     BOOST_CHECK(TestSequenceLocks(CTransaction(tx), flags));
     tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | 1;
     // Sequence locks fail.
     BOOST_CHECK(!TestSequenceLocks(CTransaction(tx), flags));
 
     pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
     BOOST_CHECK(pblocktemplate);
 
     // None of the of the absolute height/time locked tx should have made it
     // into the template because we still check IsFinalTx in CreateNewBlock, but
     // relative locked txs will if inconsistently added to g_mempool. For now
     // these will still generate a valid template until BIP68 soft fork.
     BOOST_CHECK_EQUAL(pblocktemplate->block.vtx.size(), 3UL);
     // 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++) {
         // Trick the MedianTimePast.
-        ::ChainActive()
+        m_node.chainman->ActiveChain()
             .Tip()
-            ->GetAncestor(::ChainActive().Tip()->nHeight - i)
+            ->GetAncestor(m_node.chainman->ActiveHeight() - i)
             ->nTime += 512;
     }
-    ::ChainActive().Tip()->nHeight++;
-    SetMockTime(::ChainActive().Tip()->GetMedianTimePast() + 1);
+    m_node.chainman->ActiveTip()->nHeight++;
+    SetMockTime(m_node.chainman->ActiveTip()->GetMedianTimePast() + 1);
 
     BOOST_CHECK(pblocktemplate =
                     AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
     BOOST_CHECK_EQUAL(pblocktemplate->block.vtx.size(), 5UL);
 
-    ::ChainActive().Tip()->nHeight--;
+    m_node.chainman->ActiveTip()->nHeight--;
     SetMockTime(0);
     m_node.mempool->clear();
 
     TestPackageSelection(chainparams, scriptPubKey, txFirst);
 
     fCheckpointsEnabled = true;
 }
 
 static void CheckBlockMaxSize(const Config &config, const CTxMemPool &mempool,
                               CChainState &active_chainstate, uint64_t size,
                               uint64_t expected) {
     gArgs.ForceSetArg("-blockmaxsize", ToString(size));
 
     BlockAssembler ba(config, active_chainstate, mempool);
     BOOST_CHECK_EQUAL(ba.GetMaxGeneratedBlockSize(), expected);
 }
 
 BOOST_AUTO_TEST_CASE(BlockAssembler_construction) {
     GlobalConfig config;
 
     // We are working on a fake chain and need to protect ourselves.
     LOCK(cs_main);
 
     const CTxMemPool &mempool = *m_node.mempool;
     CChainState &active_chainstate = m_node.chainman->ActiveChainstate();
 
     // Test around historical 1MB (plus one byte because that's mandatory)
     config.SetMaxBlockSize(ONE_MEGABYTE + 1);
     CheckBlockMaxSize(config, mempool, active_chainstate, 0, 1000);
     CheckBlockMaxSize(config, mempool, active_chainstate, 1000, 1000);
     CheckBlockMaxSize(config, mempool, active_chainstate, 1001, 1001);
     CheckBlockMaxSize(config, mempool, active_chainstate, 12345, 12345);
 
     CheckBlockMaxSize(config, mempool, active_chainstate, ONE_MEGABYTE - 1001,
                       ONE_MEGABYTE - 1001);
     CheckBlockMaxSize(config, mempool, active_chainstate, ONE_MEGABYTE - 1000,
                       ONE_MEGABYTE - 1000);
     CheckBlockMaxSize(config, mempool, active_chainstate, ONE_MEGABYTE - 999,
                       ONE_MEGABYTE - 999);
     CheckBlockMaxSize(config, mempool, active_chainstate, ONE_MEGABYTE,
                       ONE_MEGABYTE - 999);
 
     // Test around default cap
     config.SetMaxBlockSize(DEFAULT_MAX_BLOCK_SIZE);
 
     // Now we can use the default max block size.
     CheckBlockMaxSize(config, mempool, active_chainstate,
                       DEFAULT_MAX_BLOCK_SIZE - 1001,
                       DEFAULT_MAX_BLOCK_SIZE - 1001);
     CheckBlockMaxSize(config, mempool, active_chainstate,
                       DEFAULT_MAX_BLOCK_SIZE - 1000,
                       DEFAULT_MAX_BLOCK_SIZE - 1000);
     CheckBlockMaxSize(config, mempool, active_chainstate,
                       DEFAULT_MAX_BLOCK_SIZE - 999,
                       DEFAULT_MAX_BLOCK_SIZE - 1000);
     CheckBlockMaxSize(config, mempool, active_chainstate,
                       DEFAULT_MAX_BLOCK_SIZE, DEFAULT_MAX_BLOCK_SIZE - 1000);
 
     // If the parameter is not specified, we use
     // DEFAULT_MAX_GENERATED_BLOCK_SIZE
     {
         gArgs.ClearForcedArg("-blockmaxsize");
-        BlockAssembler ba(config, ::ChainstateActive(), *m_node.mempool);
+        BlockAssembler ba(config, m_node.chainman->ActiveChainstate(),
+                          *m_node.mempool);
         BOOST_CHECK_EQUAL(ba.GetMaxGeneratedBlockSize(),
                           DEFAULT_MAX_GENERATED_BLOCK_SIZE);
     }
 }
 
 BOOST_AUTO_TEST_CASE(TestCBlockTemplateEntry) {
     const CTransaction tx;
     CTransactionRef txRef = MakeTransactionRef(tx);
     CBlockTemplateEntry txEntry(txRef, 1 * SATOSHI, 10);
     BOOST_CHECK_MESSAGE(txEntry.tx == txRef, "Transactions did not match");
     BOOST_CHECK_EQUAL(txEntry.fees, 1 * SATOSHI);
     BOOST_CHECK_EQUAL(txEntry.sigOpCount, 10);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/txindex_tests.cpp b/src/test/txindex_tests.cpp
index 193521bd8..0f388c269 100644
--- a/src/test/txindex_tests.cpp
+++ b/src/test/txindex_tests.cpp
@@ -1,83 +1,83 @@
 // Copyright (c) 2017-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <index/txindex.h>
 
 #include <chainparams.h>
 #include <script/standard.h>
 #include <util/time.h>
 #include <validation.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_AUTO_TEST_SUITE(txindex_tests)
 
 BOOST_FIXTURE_TEST_CASE(txindex_initial_sync, TestChain100Setup) {
     TxIndex txindex(1 << 20, true);
 
     CTransactionRef tx_disk;
     BlockHash block_hash;
 
     // Transaction should not be found in the index before it is started.
     for (const auto &txn : m_coinbase_txns) {
         BOOST_CHECK(!txindex.FindTx(txn->GetId(), block_hash, tx_disk));
     }
 
     // BlockUntilSyncedToCurrentChain should return false before txindex is
     // started.
     BOOST_CHECK(!txindex.BlockUntilSyncedToCurrentChain());
 
-    txindex.Start(::ChainstateActive());
+    txindex.Start(m_node.chainman->ActiveChainstate());
 
     // Allow tx index to catch up with the block index.
     constexpr int64_t timeout_ms = 10 * 1000;
     int64_t time_start = GetTimeMillis();
     while (!txindex.BlockUntilSyncedToCurrentChain()) {
         BOOST_REQUIRE(time_start + timeout_ms > GetTimeMillis());
         UninterruptibleSleep(std::chrono::milliseconds{100});
     }
 
     // Check that txindex excludes genesis block transactions.
     const CBlock &genesis_block = Params().GenesisBlock();
     for (const auto &txn : genesis_block.vtx) {
         BOOST_CHECK(!txindex.FindTx(txn->GetId(), block_hash, tx_disk));
     }
 
     // Check that txindex has all txs that were in the chain before it started.
     for (const auto &txn : m_coinbase_txns) {
         if (!txindex.FindTx(txn->GetId(), block_hash, tx_disk)) {
             BOOST_ERROR("FindTx failed");
         } else if (tx_disk->GetId() != txn->GetId()) {
             BOOST_ERROR("Read incorrect tx");
         }
     }
 
     // Check that new transactions in new blocks make it into the index.
     for (int i = 0; i < 10; i++) {
         CScript coinbase_script_pub_key =
             GetScriptForDestination(PKHash(coinbaseKey.GetPubKey()));
         std::vector<CMutableTransaction> no_txns;
         const CBlock &block =
             CreateAndProcessBlock(no_txns, coinbase_script_pub_key);
         const CTransactionRef &txn = block.vtx[0];
 
         BOOST_CHECK(txindex.BlockUntilSyncedToCurrentChain());
         if (!txindex.FindTx(txn->GetId(), block_hash, tx_disk)) {
             BOOST_ERROR("FindTx failed");
         } else if (tx_disk->GetId() != txn->GetId()) {
             BOOST_ERROR("Read incorrect tx");
         }
     }
 
     // shutdown sequence (c.f. Shutdown() in init.cpp)
     txindex.Stop();
 
     // Let scheduler events finish running to avoid accessing any memory related
     // to txindex after it is destructed
     SyncWithValidationInterfaceQueue();
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/txvalidation_tests.cpp b/src/test/txvalidation_tests.cpp
index 6de39152a..bce0b9917 100644
--- a/src/test/txvalidation_tests.cpp
+++ b/src/test/txvalidation_tests.cpp
@@ -1,55 +1,56 @@
 // Copyright (c) 2017-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <config.h>
 #include <consensus/validation.h>
 #include <primitives/transaction.h>
 #include <script/script.h>
 #include <txmempool.h>
 #include <validation.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_AUTO_TEST_SUITE(txvalidation_tests)
 
 /**
  * Ensure that the mempool won't accept coinbase transactions.
  */
 BOOST_FIXTURE_TEST_CASE(tx_mempool_reject_coinbase, TestChain100Setup) {
     CScript scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey())
                                      << OP_CHECKSIG;
     CMutableTransaction coinbaseTx;
 
     coinbaseTx.nVersion = 1;
     coinbaseTx.vin.resize(1);
     coinbaseTx.vout.resize(1);
     coinbaseTx.vin[0].scriptSig = CScript() << OP_11 << OP_EQUAL;
     coinbaseTx.vout[0].nValue = 1 * CENT;
     coinbaseTx.vout[0].scriptPubKey = scriptPubKey;
 
     BOOST_CHECK(CTransaction(coinbaseTx).IsCoinBase());
 
     TxValidationState state;
 
     LOCK(cs_main);
 
     unsigned int initialPoolSize = m_node.mempool->size();
 
-    BOOST_CHECK_EQUAL(
-        false, AcceptToMemoryPool(
-                   ::ChainstateActive(), GetConfig(), *m_node.mempool, state,
-                   MakeTransactionRef(coinbaseTx), true /* bypass_limits */));
+    BOOST_CHECK_EQUAL(false,
+                      AcceptToMemoryPool(m_node.chainman->ActiveChainstate(),
+                                         GetConfig(), *m_node.mempool, state,
+                                         MakeTransactionRef(coinbaseTx),
+                                         true /* bypass_limits */));
 
     // Check that the transaction hasn't been added to mempool.
     BOOST_CHECK_EQUAL(m_node.mempool->size(), initialPoolSize);
 
     // Check that the validation state reflects the unsuccesful attempt.
     BOOST_CHECK(state.IsInvalid());
     BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-tx-coinbase");
     BOOST_CHECK(state.GetResult() == TxValidationResult::TX_CONSENSUS);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/txvalidationcache_tests.cpp b/src/test/txvalidationcache_tests.cpp
index ab5c8a0dd..35c038b45 100644
--- a/src/test/txvalidationcache_tests.cpp
+++ b/src/test/txvalidationcache_tests.cpp
@@ -1,683 +1,694 @@
 // Copyright (c) 2011-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chain.h>
 #include <config.h>
 #include <consensus/validation.h>
 #include <key.h>
 #include <policy/policy.h>
 #include <script/scriptcache.h>
 #include <script/sighashtype.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
 #include <txmempool.h>
 #include <validation.h>
 
 #include <test/lcg.h>
 #include <test/sigutil.h>
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_AUTO_TEST_SUITE(txvalidationcache_tests)
 
 BOOST_FIXTURE_TEST_CASE(tx_mempool_block_doublespend, TestChain100Setup) {
     // Make sure skipping validation of transactions that were validated going
     // into the memory pool does not allow double-spends in blocks to pass
     // validation when they should not.
     CScript scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey())
                                      << OP_CHECKSIG;
 
     const auto ToMemPool = [this](const CMutableTransaction &tx) {
         LOCK(cs_main);
 
         TxValidationState state;
         return AcceptToMemoryPool(
-            ::ChainstateActive(), GetConfig(), *m_node.mempool, state,
-            MakeTransactionRef(tx), true /* bypass_limits */);
+            m_node.chainman->ActiveChainstate(), GetConfig(), *m_node.mempool,
+            state, MakeTransactionRef(tx), true /* bypass_limits */);
     };
 
     // Create a double-spend of mature coinbase txn:
     std::vector<CMutableTransaction> spends;
     spends.resize(2);
     for (int i = 0; i < 2; i++) {
         spends[i].nVersion = 1;
         spends[i].vin.resize(1);
         spends[i].vin[0].prevout = COutPoint(m_coinbase_txns[0]->GetId(), 0);
         spends[i].vout.resize(1);
         spends[i].vout[0].nValue = 11 * CENT;
         spends[i].vout[0].scriptPubKey = scriptPubKey;
 
         // Sign:
         std::vector<uint8_t> vchSig;
         uint256 hash = SignatureHash(scriptPubKey, CTransaction(spends[i]), 0,
                                      SigHashType().withForkId(),
                                      m_coinbase_txns[0]->vout[0].nValue);
         BOOST_CHECK(coinbaseKey.SignECDSA(hash, vchSig));
         vchSig.push_back(uint8_t(SIGHASH_ALL | SIGHASH_FORKID));
         spends[i].vin[0].scriptSig << vchSig;
     }
 
     CBlock block;
 
     // Test 1: block with both of those transactions should be rejected.
     block = CreateAndProcessBlock(spends, scriptPubKey);
     {
         LOCK(cs_main);
-        BOOST_CHECK(::ChainActive().Tip()->GetBlockHash() != block.GetHash());
+        BOOST_CHECK(m_node.chainman->ActiveTip()->GetBlockHash() !=
+                    block.GetHash());
     }
 
     // Test 2: ... and should be rejected if spend1 is in the memory pool
     BOOST_CHECK(ToMemPool(spends[0]));
     block = CreateAndProcessBlock(spends, scriptPubKey);
     {
         LOCK(cs_main);
-        BOOST_CHECK(::ChainActive().Tip()->GetBlockHash() != block.GetHash());
+        BOOST_CHECK(m_node.chainman->ActiveTip()->GetBlockHash() !=
+                    block.GetHash());
     }
     m_node.mempool->clear();
 
     // Test 3: ... and should be rejected if spend2 is in the memory pool
     BOOST_CHECK(ToMemPool(spends[1]));
     block = CreateAndProcessBlock(spends, scriptPubKey);
     {
         LOCK(cs_main);
-        BOOST_CHECK(::ChainActive().Tip()->GetBlockHash() != block.GetHash());
+        BOOST_CHECK(m_node.chainman->ActiveTip()->GetBlockHash() !=
+                    block.GetHash());
     }
     m_node.mempool->clear();
 
     // Final sanity test: first spend in mempool, second in block, that's OK:
     std::vector<CMutableTransaction> oneSpend;
     oneSpend.push_back(spends[0]);
     BOOST_CHECK(ToMemPool(spends[1]));
     block = CreateAndProcessBlock(oneSpend, scriptPubKey);
     {
         LOCK(cs_main);
-        BOOST_CHECK(::ChainActive().Tip()->GetBlockHash() == block.GetHash());
+        BOOST_CHECK(m_node.chainman->ActiveTip()->GetBlockHash() ==
+                    block.GetHash());
     }
     // spends[1] should have been removed from the mempool when the block with
     // spends[0] is accepted:
     BOOST_CHECK_EQUAL(m_node.mempool->size(), 0U);
 }
 
 static inline bool
 CheckInputScripts(const CTransaction &tx, TxValidationState &state,
                   const CCoinsViewCache &view, const uint32_t flags,
                   bool sigCacheStore, bool scriptCacheStore,
                   const PrecomputedTransactionData &txdata, int &nSigChecksOut,
                   std::vector<CScriptCheck> *pvChecks,
                   CheckInputsLimiter *pBlockLimitSigChecks = nullptr)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     // nSigChecksTxLimiter need to outlive this function call, because test
     // cases are using pvChecks, so the verification is done asynchronously.
     static TxSigCheckLimiter nSigChecksTxLimiter;
     nSigChecksTxLimiter = TxSigCheckLimiter();
     return CheckInputScripts(
         tx, state, view, flags, sigCacheStore, scriptCacheStore, txdata,
         nSigChecksOut, nSigChecksTxLimiter, pBlockLimitSigChecks, pvChecks);
 }
 
 // Run CheckInputScripts (using CoinsTip()) on the given transaction, for all
 // script flags. Test that CheckInputScripts passes for all flags that don't
 // overlap with the failing_flags argument, but otherwise fails.
 // CHECKLOCKTIMEVERIFY and CHECKSEQUENCEVERIFY (and future NOP codes that may
 // get reassigned) have an interaction with DISCOURAGE_UPGRADABLE_NOPS: if the
 // script flags used contain DISCOURAGE_UPGRADABLE_NOPS but don't contain
 // CHECKLOCKTIMEVERIFY (or CHECKSEQUENCEVERIFY), but the script does contain
 // OP_CHECKLOCKTIMEVERIFY (or OP_CHECKSEQUENCEVERIFY), then script execution
 // should fail.
 // Capture this interaction with the upgraded_nop argument: set it when
 // evaluating any script flag that is implemented as an upgraded NOP code.
 static void ValidateCheckInputsForAllFlags(
     const CTransaction &tx, uint32_t failing_flags, uint32_t required_flags,
     bool add_to_cache, CCoinsViewCache &active_coins_tip,
     int expected_sigchecks) EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     PrecomputedTransactionData txdata(tx);
 
     MMIXLinearCongruentialGenerator lcg;
     for (int i = 0; i < 4096; i++) {
         uint32_t test_flags = lcg.next() | required_flags;
         TxValidationState state;
 
         // Filter out incompatible flag choices
         if ((test_flags & SCRIPT_VERIFY_CLEANSTACK)) {
             // CLEANSTACK requires P2SH, see VerifyScript() in
             // script/interpreter.cpp
             test_flags |= SCRIPT_VERIFY_P2SH;
         }
 
         int nSigChecksDirect = 0xf00d;
         bool ret =
             CheckInputScripts(tx, state, &active_coins_tip, test_flags, true,
                               add_to_cache, txdata, nSigChecksDirect);
 
         // CheckInputScripts should succeed iff test_flags doesn't intersect
         // with failing_flags
         bool expected_return_value = !(test_flags & failing_flags);
         BOOST_CHECK_EQUAL(ret, expected_return_value);
 
         if (ret) {
             BOOST_CHECK(nSigChecksDirect == expected_sigchecks);
         }
 
         // Test the caching
         if (ret && add_to_cache) {
             // Check that we get a cache hit if the tx was valid
             std::vector<CScriptCheck> scriptchecks;
             int nSigChecksCached = 0xbeef;
             BOOST_CHECK(CheckInputScripts(
                 tx, state, &active_coins_tip, test_flags, true, add_to_cache,
                 txdata, nSigChecksCached, &scriptchecks));
             BOOST_CHECK(nSigChecksCached == nSigChecksDirect);
             BOOST_CHECK(scriptchecks.empty());
         } else {
             // Check that we get script executions to check, if the transaction
             // was invalid, or we didn't add to cache.
             std::vector<CScriptCheck> scriptchecks;
             int nSigChecksUncached = 0xbabe;
             BOOST_CHECK(CheckInputScripts(
                 tx, state, &active_coins_tip, test_flags, true, add_to_cache,
                 txdata, nSigChecksUncached, &scriptchecks));
             BOOST_CHECK(!ret || nSigChecksUncached == 0);
             BOOST_CHECK_EQUAL(scriptchecks.size(), tx.vin.size());
         }
     }
 }
 
 BOOST_FIXTURE_TEST_CASE(checkinputs_test, TestChain100Setup) {
     // Test that passing CheckInputScripts with one set of script flags doesn't
     // imply that we would pass again with a different set of flags.
     {
         LOCK(cs_main);
         InitScriptExecutionCache();
     }
 
     CScript p2pk_scriptPubKey =
         CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
     CScript p2sh_scriptPubKey =
         GetScriptForDestination(ScriptHash(p2pk_scriptPubKey));
     CScript p2pkh_scriptPubKey =
         GetScriptForDestination(PKHash(coinbaseKey.GetPubKey()));
 
     FillableSigningProvider keystore;
     BOOST_CHECK(keystore.AddKey(coinbaseKey));
     BOOST_CHECK(keystore.AddCScript(p2pk_scriptPubKey));
 
     CMutableTransaction funding_tx;
     // Needed when spending the output of this transaction
     CScript noppyScriptPubKey;
     // Create a transaction output that can fail DISCOURAGE_UPGRADABLE_NOPS
     // checks when spent. This is for testing consensus vs non-standard rules in
     // `checkinputs_test`.
     {
         funding_tx.nVersion = 1;
         funding_tx.vin.resize(1);
         funding_tx.vin[0].prevout = COutPoint(m_coinbase_txns[0]->GetId(), 0);
         funding_tx.vout.resize(1);
         funding_tx.vout[0].nValue = 50 * COIN;
 
         noppyScriptPubKey << OP_IF << OP_NOP10 << OP_ENDIF << OP_1;
         funding_tx.vout[0].scriptPubKey = noppyScriptPubKey;
         std::vector<uint8_t> fundingVchSig;
         uint256 fundingSigHash = SignatureHash(
             p2pk_scriptPubKey, CTransaction(funding_tx), 0,
             SigHashType().withForkId(), m_coinbase_txns[0]->vout[0].nValue);
         BOOST_CHECK(coinbaseKey.SignECDSA(fundingSigHash, fundingVchSig));
         fundingVchSig.push_back(uint8_t(SIGHASH_ALL | SIGHASH_FORKID));
         funding_tx.vin[0].scriptSig << fundingVchSig;
     }
 
     // Spend the funding transaction by mining it into a block
     {
         CBlock block = CreateAndProcessBlock({funding_tx}, p2pk_scriptPubKey);
-        BOOST_CHECK(::ChainActive().Tip()->GetBlockHash() == block.GetHash());
-        LOCK(cs_main);
-        BOOST_CHECK(::ChainstateActive().CoinsTip().GetBestBlock() ==
+        BOOST_CHECK(m_node.chainman->ActiveTip()->GetBlockHash() ==
                     block.GetHash());
+        LOCK(cs_main);
+        BOOST_CHECK(
+            m_node.chainman->ActiveChainstate().CoinsTip().GetBestBlock() ==
+            block.GetHash());
     }
 
     // flags to test: SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY,
     // SCRIPT_VERIFY_CHECKSEQUENCE_VERIFY,
     // SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS, uncompressed pubkey thing
 
     // Create 2 outputs that match the three scripts above, spending the first
     // coinbase tx.
     CMutableTransaction spend_tx;
     spend_tx.nVersion = 1;
     spend_tx.vin.resize(1);
     spend_tx.vin[0].prevout = COutPoint(funding_tx.GetId(), 0);
     spend_tx.vout.resize(4);
     spend_tx.vout[0].nValue = 11 * CENT;
     spend_tx.vout[0].scriptPubKey = p2sh_scriptPubKey;
     spend_tx.vout[1].nValue = 11 * CENT;
     spend_tx.vout[1].scriptPubKey =
         CScript() << OP_CHECKLOCKTIMEVERIFY << OP_DROP
                   << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
     spend_tx.vout[2].nValue = 11 * CENT;
     spend_tx.vout[2].scriptPubKey =
         CScript() << OP_CHECKSEQUENCEVERIFY << OP_DROP
                   << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
     spend_tx.vout[3].nValue = 11 * CENT;
     spend_tx.vout[3].scriptPubKey = p2sh_scriptPubKey;
 
     // "Sign" the main transaction that we spend from.
     {
         // This will cause OP_NOP10 to execute.
         spend_tx.vin[0].scriptSig << OP_1;
     }
 
     // Test that invalidity under a set of flags doesn't preclude validity under
     // other (eg consensus) flags.
     // spend_tx is invalid according to DISCOURAGE_UPGRADABLE_NOPS
     {
         const CTransaction tx(spend_tx);
 
         LOCK(cs_main);
 
         TxValidationState state;
         PrecomputedTransactionData ptd_spend_tx(tx);
         int nSigChecksDummy;
 
-        BOOST_CHECK(!CheckInputScripts(tx, state,
-                                       &::ChainstateActive().CoinsTip(),
-                                       STANDARD_SCRIPT_VERIFY_FLAGS, true, true,
-                                       ptd_spend_tx, nSigChecksDummy, nullptr));
+        BOOST_CHECK(!CheckInputScripts(
+            tx, state, &m_node.chainman->ActiveChainstate().CoinsTip(),
+            STANDARD_SCRIPT_VERIFY_FLAGS, true, true, ptd_spend_tx,
+            nSigChecksDummy, nullptr));
 
         // If we call again asking for scriptchecks (as happens in
         // ConnectBlock), we should add a script check object for this -- we're
         // not caching invalidity (if that changes, delete this test case).
         std::vector<CScriptCheck> scriptchecks;
-        BOOST_CHECK(
-            CheckInputScripts(tx, state, &::ChainstateActive().CoinsTip(),
-                              STANDARD_SCRIPT_VERIFY_FLAGS, true, true,
-                              ptd_spend_tx, nSigChecksDummy, &scriptchecks));
+        BOOST_CHECK(CheckInputScripts(
+            tx, state, &m_node.chainman->ActiveChainstate().CoinsTip(),
+            STANDARD_SCRIPT_VERIFY_FLAGS, true, true, ptd_spend_tx,
+            nSigChecksDummy, &scriptchecks));
         BOOST_CHECK_EQUAL(scriptchecks.size(), 1U);
 
         // Test that CheckInputScripts returns true iff cleanstack-enforcing
         // flags are not present. Don't add these checks to the cache, so that
         // we can test later that block validation works fine in the absence of
         // cached successes.
         ValidateCheckInputsForAllFlags(
             tx, SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS, 0, false,
-            ::ChainstateActive().CoinsTip(), 0);
+            m_node.chainman->ActiveChainstate().CoinsTip(), 0);
     }
 
     // And if we produce a block with this tx, it should be valid, even though
     // there's no cache entry.
     CBlock block;
 
     block = CreateAndProcessBlock({spend_tx}, p2pk_scriptPubKey);
     LOCK(cs_main);
-    BOOST_CHECK(::ChainActive().Tip()->GetBlockHash() == block.GetHash());
-    BOOST_CHECK(::ChainstateActive().CoinsTip().GetBestBlock() ==
+    BOOST_CHECK(m_node.chainman->ActiveTip()->GetBlockHash() ==
+                block.GetHash());
+    BOOST_CHECK(m_node.chainman->ActiveChainstate().CoinsTip().GetBestBlock() ==
                 block.GetHash());
 
     // Test P2SH: construct a transaction that is valid without P2SH, and then
     // test validity with P2SH.
     {
         CMutableTransaction invalid_under_p2sh_tx;
         invalid_under_p2sh_tx.nVersion = 1;
         invalid_under_p2sh_tx.vin.resize(1);
         invalid_under_p2sh_tx.vin[0].prevout = COutPoint(spend_tx.GetId(), 0);
         invalid_under_p2sh_tx.vout.resize(1);
         invalid_under_p2sh_tx.vout[0].nValue = 11 * CENT;
         invalid_under_p2sh_tx.vout[0].scriptPubKey = p2pk_scriptPubKey;
         std::vector<uint8_t> vchSig2(p2pk_scriptPubKey.begin(),
                                      p2pk_scriptPubKey.end());
         invalid_under_p2sh_tx.vin[0].scriptSig << vchSig2;
 
-        ValidateCheckInputsForAllFlags(CTransaction(invalid_under_p2sh_tx),
-                                       SCRIPT_VERIFY_P2SH, 0, true,
-                                       ::ChainstateActive().CoinsTip(), 0);
+        ValidateCheckInputsForAllFlags(
+            CTransaction(invalid_under_p2sh_tx), SCRIPT_VERIFY_P2SH, 0, true,
+            m_node.chainman->ActiveChainstate().CoinsTip(), 0);
     }
 
     // Test CHECKLOCKTIMEVERIFY
     {
         CMutableTransaction invalid_with_cltv_tx;
         invalid_with_cltv_tx.nVersion = 1;
         invalid_with_cltv_tx.nLockTime = 100;
         invalid_with_cltv_tx.vin.resize(1);
         invalid_with_cltv_tx.vin[0].prevout = COutPoint(spend_tx.GetId(), 1);
         invalid_with_cltv_tx.vin[0].nSequence = 0;
         invalid_with_cltv_tx.vout.resize(1);
         invalid_with_cltv_tx.vout[0].nValue = 11 * CENT;
         invalid_with_cltv_tx.vout[0].scriptPubKey = p2pk_scriptPubKey;
 
         // Sign
         std::vector<uint8_t> vchSig;
         uint256 hash = SignatureHash(
             spend_tx.vout[1].scriptPubKey, CTransaction(invalid_with_cltv_tx),
             0, SigHashType().withForkId(), spend_tx.vout[1].nValue);
         BOOST_CHECK(coinbaseKey.SignECDSA(hash, vchSig));
         vchSig.push_back(uint8_t(SIGHASH_ALL | SIGHASH_FORKID));
         invalid_with_cltv_tx.vin[0].scriptSig = CScript() << vchSig << 101;
 
-        ValidateCheckInputsForAllFlags(CTransaction(invalid_with_cltv_tx),
-                                       SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY |
-                                           SCRIPT_ENABLE_REPLAY_PROTECTION,
-                                       SCRIPT_ENABLE_SIGHASH_FORKID, true,
-                                       ::ChainstateActive().CoinsTip(), 1);
+        ValidateCheckInputsForAllFlags(
+            CTransaction(invalid_with_cltv_tx),
+            SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY | SCRIPT_ENABLE_REPLAY_PROTECTION,
+            SCRIPT_ENABLE_SIGHASH_FORKID, true,
+            m_node.chainman->ActiveChainstate().CoinsTip(), 1);
 
         // Make it valid, and check again
         invalid_with_cltv_tx.vin[0].scriptSig = CScript() << vchSig << 100;
         TxValidationState state;
 
         CTransaction transaction(invalid_with_cltv_tx);
         PrecomputedTransactionData txdata(transaction);
 
         int nSigChecksRet;
-        BOOST_CHECK(CheckInputScripts(transaction, state,
-                                      ::ChainstateActive().CoinsTip(),
-                                      STANDARD_SCRIPT_VERIFY_FLAGS, true, true,
-                                      txdata, nSigChecksRet, nullptr));
+        BOOST_CHECK(CheckInputScripts(
+            transaction, state, m_node.chainman->ActiveChainstate().CoinsTip(),
+            STANDARD_SCRIPT_VERIFY_FLAGS, true, true, txdata, nSigChecksRet,
+            nullptr));
         BOOST_CHECK(nSigChecksRet == 1);
     }
 
     // TEST CHECKSEQUENCEVERIFY
     {
         CMutableTransaction invalid_with_csv_tx;
         invalid_with_csv_tx.nVersion = 2;
         invalid_with_csv_tx.vin.resize(1);
         invalid_with_csv_tx.vin[0].prevout = COutPoint(spend_tx.GetId(), 2);
         invalid_with_csv_tx.vin[0].nSequence = 100;
         invalid_with_csv_tx.vout.resize(1);
         invalid_with_csv_tx.vout[0].nValue = 11 * CENT;
         invalid_with_csv_tx.vout[0].scriptPubKey = p2pk_scriptPubKey;
 
         // Sign
         std::vector<uint8_t> vchSig;
         uint256 hash = SignatureHash(
             spend_tx.vout[2].scriptPubKey, CTransaction(invalid_with_csv_tx), 0,
             SigHashType().withForkId(), spend_tx.vout[2].nValue);
         BOOST_CHECK(coinbaseKey.SignECDSA(hash, vchSig));
         vchSig.push_back(uint8_t(SIGHASH_ALL | SIGHASH_FORKID));
         invalid_with_csv_tx.vin[0].scriptSig = CScript() << vchSig << 101;
 
-        ValidateCheckInputsForAllFlags(CTransaction(invalid_with_csv_tx),
-                                       SCRIPT_VERIFY_CHECKSEQUENCEVERIFY |
-                                           SCRIPT_ENABLE_REPLAY_PROTECTION,
-                                       SCRIPT_ENABLE_SIGHASH_FORKID, true,
-                                       ::ChainstateActive().CoinsTip(), 1);
+        ValidateCheckInputsForAllFlags(
+            CTransaction(invalid_with_csv_tx),
+            SCRIPT_VERIFY_CHECKSEQUENCEVERIFY | SCRIPT_ENABLE_REPLAY_PROTECTION,
+            SCRIPT_ENABLE_SIGHASH_FORKID, true,
+            m_node.chainman->ActiveChainstate().CoinsTip(), 1);
 
         // Make it valid, and check again
         invalid_with_csv_tx.vin[0].scriptSig = CScript() << vchSig << 100;
         TxValidationState state;
 
         CTransaction transaction(invalid_with_csv_tx);
         PrecomputedTransactionData txdata(transaction);
 
         int nSigChecksRet;
-        BOOST_CHECK(CheckInputScripts(transaction, state,
-                                      &::ChainstateActive().CoinsTip(),
-                                      STANDARD_SCRIPT_VERIFY_FLAGS, true, true,
-                                      txdata, nSigChecksRet, nullptr));
+        BOOST_CHECK(CheckInputScripts(
+            transaction, state, &m_node.chainman->ActiveChainstate().CoinsTip(),
+            STANDARD_SCRIPT_VERIFY_FLAGS, true, true, txdata, nSigChecksRet,
+            nullptr));
         BOOST_CHECK(nSigChecksRet == 1);
     }
 
     // TODO: add tests for remaining script flags
 
     {
         // Test a transaction with multiple inputs.
         CMutableTransaction tx;
 
         tx.nVersion = 1;
         tx.vin.resize(2);
         tx.vin[0].prevout = COutPoint(spend_tx.GetId(), 0);
         tx.vin[1].prevout = COutPoint(spend_tx.GetId(), 3);
         tx.vout.resize(1);
         tx.vout[0].nValue = 22 * CENT;
         tx.vout[0].scriptPubKey = p2pk_scriptPubKey;
 
         // Sign
         {
             SignatureData sigdata;
             BOOST_CHECK(ProduceSignature(
                 keystore,
                 MutableTransactionSignatureCreator(&tx, 0, 11 * CENT,
                                                    SigHashType().withForkId()),
                 spend_tx.vout[0].scriptPubKey, sigdata));
             UpdateInput(tx.vin[0], sigdata);
         }
         {
             SignatureData sigdata;
             BOOST_CHECK(ProduceSignature(
                 keystore,
                 MutableTransactionSignatureCreator(&tx, 1, 11 * CENT,
                                                    SigHashType().withForkId()),
                 spend_tx.vout[3].scriptPubKey, sigdata));
             UpdateInput(tx.vin[1], sigdata);
         }
 
         // This should be valid under all script flags that support our sighash
         // convention.
         ValidateCheckInputsForAllFlags(
             CTransaction(tx), SCRIPT_ENABLE_REPLAY_PROTECTION,
             SCRIPT_ENABLE_SIGHASH_FORKID | SCRIPT_VERIFY_P2SH, true,
-            ::ChainstateActive().CoinsTip(), 2);
+            m_node.chainman->ActiveChainstate().CoinsTip(), 2);
 
         {
             // Try checking this valid transaction with sigchecks limiter
             // supplied. Each input consumes 1 sigcheck.
 
             TxValidationState state;
             CTransaction transaction(tx);
             PrecomputedTransactionData txdata(transaction);
             const uint32_t flags =
                 STANDARD_SCRIPT_VERIFY_FLAGS | SCRIPT_ENFORCE_SIGCHECKS;
             int nSigChecksDummy;
 
             /**
              * Parallel validation initially works (no cached value), but
              * evaluation of the script checks produces a failure.
              */
             std::vector<CScriptCheck> scriptchecks1;
             CheckInputsLimiter sigchecklimiter1(1);
             BOOST_CHECK(CheckInputScripts(
-                transaction, state, &::ChainstateActive().CoinsTip(), flags,
-                true, true, txdata, nSigChecksDummy, &scriptchecks1,
+                transaction, state,
+                &m_node.chainman->ActiveChainstate().CoinsTip(), flags, true,
+                true, txdata, nSigChecksDummy, &scriptchecks1,
                 &sigchecklimiter1));
             // the first check passes but it did consume the limit.
             BOOST_CHECK(scriptchecks1[1]());
             BOOST_CHECK(sigchecklimiter1.check());
             // the second check (the first input) fails due to the limiter.
             BOOST_CHECK(!scriptchecks1[0]());
             BOOST_CHECK_EQUAL(scriptchecks1[0].GetScriptError(),
                               ScriptError::SIGCHECKS_LIMIT_EXCEEDED);
             BOOST_CHECK(!sigchecklimiter1.check());
 
             // Serial validation fails with the limiter.
             CheckInputsLimiter sigchecklimiter2(1);
             TxValidationState state2;
             BOOST_CHECK(!CheckInputScripts(
-                transaction, state2, &::ChainstateActive().CoinsTip(), flags,
-                true, true, txdata, nSigChecksDummy, nullptr,
-                &sigchecklimiter2));
+                transaction, state2,
+                &m_node.chainman->ActiveChainstate().CoinsTip(), flags, true,
+                true, txdata, nSigChecksDummy, nullptr, &sigchecklimiter2));
             BOOST_CHECK(!sigchecklimiter2.check());
             BOOST_CHECK_EQUAL(state2.GetRejectReason(),
                               "non-mandatory-script-verify-flag (Validation "
                               "resources exceeded (SigChecks))");
 
             /**
              * A slightly more permissive limiter (just enough) passes, and
              * allows caching the result.
              */
             std::vector<CScriptCheck> scriptchecks3;
             CheckInputsLimiter sigchecklimiter3(2);
             // first in parallel
             BOOST_CHECK(CheckInputScripts(
-                transaction, state, &::ChainstateActive().CoinsTip(), flags,
-                true, true, txdata, nSigChecksDummy, &scriptchecks3,
+                transaction, state,
+                &m_node.chainman->ActiveChainstate().CoinsTip(), flags, true,
+                true, txdata, nSigChecksDummy, &scriptchecks3,
                 &sigchecklimiter3));
             BOOST_CHECK(scriptchecks3[1]());
             BOOST_CHECK(scriptchecks3[0]());
             BOOST_CHECK(sigchecklimiter3.check());
             // then in serial, caching the result.
             CheckInputsLimiter sigchecklimiter4(2);
             BOOST_CHECK(CheckInputScripts(
-                transaction, state, &::ChainstateActive().CoinsTip(), flags,
-                true, true, txdata, nSigChecksDummy, nullptr,
-                &sigchecklimiter4));
+                transaction, state,
+                &m_node.chainman->ActiveChainstate().CoinsTip(), flags, true,
+                true, txdata, nSigChecksDummy, nullptr, &sigchecklimiter4));
             BOOST_CHECK(sigchecklimiter4.check());
             // now in parallel again, grabbing the cached result.
             std::vector<CScriptCheck> scriptchecks5;
             CheckInputsLimiter sigchecklimiter5(2);
             BOOST_CHECK(CheckInputScripts(
-                transaction, state, &::ChainstateActive().CoinsTip(), flags,
-                true, true, txdata, nSigChecksDummy, &scriptchecks5,
+                transaction, state,
+                &m_node.chainman->ActiveChainstate().CoinsTip(), flags, true,
+                true, txdata, nSigChecksDummy, &scriptchecks5,
                 &sigchecklimiter5));
             BOOST_CHECK(scriptchecks5.empty());
             BOOST_CHECK(sigchecklimiter5.check());
 
             /**
              * Going back to the lower limit, we now fail immediately due to the
              * caching.
              */
             CheckInputsLimiter sigchecklimiter6(1);
             TxValidationState state6;
             BOOST_CHECK(!CheckInputScripts(
-                transaction, state6, &::ChainstateActive().CoinsTip(), flags,
-                true, true, txdata, nSigChecksDummy, nullptr,
-                &sigchecklimiter6));
+                transaction, state6,
+                &m_node.chainman->ActiveChainstate().CoinsTip(), flags, true,
+                true, txdata, nSigChecksDummy, nullptr, &sigchecklimiter6));
             BOOST_CHECK_EQUAL(state6.GetRejectReason(), "too-many-sigchecks");
             BOOST_CHECK_EQUAL(state6.GetResult(),
                               TxValidationResult::TX_CONSENSUS);
             BOOST_CHECK(!sigchecklimiter6.check());
             // even in parallel validation, immediate fail from the cache.
             std::vector<CScriptCheck> scriptchecks7;
             CheckInputsLimiter sigchecklimiter7(1);
             TxValidationState state7;
             BOOST_CHECK(!CheckInputScripts(
-                transaction, state7, &::ChainstateActive().CoinsTip(), flags,
-                true, true, txdata, nSigChecksDummy, &scriptchecks7,
+                transaction, state7,
+                &m_node.chainman->ActiveChainstate().CoinsTip(), flags, true,
+                true, txdata, nSigChecksDummy, &scriptchecks7,
                 &sigchecklimiter7));
             BOOST_CHECK_EQUAL(state7.GetRejectReason(), "too-many-sigchecks");
             BOOST_CHECK_EQUAL(state6.GetResult(),
                               TxValidationResult::TX_CONSENSUS);
             BOOST_CHECK(!sigchecklimiter7.check());
             BOOST_CHECK(scriptchecks7.empty());
         }
 
         // Check that if the second input is invalid, but the first input is
         // valid, the transaction is not cached.
         // Invalidate vin[1]
         tx.vin[1].scriptSig = CScript();
 
         TxValidationState state;
         CTransaction transaction(tx);
         PrecomputedTransactionData txdata(transaction);
 
         // This transaction is now invalid because the second signature is
         // missing.
         int nSigChecksDummy;
-        BOOST_CHECK(!CheckInputScripts(transaction, state,
-                                       &::ChainstateActive().CoinsTip(),
-                                       STANDARD_SCRIPT_VERIFY_FLAGS, true, true,
-                                       txdata, nSigChecksDummy, nullptr));
+        BOOST_CHECK(!CheckInputScripts(
+            transaction, state, &m_node.chainman->ActiveChainstate().CoinsTip(),
+            STANDARD_SCRIPT_VERIFY_FLAGS, true, true, txdata, nSigChecksDummy,
+            nullptr));
 
         // Make sure this transaction was not cached (ie becausethe first input
         // was valid)
         std::vector<CScriptCheck> scriptchecks;
         BOOST_CHECK(CheckInputScripts(
-            transaction, state, &::ChainstateActive().CoinsTip(),
+            transaction, state, &m_node.chainman->ActiveChainstate().CoinsTip(),
             STANDARD_SCRIPT_VERIFY_FLAGS | SCRIPT_ENFORCE_SIGCHECKS, true, true,
             txdata, nSigChecksDummy, &scriptchecks));
         // Should get 2 script checks back -- caching is on a whole-transaction
         // basis.
         BOOST_CHECK_EQUAL(scriptchecks.size(), 2U);
 
         // Execute the first check, and check its result
         BOOST_CHECK(scriptchecks[0]());
         BOOST_CHECK_EQUAL(scriptchecks[0].GetScriptError(), ScriptError::OK);
         BOOST_CHECK_EQUAL(
             scriptchecks[0].GetScriptExecutionMetrics().nSigChecks, 1);
         // The second check does fail
         BOOST_CHECK(!scriptchecks[1]());
         BOOST_CHECK_EQUAL(scriptchecks[1].GetScriptError(),
                           ScriptError::INVALID_STACK_OPERATION);
     }
 }
 
 BOOST_AUTO_TEST_CASE(scriptcache_values) {
     LOCK(cs_main);
     // Test insertion and querying of keys&values from the script cache.
 
     // Define a couple of macros (handier than functions since errors will print
     // out the correct line number)
 #define CHECK_CACHE_HAS(key, expected_sigchecks)                               \
     {                                                                          \
         int nSigChecksRet(0x12345678 ^ (expected_sigchecks));                  \
         BOOST_CHECK(IsKeyInScriptCache(key, false, nSigChecksRet));            \
         BOOST_CHECK(nSigChecksRet == (expected_sigchecks));                    \
     }
 #define CHECK_CACHE_MISSING(key)                                               \
     {                                                                          \
         int dummy;                                                             \
         BOOST_CHECK(!IsKeyInScriptCache(key, false, dummy));                   \
     }
 
     InitScriptExecutionCache();
 
     // construct four distinct keys from very slightly different data
     CMutableTransaction tx1;
     tx1.nVersion = 1;
     CMutableTransaction tx2;
     tx2.nVersion = 2;
     uint32_t flagsA = 0x7fffffff;
     uint32_t flagsB = 0xffffffff;
     ScriptCacheKey key1A(CTransaction(tx1), flagsA);
     ScriptCacheKey key1B(CTransaction(tx1), flagsB);
     ScriptCacheKey key2A(CTransaction(tx2), flagsA);
     ScriptCacheKey key2B(CTransaction(tx2), flagsB);
 
     BOOST_CHECK(key1A == key1A);
     BOOST_CHECK(!(key1A == key1B));
     BOOST_CHECK(!(key1A == key2A));
     BOOST_CHECK(!(key1A == key2B));
     BOOST_CHECK(key1B == key1B);
     BOOST_CHECK(!(key1B == key2A));
     BOOST_CHECK(!(key1B == key2B));
     BOOST_CHECK(key2A == key2A);
     BOOST_CHECK(!(key2A == key2B));
     BOOST_CHECK(key2B == key2B);
 
     // Key is not yet inserted.
     CHECK_CACHE_MISSING(key1A);
     // Add the key and check it worked
     AddKeyInScriptCache(key1A, 42);
     CHECK_CACHE_HAS(key1A, 42);
 
     CHECK_CACHE_MISSING(key1B);
     CHECK_CACHE_MISSING(key2A);
     CHECK_CACHE_MISSING(key2B);
 
     // 0 may be stored
     AddKeyInScriptCache(key1B, 0);
 
     // Calculate the most possible transaction sigchecks that can occur in a
     // standard transaction, and make sure the cache can hold it.
     //
     // To be pessimistic, use consensus (MAX_TX_SIZE) instead of policy
     // (MAX_STANDARD_TX_SIZE) since that particular policy limit is bypassed on
     // testnet.
     //
     // Assume that a standardness rule limiting density to ~33 bytes/sigcheck is
     // in place.
     const int max_standard_sigchecks = 1 + (MAX_TX_SIZE / 33);
     AddKeyInScriptCache(key2A, max_standard_sigchecks);
 
     // Read out values again.
     CHECK_CACHE_HAS(key1A, 42);
     CHECK_CACHE_HAS(key1B, 0);
     CHECK_CACHE_HAS(key2A, max_standard_sigchecks);
     CHECK_CACHE_MISSING(key2B);
 
     // Try overwriting an existing entry with different value (should never
     // happen in practice but see what happens).
     AddKeyInScriptCache(key1A, 99);
     // This succeeds without error, but (currently) no replacement is done.
     // It would also be acceptable to overwrite, but if we ever come to a
     // situation where this matters then neither alternative is better.
     CHECK_CACHE_HAS(key1A, 42);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index 2e5f08bb2..2f1ff3aad 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -1,446 +1,448 @@
 // Copyright (c) 2011-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <test/util/setup_common.h>
 
 #include <banman.h>
 #include <chainparams.h>
 #include <config.h>
 #include <consensus/consensus.h>
 #include <consensus/validation.h>
 #include <crypto/sha256.h>
 #include <init.h>
 #include <interfaces/chain.h>
 #include <logging.h>
 #include <miner.h>
 #include <net.h>
 #include <net_processing.h>
 #include <noui.h>
 #include <pow/pow.h>
 #include <rpc/blockchain.h>
 #include <rpc/register.h>
 #include <rpc/server.h>
 #include <scheduler.h>
 #include <script/script_error.h>
 #include <script/scriptcache.h>
 #include <script/sigcache.h>
 #include <streams.h>
 #include <txdb.h>
 #include <txmempool.h>
 #include <util/strencodings.h>
 #include <util/time.h>
 #include <util/translation.h>
 #include <util/vector.h>
 #include <validation.h>
 #include <validationinterface.h>
 #include <walletinitinterface.h>
 
 #include <functional>
 #include <memory>
 
 const std::function<std::string(const char *)> G_TRANSLATION_FUN = nullptr;
 
 FastRandomContext g_insecure_rand_ctx;
 /**
  * Random context to get unique temp data dirs. Separate from
  * g_insecure_rand_ctx, which can be seeded from a const env var
  */
 static FastRandomContext g_insecure_rand_ctx_temp_path;
 
 /**
  * Return the unsigned from the environment var if available,
  * otherwise 0
  */
 static uint256 GetUintFromEnv(const std::string &env_name) {
     const char *num = std::getenv(env_name.c_str());
     if (!num) {
         return {};
     }
     return uint256S(num);
 }
 
 void Seed(FastRandomContext &ctx) {
     // Should be enough to get the seed once for the process
     static uint256 seed{};
     static const std::string RANDOM_CTX_SEED{"RANDOM_CTX_SEED"};
     if (seed.IsNull()) {
         seed = GetUintFromEnv(RANDOM_CTX_SEED);
     }
     if (seed.IsNull()) {
         seed = GetRandHash();
     }
     LogPrintf("%s: Setting random seed for current tests to %s=%s\n", __func__,
               RANDOM_CTX_SEED, seed.GetHex());
     ctx = FastRandomContext(seed);
 }
 
 std::ostream &operator<<(std::ostream &os, const uint256 &num) {
     os << num.ToString();
     return os;
 }
 
 std::ostream &operator<<(std::ostream &os, const ScriptError &err) {
     os << ScriptErrorString(err);
     return os;
 }
 
 std::vector<const char *> fixture_extra_args{};
 
 BasicTestingSetup::BasicTestingSetup(
     const std::string &chainName, const std::vector<const char *> &extra_args)
     : m_path_root{fs::temp_directory_path() / "test_common_" PACKAGE_NAME /
                   g_insecure_rand_ctx_temp_path.rand256().ToString()},
       m_args{} {
     // clang-format off
     std::vector<const char *> arguments = Cat(
         {
             "dummy",
             "-printtoconsole=0",
             "-logsourcelocations",
             "-logtimemicros",
             "-debug",
             "-debugexclude=libevent",
             "-debugexclude=leveldb",
         },
         extra_args);
     // clang-format on
     arguments = Cat(arguments, fixture_extra_args);
     auto &config = const_cast<Config &>(GetConfig());
     SetMockTime(0);
     fs::create_directories(m_path_root);
     m_args.ForceSetArg("-datadir", fs::PathToString(m_path_root));
     gArgs.ForceSetArg("-datadir", fs::PathToString(m_path_root));
     gArgs.ClearPathCache();
     {
         SetupServerArgs(m_node);
         std::string error;
         const bool success{m_node.args->ParseParameters(
             arguments.size(), arguments.data(), error)};
         assert(success);
         assert(error.empty());
     }
     SelectParams(chainName);
     SeedInsecureRand();
     InitLogging(*m_node.args);
     AppInitParameterInteraction(config, *m_node.args);
     LogInstance().StartLogging();
     SHA256AutoDetect();
     ECC_Start();
     SetupEnvironment();
     SetupNetworking();
     InitSignatureCache();
     InitScriptExecutionCache();
 
     m_node.chain = interfaces::MakeChain(m_node, config.GetChainParams());
     g_wallet_init_interface.Construct(m_node);
 
     fCheckBlockIndex = true;
     static bool noui_connected = false;
     if (!noui_connected) {
         noui_connect();
         noui_connected = true;
     }
 }
 
 BasicTestingSetup::~BasicTestingSetup() {
     LogInstance().DisconnectTestLogger();
     fs::remove_all(m_path_root);
     gArgs.ClearArgs();
     ECC_Stop();
 }
 
 ChainTestingSetup::ChainTestingSetup(
     const std::string &chainName, const std::vector<const char *> &extra_args)
     : BasicTestingSetup(chainName, extra_args) {
     // We have to run a scheduler thread to prevent ActivateBestChain
     // from blocking due to queue overrun.
     m_node.scheduler = std::make_unique<CScheduler>();
     m_node.scheduler->m_service_thread = std::thread([&] {
         TraceThread("scheduler", [&] { m_node.scheduler->serviceQueue(); });
     });
     GetMainSignals().RegisterBackgroundSignalScheduler(*m_node.scheduler);
 
     pblocktree.reset(new CBlockTreeDB(1 << 20, true));
 
     m_node.mempool = std::make_unique<CTxMemPool>(1);
 
     m_node.chainman = &::g_chainman;
 
     constexpr int script_check_threads = 2;
     StartScriptCheckWorkerThreads(script_check_threads);
 }
 
 ChainTestingSetup::~ChainTestingSetup() {
     if (m_node.scheduler) {
         m_node.scheduler->stop();
     }
     StopScriptCheckWorkerThreads();
     GetMainSignals().FlushBackgroundCallbacks();
     GetMainSignals().UnregisterBackgroundSignalScheduler();
     m_node.connman.reset();
     m_node.banman.reset();
     m_node.args = nullptr;
     UnloadBlockIndex(m_node.mempool.get(), *m_node.chainman);
     m_node.mempool.reset();
     m_node.scheduler.reset();
     m_node.chainman->Reset();
     m_node.chainman = nullptr;
     pblocktree.reset();
 }
 
 TestingSetup::TestingSetup(const std::string &chainName,
                            const std::vector<const char *> &extra_args)
     : ChainTestingSetup(chainName, extra_args) {
     const Config &config = GetConfig();
     const CChainParams &chainparams = config.GetChainParams();
 
     // Ideally we'd move all the RPC tests to the functional testing framework
     // instead of unit tests, but for now we need these here.
     RPCServer rpcServer;
     RegisterAllRPCCommands(config, rpcServer, tableRPC);
 
     /**
      * RPC does not come out of the warmup state on its own. Normally, this is
      * handled in bitcoind's init path, but unit tests do not trigger this
      * codepath, so we call it explicitly as part of setup.
      */
     std::string rpcWarmupStatus;
     if (RPCIsInWarmup(&rpcWarmupStatus)) {
         SetRPCWarmupFinished();
     }
 
     m_node.chainman->InitializeChainstate(*m_node.mempool);
-    ::ChainstateActive().InitCoinsDB(
+    m_node.chainman->ActiveChainstate().InitCoinsDB(
         /* cache_size_bytes */ 1 << 23, /* in_memory */ true,
         /* should_wipe */ false);
-    assert(!::ChainstateActive().CanFlushToDisk());
-    ::ChainstateActive().InitCoinsCache(1 << 23);
-    assert(::ChainstateActive().CanFlushToDisk());
-    if (!::ChainstateActive().LoadGenesisBlock(chainparams)) {
+    assert(!m_node.chainman->ActiveChainstate().CanFlushToDisk());
+    m_node.chainman->ActiveChainstate().InitCoinsCache(1 << 23);
+    assert(m_node.chainman->ActiveChainstate().CanFlushToDisk());
+    if (!m_node.chainman->ActiveChainstate().LoadGenesisBlock(chainparams)) {
         throw std::runtime_error("LoadGenesisBlock failed.");
     }
     {
         BlockValidationState state;
-        if (!::ChainstateActive().ActivateBestChain(config, state)) {
+        if (!m_node.chainman->ActiveChainstate().ActivateBestChain(config,
+                                                                   state)) {
             throw std::runtime_error(
                 strprintf("ActivateBestChain failed. (%s)", state.ToString()));
         }
     }
 
     m_node.banman = std::make_unique<BanMan>(
         m_args.GetDataDirPath() / "banlist.dat", chainparams, nullptr,
         DEFAULT_MISBEHAVING_BANTIME);
     // Deterministic randomness for tests.
     m_node.connman = std::make_unique<CConnman>(config, 0x1337, 0x1337);
     m_node.peerman = PeerManager::make(
         chainparams, *m_node.connman, m_node.banman.get(), *m_node.scheduler,
         *m_node.chainman, *m_node.mempool, false);
     {
         CConnman::Options options;
         options.m_msgproc.push_back(m_node.peerman.get());
         m_node.connman->Init(options);
     }
 }
 
 TestChain100Setup::TestChain100Setup(bool deterministic) {
     m_deterministic = deterministic;
 
     if (m_deterministic) {
         SetMockTime(1598887952);
         constexpr std::array<uint8_t, 32> vchKey = {
             {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
              0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}};
         coinbaseKey.Set(vchKey.begin(), vchKey.end(), false);
     } else {
         coinbaseKey.MakeNewKey(true);
     }
 
     // Generate a 100-block chain:
     this->mineBlocks(COINBASE_MATURITY);
 
     if (m_deterministic) {
         LOCK(::cs_main);
         assert(
-            m_node.chainman->ActiveChain().Tip()->GetBlockHash().ToString() ==
+            m_node.chainman->ActiveTip()->GetBlockHash().ToString() ==
             "7709f3c48b74400f751dc88fcb318431cbe43f2284c43d830775defb89b50168");
     }
 }
 
 void TestChain100Setup::mineBlocks(int num_blocks) {
     CScript scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey())
                                      << OP_CHECKSIG;
     for (int i = 0; i < num_blocks; i++) {
         std::vector<CMutableTransaction> noTxns;
         CBlock b = CreateAndProcessBlock(noTxns, scriptPubKey);
         if (m_deterministic) {
             SetMockTime(GetTime() + 1);
         }
         m_coinbase_txns.push_back(b.vtx[0]);
     }
 }
 
 CBlock TestChain100Setup::CreateAndProcessBlock(
     const std::vector<CMutableTransaction> &txns, const CScript &scriptPubKey) {
     const Config &config = GetConfig();
     CTxMemPool empty_pool;
-    CBlock block = BlockAssembler(config, ::ChainstateActive(), empty_pool)
-                       .CreateNewBlock(scriptPubKey)
-                       ->block;
+    CBlock block =
+        BlockAssembler(config, m_node.chainman->ActiveChainstate(), empty_pool)
+            .CreateNewBlock(scriptPubKey)
+            ->block;
 
     Assert(block.vtx.size() == 1);
     for (const CMutableTransaction &tx : txns) {
         block.vtx.push_back(MakeTransactionRef(tx));
     }
 
     // Order transactions by canonical order
     std::sort(std::begin(block.vtx) + 1, std::end(block.vtx),
               [](const std::shared_ptr<const CTransaction> &txa,
                  const std::shared_ptr<const CTransaction> &txb) -> bool {
                   return txa->GetId() < txb->GetId();
               });
 
     // IncrementExtraNonce creates a valid coinbase and merkleRoot
     {
         LOCK(cs_main);
         unsigned int extraNonce = 0;
-        IncrementExtraNonce(&block, ::ChainActive().Tip(),
+        IncrementExtraNonce(&block, m_node.chainman->ActiveTip(),
                             config.GetMaxBlockSize(), extraNonce);
     }
 
     const Consensus::Params &params = config.GetChainParams().GetConsensus();
     while (!CheckProofOfWork(block.GetHash(), block.nBits, params)) {
         ++block.nNonce;
     }
 
     std::shared_ptr<const CBlock> shared_pblock =
         std::make_shared<const CBlock>(block);
     Assert(m_node.chainman)
         ->ProcessNewBlock(config, shared_pblock, true, nullptr);
 
     return block;
 }
 
 TestChain100Setup::~TestChain100Setup() {
     if (m_deterministic) {
         SetMockTime(0);
     }
 }
 
 CTxMemPoolEntry
 TestMemPoolEntryHelper::FromTx(const CMutableTransaction &tx) const {
     return FromTx(MakeTransactionRef(tx));
 }
 
 CTxMemPoolEntry
 TestMemPoolEntryHelper::FromTx(const CTransactionRef &tx) const {
     return CTxMemPoolEntry(tx, nFee, nTime, nHeight, spendsCoinbase,
                            nSigOpCount, LockPoints());
 }
 
 /**
  * @returns a real block
  * (0000000000013b8ab2cd513b0261a14096412195a72a0c4827d229dcc7e0f7af) with 9
  * txs.
  */
 CBlock getBlock13b8a() {
     CBlock block;
     CDataStream stream(
         ParseHex(
             "0100000090f0a9f110702f808219ebea1173056042a714bad51b916cb680000000"
             "0000005275289558f51c9966699404ae2294730c3c9f9bda53523ce50e9b95e558"
             "da2fdb261b4d4c86041b1ab1bf9309010000000100000000000000000000000000"
             "00000000000000000000000000000000000000ffffffff07044c86041b0146ffff"
             "ffff0100f2052a01000000434104e18f7afbe4721580e81e8414fc8c24d7cfacf2"
             "54bb5c7b949450c3e997c2dc1242487a8169507b631eb3771f2b425483fb13102c"
             "4eb5d858eef260fe70fbfae0ac00000000010000000196608ccbafa16abada9027"
             "80da4dc35dafd7af05fa0da08cf833575f8cf9e836000000004a493046022100da"
             "b24889213caf43ae6adc41cf1c9396c08240c199f5225acf45416330fd7dbd0221"
             "00fe37900e0644bf574493a07fc5edba06dbc07c311b947520c2d514bc5725dcb4"
             "01ffffffff0100f2052a010000001976a914f15d1921f52e4007b146dfa60f369e"
             "d2fc393ce288ac000000000100000001fb766c1288458c2bafcfec81e48b24d98e"
             "c706de6b8af7c4e3c29419bfacb56d000000008c493046022100f268ba165ce0ad"
             "2e6d93f089cfcd3785de5c963bb5ea6b8c1b23f1ce3e517b9f022100da7c0f21ad"
             "c6c401887f2bfd1922f11d76159cbc597fbd756a23dcbb00f4d7290141042b4e86"
             "25a96127826915a5b109852636ad0da753c9e1d5606a50480cd0c40f1f8b8d8982"
             "35e571fe9357d9ec842bc4bba1827daaf4de06d71844d0057707966affffffff02"
             "80969800000000001976a9146963907531db72d0ed1a0cfb471ccb63923446f388"
             "ac80d6e34c000000001976a914f0688ba1c0d1ce182c7af6741e02658c7d4dfcd3"
             "88ac000000000100000002c40297f730dd7b5a99567eb8d27b78758f607507c522"
             "92d02d4031895b52f2ff010000008b483045022100f7edfd4b0aac404e5bab4fd3"
             "889e0c6c41aa8d0e6fa122316f68eddd0a65013902205b09cc8b2d56e1cd1f7f2f"
             "afd60a129ed94504c4ac7bdc67b56fe67512658b3e014104732012cb962afa90d3"
             "1b25d8fb0e32c94e513ab7a17805c14ca4c3423e18b4fb5d0e676841733cb83aba"
             "f975845c9f6f2a8097b7d04f4908b18368d6fc2d68ecffffffffca5065ff9617cb"
             "cba45eb23726df6498a9b9cafed4f54cbab9d227b0035ddefb000000008a473044"
             "022068010362a13c7f9919fa832b2dee4e788f61f6f5d344a7c2a0da6ae7406056"
             "58022006d1af525b9a14a35c003b78b72bd59738cd676f845d1ff3fc25049e0100"
             "3614014104732012cb962afa90d31b25d8fb0e32c94e513ab7a17805c14ca4c342"
             "3e18b4fb5d0e676841733cb83abaf975845c9f6f2a8097b7d04f4908b18368d6fc"
             "2d68ecffffffff01001ec4110200000043410469ab4181eceb28985b9b4e895c13"
             "fa5e68d85761b7eee311db5addef76fa8621865134a221bd01f28ec9999ee3e021"
             "e60766e9d1f3458c115fb28650605f11c9ac000000000100000001cdaf2f758e91"
             "c514655e2dc50633d1e4c84989f8aa90a0dbc883f0d23ed5c2fa010000008b4830"
             "4502207ab51be6f12a1962ba0aaaf24a20e0b69b27a94fac5adf45aa7d2d18ffd9"
             "236102210086ae728b370e5329eead9accd880d0cb070aea0c96255fae6c4f1ddc"
             "ce1fd56e014104462e76fd4067b3a0aa42070082dcb0bf2f388b6495cf33d78990"
             "4f07d0f55c40fbd4b82963c69b3dc31895d0c772c812b1d5fbcade15312ef1c0e8"
             "ebbb12dcd4ffffffff02404b4c00000000001976a9142b6ba7c9d796b75eef7942"
             "fc9288edd37c32f5c388ac002d3101000000001976a9141befba0cdc1ad5652937"
             "1864d9f6cb042faa06b588ac000000000100000001b4a47603e71b61bc3326efd9"
             "0111bf02d2f549b067f4c4a8fa183b57a0f800cb010000008a4730440220177c37"
             "f9a505c3f1a1f0ce2da777c339bd8339ffa02c7cb41f0a5804f473c9230220585b"
             "25a2ee80eb59292e52b987dad92acb0c64eced92ed9ee105ad153cdb12d0014104"
             "43bd44f683467e549dae7d20d1d79cbdb6df985c6e9c029c8d0c6cb46cc1a4d3cf"
             "7923c5021b27f7a0b562ada113bc85d5fda5a1b41e87fe6e8802817cf69996ffff"
             "ffff0280651406000000001976a9145505614859643ab7b547cd7f1f5e7e2a1232"
             "2d3788ac00aa0271000000001976a914ea4720a7a52fc166c55ff2298e07baf70a"
             "e67e1b88ac00000000010000000586c62cd602d219bb60edb14a3e204de0705176"
             "f9022fe49a538054fb14abb49e010000008c493046022100f2bc2aba2534becbdf"
             "062eb993853a42bbbc282083d0daf9b4b585bd401aa8c9022100b1d7fd7ee0b956"
             "00db8535bbf331b19eed8d961f7a8e54159c53675d5f69df8c014104462e76fd40"
             "67b3a0aa42070082dcb0bf2f388b6495cf33d789904f07d0f55c40fbd4b82963c6"
             "9b3dc31895d0c772c812b1d5fbcade15312ef1c0e8ebbb12dcd4ffffffff03ad0e"
             "58ccdac3df9dc28a218bcf6f1997b0a93306faaa4b3a28ae83447b217901000000"
             "8b483045022100be12b2937179da88599e27bb31c3525097a07cdb52422d165b3c"
             "a2f2020ffcf702200971b51f853a53d644ebae9ec8f3512e442b1bcb6c315a5b49"
             "1d119d10624c83014104462e76fd4067b3a0aa42070082dcb0bf2f388b6495cf33"
             "d789904f07d0f55c40fbd4b82963c69b3dc31895d0c772c812b1d5fbcade15312e"
             "f1c0e8ebbb12dcd4ffffffff2acfcab629bbc8685792603762c921580030ba144a"
             "f553d271716a95089e107b010000008b483045022100fa579a840ac258871365dd"
             "48cd7552f96c8eea69bd00d84f05b283a0dab311e102207e3c0ee9234814cfbb1b"
             "659b83671618f45abc1326b9edcc77d552a4f2a805c0014104462e76fd4067b3a0"
             "aa42070082dcb0bf2f388b6495cf33d789904f07d0f55c40fbd4b82963c69b3dc3"
             "1895d0c772c812b1d5fbcade15312ef1c0e8ebbb12dcd4ffffffffdcdc6023bbc9"
             "944a658ddc588e61eacb737ddf0a3cd24f113b5a8634c517fcd2000000008b4830"
             "450221008d6df731df5d32267954bd7d2dda2302b74c6c2a6aa5c0ca64ecbabc1a"
             "f03c75022010e55c571d65da7701ae2da1956c442df81bbf076cdbac25133f99d9"
             "8a9ed34c014104462e76fd4067b3a0aa42070082dcb0bf2f388b6495cf33d78990"
             "4f07d0f55c40fbd4b82963c69b3dc31895d0c772c812b1d5fbcade15312ef1c0e8"
             "ebbb12dcd4ffffffffe15557cd5ce258f479dfd6dc6514edf6d7ed5b21fcfa4a03"
             "8fd69f06b83ac76e010000008b483045022023b3e0ab071eb11de2eb1cc3a67261"
             "b866f86bf6867d4558165f7c8c8aca2d86022100dc6e1f53a91de3efe8f6351285"
             "0811f26284b62f850c70ca73ed5de8771fb451014104462e76fd4067b3a0aa4207"
             "0082dcb0bf2f388b6495cf33d789904f07d0f55c40fbd4b82963c69b3dc31895d0"
             "c772c812b1d5fbcade15312ef1c0e8ebbb12dcd4ffffffff01404b4c0000000000"
             "1976a9142b6ba7c9d796b75eef7942fc9288edd37c32f5c388ac00000000010000"
             "000166d7577163c932b4f9690ca6a80b6e4eb001f0a2fa9023df5595602aae96ed"
             "8d000000008a4730440220262b42546302dfb654a229cefc86432b89628ff259dc"
             "87edd1154535b16a67e102207b4634c020a97c3e7bbd0d4d19da6aa2269ad9dded"
             "4026e896b213d73ca4b63f014104979b82d02226b3a4597523845754d44f13639e"
             "3bf2df5e82c6aab2bdc79687368b01b1ab8b19875ae3c90d661a3d0a33161dab29"
             "934edeb36aa01976be3baf8affffffff02404b4c00000000001976a9144854e695"
             "a02af0aeacb823ccbc272134561e0a1688ac40420f00000000001976a914abee93"
             "376d6b37b5c2940655a6fcaf1c8e74237988ac0000000001000000014e3f8ef2e9"
             "1349a9059cb4f01e54ab2597c1387161d3da89919f7ea6acdbb371010000008c49"
             "304602210081f3183471a5ca22307c0800226f3ef9c353069e0773ac76bb580654"
             "d56aa523022100d4c56465bdc069060846f4fbf2f6b20520b2a80b08b168b31e66"
             "ddb9c694e240014104976c79848e18251612f8940875b2b08d06e6dc73b9840e88"
             "60c066b7e87432c477e9a59a453e71e6d76d5fe34058b800a098fc1740ce3012e8"
             "fc8a00c96af966ffffffff02c0e1e400000000001976a9144134e75a6fcb604203"
             "4aab5e18570cf1f844f54788ac404b4c00000000001976a9142b6ba7c9d796b75e"
             "ef7942fc9288edd37c32f5c388ac00000000"),
         SER_NETWORK, PROTOCOL_VERSION);
     stream >> block;
     return block;
 }
diff --git a/src/test/validation_block_tests.cpp b/src/test/validation_block_tests.cpp
index 4fb3c6b71..5bc230c1e 100644
--- a/src/test/validation_block_tests.cpp
+++ b/src/test/validation_block_tests.cpp
@@ -1,390 +1,390 @@
 // Copyright (c) 2018-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <boost/test/unit_test.hpp>
 
 #include <chain.h>
 #include <chainparams.h>
 #include <config.h>
 #include <consensus/merkle.h>
 #include <consensus/validation.h>
 #include <miner.h>
 #include <pow/pow.h>
 #include <random.h>
 #include <script/standard.h>
 #include <test/util/setup_common.h>
 #include <util/time.h>
 #include <validation.h>
 #include <validationinterface.h>
 
 #include <thread>
 
 namespace validation_block_tests {
 struct MinerTestingSetup : public RegTestingSetup {
     std::shared_ptr<CBlock> Block(const Config &config,
                                   const BlockHash &prev_hash);
     std::shared_ptr<const CBlock> GoodBlock(const Config &config,
                                             const BlockHash &prev_hash);
     std::shared_ptr<const CBlock> BadBlock(const Config &config,
                                            const BlockHash &prev_hash);
     std::shared_ptr<CBlock> FinalizeBlock(const Consensus::Params &params,
                                           std::shared_ptr<CBlock> pblock);
     void BuildChain(const Config &config, const BlockHash &root, int height,
                     const unsigned int invalid_rate,
                     const unsigned int branch_rate, const unsigned int max_size,
                     std::vector<std::shared_ptr<const CBlock>> &blocks);
 };
 } // namespace validation_block_tests
 
 BOOST_FIXTURE_TEST_SUITE(validation_block_tests, MinerTestingSetup)
 
 struct TestSubscriber final : public CValidationInterface {
     uint256 m_expected_tip;
 
     explicit TestSubscriber(uint256 tip) : m_expected_tip(tip) {}
 
     void UpdatedBlockTip(const CBlockIndex *pindexNew,
                          const CBlockIndex *pindexFork,
                          bool fInitialDownload) override {
         BOOST_CHECK_EQUAL(m_expected_tip, pindexNew->GetBlockHash());
     }
 
     void BlockConnected(const std::shared_ptr<const CBlock> &block,
                         const CBlockIndex *pindex) override {
         BOOST_CHECK_EQUAL(m_expected_tip, block->hashPrevBlock);
         BOOST_CHECK_EQUAL(m_expected_tip, pindex->pprev->GetBlockHash());
 
         m_expected_tip = block->GetHash();
     }
 
     void BlockDisconnected(const std::shared_ptr<const CBlock> &block,
                            const CBlockIndex *pindex) override {
         BOOST_CHECK_EQUAL(m_expected_tip, block->GetHash());
         BOOST_CHECK_EQUAL(m_expected_tip, pindex->GetBlockHash());
 
         m_expected_tip = block->hashPrevBlock;
     }
 };
 
 std::shared_ptr<CBlock> MinerTestingSetup::Block(const Config &config,
                                                  const BlockHash &prev_hash) {
     static int i = 0;
     static uint64_t time = config.GetChainParams().GenesisBlock().nTime;
 
     CScript pubKey;
     pubKey << i++ << OP_TRUE;
 
     auto ptemplate = BlockAssembler(config, m_node.chainman->ActiveChainstate(),
                                     *m_node.mempool)
                          .CreateNewBlock(pubKey);
     auto pblock = std::make_shared<CBlock>(ptemplate->block);
     pblock->hashPrevBlock = prev_hash;
     pblock->nTime = ++time;
 
     pubKey.clear();
     {
         pubKey << OP_HASH160 << ToByteVector(CScriptID(CScript() << OP_TRUE))
                << OP_EQUAL;
     }
     // Make the coinbase transaction with two outputs:
     // One zero-value one that has a unique pubkey to make sure that blocks at
     // the same height can have a different hash. Another one that has the
     // coinbase reward in a P2SH with OP_TRUE as scriptPubKey to make it easy to
     // spend
     CMutableTransaction txCoinbase(*pblock->vtx[0]);
     txCoinbase.vout.resize(2);
     txCoinbase.vout[1].scriptPubKey = pubKey;
     txCoinbase.vout[1].nValue = txCoinbase.vout[0].nValue;
     txCoinbase.vout[0].nValue = Amount::zero();
     pblock->vtx[0] = MakeTransactionRef(std::move(txCoinbase));
 
     return pblock;
 }
 
 std::shared_ptr<CBlock>
 MinerTestingSetup::FinalizeBlock(const Consensus::Params &params,
                                  std::shared_ptr<CBlock> pblock) {
     pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);
 
     while (!CheckProofOfWork(pblock->GetHash(), pblock->nBits, params)) {
         ++(pblock->nNonce);
     }
 
     return pblock;
 }
 
 // construct a valid block
 std::shared_ptr<const CBlock>
 MinerTestingSetup::GoodBlock(const Config &config, const BlockHash &prev_hash) {
     return FinalizeBlock(config.GetChainParams().GetConsensus(),
                          Block(config, prev_hash));
 }
 
 // construct an invalid block (but with a valid header)
 std::shared_ptr<const CBlock>
 MinerTestingSetup::BadBlock(const Config &config, const BlockHash &prev_hash) {
     auto pblock = Block(config, prev_hash);
 
     CMutableTransaction coinbase_spend;
     coinbase_spend.vin.push_back(
         CTxIn(COutPoint(pblock->vtx[0]->GetId(), 0), CScript(), 0));
     coinbase_spend.vout.push_back(pblock->vtx[0]->vout[0]);
 
     CTransactionRef tx = MakeTransactionRef(coinbase_spend);
     pblock->vtx.push_back(tx);
 
     auto ret = FinalizeBlock(config.GetChainParams().GetConsensus(), pblock);
     return ret;
 }
 
 void MinerTestingSetup::BuildChain(
     const Config &config, const BlockHash &root, int height,
     const unsigned int invalid_rate, const unsigned int branch_rate,
     const unsigned int max_size,
     std::vector<std::shared_ptr<const CBlock>> &blocks) {
     if (height <= 0 || blocks.size() >= max_size) {
         return;
     }
 
     bool gen_invalid = InsecureRandRange(100) < invalid_rate;
     bool gen_fork = InsecureRandRange(100) < branch_rate;
 
     const std::shared_ptr<const CBlock> pblock =
         gen_invalid ? BadBlock(config, root) : GoodBlock(config, root);
     blocks.push_back(pblock);
     if (!gen_invalid) {
         BuildChain(config, pblock->GetHash(), height - 1, invalid_rate,
                    branch_rate, max_size, blocks);
     }
 
     if (gen_fork) {
         blocks.push_back(GoodBlock(config, root));
         BuildChain(config, blocks.back()->GetHash(), height - 1, invalid_rate,
                    branch_rate, max_size, blocks);
     }
 }
 
 BOOST_AUTO_TEST_CASE(processnewblock_signals_ordering) {
     GlobalConfig config;
     const CChainParams &chainParams = config.GetChainParams();
 
     // build a large-ish chain that's likely to have some forks
     std::vector<std::shared_ptr<const CBlock>> blocks;
     while (blocks.size() < 50) {
         blocks.clear();
         BuildChain(config, chainParams.GenesisBlock().GetHash(), 100, 15, 10,
                    500, blocks);
     }
 
     bool ignored;
     BlockValidationState state;
     std::vector<CBlockHeader> headers;
     std::transform(
         blocks.begin(), blocks.end(), std::back_inserter(headers),
         [](std::shared_ptr<const CBlock> b) { return b->GetBlockHeader(); });
 
     // Process all the headers so we understand the toplogy of the chain
     BOOST_CHECK(Assert(m_node.chainman)
                     ->ProcessNewBlockHeaders(config, headers, state));
 
     // Connect the genesis block and drain any outstanding events
     BOOST_CHECK(Assert(m_node.chainman)
                     ->ProcessNewBlock(
                         config,
                         std::make_shared<CBlock>(chainParams.GenesisBlock()),
                         true, &ignored));
     SyncWithValidationInterfaceQueue();
 
     // subscribe to events (this subscriber will validate event ordering)
     const CBlockIndex *initial_tip = nullptr;
     {
         LOCK(cs_main);
-        initial_tip = ::ChainActive().Tip();
+        initial_tip = m_node.chainman->ActiveTip();
     }
     auto sub = std::make_shared<TestSubscriber>(initial_tip->GetBlockHash());
     RegisterSharedValidationInterface(sub);
 
     // create a bunch of threads that repeatedly process a block generated above
     // at random this will create parallelism and randomness inside validation -
     // the ValidationInterface will subscribe to events generated during block
     // validation and assert on ordering invariance
     std::vector<std::thread> threads;
     for (int i = 0; i < 10; i++) {
         threads.emplace_back([&]() {
             bool tlignored;
             FastRandomContext insecure;
             for (int j = 0; j < 1000; j++) {
                 auto block = blocks[insecure.randrange(blocks.size() - 1)];
                 Assert(m_node.chainman)
                     ->ProcessNewBlock(config, block, true, &tlignored);
             }
 
             // to make sure that eventually we process the full chain - do it
             // here
             for (auto block : blocks) {
                 if (block->vtx.size() == 1) {
                     bool processed =
                         Assert(m_node.chainman)
                             ->ProcessNewBlock(config, block, true, &tlignored);
                     assert(processed);
                 }
             }
         });
     }
 
     for (auto &t : threads) {
         t.join();
     }
     SyncWithValidationInterfaceQueue();
 
     UnregisterSharedValidationInterface(sub);
 
     LOCK(cs_main);
     BOOST_CHECK_EQUAL(sub->m_expected_tip,
-                      ::ChainActive().Tip()->GetBlockHash());
+                      m_node.chainman->ActiveTip()->GetBlockHash());
 }
 
 /**
  * Test that mempool updates happen atomically with reorgs.
  *
  * This prevents RPC clients, among others, from retrieving
  * immediately-out-of-date mempool data during large reorgs.
  *
  * The test verifies this by creating a chain of `num_txs` blocks, matures their
  * coinbases, and then submits txns spending from their coinbase to the mempool.
  * A fork chain is then processed, invalidating the txns and evicting them from
  * the mempool.
  *
  * We verify that the mempool updates atomically by polling it continuously
  * from another thread during the reorg and checking that its size only changes
  * once. The size changing exactly once indicates that the polling thread's
  * view of the mempool is either consistent with the chain state before reorg,
  * or consistent with the chain state after the reorg, and not just consistent
  * with some intermediate state during the reorg.
  */
 BOOST_AUTO_TEST_CASE(mempool_locks_reorg) {
     GlobalConfig config;
     const CChainParams &chainParams = config.GetChainParams();
 
     bool ignored;
     auto ProcessBlock = [&](std::shared_ptr<const CBlock> block) -> bool {
         return Assert(m_node.chainman)
             ->ProcessNewBlock(config, block, /* fForceProcessing */ true,
                               /* fNewBlock */ &ignored);
     };
 
     // Process all mined blocks
     BOOST_REQUIRE(
         ProcessBlock(std::make_shared<CBlock>(chainParams.GenesisBlock())));
     auto last_mined = GoodBlock(config, chainParams.GenesisBlock().GetHash());
     BOOST_REQUIRE(ProcessBlock(last_mined));
 
     // Run the test multiple times
     for (int test_runs = 3; test_runs > 0; --test_runs) {
         BOOST_CHECK_EQUAL(last_mined->GetHash(),
-                          ::ChainActive().Tip()->GetBlockHash());
+                          m_node.chainman->ActiveTip()->GetBlockHash());
 
         // Later on split from here
         const BlockHash split_hash{last_mined->hashPrevBlock};
 
         // Create a bunch of transactions to spend the miner rewards of the
         // most recent blocks
         std::vector<CTransactionRef> txs;
         for (int num_txs = 22; num_txs > 0; --num_txs) {
             CMutableTransaction mtx;
             mtx.vin.push_back(
                 CTxIn(COutPoint(last_mined->vtx[0]->GetId(), 1),
                       CScript() << ToByteVector(CScript() << OP_TRUE)));
             // Two outputs to make sure the transaction is larger than 100 bytes
             for (int i = 1; i < 3; ++i) {
                 mtx.vout.emplace_back(
                     CTxOut(50000 * SATOSHI,
                            CScript() << OP_DUP << OP_HASH160
                                      << ToByteVector(CScriptID(CScript() << i))
                                      << OP_EQUALVERIFY << OP_CHECKSIG));
             }
             txs.push_back(MakeTransactionRef(mtx));
             last_mined = GoodBlock(config, last_mined->GetHash());
             BOOST_REQUIRE(ProcessBlock(last_mined));
         }
 
         // Mature the inputs of the txs
         for (int j = COINBASE_MATURITY; j > 0; --j) {
             last_mined = GoodBlock(config, last_mined->GetHash());
             BOOST_REQUIRE(ProcessBlock(last_mined));
         }
 
         // Mine a reorg (and hold it back) before adding the txs to the mempool
         const BlockHash tip_init{last_mined->GetHash()};
 
         std::vector<std::shared_ptr<const CBlock>> reorg;
         last_mined = GoodBlock(config, split_hash);
         reorg.push_back(last_mined);
         for (size_t j = COINBASE_MATURITY + txs.size() + 1; j > 0; --j) {
             last_mined = GoodBlock(config, last_mined->GetHash());
             reorg.push_back(last_mined);
         }
 
         // Add the txs to the tx pool
         {
             LOCK(cs_main);
             TxValidationState state;
             for (const auto &tx : txs) {
                 BOOST_REQUIRE_MESSAGE(
-                    AcceptToMemoryPool(::ChainstateActive(), config,
-                                       *m_node.mempool, state, tx,
+                    AcceptToMemoryPool(m_node.chainman->ActiveChainstate(),
+                                       config, *m_node.mempool, state, tx,
                                        /* bypass_limits */ false),
                     state.GetRejectReason());
             }
         }
 
         // Check that all txs are in the pool
         {
             LOCK(m_node.mempool->cs);
             BOOST_CHECK_EQUAL(m_node.mempool->mapTx.size(), txs.size());
         }
 
         // Run a thread that simulates an RPC caller that is polling while
         // validation is doing a reorg
         std::thread rpc_thread{[&]() {
             // This thread is checking that the mempool either contains all of
             // the transactions invalidated by the reorg, or none of them, and
             // not some intermediate amount.
             while (true) {
                 LOCK(m_node.mempool->cs);
                 if (m_node.mempool->mapTx.size() == 0) {
                     // We are done with the reorg
                     break;
                 }
                 // Internally, we might be in the middle of the reorg, but
                 // externally the reorg to the most-proof-of-work chain should
                 // be atomic. So the caller assumes that the returned mempool
                 // is consistent. That is, it has all txs that were there
                 // before the reorg.
                 assert(m_node.mempool->mapTx.size() == txs.size());
                 continue;
             }
             LOCK(cs_main);
             // We are done with the reorg, so the tip must have changed
-            assert(tip_init != ::ChainActive().Tip()->GetBlockHash());
+            assert(tip_init != m_node.chainman->ActiveTip()->GetBlockHash());
         }};
 
         // Make sure we disable reorg protection.
         gArgs.ForceSetArg("-parkdeepreorg", "false");
 
         // Submit the reorg in this thread to invalidate and remove the txs from
         // the tx pool
         for (const auto &b : reorg) {
             ProcessBlock(b);
         }
         // Check that the reorg was eventually successful
         BOOST_CHECK_EQUAL(last_mined->GetHash(),
-                          ::ChainActive().Tip()->GetBlockHash());
+                          m_node.chainman->ActiveTip()->GetBlockHash());
 
         // We can join the other thread, which returns when the reorg was
         // successful
         rpc_thread.join();
     }
 }
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/validation_tests.cpp b/src/test/validation_tests.cpp
index c8399f320..0e0eea7d7 100644
--- a/src/test/validation_tests.cpp
+++ b/src/test/validation_tests.cpp
@@ -1,161 +1,163 @@
 // Copyright (c) 2011-2019 The Bitcoin Core developers
 // Copyright (c) 2017-2019 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <validation.h>
 
 #include <chainparams.h>
 #include <clientversion.h>
 #include <config.h>
 #include <consensus/consensus.h>
 #include <net.h>
 #include <primitives/transaction.h>
 #include <streams.h>
 #include <uint256.h>
 #include <util/system.h>
 #include <validation.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/signals2/signal.hpp>
 #include <boost/test/unit_test.hpp>
 
 #include <cstdint>
 #include <cstdio>
 #include <vector>
 
 BOOST_FIXTURE_TEST_SUITE(validation_tests, TestingSetup)
 
 static void TestBlockSubsidyHalvings(const Consensus::Params &consensusParams) {
     int maxHalvings = 64;
     Amount nInitialSubsidy = 50 * COIN;
 
     // for height == 0
     Amount nPreviousSubsidy = 2 * nInitialSubsidy;
     BOOST_CHECK_EQUAL(nPreviousSubsidy, 2 * nInitialSubsidy);
     for (int nHalvings = 0; nHalvings < maxHalvings; nHalvings++) {
         int nHeight = nHalvings * consensusParams.nSubsidyHalvingInterval;
         Amount nSubsidy = GetBlockSubsidy(nHeight, consensusParams);
         BOOST_CHECK(nSubsidy <= nInitialSubsidy);
         BOOST_CHECK_EQUAL(nSubsidy, nPreviousSubsidy / 2);
         nPreviousSubsidy = nSubsidy;
     }
     BOOST_CHECK_EQUAL(
         GetBlockSubsidy(maxHalvings * consensusParams.nSubsidyHalvingInterval,
                         consensusParams),
         Amount::zero());
 }
 
 static void TestBlockSubsidyHalvings(int nSubsidyHalvingInterval) {
     Consensus::Params consensusParams;
     consensusParams.nSubsidyHalvingInterval = nSubsidyHalvingInterval;
     TestBlockSubsidyHalvings(consensusParams);
 }
 
 BOOST_AUTO_TEST_CASE(block_subsidy_test) {
     const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
     // As in main
     TestBlockSubsidyHalvings(chainParams->GetConsensus());
     // As in regtest
     TestBlockSubsidyHalvings(150);
     // Just another interval
     TestBlockSubsidyHalvings(1000);
 }
 
 BOOST_AUTO_TEST_CASE(subsidy_limit_test) {
     const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
     Amount nSum = Amount::zero();
     for (int nHeight = 0; nHeight < 14000000; nHeight += 1000) {
         Amount nSubsidy = GetBlockSubsidy(nHeight, chainParams->GetConsensus());
         BOOST_CHECK(nSubsidy <= 50 * COIN);
         nSum += 1000 * nSubsidy;
         BOOST_CHECK(MoneyRange(nSum));
     }
     BOOST_CHECK_EQUAL(nSum, int64_t(2099999997690000LL) * SATOSHI);
 }
 
 static CBlock makeLargeDummyBlock(const size_t num_tx) {
     CBlock block;
     block.vtx.reserve(num_tx);
 
     CTransaction tx;
     for (size_t i = 0; i < num_tx; i++) {
         block.vtx.push_back(MakeTransactionRef(tx));
     }
     return block;
 }
 
 /**
  * Test that LoadExternalBlockFile works with the buffer size set below the
  * size of a large block. Currently, LoadExternalBlockFile has the buffer size
  * for CBufferedFile set to 2 * MAX_TX_SIZE. Test with a value of
  * 10 * MAX_TX_SIZE.
  */
 BOOST_AUTO_TEST_CASE(validation_load_external_block_file) {
     fs::path tmpfile_name = GetDataDir() / "block.dat";
 
     FILE *fp = fopen(fs::PathToString(tmpfile_name).c_str(), "wb+");
 
     BOOST_CHECK(fp != nullptr);
 
     const Config &config = GetConfig();
     const CChainParams &chainparams = config.GetChainParams();
 
     // serialization format is:
     // message start magic, size of block, block
 
     size_t nwritten = fwrite(std::begin(chainparams.DiskMagic()),
                              CMessageHeader::MESSAGE_START_SIZE, 1, fp);
 
     BOOST_CHECK_EQUAL(nwritten, 1UL);
 
     CTransaction empty_tx;
     size_t empty_tx_size = GetSerializeSize(empty_tx, CLIENT_VERSION);
 
     size_t num_tx = (10 * MAX_TX_SIZE) / empty_tx_size;
 
     CBlock block = makeLargeDummyBlock(num_tx);
 
     BOOST_CHECK(GetSerializeSize(block, CLIENT_VERSION) > 2 * MAX_TX_SIZE);
 
     unsigned int size = GetSerializeSize(block, CLIENT_VERSION);
     {
         CAutoFile outs(fp, SER_DISK, CLIENT_VERSION);
         outs << size;
         outs << block;
         outs.release();
     }
 
     fseek(fp, 0, SEEK_SET);
-    BOOST_CHECK_NO_THROW(
-        { ::ChainstateActive().LoadExternalBlockFile(config, fp, 0); });
+    BOOST_CHECK_NO_THROW({
+        m_node.chainman->ActiveChainstate().LoadExternalBlockFile(config, fp,
+                                                                  0);
+    });
 }
 
 //! Test retrieval of valid assumeutxo values.
 BOOST_AUTO_TEST_CASE(test_assumeutxo) {
     const auto params = CreateChainParams(CBaseChainParams::REGTEST);
 
     // These heights don't have assumeutxo configurations associated, per the
     // contents of chainparams.cpp.
     std::vector<int> bad_heights{0, 100, 111, 115, 209, 211};
 
     for (auto empty : bad_heights) {
         const auto out = ExpectedAssumeutxo(empty, *params);
         BOOST_CHECK(!out);
     }
 
     const auto out110 = *ExpectedAssumeutxo(110, *params);
     BOOST_CHECK_EQUAL(
         out110.hash_serialized.ToString(),
         "f5a6cff6749a5a2e1f01a706cd6d139739cd029d14912c2fab284f1d22e79268");
     BOOST_CHECK_EQUAL(out110.nChainTx, (unsigned int)110);
 
     const auto out210 = *ExpectedAssumeutxo(210, *params);
     BOOST_CHECK_EQUAL(
         out210.hash_serialized.ToString(),
         "37636b5bb17459fe77f2d77fcae80992ae03dff848033c7225dab8a9722821a6");
     BOOST_CHECK_EQUAL(out210.nChainTx, (unsigned int)210);
 }
 
 BOOST_AUTO_TEST_SUITE_END()