diff --git a/src/test/interfaces_tests.cpp b/src/test/interfaces_tests.cpp
index b0f900779..ccf15f1f0 100644
--- a/src/test/interfaces_tests.cpp
+++ b/src/test/interfaces_tests.cpp
@@ -1,186 +1,186 @@
 // 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 = interfaces::MakeChain(m_node, Params());
+    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 = interfaces::MakeChain(m_node, Params());
+    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 = interfaces::MakeChain(m_node, Params());
+    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 = interfaces::MakeChain(m_node, Params());
+    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 = interfaces::MakeChain(m_node, Params());
+    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());
     }
     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 = interfaces::MakeChain(m_node, Params());
+    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/wallet/test/coinselector_tests.cpp b/src/wallet/test/coinselector_tests.cpp
index 65a441687..4ef8f8165 100644
--- a/src/wallet/test/coinselector_tests.cpp
+++ b/src/wallet/test/coinselector_tests.cpp
@@ -1,825 +1,825 @@
 // Copyright (c) 2017 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 <amount.h>
 #include <chainparams.h> // For Params
 #include <node/context.h>
 #include <primitives/transaction.h>
 #include <random.h>
 #include <wallet/coincontrol.h>
 #include <wallet/coinselection.h>
 #include <wallet/wallet.h>
 
 #include <test/util/setup_common.h>
 #include <wallet/test/wallet_test_fixture.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <memory>
 #include <random>
 
 BOOST_FIXTURE_TEST_SUITE(coinselector_tests, WalletTestingSetup)
 
 // how many times to run all the tests to have a chance to catch errors that
 // only show up with particular random shuffles
 #define RUN_TESTS 100
 
 // some tests fail 1% of the time due to bad luck.
 // we repeat those tests this many times and only complain if all iterations of
 // the test fail
 #define RANDOM_REPEATS 5
 
 typedef std::set<CInputCoin> CoinSet;
 
 static std::vector<COutput> vCoins;
 static NodeContext testNode;
 static Amount balance = Amount::zero();
 
 CoinEligibilityFilter filter_standard(1, 6, 0);
 CoinEligibilityFilter filter_confirmed(1, 1, 0);
 CoinEligibilityFilter filter_standard_extra(6, 6, 0);
 CoinSelectionParams coin_selection_params(false, 0, 0, CFeeRate(Amount::zero()),
                                           0);
 
 static void add_coin(const Amount nValue, int nInput,
                      std::vector<CInputCoin> &set) {
     CMutableTransaction tx;
     tx.vout.resize(nInput + 1);
     tx.vout[nInput].nValue = nValue;
     set.emplace_back(MakeTransactionRef(tx), nInput);
 }
 
 static void add_coin(const Amount nValue, int nInput, CoinSet &set) {
     CMutableTransaction tx;
     tx.vout.resize(nInput + 1);
     tx.vout[nInput].nValue = nValue;
     set.emplace(MakeTransactionRef(tx), nInput);
 }
 
 static void add_coin(CWallet &wallet, const Amount nValue, int nAge = 6 * 24,
                      bool fIsFromMe = false, int nInput = 0,
                      bool spendable = false) {
     balance += nValue;
     static int nextLockTime = 0;
     CMutableTransaction tx;
     // so all transactions get different hashes
     tx.nLockTime = nextLockTime++;
     tx.vout.resize(nInput + 1);
     tx.vout[nInput].nValue = nValue;
     if (spendable) {
         CTxDestination dest;
         std::string error;
         assert(wallet.GetNewDestination(OutputType::LEGACY, "", dest, error));
         tx.vout[nInput].scriptPubKey = GetScriptForDestination(dest);
     }
     if (fIsFromMe) {
         // IsFromMe() returns (GetDebit() > 0), and GetDebit() is 0 if
         // vin.empty(), so stop vin being empty, and cache a non-zero Debit to
         // fake out IsFromMe()
         tx.vin.resize(1);
     }
     CWalletTx *wtx = wallet.AddToWallet(MakeTransactionRef(std::move(tx)),
                                         /* confirm= */ {});
     if (fIsFromMe) {
         wtx->m_amounts[CWalletTx::DEBIT].Set(ISMINE_SPENDABLE, SATOSHI);
         wtx->m_is_cache_empty = false;
     }
     COutput output(wtx, nInput, nAge, true /* spendable */, true /* solvable */,
                    true /* safe */);
     vCoins.push_back(output);
 }
 
 static void empty_wallet() {
     vCoins.clear();
     balance = Amount::zero();
 }
 
 static bool equal_sets(CoinSet a, CoinSet b) {
     std::pair<CoinSet::iterator, CoinSet::iterator> ret =
         mismatch(a.begin(), a.end(), b.begin());
     return ret.first == a.end() && ret.second == b.end();
 }
 
 static Amount make_hard_case(int utxos, std::vector<CInputCoin> &utxo_pool) {
     utxo_pool.clear();
     Amount target = Amount::zero();
     for (int i = 0; i < utxos; ++i) {
         const Amount base = (int64_t(1) << (utxos + i)) * SATOSHI;
         target += base;
         add_coin(base, 2 * i, utxo_pool);
         add_coin(base + (int64_t(1) << (utxos - 1 - i)) * SATOSHI, 2 * i + 1,
                  utxo_pool);
     }
     return target;
 }
 
 inline std::vector<OutputGroup> &
 GroupCoins(const std::vector<CInputCoin> &coins) {
     static std::vector<OutputGroup> static_groups;
     static_groups.clear();
     for (auto &coin : coins) {
         static_groups.emplace_back(coin, 0, true, 0, 0);
     }
     return static_groups;
 }
 
 inline std::vector<OutputGroup> &GroupCoins(const std::vector<COutput> &coins) {
     static std::vector<OutputGroup> static_groups;
     static_groups.clear();
     for (auto &coin : coins) {
         // HACK: we can't figure out the is_me flag so we use the conditions
         // defined below; perhaps set safe to false for !fIsFromMe in add_coin()
         const bool is_me =
             coin.tx->m_amounts[CWalletTx::DEBIT].m_cached[ISMINE_SPENDABLE] &&
             coin.tx->m_amounts[CWalletTx::DEBIT].m_value[ISMINE_SPENDABLE] ==
                 SATOSHI;
         static_groups.emplace_back(coin.GetInputCoin(), coin.nDepth, is_me, 0,
                                    0);
     }
     return static_groups;
 }
 
 // Branch and bound coin selection tests
 BOOST_AUTO_TEST_CASE(bnb_search_test) {
     LOCK(m_wallet.cs_wallet);
     m_wallet.SetupLegacyScriptPubKeyMan();
 
     // Setup
     std::vector<CInputCoin> utxo_pool;
     CoinSet selection;
     CoinSet actual_selection;
     Amount value_ret = Amount::zero();
     Amount not_input_fees = Amount::zero();
 
     /////////////////////////
     // Known Outcome tests //
     /////////////////////////
 
     // Empty utxo pool
     BOOST_CHECK(!SelectCoinsBnB(GroupCoins(utxo_pool), 1 * CENT, CENT / 2,
                                 selection, value_ret, not_input_fees));
     selection.clear();
 
     // Add utxos
     add_coin(1 * CENT, 1, utxo_pool);
     add_coin(2 * CENT, 2, utxo_pool);
     add_coin(3 * CENT, 3, utxo_pool);
     add_coin(4 * CENT, 4, utxo_pool);
 
     // Select 1 Cent
     add_coin(1 * CENT, 1, actual_selection);
     BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), 1 * CENT, CENT / 2,
                                selection, value_ret, not_input_fees));
     BOOST_CHECK(equal_sets(selection, actual_selection));
     BOOST_CHECK_EQUAL(value_ret, 1 * CENT);
     actual_selection.clear();
     selection.clear();
 
     // Select 2 Cent
     add_coin(2 * CENT, 2, actual_selection);
     BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), 2 * CENT, CENT / 2,
                                selection, value_ret, not_input_fees));
     BOOST_CHECK(equal_sets(selection, actual_selection));
     BOOST_CHECK_EQUAL(value_ret, 2 * CENT);
     actual_selection.clear();
     selection.clear();
 
     // Select 5 Cent
     add_coin(4 * CENT, 4, actual_selection);
     add_coin(1 * CENT, 1, actual_selection);
     BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), 5 * CENT, CENT / 2,
                                selection, value_ret, not_input_fees));
     BOOST_CHECK(equal_sets(selection, actual_selection));
     BOOST_CHECK_EQUAL(value_ret, 5 * CENT);
     actual_selection.clear();
     selection.clear();
 
     // Select 11 Cent, not possible
     BOOST_CHECK(!SelectCoinsBnB(GroupCoins(utxo_pool), 11 * CENT, CENT / 2,
                                 selection, value_ret, not_input_fees));
     actual_selection.clear();
     selection.clear();
 
     // Cost of change is greater than the difference between target value and
     // utxo sum
     add_coin(1 * CENT, 1, actual_selection);
     BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), 9 * CENT / 10,
                                5 * CENT / 10, selection, value_ret,
                                not_input_fees));
     BOOST_CHECK_EQUAL(value_ret, 1 * CENT);
     BOOST_CHECK(equal_sets(selection, actual_selection));
     actual_selection.clear();
     selection.clear();
 
     // Cost of change is less than the difference between target value and utxo
     // sum
     BOOST_CHECK(!SelectCoinsBnB(GroupCoins(utxo_pool), 9 * CENT / 10,
                                 Amount::zero(), selection, value_ret,
                                 not_input_fees));
     actual_selection.clear();
     selection.clear();
 
     // Select 10 Cent
     add_coin(5 * CENT, 5, utxo_pool);
     add_coin(5 * CENT, 5, actual_selection);
     add_coin(4 * CENT, 4, actual_selection);
     add_coin(1 * CENT, 1, actual_selection);
     BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), 10 * CENT, CENT / 2,
                                selection, value_ret, not_input_fees));
     BOOST_CHECK(equal_sets(selection, actual_selection));
     BOOST_CHECK_EQUAL(value_ret, 10 * CENT);
     actual_selection.clear();
     selection.clear();
 
     // Negative effective value
     // Select 10 Cent but have 1 Cent not be possible because too small
     add_coin(5 * CENT, 5, actual_selection);
     add_coin(3 * CENT, 3, actual_selection);
     add_coin(2 * CENT, 2, actual_selection);
     BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), 10 * CENT, 5000 * SATOSHI,
                                selection, value_ret, not_input_fees));
     BOOST_CHECK_EQUAL(value_ret, 10 * CENT);
     // FIXME: this test is redundant with the above, because 1 Cent is selected,
     // not "too small" BOOST_CHECK(equal_sets(selection, actual_selection));
 
     // Select 0.25 Cent, not possible
     BOOST_CHECK(!SelectCoinsBnB(GroupCoins(utxo_pool), CENT / 4, CENT / 2,
                                 selection, value_ret, not_input_fees));
     actual_selection.clear();
     selection.clear();
 
     // Iteration exhaustion test
     Amount target = make_hard_case(17, utxo_pool);
     // Should exhaust
     BOOST_CHECK(!SelectCoinsBnB(GroupCoins(utxo_pool), target, Amount::zero(),
                                 selection, value_ret, not_input_fees));
     target = make_hard_case(14, utxo_pool);
     // Should not exhaust
     BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), target, Amount::zero(),
                                selection, value_ret, not_input_fees));
 
     // Test same value early bailout optimization
     utxo_pool.clear();
     add_coin(7 * CENT, 7, actual_selection);
     add_coin(7 * CENT, 7, actual_selection);
     add_coin(7 * CENT, 7, actual_selection);
     add_coin(7 * CENT, 7, actual_selection);
     add_coin(2 * CENT, 7, actual_selection);
     add_coin(7 * CENT, 7, utxo_pool);
     add_coin(7 * CENT, 7, utxo_pool);
     add_coin(7 * CENT, 7, utxo_pool);
     add_coin(7 * CENT, 7, utxo_pool);
     add_coin(2 * CENT, 7, utxo_pool);
     for (int i = 0; i < 50000; ++i) {
         add_coin(5 * CENT, 7, utxo_pool);
     }
     BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), 30 * CENT, 5000 * SATOSHI,
                                selection, value_ret, not_input_fees));
     BOOST_CHECK_EQUAL(value_ret, 30 * CENT);
     BOOST_CHECK(equal_sets(selection, actual_selection));
 
     ////////////////////
     // Behavior tests //
     ////////////////////
     // Select 1 Cent with pool of only greater than 5 Cent
     utxo_pool.clear();
     for (int i = 5; i <= 20; ++i) {
         add_coin(i * CENT, i, utxo_pool);
     }
     // Run 100 times, to make sure it is never finding a solution
     for (int i = 0; i < 100; ++i) {
         BOOST_CHECK(!SelectCoinsBnB(GroupCoins(utxo_pool), 1 * CENT, 2 * CENT,
                                     selection, value_ret, not_input_fees));
     }
 
     // Make sure that effective value is working in SelectCoinsMinConf when BnB
     // is used
     CoinSelectionParams coin_selection_params_bnb(true, 0, 0,
                                                   CFeeRate(3000 * SATOSHI), 0);
     CoinSet setCoinsRet;
     Amount nValueRet;
     bool bnb_used;
     empty_wallet();
     add_coin(m_wallet, SATOSHI);
     // Make sure that it has a negative effective value. The next check should
     // assert if this somehow got through. Otherwise it will fail
     vCoins.at(0).nInputBytes = 40;
     BOOST_CHECK(!m_wallet.SelectCoinsMinConf(
         1 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet,
         coin_selection_params_bnb, bnb_used));
 
     // Test fees subtracted from output:
     empty_wallet();
     add_coin(m_wallet, 1 * CENT);
     vCoins.at(0).nInputBytes = 40;
     BOOST_CHECK(!m_wallet.SelectCoinsMinConf(
         1 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet,
         coin_selection_params_bnb, bnb_used));
     coin_selection_params_bnb.m_subtract_fee_outputs = true;
     BOOST_CHECK(m_wallet.SelectCoinsMinConf(
         1 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet,
         coin_selection_params_bnb, bnb_used));
     BOOST_CHECK_EQUAL(nValueRet, 1 * CENT);
 
     // Make sure that can use BnB when there are preset inputs
     empty_wallet();
     {
-        auto wallet = std::make_unique<CWallet>(m_chain.get(), "",
+        auto wallet = std::make_unique<CWallet>(m_node.chain.get(), "",
                                                 CreateMockWalletDatabase());
         bool firstRun;
         wallet->LoadWallet(firstRun);
         LOCK(wallet->cs_wallet);
         wallet->SetupLegacyScriptPubKeyMan();
         add_coin(*wallet, 5 * CENT, 6 * 24, false, 0, true);
         add_coin(*wallet, 3 * CENT, 6 * 24, false, 0, true);
         add_coin(*wallet, 2 * CENT, 6 * 24, false, 0, true);
         CCoinControl coin_control;
         coin_control.fAllowOtherInputs = true;
         coin_control.Select(
             COutPoint(vCoins.at(0).tx->GetId(), vCoins.at(0).i));
         coin_selection_params_bnb.effective_fee = CFeeRate(Amount::zero());
         BOOST_CHECK(wallet->SelectCoins(vCoins, 10 * CENT, setCoinsRet,
                                         nValueRet, coin_control,
                                         coin_selection_params_bnb, bnb_used));
         BOOST_CHECK(bnb_used);
         BOOST_CHECK(coin_selection_params_bnb.use_bnb);
     }
 }
 
 BOOST_AUTO_TEST_CASE(knapsack_solver_test) {
     auto testChain = interfaces::MakeChain(testNode, Params());
     CWallet testWallet(testChain.get(), "", CreateDummyWalletDatabase());
 
     CoinSet setCoinsRet, setCoinsRet2;
     Amount nValueRet;
     bool bnb_used;
 
     LOCK(testWallet.cs_wallet);
     testWallet.SetupLegacyScriptPubKeyMan();
 
     // test multiple times to allow for differences in the shuffle order
     for (int i = 0; i < RUN_TESTS; i++) {
         empty_wallet();
 
         // with an empty wallet we can't even pay one cent
         BOOST_CHECK(!testWallet.SelectCoinsMinConf(
             1 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
 
         // add a new 1 cent coin
         add_coin(testWallet, 1 * CENT, 4);
 
         // with a new 1 cent coin, we still can't find a mature 1 cent
         BOOST_CHECK(!testWallet.SelectCoinsMinConf(
             1 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
 
         // but we can find a new 1 cent
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             1 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 1 * CENT);
         // add a mature 2 cent coin
         add_coin(testWallet, 2 * CENT);
 
         // we can't make 3 cents of mature coins
         BOOST_CHECK(!testWallet.SelectCoinsMinConf(
             3 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
 
         // we can make 3 cents of new coins
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             3 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 3 * CENT);
 
         // add a mature 5 cent coin,
         add_coin(testWallet, 5 * CENT);
         // a new 10 cent coin sent from one of our own addresses
         add_coin(testWallet, 10 * CENT, 3, true);
         // and a mature 20 cent coin
         add_coin(testWallet, 20 * CENT);
 
         // now we have new: 1+10=11 (of which 10 was self-sent), and mature:
         // 2+5+20=27.  total = 38
 
         // we can't make 38 cents only if we disallow new coins:
         BOOST_CHECK(!testWallet.SelectCoinsMinConf(
             38 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we can't even make 37 cents if we don't allow new coins even if
         // they're from us
         BOOST_CHECK(!testWallet.SelectCoinsMinConf(
             38 * CENT, filter_standard_extra, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // but we can make 37 cents if we accept new coins from ourself
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             37 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 37 * CENT);
         // and we can make 38 cents if we accept all new coins
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             38 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 38 * CENT);
 
         // try making 34 cents from 1,2,5,10,20 - we can't do it exactly
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             34 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // but 35 cents is closest
         BOOST_CHECK_EQUAL(nValueRet, 35 * CENT);
         // the best should be 20+10+5.  it's incredibly unlikely the 1 or 2 got
         // included (but possible)
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 3U);
 
         // when we try making 7 cents, the smaller coins (1,2,5) are enough.  We
         // should see just 2+5
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             7 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 7 * CENT);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U);
 
         // when we try making 8 cents, the smaller coins (1,2,5) are exactly
         // enough.
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             8 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK(nValueRet == 8 * CENT);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 3U);
 
         // when we try making 9 cents, no subset of smaller coins is enough, and
         // we get the next bigger coin (10)
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             9 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 10 * CENT);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
 
         // now clear out the wallet and start again to test choosing between
         // subsets of smaller coins and the next biggest coin
         empty_wallet();
 
         add_coin(testWallet, 6 * CENT);
         add_coin(testWallet, 7 * CENT);
         add_coin(testWallet, 8 * CENT);
         add_coin(testWallet, 20 * CENT);
         // now we have 6+7+8+20+30 = 71 cents total
         add_coin(testWallet, 30 * CENT);
 
         // check that we have 71 and not 72
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             71 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK(!testWallet.SelectCoinsMinConf(
             72 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
 
         // now try making 16 cents.  the best smaller coins can do is 6+7+8 =
         // 21; not as good at the next biggest coin, 20
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             16 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we should get 20 in one coin
         BOOST_CHECK_EQUAL(nValueRet, 20 * CENT);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
 
         // now we have 5+6+7+8+20+30 = 75 cents total
         add_coin(testWallet, 5 * CENT);
 
         // now if we try making 16 cents again, the smaller coins can make 5+6+7
         // = 18 cents, better than the next biggest coin, 20
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             16 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we should get 18 in 3 coins
         BOOST_CHECK_EQUAL(nValueRet, 18 * CENT);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 3U);
 
         // now we have 5+6+7+8+18+20+30
         add_coin(testWallet, 18 * CENT);
 
         // and now if we try making 16 cents again, the smaller coins can make
         // 5+6+7 = 18 cents, the same as the next biggest coin, 18
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             16 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we should get 18 in 1 coin
         BOOST_CHECK_EQUAL(nValueRet, 18 * CENT);
         // because in the event of a tie, the biggest coin wins
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
 
         // now try making 11 cents.  we should get 5+6
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             11 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 11 * CENT);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U);
 
         // check that the smallest bigger coin is used
         add_coin(testWallet, 1 * COIN);
         add_coin(testWallet, 2 * COIN);
         add_coin(testWallet, 3 * COIN);
         // now we have 5+6+7+8+18+20+30+100+200+300+400 = 1094 cents
         add_coin(testWallet, 4 * COIN);
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             95 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we should get 1,000,000 XEC in 1 coin
         BOOST_CHECK_EQUAL(nValueRet, 1 * COIN);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
 
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             195 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we should get 2,000,000 XEC in 1 coin
         BOOST_CHECK_EQUAL(nValueRet, 2 * COIN);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
 
         // empty the wallet and start again, now with fractions of a cent, to
         // test small change avoidance
 
         empty_wallet();
         add_coin(testWallet, 1 * MIN_CHANGE / 10);
         add_coin(testWallet, 2 * MIN_CHANGE / 10);
         add_coin(testWallet, 3 * MIN_CHANGE / 10);
         add_coin(testWallet, 4 * MIN_CHANGE / 10);
         add_coin(testWallet, 5 * MIN_CHANGE / 10);
 
         // try making 1 * MIN_CHANGE from the 1.5 * MIN_CHANGE
         // we'll get change smaller than MIN_CHANGE whatever happens, so can
         // expect MIN_CHANGE exactly
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, MIN_CHANGE);
 
         // but if we add a bigger coin, small change is avoided
         add_coin(testWallet, 1111 * MIN_CHANGE);
 
         // try making 1 from 0.1 + 0.2 + 0.3 + 0.4 + 0.5 + 1111 = 1112.5
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             1 * MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we should get the exact amount
         BOOST_CHECK_EQUAL(nValueRet, 1 * MIN_CHANGE);
 
         // if we add more small coins:
         add_coin(testWallet, 6 * MIN_CHANGE / 10);
         add_coin(testWallet, 7 * MIN_CHANGE / 10);
 
         // and try again to make 1.0 * MIN_CHANGE
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             1 * MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we should get the exact amount
         BOOST_CHECK_EQUAL(nValueRet, 1 * MIN_CHANGE);
 
         // run the 'mtgox' test (see
         // http://blockexplorer.com/tx/29a3efd3ef04f9153d47a990bd7b048a4b2d213daaa5fb8ed670fb85f13bdbcf)
         // they tried to consolidate 10 50k coins into one 500k coin, and ended
         // up with 50k in change
         empty_wallet();
         for (int j = 0; j < 20; j++) {
             add_coin(testWallet, 50000 * COIN);
         }
 
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             500000 * COIN, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we should get the exact amount
         BOOST_CHECK_EQUAL(nValueRet, 500000 * COIN);
         // in ten coins
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 10U);
 
         // if there's not enough in the smaller coins to make at least 1 *
         // MIN_CHANGE change (0.5+0.6+0.7 < 1.0+1.0), we need to try finding an
         // exact subset anyway
 
         // sometimes it will fail, and so we use the next biggest coin:
         empty_wallet();
         add_coin(testWallet, 5 * MIN_CHANGE / 10);
         add_coin(testWallet, 6 * MIN_CHANGE / 10);
         add_coin(testWallet, 7 * MIN_CHANGE / 10);
         add_coin(testWallet, 1111 * MIN_CHANGE);
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             1 * MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we get the bigger coin
         BOOST_CHECK_EQUAL(nValueRet, 1111 * MIN_CHANGE);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
 
         // but sometimes it's possible, and we use an exact subset (0.4 + 0.6 =
         // 1.0)
         empty_wallet();
         add_coin(testWallet, 4 * MIN_CHANGE / 10);
         add_coin(testWallet, 6 * MIN_CHANGE / 10);
         add_coin(testWallet, 8 * MIN_CHANGE / 10);
         add_coin(testWallet, 1111 * MIN_CHANGE);
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet,
             nValueRet, coin_selection_params, bnb_used));
         // we should get the exact amount
         BOOST_CHECK_EQUAL(nValueRet, MIN_CHANGE);
         // in two coins 0.4+0.6
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U);
 
         // test avoiding small change
         empty_wallet();
         add_coin(testWallet, 5 * MIN_CHANGE / 100);
         add_coin(testWallet, 1 * MIN_CHANGE);
         add_coin(testWallet, 100 * MIN_CHANGE);
 
         // trying to make 100.01 from these three coins
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             10001 * MIN_CHANGE / 100, filter_confirmed, GroupCoins(vCoins),
             setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         // we should get all coins
         BOOST_CHECK_EQUAL(nValueRet, 10105 * MIN_CHANGE / 100);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 3U);
 
         // but if we try to make 99.9, we should take the bigger of the two
         // small coins to avoid small change
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
             9990 * MIN_CHANGE / 100, filter_confirmed, GroupCoins(vCoins),
             setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 101 * MIN_CHANGE);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U);
     }
 
     // test with many inputs
     for (Amount amt = 1500 * SATOSHI; amt < COIN; amt = 10 * amt) {
         empty_wallet();
         // Create 676 inputs (=  (old MAX_STANDARD_TX_SIZE == 100000)  / 148
         // bytes per input)
         for (uint16_t j = 0; j < 676; j++) {
             add_coin(testWallet, amt);
         }
 
         // We only create the wallet once to save time, but we still run the
         // coin selection RUN_TESTS times.
         for (int i = 0; i < RUN_TESTS; i++) {
             BOOST_CHECK(testWallet.SelectCoinsMinConf(
                 2000 * SATOSHI, filter_confirmed, GroupCoins(vCoins),
                 setCoinsRet, nValueRet, coin_selection_params, bnb_used));
 
             if (amt - 2000 * SATOSHI < MIN_CHANGE) {
                 // needs more than one input:
                 uint16_t returnSize = std::ceil(
                     (2000.0 + (MIN_CHANGE / SATOSHI)) / (amt / SATOSHI));
                 Amount returnValue = returnSize * amt;
                 BOOST_CHECK_EQUAL(nValueRet, returnValue);
                 BOOST_CHECK_EQUAL(setCoinsRet.size(), returnSize);
             } else {
                 // one input is sufficient:
                 BOOST_CHECK_EQUAL(nValueRet, amt);
                 BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
             }
         }
     }
 
     // test randomness
     {
         empty_wallet();
         for (int i2 = 0; i2 < 100; i2++) {
             add_coin(testWallet, COIN);
         }
 
         // Again, we only create the wallet once to save time, but we still run
         // the coin selection RUN_TESTS times.
         for (int i = 0; i < RUN_TESTS; i++) {
             // picking 50 from 100 coins doesn't depend on the shuffle, but does
             // depend on randomness in the stochastic approximation code
             BOOST_CHECK(testWallet.SelectCoinsMinConf(
                 50 * COIN, filter_standard, GroupCoins(vCoins), setCoinsRet,
                 nValueRet, coin_selection_params, bnb_used));
             BOOST_CHECK(testWallet.SelectCoinsMinConf(
                 50 * COIN, filter_standard, GroupCoins(vCoins), setCoinsRet2,
                 nValueRet, coin_selection_params, bnb_used));
             BOOST_CHECK(!equal_sets(setCoinsRet, setCoinsRet2));
 
             int fails = 0;
             for (int j = 0; j < RANDOM_REPEATS; j++) {
                 // selecting 1 from 100 identical coins depends on the shuffle;
                 // this test will fail 1% of the time run the test
                 // RANDOM_REPEATS times and only complain if all of them fail
                 BOOST_CHECK(testWallet.SelectCoinsMinConf(
                     COIN, filter_standard, GroupCoins(vCoins), setCoinsRet,
                     nValueRet, coin_selection_params, bnb_used));
                 BOOST_CHECK(testWallet.SelectCoinsMinConf(
                     COIN, filter_standard, GroupCoins(vCoins), setCoinsRet2,
                     nValueRet, coin_selection_params, bnb_used));
                 if (equal_sets(setCoinsRet, setCoinsRet2)) {
                     fails++;
                 }
             }
             BOOST_CHECK_NE(fails, RANDOM_REPEATS);
         }
 
         // add 75 cents in small change.  not enough to make 90 cents, then
         // try making 90 cents.  there are multiple competing "smallest
         // bigger" coins, one of which should be picked at random
         add_coin(testWallet, 5 * CENT);
         add_coin(testWallet, 10 * CENT);
         add_coin(testWallet, 15 * CENT);
         add_coin(testWallet, 20 * CENT);
         add_coin(testWallet, 25 * CENT);
 
         for (int i = 0; i < RUN_TESTS; i++) {
             int fails = 0;
             for (int j = 0; j < RANDOM_REPEATS; j++) {
                 // selecting 1 from 100 identical coins depends on the shuffle;
                 // this test will fail 1% of the time run the test
                 // RANDOM_REPEATS times and only complain if all of them fail
                 BOOST_CHECK(testWallet.SelectCoinsMinConf(
                     90 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet,
                     nValueRet, coin_selection_params, bnb_used));
                 BOOST_CHECK(testWallet.SelectCoinsMinConf(
                     90 * CENT, filter_standard, GroupCoins(vCoins),
                     setCoinsRet2, nValueRet, coin_selection_params, bnb_used));
                 if (equal_sets(setCoinsRet, setCoinsRet2)) {
                     fails++;
                 }
             }
             BOOST_CHECK_NE(fails, RANDOM_REPEATS);
         }
     }
 
     empty_wallet();
 }
 
 BOOST_AUTO_TEST_CASE(ApproximateBestSubset) {
     CoinSet setCoinsRet;
     Amount nValueRet;
     bool bnb_used;
 
     LOCK(m_wallet.cs_wallet);
     m_wallet.SetupLegacyScriptPubKeyMan();
 
     empty_wallet();
 
     // Test vValue sort order
     for (int i = 0; i < 1000; i++) {
         add_coin(m_wallet, 1000 * COIN);
     }
     add_coin(m_wallet, 3 * COIN);
 
     BOOST_CHECK(m_wallet.SelectCoinsMinConf(
         1003 * COIN, filter_standard, GroupCoins(vCoins), setCoinsRet,
         nValueRet, coin_selection_params, bnb_used));
     BOOST_CHECK_EQUAL(nValueRet, 1003 * COIN);
     BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U);
 
     empty_wallet();
 }
 
 // Tests that with the ideal conditions, the coin selector will always be able
 // to find a solution that can pay the target value
 BOOST_AUTO_TEST_CASE(SelectCoins_test) {
     auto testChain = interfaces::MakeChain(testNode, Params());
     CWallet testWallet(testChain.get(), "", CreateDummyWalletDatabase());
     testWallet.SetupLegacyScriptPubKeyMan();
 
     // Random generator stuff
     std::default_random_engine generator;
     std::exponential_distribution<double> distribution(100);
     FastRandomContext rand;
 
     // Run this test 100 times
     for (int i = 0; i < 100; ++i) {
         empty_wallet();
 
         // Make a wallet with 1000 exponentially distributed random inputs
         for (int j = 0; j < 1000; ++j) {
             add_coin(testWallet,
                      int64_t(10000000 * distribution(generator)) * SATOSHI);
         }
 
         // Generate a random fee rate in the range of 100 - 400
         CFeeRate rate(int64_t(rand.randrange(300) + 100) * SATOSHI);
 
         // Generate a random target value between 1000 and wallet balance
         Amount target =
             int64_t(rand.randrange(balance / SATOSHI - 1000) + 1000) * SATOSHI;
 
         // Perform selection
         CoinSelectionParams coin_selection_params_knapsack(
             false, 34, 148, CFeeRate(Amount::zero()), 0);
         CoinSelectionParams coin_selection_params_bnb(
             true, 34, 148, CFeeRate(Amount::zero()), 0);
         CoinSet out_set;
         Amount out_value = Amount::zero();
         bool bnb_used = false;
         BOOST_CHECK(testWallet.SelectCoinsMinConf(
                         target, filter_standard, GroupCoins(vCoins), out_set,
                         out_value, coin_selection_params_bnb, bnb_used) ||
                     testWallet.SelectCoinsMinConf(
                         target, filter_standard, GroupCoins(vCoins), out_set,
                         out_value, coin_selection_params_knapsack, bnb_used));
         BOOST_CHECK_GE(out_value, target);
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/wallet/test/init_test_fixture.cpp b/src/wallet/test/init_test_fixture.cpp
index e6c6a60a7..5bdc777df 100644
--- a/src/wallet/test/init_test_fixture.cpp
+++ b/src/wallet/test/init_test_fixture.cpp
@@ -1,47 +1,46 @@
 // Copyright (c) 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 <wallet/test/init_test_fixture.h>
 
 #include <chainparams.h>
 #include <fs.h>
 #include <util/check.h>
 #include <util/system.h>
 
 InitWalletDirTestingSetup::InitWalletDirTestingSetup(
     const std::string &chainName)
     : BasicTestingSetup(chainName) {
-    m_chain = interfaces::MakeChain(m_node, Params());
-    m_wallet_client = MakeWalletClient(*m_chain, *Assert(m_node.args));
+    m_wallet_client = MakeWalletClient(*m_node.chain, *Assert(m_node.args));
 
     std::string sep;
     sep += fs::path::preferred_separator;
 
     m_datadir = GetDataDir();
     m_cwd = fs::current_path();
 
     m_walletdir_path_cases["default"] = m_datadir / "wallets";
     m_walletdir_path_cases["custom"] = m_datadir / "my_wallets";
     m_walletdir_path_cases["nonexistent"] = m_datadir / "path_does_not_exist";
     m_walletdir_path_cases["file"] = m_datadir / "not_a_directory.dat";
     m_walletdir_path_cases["trailing"] = m_datadir / "wallets" / sep;
     m_walletdir_path_cases["trailing2"] = m_datadir / "wallets" / sep / sep;
 
     fs::current_path(m_datadir);
     m_walletdir_path_cases["relative"] = "wallets";
 
     fs::create_directories(m_walletdir_path_cases["default"]);
     fs::create_directories(m_walletdir_path_cases["custom"]);
     fs::create_directories(m_walletdir_path_cases["relative"]);
     fs::ofstream f(m_walletdir_path_cases["file"]);
     f.close();
 }
 
 InitWalletDirTestingSetup::~InitWalletDirTestingSetup() {
     fs::current_path(m_cwd);
 }
 
 void InitWalletDirTestingSetup::SetWalletDir(const fs::path &walletdir_path) {
     gArgs.ForceSetArg("-walletdir", fs::PathToString(walletdir_path));
 }
diff --git a/src/wallet/test/init_test_fixture.h b/src/wallet/test/init_test_fixture.h
index fcc892d31..56026635f 100644
--- a/src/wallet/test/init_test_fixture.h
+++ b/src/wallet/test/init_test_fixture.h
@@ -1,26 +1,25 @@
 // Copyright (c) 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.
 
 #ifndef BITCOIN_WALLET_TEST_INIT_TEST_FIXTURE_H
 #define BITCOIN_WALLET_TEST_INIT_TEST_FIXTURE_H
 
 #include <interfaces/chain.h>
 #include <interfaces/wallet.h>
 #include <node/context.h>
 #include <test/util/setup_common.h>
 
 struct InitWalletDirTestingSetup : public BasicTestingSetup {
     explicit InitWalletDirTestingSetup(
         const std::string &chainName = CBaseChainParams::MAIN);
     ~InitWalletDirTestingSetup();
     void SetWalletDir(const fs::path &walletdir_path);
 
     fs::path m_datadir;
     fs::path m_cwd;
     std::map<std::string, fs::path> m_walletdir_path_cases;
-    std::unique_ptr<interfaces::Chain> m_chain;
     std::unique_ptr<interfaces::WalletClient> m_wallet_client;
 };
 
 #endif // BITCOIN_WALLET_TEST_INIT_TEST_FIXTURE_H
diff --git a/src/wallet/test/ismine_tests.cpp b/src/wallet/test/ismine_tests.cpp
index 7d6e78220..048bad291 100644
--- a/src/wallet/test/ismine_tests.cpp
+++ b/src/wallet/test/ismine_tests.cpp
@@ -1,251 +1,249 @@
 // 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 <chainparams.h>
 #include <key.h>
 #include <node/context.h>
 #include <script/script.h>
 #include <script/script_error.h>
 #include <script/standard.h>
 #include <wallet/ismine.h>
 #include <wallet/wallet.h>
 
 #include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_FIXTURE_TEST_SUITE(ismine_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(ismine_standard) {
     CKey keys[2];
     CPubKey pubkeys[2];
     for (int i = 0; i < 2; i++) {
         keys[i].MakeNewKey(true);
         pubkeys[i] = keys[i].GetPubKey();
     }
 
     CKey uncompressedKey;
     uncompressedKey.MakeNewKey(false);
     CPubKey uncompressedPubkey = uncompressedKey.GetPubKey();
-    NodeContext node;
-    std::unique_ptr<interfaces::Chain> chain =
-        interfaces::MakeChain(node, Params());
+    std::unique_ptr<interfaces::Chain> &chain = m_node.chain;
 
     CScript scriptPubKey;
     isminetype result;
 
     // P2PK compressed
     {
         CWallet keystore(chain.get(), "", CreateDummyWalletDatabase());
         keystore.SetupLegacyScriptPubKeyMan();
         LOCK(keystore.GetLegacyScriptPubKeyMan()->cs_KeyStore);
         scriptPubKey = GetScriptForRawPubKey(pubkeys[0]);
 
         // Keystore does not have key
         result = keystore.GetLegacyScriptPubKeyMan()->IsMine(scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has key
         BOOST_CHECK(keystore.GetLegacyScriptPubKeyMan()->AddKey(keys[0]));
         result = keystore.GetLegacyScriptPubKeyMan()->IsMine(scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
     }
 
     // P2PK uncompressed
     {
         CWallet keystore(chain.get(), "", CreateDummyWalletDatabase());
         keystore.SetupLegacyScriptPubKeyMan();
         LOCK(keystore.GetLegacyScriptPubKeyMan()->cs_KeyStore);
         scriptPubKey = GetScriptForRawPubKey(uncompressedPubkey);
 
         // Keystore does not have key
         result = keystore.GetLegacyScriptPubKeyMan()->IsMine(scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has key
         BOOST_CHECK(
             keystore.GetLegacyScriptPubKeyMan()->AddKey(uncompressedKey));
         result = keystore.GetLegacyScriptPubKeyMan()->IsMine(scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
     }
 
     // P2PKH compressed
     {
         CWallet keystore(chain.get(), "", CreateDummyWalletDatabase());
 
         keystore.SetupLegacyScriptPubKeyMan();
         LOCK(keystore.GetLegacyScriptPubKeyMan()->cs_KeyStore);
         scriptPubKey = GetScriptForDestination(PKHash(pubkeys[0]));
 
         // Keystore does not have key
         result = keystore.GetLegacyScriptPubKeyMan()->IsMine(scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has key
         BOOST_CHECK(keystore.GetLegacyScriptPubKeyMan()->AddKey(keys[0]));
         result = keystore.GetLegacyScriptPubKeyMan()->IsMine(scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
     }
 
     // P2PKH uncompressed
     {
         CWallet keystore(chain.get(), "", CreateDummyWalletDatabase());
 
         keystore.SetupLegacyScriptPubKeyMan();
         LOCK(keystore.GetLegacyScriptPubKeyMan()->cs_KeyStore);
         scriptPubKey = GetScriptForDestination(PKHash(uncompressedPubkey));
 
         // Keystore does not have key
         result = keystore.GetLegacyScriptPubKeyMan()->IsMine(scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has key
         BOOST_CHECK(
             keystore.GetLegacyScriptPubKeyMan()->AddKey(uncompressedKey));
         result = keystore.GetLegacyScriptPubKeyMan()->IsMine(scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
     }
 
     // P2SH
     {
         CWallet keystore(chain.get(), "", CreateDummyWalletDatabase());
 
         keystore.SetupLegacyScriptPubKeyMan();
         LOCK(keystore.GetLegacyScriptPubKeyMan()->cs_KeyStore);
 
         CScript redeemScript = GetScriptForDestination(PKHash(pubkeys[0]));
         scriptPubKey = GetScriptForDestination(ScriptHash(redeemScript));
 
         // Keystore does not have redeemScript or key
         result = keystore.GetLegacyScriptPubKeyMan()->IsMine(scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has redeemScript but no key
         BOOST_CHECK(
             keystore.GetLegacyScriptPubKeyMan()->AddCScript(redeemScript));
         result = keystore.GetLegacyScriptPubKeyMan()->IsMine(scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has redeemScript and key
         BOOST_CHECK(keystore.GetLegacyScriptPubKeyMan()->AddKey(keys[0]));
         result = keystore.GetLegacyScriptPubKeyMan()->IsMine(scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
     }
 
     // (P2PKH inside) P2SH inside P2SH (invalid)
     {
         CWallet keystore(chain.get(), "", CreateDummyWalletDatabase());
 
         keystore.SetupLegacyScriptPubKeyMan();
         LOCK(keystore.GetLegacyScriptPubKeyMan()->cs_KeyStore);
 
         CScript redeemscript_inner =
             GetScriptForDestination(PKHash(pubkeys[0]));
         CScript redeemscript =
             GetScriptForDestination(ScriptHash(redeemscript_inner));
         scriptPubKey = GetScriptForDestination(ScriptHash(redeemscript));
 
         BOOST_CHECK(
             keystore.GetLegacyScriptPubKeyMan()->AddCScript(redeemscript));
         BOOST_CHECK(keystore.GetLegacyScriptPubKeyMan()->AddCScript(
             redeemscript_inner));
         BOOST_CHECK(
             keystore.GetLegacyScriptPubKeyMan()->AddCScript(scriptPubKey));
         BOOST_CHECK(keystore.GetLegacyScriptPubKeyMan()->AddKey(keys[0]));
         result = keystore.GetLegacyScriptPubKeyMan()->IsMine(scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
     }
 
     // scriptPubKey multisig
     {
         CWallet keystore(chain.get(), "", CreateDummyWalletDatabase());
 
         keystore.SetupLegacyScriptPubKeyMan();
         LOCK(keystore.GetLegacyScriptPubKeyMan()->cs_KeyStore);
 
         scriptPubKey =
             GetScriptForMultisig(2, {uncompressedPubkey, pubkeys[1]});
 
         // Keystore does not have any keys
         result = keystore.GetLegacyScriptPubKeyMan()->IsMine(scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has 1/2 keys
         BOOST_CHECK(
             keystore.GetLegacyScriptPubKeyMan()->AddKey(uncompressedKey));
 
         result = keystore.GetLegacyScriptPubKeyMan()->IsMine(scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has 2/2 keys
         BOOST_CHECK(keystore.GetLegacyScriptPubKeyMan()->AddKey(keys[1]));
 
         result = keystore.GetLegacyScriptPubKeyMan()->IsMine(scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has 2/2 keys and the script
         BOOST_CHECK(
             keystore.GetLegacyScriptPubKeyMan()->AddCScript(scriptPubKey));
 
         result = keystore.GetLegacyScriptPubKeyMan()->IsMine(scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
     }
 
     // P2SH multisig
     {
         CWallet keystore(chain.get(), "", CreateDummyWalletDatabase());
 
         keystore.SetupLegacyScriptPubKeyMan();
         LOCK(keystore.GetLegacyScriptPubKeyMan()->cs_KeyStore);
         BOOST_CHECK(
             keystore.GetLegacyScriptPubKeyMan()->AddKey(uncompressedKey));
         BOOST_CHECK(keystore.GetLegacyScriptPubKeyMan()->AddKey(keys[1]));
 
         CScript redeemScript =
             GetScriptForMultisig(2, {uncompressedPubkey, pubkeys[1]});
         scriptPubKey = GetScriptForDestination(ScriptHash(redeemScript));
 
         // Keystore has no redeemScript
         result = keystore.GetLegacyScriptPubKeyMan()->IsMine(scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
 
         // Keystore has redeemScript
         BOOST_CHECK(
             keystore.GetLegacyScriptPubKeyMan()->AddCScript(redeemScript));
         result = keystore.GetLegacyScriptPubKeyMan()->IsMine(scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
     }
 
     // OP_RETURN
     {
         CWallet keystore(chain.get(), "", CreateDummyWalletDatabase());
 
         keystore.SetupLegacyScriptPubKeyMan();
         LOCK(keystore.GetLegacyScriptPubKeyMan()->cs_KeyStore);
         BOOST_CHECK(keystore.GetLegacyScriptPubKeyMan()->AddKey(keys[0]));
 
         scriptPubKey.clear();
         scriptPubKey << OP_RETURN << ToByteVector(pubkeys[0]);
 
         result = keystore.GetLegacyScriptPubKeyMan()->IsMine(scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
     }
 
     // Nonstandard
     {
         CWallet keystore(chain.get(), "", CreateDummyWalletDatabase());
 
         keystore.SetupLegacyScriptPubKeyMan();
         LOCK(keystore.GetLegacyScriptPubKeyMan()->cs_KeyStore);
         BOOST_CHECK(keystore.GetLegacyScriptPubKeyMan()->AddKey(keys[0]));
 
         scriptPubKey.clear();
         scriptPubKey << OP_9 << OP_ADD << OP_11 << OP_EQUAL;
 
         result = keystore.GetLegacyScriptPubKeyMan()->IsMine(scriptPubKey);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/wallet/test/scriptpubkeyman_tests.cpp b/src/wallet/test/scriptpubkeyman_tests.cpp
index bf4384794..b1123b714 100644
--- a/src/wallet/test/scriptpubkeyman_tests.cpp
+++ b/src/wallet/test/scriptpubkeyman_tests.cpp
@@ -1,44 +1,41 @@
 // 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 <key.h>
 #include <script/standard.h>
 #include <test/util/setup_common.h>
 #include <wallet/scriptpubkeyman.h>
 #include <wallet/wallet.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_FIXTURE_TEST_SUITE(scriptpubkeyman_tests, BasicTestingSetup)
 
 // Test LegacyScriptPubKeyMan::CanProvide behavior, making sure it returns true
 // for recognized scripts even when keys may not be available for signing.
 BOOST_AUTO_TEST_CASE(CanProvide) {
     // Set up wallet and keyman variables.
-    NodeContext node;
-    std::unique_ptr<interfaces::Chain> chain =
-        interfaces::MakeChain(node, Params());
-    CWallet wallet(chain.get(), "", CreateDummyWalletDatabase());
+    CWallet wallet(m_node.chain.get(), "", CreateDummyWalletDatabase());
     LegacyScriptPubKeyMan &keyman = *wallet.GetOrCreateLegacyScriptPubKeyMan();
 
     // Make a 1 of 2 multisig script
     std::vector<CKey> keys(2);
     std::vector<CPubKey> pubkeys;
     for (CKey &key : keys) {
         key.MakeNewKey(true);
         pubkeys.emplace_back(key.GetPubKey());
     }
     CScript multisig_script = GetScriptForMultisig(1, pubkeys);
     CScript p2sh_script = GetScriptForDestination(ScriptHash(multisig_script));
     SignatureData data;
 
     // Verify the p2sh(multisig) script is not recognized until the multisig
     // script is added to the keystore to make it solvable
     BOOST_CHECK(!keyman.CanProvide(p2sh_script, data));
     keyman.AddCScript(multisig_script);
     BOOST_CHECK(keyman.CanProvide(p2sh_script, data));
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/wallet/test/wallet_test_fixture.cpp b/src/wallet/test/wallet_test_fixture.cpp
index c88fd7591..684340d33 100644
--- a/src/wallet/test/wallet_test_fixture.cpp
+++ b/src/wallet/test/wallet_test_fixture.cpp
@@ -1,26 +1,26 @@
 // Copyright (c) 2016 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 <wallet/test/wallet_test_fixture.h>
 
 #include <chainparams.h>
 #include <scheduler.h>
 #include <validationinterface.h>
 #include <wallet/rpcdump.h>
 
 WalletTestingSetup::WalletTestingSetup(const std::string &chainName)
-    : TestingSetup(chainName), m_chain(interfaces::MakeChain(m_node, Params())),
-      m_wallet(m_chain.get(), "", CreateMockWalletDatabase()) {
+    : TestingSetup(chainName),
+      m_wallet(m_node.chain.get(), "", CreateMockWalletDatabase()) {
     bool fFirstRun;
     m_wallet.LoadWallet(fFirstRun);
     m_chain_notifications_handler =
-        m_chain->handleNotifications({&m_wallet, [](CWallet *) {}});
+        m_node.chain->handleNotifications({&m_wallet, [](CWallet *) {}});
     m_wallet_client->registerRpcs();
 }
 
 WalletTestingSetup::~WalletTestingSetup() {
     if (m_node.scheduler) {
         m_node.scheduler->stop();
     }
 }
diff --git a/src/wallet/test/wallet_test_fixture.h b/src/wallet/test/wallet_test_fixture.h
index cc6a495f2..a93550b37 100644
--- a/src/wallet/test/wallet_test_fixture.h
+++ b/src/wallet/test/wallet_test_fixture.h
@@ -1,33 +1,32 @@
 // Copyright (c) 2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_WALLET_TEST_WALLET_TEST_FIXTURE_H
 #define BITCOIN_WALLET_TEST_WALLET_TEST_FIXTURE_H
 
 #include <interfaces/chain.h>
 #include <interfaces/wallet.h>
 #include <node/context.h>
 #include <util/check.h>
 #include <wallet/wallet.h>
 
 #include <test/util/setup_common.h>
 
 #include <memory>
 
 /**
  * Testing setup and teardown for wallet.
  */
 struct WalletTestingSetup : public TestingSetup {
     explicit WalletTestingSetup(
         const std::string &chainName = CBaseChainParams::MAIN);
     ~WalletTestingSetup();
 
-    std::unique_ptr<interfaces::Chain> m_chain;
     std::unique_ptr<interfaces::WalletClient> m_wallet_client =
-        interfaces::MakeWalletClient(*m_chain, *Assert(m_node.args));
+        interfaces::MakeWalletClient(*m_node.chain, *Assert(m_node.args));
     CWallet m_wallet;
     std::unique_ptr<interfaces::Handler> m_chain_notifications_handler;
 };
 
 #endif // BITCOIN_WALLET_TEST_WALLET_TEST_FIXTURE_H
diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
index c9d52ff65..1f8bb072a 100644
--- a/src/wallet/test/wallet_tests.cpp
+++ b/src/wallet/test/wallet_tests.cpp
@@ -1,895 +1,894 @@
 // Copyright (c) 2012-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 <chainparams.h>
 #include <config.h>
 #include <interfaces/chain.h>
 #include <node/context.h>
 #include <policy/policy.h>
 #include <rpc/server.h>
 #include <util/ref.h>
 #include <util/translation.h>
 #include <validation.h>
 #include <wallet/coincontrol.h>
 #include <wallet/rpcdump.h>
 #include <wallet/wallet.h>
 
 #include <test/util/logging.h>
 #include <test/util/setup_common.h>
 #include <wallet/test/wallet_test_fixture.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <univalue.h>
 
 #include <cstdint>
 #include <future>
 #include <memory>
 #include <vector>
 
 extern RecursiveMutex cs_wallets;
 
 BOOST_FIXTURE_TEST_SUITE(wallet_tests, WalletTestingSetup)
 
 static std::shared_ptr<CWallet> TestLoadWallet(interfaces::Chain &chain) {
     DatabaseOptions options;
     DatabaseStatus status;
     bilingual_str error;
     std::vector<bilingual_str> warnings;
     auto database = MakeWalletDatabase("", options, status, error);
     auto wallet = CWallet::Create(chain, "", std::move(database),
                                   options.create_flags, error, warnings);
     wallet->postInitProcess();
     return wallet;
 }
 
 static void TestUnloadWallet(std::shared_ptr<CWallet> &&wallet) {
     SyncWithValidationInterfaceQueue();
     wallet->m_chain_notifications_handler.reset();
     UnloadWallet(std::move(wallet));
 }
 
 static CMutableTransaction TestSimpleSpend(const CTransaction &from,
                                            uint32_t index, const CKey &key,
                                            const CScript &pubkey) {
     CMutableTransaction mtx;
     mtx.vout.push_back(
         {from.vout[index].nValue - DEFAULT_TRANSACTION_MAXFEE, pubkey});
     mtx.vin.push_back({CTxIn{from.GetId(), index}});
     FillableSigningProvider keystore;
     keystore.AddKey(key);
     std::map<COutPoint, Coin> coins;
     coins[mtx.vin[0].prevout].GetTxOut() = from.vout[index];
     std::map<int, std::string> input_errors;
     BOOST_CHECK(SignTransaction(mtx, &keystore, coins,
                                 SigHashType().withForkId(), input_errors));
     return mtx;
 }
 
 static void AddKey(CWallet &wallet, const CKey &key) {
     auto spk_man = wallet.GetOrCreateLegacyScriptPubKeyMan();
     LOCK2(wallet.cs_wallet, spk_man->cs_KeyStore);
     spk_man->AddKeyPubKey(key, key.GetPubKey());
 }
 
 BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions, TestChain100Setup) {
     // Cap last block file size, and mine new block in a new block file.
     CBlockIndex *oldTip = ::ChainActive().Tip();
     GetBlockFileInfo(oldTip->GetBlockPos().nFile)->nSize = MAX_BLOCKFILE_SIZE;
     CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
     CBlockIndex *newTip = ::ChainActive().Tip();
 
     // Verify ScanForWalletTransactions fails to read an unknown start block.
     {
         CWallet wallet(m_node.chain.get(), "", CreateDummyWalletDatabase());
         {
             LOCK(wallet.cs_wallet);
             wallet.SetLastBlockProcessed(::ChainActive().Height(),
                                          ::ChainActive().Tip()->GetBlockHash());
         }
         AddKey(wallet, coinbaseKey);
         WalletRescanReserver reserver(wallet);
         reserver.reserve();
         CWallet::ScanResult result = wallet.ScanForWalletTransactions(
             BlockHash() /* start_block */, 0 /* start_height */,
             {} /* max_height */, reserver, false /* update */);
         BOOST_CHECK_EQUAL(result.status, CWallet::ScanResult::FAILURE);
         BOOST_CHECK(result.last_failed_block.IsNull());
         BOOST_CHECK(result.last_scanned_block.IsNull());
         BOOST_CHECK(!result.last_scanned_height);
         BOOST_CHECK_EQUAL(wallet.GetBalance().m_mine_immature, Amount::zero());
     }
 
     // Verify ScanForWalletTransactions picks up transactions in both the old
     // and new block files.
     {
         CWallet wallet(m_node.chain.get(), "", CreateDummyWalletDatabase());
         {
             LOCK(wallet.cs_wallet);
             wallet.SetLastBlockProcessed(::ChainActive().Height(),
                                          ::ChainActive().Tip()->GetBlockHash());
         }
         AddKey(wallet, coinbaseKey);
         WalletRescanReserver reserver(wallet);
         reserver.reserve();
         CWallet::ScanResult result = wallet.ScanForWalletTransactions(
             oldTip->GetBlockHash(), oldTip->nHeight, {} /* max_height */,
             reserver, false /* update */);
         BOOST_CHECK_EQUAL(result.status, CWallet::ScanResult::SUCCESS);
         BOOST_CHECK(result.last_failed_block.IsNull());
         BOOST_CHECK_EQUAL(result.last_scanned_block, newTip->GetBlockHash());
         BOOST_CHECK_EQUAL(*result.last_scanned_height, newTip->nHeight);
         BOOST_CHECK_EQUAL(wallet.GetBalance().m_mine_immature, 100 * COIN);
     }
 
     // Prune the older block file.
     {
         LOCK(cs_main);
         Assert(m_node.chainman)
             ->m_blockman.PruneOneBlockFile(oldTip->GetBlockPos().nFile);
     }
     UnlinkPrunedFiles({oldTip->GetBlockPos().nFile});
 
     // Verify ScanForWalletTransactions only picks transactions in the new block
     // file.
     {
         CWallet wallet(m_node.chain.get(), "", CreateDummyWalletDatabase());
         {
             LOCK(wallet.cs_wallet);
             wallet.SetLastBlockProcessed(::ChainActive().Height(),
                                          ::ChainActive().Tip()->GetBlockHash());
         }
         AddKey(wallet, coinbaseKey);
         WalletRescanReserver reserver(wallet);
         reserver.reserve();
         CWallet::ScanResult result = wallet.ScanForWalletTransactions(
             oldTip->GetBlockHash(), oldTip->nHeight, {} /* max_height */,
             reserver, false /* update */);
         BOOST_CHECK_EQUAL(result.status, CWallet::ScanResult::FAILURE);
         BOOST_CHECK_EQUAL(result.last_failed_block, oldTip->GetBlockHash());
         BOOST_CHECK_EQUAL(result.last_scanned_block, newTip->GetBlockHash());
         BOOST_CHECK_EQUAL(*result.last_scanned_height, newTip->nHeight);
         BOOST_CHECK_EQUAL(wallet.GetBalance().m_mine_immature, 50 * COIN);
     }
 
     // Prune the remaining block file.
     {
         LOCK(cs_main);
         Assert(m_node.chainman)
             ->m_blockman.PruneOneBlockFile(newTip->GetBlockPos().nFile);
     }
     UnlinkPrunedFiles({newTip->GetBlockPos().nFile});
 
     // Verify ScanForWalletTransactions scans no blocks.
     {
         CWallet wallet(m_node.chain.get(), "", CreateDummyWalletDatabase());
         {
             LOCK(wallet.cs_wallet);
             wallet.SetLastBlockProcessed(::ChainActive().Height(),
                                          ::ChainActive().Tip()->GetBlockHash());
         }
         AddKey(wallet, coinbaseKey);
         WalletRescanReserver reserver(wallet);
         reserver.reserve();
         CWallet::ScanResult result = wallet.ScanForWalletTransactions(
             oldTip->GetBlockHash(), oldTip->nHeight, {} /* max_height */,
             reserver, false /* update */);
         BOOST_CHECK_EQUAL(result.status, CWallet::ScanResult::FAILURE);
         BOOST_CHECK_EQUAL(result.last_failed_block, newTip->GetBlockHash());
         BOOST_CHECK(result.last_scanned_block.IsNull());
         BOOST_CHECK(!result.last_scanned_height);
         BOOST_CHECK_EQUAL(wallet.GetBalance().m_mine_immature, Amount::zero());
     }
 }
 
 BOOST_FIXTURE_TEST_CASE(importmulti_rescan, TestChain100Setup) {
     // Cap last block file size, and mine new block in a new block file.
     CBlockIndex *oldTip = ::ChainActive().Tip();
     GetBlockFileInfo(oldTip->GetBlockPos().nFile)->nSize = MAX_BLOCKFILE_SIZE;
     CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
     CBlockIndex *newTip = ::ChainActive().Tip();
 
     // Prune the older block file.
     {
         LOCK(cs_main);
         Assert(m_node.chainman)
             ->m_blockman.PruneOneBlockFile(oldTip->GetBlockPos().nFile);
     }
     UnlinkPrunedFiles({oldTip->GetBlockPos().nFile});
 
     // Verify importmulti RPC returns failure for a key whose creation time is
     // before the missing block, and success for a key whose creation time is
     // after.
     {
         std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(
             m_node.chain.get(), "", CreateDummyWalletDatabase());
         wallet->SetupLegacyScriptPubKeyMan();
         WITH_LOCK(wallet->cs_wallet,
                   wallet->SetLastBlockProcessed(newTip->nHeight,
                                                 newTip->GetBlockHash()));
         AddWallet(wallet);
         UniValue keys;
         keys.setArray();
         UniValue key;
         key.setObject();
         key.pushKV("scriptPubKey",
                    HexStr(GetScriptForRawPubKey(coinbaseKey.GetPubKey())));
         key.pushKV("timestamp", 0);
         key.pushKV("internal", UniValue(true));
         keys.push_back(key);
         key.clear();
         key.setObject();
         CKey futureKey;
         futureKey.MakeNewKey(true);
         key.pushKV("scriptPubKey",
                    HexStr(GetScriptForRawPubKey(futureKey.GetPubKey())));
         key.pushKV("timestamp",
                    newTip->GetBlockTimeMax() + TIMESTAMP_WINDOW + 1);
         key.pushKV("internal", UniValue(true));
         keys.push_back(key);
         util::Ref context;
         JSONRPCRequest request(context);
         request.params.setArray();
         request.params.push_back(keys);
 
         UniValue response = importmulti().HandleRequest(GetConfig(), request);
         BOOST_CHECK_EQUAL(
             response.write(),
             strprintf("[{\"success\":false,\"error\":{\"code\":-1,\"message\":"
                       "\"Rescan failed for key with creation timestamp %d. "
                       "There was an error reading a block from time %d, which "
                       "is after or within %d seconds of key creation, and "
                       "could contain transactions pertaining to the key. As a "
                       "result, transactions and coins using this key may not "
                       "appear in the wallet. This error could be caused by "
                       "pruning or data corruption (see bitcoind log for "
                       "details) and could be dealt with by downloading and "
                       "rescanning the relevant blocks (see -reindex and "
                       "-rescan options).\"}},{\"success\":true}]",
                       0, oldTip->GetBlockTimeMax(), TIMESTAMP_WINDOW));
         RemoveWallet(wallet, std::nullopt);
     }
 }
 
 // Verify importwallet RPC starts rescan at earliest block with timestamp
 // greater or equal than key birthday. Previously there was a bug where
 // importwallet RPC would start the scan at the latest block with timestamp less
 // than or equal to key birthday.
 BOOST_FIXTURE_TEST_CASE(importwallet_rescan, TestChain100Setup) {
     // Create two blocks with same timestamp to verify that importwallet rescan
     // will pick up both blocks, not just the first.
     const int64_t BLOCK_TIME = ::ChainActive().Tip()->GetBlockTimeMax() + 5;
     SetMockTime(BLOCK_TIME);
     m_coinbase_txns.emplace_back(
         CreateAndProcessBlock({},
                               GetScriptForRawPubKey(coinbaseKey.GetPubKey()))
             .vtx[0]);
     m_coinbase_txns.emplace_back(
         CreateAndProcessBlock({},
                               GetScriptForRawPubKey(coinbaseKey.GetPubKey()))
             .vtx[0]);
 
     // Set key birthday to block time increased by the timestamp window, so
     // rescan will start at the block time.
     const int64_t KEY_TIME = BLOCK_TIME + TIMESTAMP_WINDOW;
     SetMockTime(KEY_TIME);
     m_coinbase_txns.emplace_back(
         CreateAndProcessBlock({},
                               GetScriptForRawPubKey(coinbaseKey.GetPubKey()))
             .vtx[0]);
 
     std::string backup_file = fs::PathToString(GetDataDir() / "wallet.backup");
 
     // Import key into wallet and call dumpwallet to create backup file.
     {
         std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(
             m_node.chain.get(), "", CreateDummyWalletDatabase());
         {
             auto spk_man = wallet->GetOrCreateLegacyScriptPubKeyMan();
             LOCK2(wallet->cs_wallet, spk_man->cs_KeyStore);
             spk_man->mapKeyMetadata[coinbaseKey.GetPubKey().GetID()]
                 .nCreateTime = KEY_TIME;
             spk_man->AddKeyPubKey(coinbaseKey, coinbaseKey.GetPubKey());
 
             AddWallet(wallet);
             wallet->SetLastBlockProcessed(
                 ::ChainActive().Height(),
                 ::ChainActive().Tip()->GetBlockHash());
         }
         util::Ref context;
         JSONRPCRequest request(context);
         request.params.setArray();
         request.params.push_back(backup_file);
         ::dumpwallet().HandleRequest(GetConfig(), request);
         RemoveWallet(wallet, std::nullopt);
     }
 
     // Call importwallet RPC and verify all blocks with timestamps >= BLOCK_TIME
     // were scanned, and no prior blocks were scanned.
     {
         std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(
             m_node.chain.get(), "", CreateDummyWalletDatabase());
         LOCK(wallet->cs_wallet);
         wallet->SetupLegacyScriptPubKeyMan();
 
         util::Ref context;
         JSONRPCRequest request(context);
         request.params.setArray();
         request.params.push_back(backup_file);
         AddWallet(wallet);
         wallet->SetLastBlockProcessed(::ChainActive().Height(),
                                       ::ChainActive().Tip()->GetBlockHash());
         ::importwallet().HandleRequest(GetConfig(), request);
         RemoveWallet(wallet, std::nullopt);
 
         BOOST_CHECK_EQUAL(wallet->mapWallet.size(), 3U);
         BOOST_CHECK_EQUAL(m_coinbase_txns.size(), 103U);
         for (size_t i = 0; i < m_coinbase_txns.size(); ++i) {
             bool found = wallet->GetWalletTx(m_coinbase_txns[i]->GetId());
             bool expected = i >= 100;
             BOOST_CHECK_EQUAL(found, expected);
         }
     }
 }
 
 // Check that GetImmatureCredit() returns a newly calculated value instead of
 // the cached value after a MarkDirty() call.
 //
 // This is a regression test written to verify a bugfix for the immature credit
 // function. Similar tests probably should be written for the other credit and
 // debit functions.
 BOOST_FIXTURE_TEST_CASE(coin_mark_dirty_immature_credit, TestChain100Setup) {
     CWallet wallet(m_node.chain.get(), "", CreateDummyWalletDatabase());
     auto spk_man = wallet.GetOrCreateLegacyScriptPubKeyMan();
     CWalletTx wtx(&wallet, m_coinbase_txns.back());
 
     LOCK2(wallet.cs_wallet, spk_man->cs_KeyStore);
     wallet.SetLastBlockProcessed(::ChainActive().Height(),
                                  ::ChainActive().Tip()->GetBlockHash());
 
     CWalletTx::Confirmation confirm(CWalletTx::Status::CONFIRMED,
                                     ::ChainActive().Height(),
                                     ::ChainActive().Tip()->GetBlockHash(), 0);
     wtx.m_confirm = confirm;
 
     // Call GetImmatureCredit() once before adding the key to the wallet to
     // cache the current immature credit amount, which is 0.
     BOOST_CHECK_EQUAL(wtx.GetImmatureCredit(), Amount::zero());
 
     // Invalidate the cached value, add the key, and make sure a new immature
     // credit amount is calculated.
     wtx.MarkDirty();
     BOOST_CHECK(spk_man->AddKeyPubKey(coinbaseKey, coinbaseKey.GetPubKey()));
     BOOST_CHECK_EQUAL(wtx.GetImmatureCredit(), 50 * COIN);
 }
 
 static int64_t AddTx(ChainstateManager &chainman, CWallet &wallet,
                      uint32_t lockTime, int64_t mockTime, int64_t blockTime) {
     CMutableTransaction tx;
     CWalletTx::Confirmation confirm;
     tx.nLockTime = lockTime;
     SetMockTime(mockTime);
     CBlockIndex *block = nullptr;
     if (blockTime > 0) {
         LOCK(cs_main);
         auto inserted = chainman.BlockIndex().emplace(BlockHash(GetRandHash()),
                                                       new CBlockIndex);
         assert(inserted.second);
         const BlockHash &hash = inserted.first->first;
         block = inserted.first->second;
         block->nTime = blockTime;
         block->phashBlock = &hash;
         confirm = {CWalletTx::Status::CONFIRMED, block->nHeight, hash, 0};
     }
 
     // If transaction is already in map, to avoid inconsistencies,
     // unconfirmation is needed before confirm again with different block.
     return wallet
         .AddToWallet(MakeTransactionRef(tx), confirm,
                      [&](CWalletTx &wtx, bool /* new_tx */) {
                          wtx.setUnconfirmed();
                          return true;
                      })
         ->nTimeSmart;
 }
 
 // Simple test to verify assignment of CWalletTx::nSmartTime value. Could be
 // expanded to cover more corner cases of smart time logic.
 BOOST_AUTO_TEST_CASE(ComputeTimeSmart) {
     // New transaction should use clock time if lower than block time.
     BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 1, 100, 120), 100);
 
     // Test that updating existing transaction does not change smart time.
     BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 1, 200, 220), 100);
 
     // New transaction should use clock time if there's no block time.
     BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 2, 300, 0), 300);
 
     // New transaction should use block time if lower than clock time.
     BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 3, 420, 400), 400);
 
     // New transaction should use latest entry time if higher than
     // min(block time, clock time).
     BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 4, 500, 390), 400);
 
     // If there are future entries, new transaction should use time of the
     // newest entry that is no more than 300 seconds ahead of the clock time.
     BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 5, 50, 600), 300);
 
     // Reset mock time for other tests.
     SetMockTime(0);
 }
 
 BOOST_AUTO_TEST_CASE(LoadReceiveRequests) {
     CTxDestination dest = PKHash();
     LOCK(m_wallet.cs_wallet);
     WalletBatch batch{m_wallet.GetDatabase()};
     m_wallet.AddDestData(batch, dest, "misc", "val_misc");
     m_wallet.AddDestData(batch, dest, "rr0", "val_rr0");
     m_wallet.AddDestData(batch, dest, "rr1", "val_rr1");
 
     auto values = m_wallet.GetDestValues("rr");
     BOOST_CHECK_EQUAL(values.size(), 2U);
     BOOST_CHECK_EQUAL(values[0], "val_rr0");
     BOOST_CHECK_EQUAL(values[1], "val_rr1");
 }
 
 // Test some watch-only LegacyScriptPubKeyMan methods by the procedure of
 // loading (LoadWatchOnly), checking (HaveWatchOnly), getting (GetWatchPubKey)
 // and removing (RemoveWatchOnly) a given PubKey, resp. its corresponding P2PK
 // Script. Results of the the impact on the address -> PubKey map is dependent
 // on whether the PubKey is a point on the curve
 static void TestWatchOnlyPubKey(LegacyScriptPubKeyMan *spk_man,
                                 const CPubKey &add_pubkey) {
     CScript p2pk = GetScriptForRawPubKey(add_pubkey);
     CKeyID add_address = add_pubkey.GetID();
     CPubKey found_pubkey;
     LOCK(spk_man->cs_KeyStore);
 
     // all Scripts (i.e. also all PubKeys) are added to the general watch-only
     // set
     BOOST_CHECK(!spk_man->HaveWatchOnly(p2pk));
     spk_man->LoadWatchOnly(p2pk);
     BOOST_CHECK(spk_man->HaveWatchOnly(p2pk));
 
     // only PubKeys on the curve shall be added to the watch-only address ->
     // PubKey map
     bool is_pubkey_fully_valid = add_pubkey.IsFullyValid();
     if (is_pubkey_fully_valid) {
         BOOST_CHECK(spk_man->GetWatchPubKey(add_address, found_pubkey));
         BOOST_CHECK(found_pubkey == add_pubkey);
     } else {
         BOOST_CHECK(!spk_man->GetWatchPubKey(add_address, found_pubkey));
         // passed key is unchanged
         BOOST_CHECK(found_pubkey == CPubKey());
     }
 
     spk_man->RemoveWatchOnly(p2pk);
     BOOST_CHECK(!spk_man->HaveWatchOnly(p2pk));
 
     if (is_pubkey_fully_valid) {
         BOOST_CHECK(!spk_man->GetWatchPubKey(add_address, found_pubkey));
         // passed key is unchanged
         BOOST_CHECK(found_pubkey == add_pubkey);
     }
 }
 
 // Cryptographically invalidate a PubKey whilst keeping length and first byte
 static void PollutePubKey(CPubKey &pubkey) {
     std::vector<uint8_t> pubkey_raw(pubkey.begin(), pubkey.end());
     std::fill(pubkey_raw.begin() + 1, pubkey_raw.end(), 0);
     pubkey = CPubKey(pubkey_raw);
     assert(!pubkey.IsFullyValid());
     assert(pubkey.IsValid());
 }
 
 // Test watch-only logic for PubKeys
 BOOST_AUTO_TEST_CASE(WatchOnlyPubKeys) {
     CKey key;
     CPubKey pubkey;
     LegacyScriptPubKeyMan *spk_man =
         m_wallet.GetOrCreateLegacyScriptPubKeyMan();
 
     BOOST_CHECK(!spk_man->HaveWatchOnly());
 
     // uncompressed valid PubKey
     key.MakeNewKey(false);
     pubkey = key.GetPubKey();
     assert(!pubkey.IsCompressed());
     TestWatchOnlyPubKey(spk_man, pubkey);
 
     // uncompressed cryptographically invalid PubKey
     PollutePubKey(pubkey);
     TestWatchOnlyPubKey(spk_man, pubkey);
 
     // compressed valid PubKey
     key.MakeNewKey(true);
     pubkey = key.GetPubKey();
     assert(pubkey.IsCompressed());
     TestWatchOnlyPubKey(spk_man, pubkey);
 
     // compressed cryptographically invalid PubKey
     PollutePubKey(pubkey);
     TestWatchOnlyPubKey(spk_man, pubkey);
 
     // invalid empty PubKey
     pubkey = CPubKey();
     TestWatchOnlyPubKey(spk_man, pubkey);
 }
 
 class ListCoinsTestingSetup : public TestChain100Setup {
 public:
     ListCoinsTestingSetup() {
         CreateAndProcessBlock({},
                               GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
         wallet = std::make_unique<CWallet>(m_node.chain.get(), "",
                                            CreateMockWalletDatabase());
         {
             LOCK2(wallet->cs_wallet, ::cs_main);
             wallet->SetLastBlockProcessed(
                 ::ChainActive().Height(),
                 ::ChainActive().Tip()->GetBlockHash());
         }
         bool firstRun;
         wallet->LoadWallet(firstRun);
         AddKey(*wallet, coinbaseKey);
         WalletRescanReserver reserver(*wallet);
         reserver.reserve();
         CWallet::ScanResult result = wallet->ScanForWalletTransactions(
             ::ChainActive().Genesis()->GetBlockHash(), 0 /* start_height */,
             {} /* max_height */, reserver, false /* update */);
         BOOST_CHECK_EQUAL(result.status, CWallet::ScanResult::SUCCESS);
         BOOST_CHECK_EQUAL(result.last_scanned_block,
                           ::ChainActive().Tip()->GetBlockHash());
         BOOST_CHECK_EQUAL(*result.last_scanned_height,
                           ::ChainActive().Height());
         BOOST_CHECK(result.last_failed_block.IsNull());
     }
 
     ~ListCoinsTestingSetup() { wallet.reset(); }
 
     CWalletTx &AddTx(CRecipient recipient) {
         CTransactionRef tx;
         Amount fee;
         int changePos = -1;
         bilingual_str error;
         CCoinControl dummy;
         {
             BOOST_CHECK(wallet->CreateTransaction({recipient}, tx, fee,
                                                   changePos, error, dummy));
         }
         wallet->CommitTransaction(tx, {}, {});
         CMutableTransaction blocktx;
         {
             LOCK(wallet->cs_wallet);
             blocktx =
                 CMutableTransaction(*wallet->mapWallet.at(tx->GetId()).tx);
         }
         CreateAndProcessBlock({CMutableTransaction(blocktx)},
                               GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
 
         LOCK(wallet->cs_wallet);
         wallet->SetLastBlockProcessed(wallet->GetLastBlockHeight() + 1,
                                       ::ChainActive().Tip()->GetBlockHash());
         auto it = wallet->mapWallet.find(tx->GetId());
         BOOST_CHECK(it != wallet->mapWallet.end());
         CWalletTx::Confirmation confirm(
             CWalletTx::Status::CONFIRMED, ::ChainActive().Height(),
             ::ChainActive().Tip()->GetBlockHash(), 1);
         it->second.m_confirm = confirm;
         return it->second;
     }
 
     std::unique_ptr<CWallet> wallet;
 };
 
 BOOST_FIXTURE_TEST_CASE(ListCoins, ListCoinsTestingSetup) {
     std::string coinbaseAddress = coinbaseKey.GetPubKey().GetID().ToString();
 
     // Confirm ListCoins initially returns 1 coin grouped under coinbaseKey
     // address.
     std::map<CTxDestination, std::vector<COutput>> list;
     {
         LOCK(wallet->cs_wallet);
         list = wallet->ListCoins();
     }
     BOOST_CHECK_EQUAL(list.size(), 1U);
     BOOST_CHECK_EQUAL(boost::get<PKHash>(list.begin()->first).ToString(),
                       coinbaseAddress);
     BOOST_CHECK_EQUAL(list.begin()->second.size(), 1U);
 
     // Check initial balance from one mature coinbase transaction.
     BOOST_CHECK_EQUAL(50 * COIN, wallet->GetAvailableBalance());
 
     // Add a transaction creating a change address, and confirm ListCoins still
     // returns the coin associated with the change address underneath the
     // coinbaseKey pubkey, even though the change address has a different
     // pubkey.
     AddTx(CRecipient{GetScriptForRawPubKey({}), 1 * COIN,
                      false /* subtract fee */});
     {
         LOCK(wallet->cs_wallet);
         list = wallet->ListCoins();
     }
     BOOST_CHECK_EQUAL(list.size(), 1U);
     BOOST_CHECK_EQUAL(boost::get<PKHash>(list.begin()->first).ToString(),
                       coinbaseAddress);
     BOOST_CHECK_EQUAL(list.begin()->second.size(), 2U);
 
     // Lock both coins. Confirm number of available coins drops to 0.
     {
         LOCK(wallet->cs_wallet);
         std::vector<COutput> available;
         wallet->AvailableCoins(available);
         BOOST_CHECK_EQUAL(available.size(), 2U);
     }
     for (const auto &group : list) {
         for (const auto &coin : group.second) {
             LOCK(wallet->cs_wallet);
             wallet->LockCoin(COutPoint(coin.tx->GetId(), coin.i));
         }
     }
     {
         LOCK(wallet->cs_wallet);
         std::vector<COutput> available;
         wallet->AvailableCoins(available);
         BOOST_CHECK_EQUAL(available.size(), 0U);
     }
     // Confirm ListCoins still returns same result as before, despite coins
     // being locked.
     {
         LOCK(wallet->cs_wallet);
         list = wallet->ListCoins();
     }
     BOOST_CHECK_EQUAL(list.size(), 1U);
     BOOST_CHECK_EQUAL(boost::get<PKHash>(list.begin()->first).ToString(),
                       coinbaseAddress);
     BOOST_CHECK_EQUAL(list.begin()->second.size(), 2U);
 }
 
 BOOST_FIXTURE_TEST_CASE(wallet_disableprivkeys, TestChain100Setup) {
     std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(
         m_node.chain.get(), "", CreateDummyWalletDatabase());
     wallet->SetupLegacyScriptPubKeyMan();
     wallet->SetMinVersion(FEATURE_LATEST);
     wallet->SetWalletFlag(WALLET_FLAG_DISABLE_PRIVATE_KEYS);
     BOOST_CHECK(!wallet->TopUpKeyPool(1000));
     CTxDestination dest;
     std::string error;
     BOOST_CHECK(
         !wallet->GetNewDestination(OutputType::LEGACY, "", dest, error));
 }
 
 // Explicit calculation which is used to test the wallet constant
 static size_t CalculateP2PKHInputSize(bool use_max_sig) {
     // Generate ephemeral valid pubkey
     CKey key;
     key.MakeNewKey(true);
     CPubKey pubkey = key.GetPubKey();
 
     // Generate pubkey hash
     PKHash key_hash(pubkey);
 
     // Create script to enter into keystore. Key hash can't be 0...
     CScript script = GetScriptForDestination(key_hash);
 
     // Add script to key store and key to watchonly
     FillableSigningProvider keystore;
     keystore.AddKeyPubKey(key, pubkey);
 
     // Fill in dummy signatures for fee calculation.
     SignatureData sig_data;
     if (!ProduceSignature(keystore,
                           use_max_sig ? DUMMY_MAXIMUM_SIGNATURE_CREATOR
                                       : DUMMY_SIGNATURE_CREATOR,
                           script, sig_data)) {
         // We're hand-feeding it correct arguments; shouldn't happen
         assert(false);
     }
 
     CTxIn tx_in;
     UpdateInput(tx_in, sig_data);
     return (size_t)GetVirtualTransactionInputSize(tx_in);
 }
 
 BOOST_FIXTURE_TEST_CASE(dummy_input_size_test, TestChain100Setup) {
     BOOST_CHECK(CalculateP2PKHInputSize(false) <= DUMMY_P2PKH_INPUT_SIZE);
     BOOST_CHECK_EQUAL(CalculateP2PKHInputSize(true), DUMMY_P2PKH_INPUT_SIZE);
 }
 
 bool malformed_descriptor(std::ios_base::failure e) {
     std::string s(e.what());
     return s.find("Missing checksum") != std::string::npos;
 }
 
 BOOST_FIXTURE_TEST_CASE(wallet_descriptor_test, BasicTestingSetup) {
     std::vector<uint8_t> malformed_record;
     CVectorWriter vw(0, 0, malformed_record, 0);
     vw << std::string("notadescriptor");
     vw << (uint64_t)0;
     vw << (int32_t)0;
     vw << (int32_t)0;
     vw << (int32_t)1;
 
     VectorReader vr(0, 0, malformed_record, 0);
     WalletDescriptor w_desc;
     BOOST_CHECK_EXCEPTION(vr >> w_desc, std::ios_base::failure,
                           malformed_descriptor);
 }
 
 //! Test CWallet::Create() and its behavior handling potential race
 //! conditions if it's called the same time an incoming transaction shows up in
 //! the mempool or a new block.
 //!
 //! It isn't possible to verify there aren't race condition in every case, so
 //! this test just checks two specific cases and ensures that timing of
 //! notifications in these cases doesn't prevent the wallet from detecting
 //! transactions.
 //!
 //! In the first case, block and mempool transactions are created before the
 //! wallet is loaded, but notifications about these transactions are delayed
 //! until after it is loaded. The notifications are superfluous in this case, so
 //! the test verifies the transactions are detected before they arrive.
 //!
 //! In the second case, block and mempool transactions are created after the
 //! wallet rescan and notifications are immediately synced, to verify the wallet
 //! must already have a handler in place for them, and there's no gap after
 //! rescanning where new transactions in new blocks could be lost.
 BOOST_FIXTURE_TEST_CASE(CreateWallet, TestChain100Setup) {
     // Create new wallet with known key and unload it.
     auto wallet = TestLoadWallet(*m_node.chain);
     CKey key;
     key.MakeNewKey(true);
     AddKey(*wallet, key);
     TestUnloadWallet(std::move(wallet));
 
     // Add log hook to detect AddToWallet events from rescans, blockConnected,
     // and transactionAddedToMempool notifications
     int addtx_count = 0;
     DebugLogHelper addtx_counter("[default wallet] AddToWallet",
                                  [&](const std::string *s) {
                                      if (s) {
                                          ++addtx_count;
                                      }
                                      return false;
                                  });
 
     bool rescan_completed = false;
     DebugLogHelper rescan_check("[default wallet] Rescan completed",
                                 [&](const std::string *s) {
                                     if (s) {
                                         rescan_completed = true;
                                     }
                                     return false;
                                 });
 
     // Block the queue to prevent the wallet receiving blockConnected and
     // transactionAddedToMempool notifications, and create block and mempool
     // transactions paying to the wallet
     std::promise<void> promise;
     CallFunctionInValidationInterfaceQueue(
         [&promise] { promise.get_future().wait(); });
     std::string error;
     m_coinbase_txns.push_back(
         CreateAndProcessBlock({},
                               GetScriptForRawPubKey(coinbaseKey.GetPubKey()))
             .vtx[0]);
     auto block_tx = TestSimpleSpend(*m_coinbase_txns[0], 0, coinbaseKey,
                                     GetScriptForRawPubKey(key.GetPubKey()));
     m_coinbase_txns.push_back(
         CreateAndProcessBlock({block_tx},
                               GetScriptForRawPubKey(coinbaseKey.GetPubKey()))
             .vtx[0]);
     auto mempool_tx = TestSimpleSpend(*m_coinbase_txns[1], 0, coinbaseKey,
                                       GetScriptForRawPubKey(key.GetPubKey()));
     BOOST_CHECK(m_node.chain->broadcastTransaction(
         GetConfig(), MakeTransactionRef(mempool_tx), DEFAULT_TRANSACTION_MAXFEE,
         false, error));
 
     // Reload wallet and make sure new transactions are detected despite events
     // being blocked
     wallet = TestLoadWallet(*m_node.chain);
     BOOST_CHECK(rescan_completed);
     BOOST_CHECK_EQUAL(addtx_count, 2);
     {
         LOCK(wallet->cs_wallet);
         BOOST_CHECK_EQUAL(wallet->mapWallet.count(block_tx.GetId()), 1U);
         BOOST_CHECK_EQUAL(wallet->mapWallet.count(mempool_tx.GetId()), 1U);
     }
 
     // Unblock notification queue and make sure stale blockConnected and
     // transactionAddedToMempool events are processed
     promise.set_value();
     SyncWithValidationInterfaceQueue();
     BOOST_CHECK_EQUAL(addtx_count, 4);
 
     TestUnloadWallet(std::move(wallet));
 
     // Load wallet again, this time creating new block and mempool transactions
     // paying to the wallet as the wallet finishes loading and syncing the
     // queue so the events have to be handled immediately. Releasing the wallet
     // lock during the sync is a little artificial but is needed to avoid a
     // deadlock during the sync and simulates a new block notification happening
     // as soon as possible.
     addtx_count = 0;
     auto handler = HandleLoadWallet(
         [&](std::unique_ptr<interfaces::Wallet> wallet_param)
             EXCLUSIVE_LOCKS_REQUIRED(wallet_param->wallet()->cs_wallet,
                                      cs_wallets) {
                 BOOST_CHECK(rescan_completed);
                 m_coinbase_txns.push_back(
                     CreateAndProcessBlock(
                         {}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()))
                         .vtx[0]);
                 block_tx =
                     TestSimpleSpend(*m_coinbase_txns[2], 0, coinbaseKey,
                                     GetScriptForRawPubKey(key.GetPubKey()));
                 m_coinbase_txns.push_back(
                     CreateAndProcessBlock(
                         {block_tx},
                         GetScriptForRawPubKey(coinbaseKey.GetPubKey()))
                         .vtx[0]);
                 mempool_tx =
                     TestSimpleSpend(*m_coinbase_txns[3], 0, coinbaseKey,
                                     GetScriptForRawPubKey(key.GetPubKey()));
                 BOOST_CHECK(m_node.chain->broadcastTransaction(
                     GetConfig(), MakeTransactionRef(mempool_tx),
                     DEFAULT_TRANSACTION_MAXFEE, false, error));
                 LEAVE_CRITICAL_SECTION(cs_wallets);
                 LEAVE_CRITICAL_SECTION(wallet_param->wallet()->cs_wallet);
                 SyncWithValidationInterfaceQueue();
                 ENTER_CRITICAL_SECTION(wallet_param->wallet()->cs_wallet);
                 ENTER_CRITICAL_SECTION(cs_wallets);
             });
     wallet = TestLoadWallet(*m_node.chain);
     BOOST_CHECK_EQUAL(addtx_count, 4);
     {
         LOCK(wallet->cs_wallet);
         BOOST_CHECK_EQUAL(wallet->mapWallet.count(block_tx.GetId()), 1U);
         BOOST_CHECK_EQUAL(wallet->mapWallet.count(mempool_tx.GetId()), 1U);
     }
 
     TestUnloadWallet(std::move(wallet));
 }
 
 BOOST_FIXTURE_TEST_CASE(ZapSelectTx, TestChain100Setup) {
-    auto chain = interfaces::MakeChain(m_node, Params());
-    auto wallet = TestLoadWallet(*chain);
+    auto wallet = TestLoadWallet(*m_node.chain);
     CKey key;
     key.MakeNewKey(true);
     AddKey(*wallet, key);
 
     std::string error;
     m_coinbase_txns.push_back(
         CreateAndProcessBlock({},
                               GetScriptForRawPubKey(coinbaseKey.GetPubKey()))
             .vtx[0]);
     auto block_tx = TestSimpleSpend(*m_coinbase_txns[0], 0, coinbaseKey,
                                     GetScriptForRawPubKey(key.GetPubKey()));
     CreateAndProcessBlock({block_tx},
                           GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
 
     SyncWithValidationInterfaceQueue();
 
     {
         auto block_id = block_tx.GetId();
         auto prev_id = m_coinbase_txns[0]->GetId();
 
         LOCK(wallet->cs_wallet);
         BOOST_CHECK(wallet->HasWalletSpend(prev_id));
         BOOST_CHECK_EQUAL(wallet->mapWallet.count(block_id), 1u);
 
         std::vector<TxId> vIdIn{block_id}, vIdOut;
         BOOST_CHECK_EQUAL(wallet->ZapSelectTx(vIdIn, vIdOut),
                           DBErrors::LOAD_OK);
 
         BOOST_CHECK(!wallet->HasWalletSpend(prev_id));
         BOOST_CHECK_EQUAL(wallet->mapWallet.count(block_id), 0u);
     }
 
     TestUnloadWallet(std::move(wallet));
 }
 
 BOOST_AUTO_TEST_SUITE_END()