diff --git a/src/bench/block_assemble.cpp b/src/bench/block_assemble.cpp
index 713d60b4a..de1cfee1b 100644
--- a/src/bench/block_assemble.cpp
+++ b/src/bench/block_assemble.cpp
@@ -1,58 +1,59 @@
 // Copyright (c) 2011-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 <bench/bench.h>
 #include <config.h>
 #include <consensus/validation.h>
 #include <script/standard.h>
 #include <test/util.h>
+#include <test/util/mining.h>
 #include <txmempool.h>
 #include <validation.h>
 
 #include <vector>
 
 static void AssembleBlock(benchmark::State &state) {
     const Config &config = GetConfig();
 
     const CScript redeemScript = CScript() << OP_DROP << OP_TRUE;
     const CScript SCRIPT_PUB =
         CScript() << OP_HASH160 << ToByteVector(CScriptID(redeemScript))
                   << OP_EQUAL;
 
     const CScript scriptSig = CScript() << std::vector<uint8_t>(100, 0xff)
                                         << ToByteVector(redeemScript);
 
     // Collect some loose transactions that spend the coinbases of our mined
     // blocks
     constexpr size_t NUM_BLOCKS{200};
     std::array<CTransactionRef, NUM_BLOCKS - COINBASE_MATURITY + 1> txs;
     for (size_t b = 0; b < NUM_BLOCKS; ++b) {
         CMutableTransaction tx;
         tx.vin.push_back(MineBlock(config, SCRIPT_PUB));
         tx.vin.back().scriptSig = scriptSig;
         tx.vout.emplace_back(1337 * SATOSHI, SCRIPT_PUB);
         if (NUM_BLOCKS - b >= COINBASE_MATURITY) {
             txs.at(b) = MakeTransactionRef(tx);
         }
     }
 
     {
         // Required for ::AcceptToMemoryPool.
         LOCK(::cs_main);
 
         for (const auto &txr : txs) {
             TxValidationState vstate;
             bool ret{::AcceptToMemoryPool(config, ::g_mempool, vstate, txr,
                                           false /* bypass_limits */,
                                           /* nAbsurdFee */ Amount::zero())};
             assert(ret);
         }
     }
 
     while (state.KeepRunning()) {
         PrepareBlock(config, SCRIPT_PUB);
     }
 }
 
 BENCHMARK(AssembleBlock, 700);
diff --git a/src/bench/wallet_balance.cpp b/src/bench/wallet_balance.cpp
index ab324d750..970ec6c6d 100644
--- a/src/bench/wallet_balance.cpp
+++ b/src/bench/wallet_balance.cpp
@@ -1,84 +1,85 @@
 // 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 <bench/bench.h>
 #include <config.h>
 #include <interfaces/chain.h>
 #include <node/context.h>
 #include <optional.h>
 #include <test/util.h>
+#include <test/util/mining.h>
 #include <validationinterface.h>
 #include <wallet/wallet.h>
 
 static void WalletBalance(benchmark::State &state, const bool set_dirty,
                           const bool add_watchonly, const bool add_mine) {
     const auto &ADDRESS_WATCHONLY = ADDRESS_BCHREG_UNSPENDABLE;
 
     const Config &config = GetConfig();
 
     NodeContext node;
     std::unique_ptr<interfaces::Chain> chain =
         interfaces::MakeChain(node, config.GetChainParams());
     CWallet wallet{config.GetChainParams(), chain.get(), WalletLocation(),
                    WalletDatabase::CreateMock()};
     {
         bool first_run;
         if (wallet.LoadWallet(first_run) != DBErrors::LOAD_OK) {
             assert(false);
         }
     }
 
     auto handler = chain->handleNotifications({&wallet, [](CWallet *) {}});
 
     const Optional<std::string> address_mine{
         add_mine ? Optional<std::string>{getnewaddress(config, wallet)}
                  : nullopt};
     if (add_watchonly) {
         importaddress(wallet, ADDRESS_WATCHONLY);
     }
 
     for (int i = 0; i < 100; ++i) {
         generatetoaddress(config, address_mine.get_value_or(ADDRESS_WATCHONLY));
         generatetoaddress(config, ADDRESS_WATCHONLY);
     }
     SyncWithValidationInterfaceQueue();
 
     // Cache
     auto bal = wallet.GetBalance();
 
     while (state.KeepRunning()) {
         if (set_dirty) {
             wallet.MarkDirty();
         }
         bal = wallet.GetBalance();
         if (add_mine) {
             assert(bal.m_mine_trusted > Amount::zero());
         }
         if (add_watchonly) {
             assert(bal.m_watchonly_trusted > Amount::zero());
         }
     }
 }
 
 static void WalletBalanceDirty(benchmark::State &state) {
     WalletBalance(state, /* set_dirty */ true, /* add_watchonly */ true,
                   /* add_mine */ true);
 }
 static void WalletBalanceClean(benchmark::State &state) {
     WalletBalance(state, /* set_dirty */ false, /* add_watchonly */ true,
                   /* add_mine */ true);
 }
 static void WalletBalanceMine(benchmark::State &state) {
     WalletBalance(state, /* set_dirty */ false, /* add_watchonly */ false,
                   /* add_mine */ true);
 }
 static void WalletBalanceWatch(benchmark::State &state) {
     WalletBalance(state, /* set_dirty */ false, /* add_watchonly */ true,
                   /* add_mine */ false);
 }
 
 BENCHMARK(WalletBalanceDirty, 2500);
 BENCHMARK(WalletBalanceClean, 8000);
 BENCHMARK(WalletBalanceMine, 16000);
 BENCHMARK(WalletBalanceWatch, 8000);
diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
index 6ae23ad34..9018eac49 100644
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -1,244 +1,245 @@
 # Copyright (c) 2018 The Bitcoin developers
 
 project(bitcoin-test)
 
 # Process json files.
 file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/data")
 
 function(gen_json_header NAME)
 	set(HEADERS "")
 	foreach(f ${ARGN})
 		set(h "${CMAKE_CURRENT_BINARY_DIR}/${f}.h")
 
 		# Get the proper name for the test variable.
 		get_filename_component(TEST_NAME ${f} NAME_WE)
 		add_custom_command(OUTPUT ${h}
 			COMMAND
 				"${Python_EXECUTABLE}"
 				"${CMAKE_CURRENT_SOURCE_DIR}/data/generate_header.py"
 				"${TEST_NAME}"
 				"${CMAKE_CURRENT_SOURCE_DIR}/${f}" > ${h}
 			MAIN_DEPENDENCY ${f}
 			DEPENDS
 				"data/generate_header.py"
 			VERBATIM
 		)
 		list(APPEND HEADERS ${h})
 	endforeach(f)
 	set(${NAME} "${HEADERS}" PARENT_SCOPE)
 endfunction()
 
 gen_json_header(JSON_HEADERS
 	data/base58_encode_decode.json
 	data/blockfilters.json
 	data/key_io_valid.json
 	data/key_io_invalid.json
 	data/script_tests.json
 	data/sighash.json
 	data/tx_invalid.json
 	data/tx_valid.json
 )
 
 include(TestSuite)
 create_test_suite(bitcoin)
 add_dependencies(check check-bitcoin)
 
 # An utility library for bitcoin related test suites.
 add_library(testutil OBJECT
 	util/blockfilter.cpp
 	util/logging.cpp
+	util/mining.cpp
 	util/setup_common.cpp
 	util/str.cpp
 	util/transaction_utils.cpp
 )
 
 target_link_libraries(testutil server)
 
 if(BUILD_BITCOIN_WALLET)
 	set(BITCOIN_WALLET_TEST_FIXTURE
 		../wallet/test/init_test_fixture.cpp
 		../wallet/test/wallet_test_fixture.cpp
 	)
 	set(BITCOIN_WALLET_TESTS
 		../wallet/test/db_tests.cpp
 		../wallet/test/coinselector_tests.cpp
 		../wallet/test/init_tests.cpp
 		../wallet/test/ismine_tests.cpp
 		../wallet/test/psbt_wallet_tests.cpp
 		../wallet/test/wallet_tests.cpp
 		../wallet/test/walletdb_tests.cpp
 		../wallet/test/wallet_crypto_tests.cpp
 	)
 endif()
 
 add_boost_unit_tests_to_suite(bitcoin test_bitcoin
 	fixture.cpp
 	jsonutil.cpp
 	scriptflags.cpp
 	sigutil.cpp
 
 	# Tests generated from JSON
 	${JSON_HEADERS}
 
 	# Wallet test fixture
 	${BITCOIN_WALLET_TEST_FIXTURE}
 
 	TESTS
 		activation_tests.cpp
 		addrman_tests.cpp
 		allocator_tests.cpp
 		amount_tests.cpp
 		arith_uint256_tests.cpp
 		base32_tests.cpp
 		base58_tests.cpp
 		base64_tests.cpp
 		bip32_tests.cpp
 		bitmanip_tests.cpp
 		blockchain_tests.cpp
 		blockcheck_tests.cpp
 		blockencodings_tests.cpp
 		blockfilter_tests.cpp
 		blockfilter_index_tests.cpp
 		blockindex_tests.cpp
 		blockstatus_tests.cpp
 		bloom_tests.cpp
 		bswap_tests.cpp
 		cashaddr_tests.cpp
 		cashaddrenc_tests.cpp
 		checkdatasig_tests.cpp
 		checkpoints_tests.cpp
 		checkqueue_tests.cpp
 		coins_tests.cpp
 		compress_tests.cpp
 		config_tests.cpp
 		core_io_tests.cpp
 		crypto_tests.cpp
 		cuckoocache_tests.cpp
 		dbwrapper_tests.cpp
 		denialofservice_tests.cpp
 		descriptor_tests.cpp
 		dstencode_tests.cpp
 		excessiveblock_tests.cpp
 		feerate_tests.cpp
 		finalization_tests.cpp
 		flatfile_tests.cpp
 		fs_tests.cpp
 		getarg_tests.cpp
 		hash_tests.cpp
 		inv_tests.cpp
 		key_io_tests.cpp
 		key_tests.cpp
 		lcg_tests.cpp
 		limitedmap_tests.cpp
 		mempool_tests.cpp
 		merkle_tests.cpp
 		merkleblock_tests.cpp
 		miner_tests.cpp
 		monolith_opcodes_tests.cpp
 		multisig_tests.cpp
 		net_tests.cpp
 		netbase_tests.cpp
 		op_reversebytes_tests.cpp
 		pmt_tests.cpp
 		policyestimator_tests.cpp
 		prevector_tests.cpp
 		radix_tests.cpp
 		raii_event_tests.cpp
 		random_tests.cpp
 		rcu_tests.cpp
 		reverselock_tests.cpp
 		rpc_tests.cpp
 		rpc_server_tests.cpp
 		rwcollection_tests.cpp
 		sanity_tests.cpp
 		scheduler_tests.cpp
 		schnorr_tests.cpp
 		script_bitfield_tests.cpp
 		script_commitment_tests.cpp
 		script_p2sh_tests.cpp
 		script_standard_tests.cpp
 		script_tests.cpp
 		scriptnum_tests.cpp
 		serialize_tests.cpp
 		settings_tests.cpp
 		sigcache_tests.cpp
 		sigencoding_tests.cpp
 		sighash_tests.cpp
 		sighashtype_tests.cpp
 		sigcheckcount_tests.cpp
 		skiplist_tests.cpp
 		streams_tests.cpp
 		sync_tests.cpp
 		timedata_tests.cpp
 		torcontrol_tests.cpp
 		transaction_tests.cpp
 		txindex_tests.cpp
 		txvalidation_tests.cpp
 		txvalidationcache_tests.cpp
 		uint256_tests.cpp
 		undo_tests.cpp
 		util_tests.cpp
 		util_threadnames_tests.cpp
 		validation_block_tests.cpp
 		validation_tests.cpp
 		validationinterface_tests.cpp
 		versionbits_tests.cpp
 		work_comparator_tests.cpp
 
 		# RPC Tests
 		../rpc/test/server_tests.cpp
 
 		# Wallet tests
 		${BITCOIN_WALLET_TESTS}
 )
 
 function(add_boost_test_runners_with_upgrade_activated SUITE EXECUTABLE)
 	set(SUITE_UPGRADE_ACTIVATED "${SUITE}-upgrade-activated")
 	get_target_from_suite(${SUITE_UPGRADE_ACTIVATED} TARGET_UPGRADE_ACTIVATED)
 
 	if(NOT TARGET ${TARGET_UPGRADE_ACTIVATED})
 		create_test_suite_with_parent_targets(
 			${SUITE_UPGRADE_ACTIVATED}
 			check-upgrade-activated
 			check-upgrade-activated-extended
 		)
 		add_dependencies(${TARGET_UPGRADE_ACTIVATED} ${EXECUTABLE})
 	endif()
 
 	get_target_from_suite(${SUITE} SUITE_TARGET)
 	get_target_property(BOOST_TESTS ${SUITE_TARGET} UNIT_TESTS)
 
 	get_target_from_suite(${SUITE_UPGRADE_ACTIVATED} SUITE_UPGRADE_ACTIVATED_TARGET)
 
 	set(HRF_LOGGER "HRF,test_suite")
 
 	foreach(_test_name ${BOOST_TESTS})
 		if(ENABLE_JUNIT_REPORT)
 			set(JUNIT_LOGGER ":JUNIT,message,${SUITE_UPGRADE_ACTIVATED}-${_test_name}.xml")
 		endif()
 
 		add_test_runner(
 			${SUITE_UPGRADE_ACTIVATED}
 			"${_test_name}"
 			${EXECUTABLE}
 			JUNIT
 			"--run_test=${_test_name}"
 			"--logger=${HRF_LOGGER}${JUNIT_LOGGER}"
 			# Dec. 1st, 2019 at 00:00:00
 			--
 			"-testsuitename=Bitcoin ABC unit tests with next upgrade activated"
 			-axionactivationtime=1575158400
 		)
 	endforeach()
 endfunction()
 
 add_boost_test_runners_with_upgrade_activated(bitcoin test_bitcoin)
 
 target_link_libraries(test_bitcoin rpcclient testutil)
 if(TARGET bitcoinconsensus-shared)
 	target_link_libraries(test_bitcoin bitcoinconsensus-shared)
 else()
 	target_link_libraries(test_bitcoin bitcoinconsensus)
 endif()
 
 add_subdirectory(fuzz)
diff --git a/src/test/util.cpp b/src/test/util.cpp
index 60404e03e..72d15bac3 100644
--- a/src/test/util.cpp
+++ b/src/test/util.cpp
@@ -1,85 +1,43 @@
 // Copyright (c) 2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <test/util.h>
 
-#include <chainparams.h>
 #include <config.h>
-#include <consensus/merkle.h>
 #include <key_io.h>
-#include <miner.h>
-#include <pow/pow.h>
-#include <validation.h>
 
 #ifdef ENABLE_WALLET
 #include <wallet/wallet.h>
 #endif // ENABLE_WALLET
 
 const std::string ADDRESS_BCHREG_UNSPENDABLE =
     "bchreg:qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqha9s37tt";
 
 #ifdef ENABLE_WALLET
 std::string getnewaddress(const Config &config, CWallet &w) {
     constexpr auto output_type = OutputType::LEGACY;
     CTxDestination dest;
     std::string error;
     if (!w.GetNewDestination(output_type, "", dest, error)) {
         assert(false);
     }
 
     return EncodeDestination(dest, config);
 }
 
 void importaddress(CWallet &wallet, const std::string &address) {
     auto spk_man = wallet.GetLegacyScriptPubKeyMan();
     LOCK(wallet.cs_wallet);
     AssertLockHeld(spk_man->cs_wallet);
     const auto dest = DecodeDestination(address, wallet.chainParams);
     assert(IsValidDestination(dest));
     const auto script = GetScriptForDestination(dest);
     wallet.MarkDirty();
     assert(!spk_man->HaveWatchOnly(script));
     if (!spk_man->AddWatchOnly(script, 0 /* nCreateTime */)) {
         assert(false);
     }
     wallet.SetAddressBook(dest, /* label */ "", "receive");
 }
 #endif // ENABLE_WALLET
-
-CTxIn generatetoaddress(const Config &config, const std::string &address) {
-    const auto dest = DecodeDestination(address, config.GetChainParams());
-    assert(IsValidDestination(dest));
-    const auto coinbase_script = GetScriptForDestination(dest);
-
-    return MineBlock(config, coinbase_script);
-}
-
-CTxIn MineBlock(const Config &config, const CScript &coinbase_scriptPubKey) {
-    auto block = PrepareBlock(config, coinbase_scriptPubKey);
-
-    while (!CheckProofOfWork(block->GetHash(), block->nBits,
-                             config.GetChainParams().GetConsensus())) {
-        ++block->nNonce;
-        assert(block->nNonce);
-    }
-
-    bool processed{ProcessNewBlock(config, block, true, nullptr)};
-    assert(processed);
-
-    return CTxIn{block->vtx[0]->GetId(), 0};
-}
-
-std::shared_ptr<CBlock> PrepareBlock(const Config &config,
-                                     const CScript &coinbase_scriptPubKey) {
-    auto block =
-        std::make_shared<CBlock>(BlockAssembler{config, ::g_mempool}
-                                     .CreateNewBlock(coinbase_scriptPubKey)
-                                     ->block);
-
-    LOCK(cs_main);
-    block->nTime = ::ChainActive().Tip()->GetMedianTimePast() + 1;
-    block->hashMerkleRoot = BlockMerkleRoot(*block);
-
-    return block;
-}
diff --git a/src/test/util.h b/src/test/util.h
index f37f179a3..c6131a7f9 100644
--- a/src/test/util.h
+++ b/src/test/util.h
@@ -1,38 +1,24 @@
 // Copyright (c) 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.
 
 #ifndef BITCOIN_TEST_UTIL_H
 #define BITCOIN_TEST_UTIL_H
 
-#include <memory>
 #include <string>
 
-class CBlock;
 class Config;
-class CScript;
-class CTxIn;
 class CWallet;
 
 // Constants //
 
 extern const std::string ADDRESS_BCHREG_UNSPENDABLE;
 
-// Lower-level utils //
-
-/** Returns the generated coin */
-CTxIn MineBlock(const Config &config, const CScript &coinbase_scriptPubKey);
-/** Prepare a block to be mined */
-std::shared_ptr<CBlock> PrepareBlock(const Config &config,
-                                     const CScript &coinbase_scriptPubKey);
-
 // RPC-like //
 
 /** Import the address to the wallet */
 void importaddress(CWallet &wallet, const std::string &address);
 /** Returns a new address from the wallet */
 std::string getnewaddress(const Config &config, CWallet &w);
-/** Returns the generated coin */
-CTxIn generatetoaddress(const Config &config, const std::string &address);
 
 #endif // BITCOIN_TEST_UTIL_H
diff --git a/src/test/util.cpp b/src/test/util/mining.cpp
similarity index 63%
copy from src/test/util.cpp
copy to src/test/util/mining.cpp
index 60404e03e..a33f49cbc 100644
--- a/src/test/util.cpp
+++ b/src/test/util/mining.cpp
@@ -1,85 +1,54 @@
 // Copyright (c) 2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <test/util.h>
+#include <test/util/mining.h>
 
 #include <chainparams.h>
 #include <config.h>
 #include <consensus/merkle.h>
 #include <key_io.h>
 #include <miner.h>
 #include <pow/pow.h>
+#include <script/standard.h>
 #include <validation.h>
 
-#ifdef ENABLE_WALLET
-#include <wallet/wallet.h>
-#endif // ENABLE_WALLET
-
 const std::string ADDRESS_BCHREG_UNSPENDABLE =
     "bchreg:qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqha9s37tt";
 
-#ifdef ENABLE_WALLET
-std::string getnewaddress(const Config &config, CWallet &w) {
-    constexpr auto output_type = OutputType::LEGACY;
-    CTxDestination dest;
-    std::string error;
-    if (!w.GetNewDestination(output_type, "", dest, error)) {
-        assert(false);
-    }
-
-    return EncodeDestination(dest, config);
-}
-
-void importaddress(CWallet &wallet, const std::string &address) {
-    auto spk_man = wallet.GetLegacyScriptPubKeyMan();
-    LOCK(wallet.cs_wallet);
-    AssertLockHeld(spk_man->cs_wallet);
-    const auto dest = DecodeDestination(address, wallet.chainParams);
-    assert(IsValidDestination(dest));
-    const auto script = GetScriptForDestination(dest);
-    wallet.MarkDirty();
-    assert(!spk_man->HaveWatchOnly(script));
-    if (!spk_man->AddWatchOnly(script, 0 /* nCreateTime */)) {
-        assert(false);
-    }
-    wallet.SetAddressBook(dest, /* label */ "", "receive");
-}
-#endif // ENABLE_WALLET
-
 CTxIn generatetoaddress(const Config &config, const std::string &address) {
     const auto dest = DecodeDestination(address, config.GetChainParams());
     assert(IsValidDestination(dest));
     const auto coinbase_script = GetScriptForDestination(dest);
 
     return MineBlock(config, coinbase_script);
 }
 
 CTxIn MineBlock(const Config &config, const CScript &coinbase_scriptPubKey) {
     auto block = PrepareBlock(config, coinbase_scriptPubKey);
 
     while (!CheckProofOfWork(block->GetHash(), block->nBits,
                              config.GetChainParams().GetConsensus())) {
         ++block->nNonce;
         assert(block->nNonce);
     }
 
     bool processed{ProcessNewBlock(config, block, true, nullptr)};
     assert(processed);
 
     return CTxIn{block->vtx[0]->GetId(), 0};
 }
 
 std::shared_ptr<CBlock> PrepareBlock(const Config &config,
                                      const CScript &coinbase_scriptPubKey) {
     auto block =
         std::make_shared<CBlock>(BlockAssembler{config, ::g_mempool}
                                      .CreateNewBlock(coinbase_scriptPubKey)
                                      ->block);
 
     LOCK(cs_main);
     block->nTime = ::ChainActive().Tip()->GetMedianTimePast() + 1;
     block->hashMerkleRoot = BlockMerkleRoot(*block);
 
     return block;
 }
diff --git a/src/test/util.h b/src/test/util/mining.h
similarity index 58%
copy from src/test/util.h
copy to src/test/util/mining.h
index f37f179a3..b1fdbf80e 100644
--- a/src/test/util.h
+++ b/src/test/util/mining.h
@@ -1,38 +1,26 @@
 // Copyright (c) 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.
 
-#ifndef BITCOIN_TEST_UTIL_H
-#define BITCOIN_TEST_UTIL_H
+#ifndef BITCOIN_TEST_UTIL_MINING_H
+#define BITCOIN_TEST_UTIL_MINING_H
 
 #include <memory>
 #include <string>
 
 class CBlock;
 class Config;
 class CScript;
 class CTxIn;
-class CWallet;
-
-// Constants //
-
-extern const std::string ADDRESS_BCHREG_UNSPENDABLE;
-
-// Lower-level utils //
 
 /** Returns the generated coin */
 CTxIn MineBlock(const Config &config, const CScript &coinbase_scriptPubKey);
+
 /** Prepare a block to be mined */
 std::shared_ptr<CBlock> PrepareBlock(const Config &config,
                                      const CScript &coinbase_scriptPubKey);
 
-// RPC-like //
-
-/** Import the address to the wallet */
-void importaddress(CWallet &wallet, const std::string &address);
-/** Returns a new address from the wallet */
-std::string getnewaddress(const Config &config, CWallet &w);
-/** Returns the generated coin */
+/** RPC-like helper function, returns the generated coin */
 CTxIn generatetoaddress(const Config &config, const std::string &address);
 
-#endif // BITCOIN_TEST_UTIL_H
+#endif // BITCOIN_TEST_UTIL_MINING_H