diff --git a/src/Makefile.test.include b/src/Makefile.test.include
index b37407a80..0cafce83b 100644
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -1,217 +1,218 @@
 # Copyright (c) 2013-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.
 
 bin_PROGRAMS += test/test_bitcoin
 noinst_PROGRAMS += test/test_bitcoin_fuzzy
 TEST_SRCDIR = test
 TEST_BINARY=test/test_bitcoin$(EXEEXT)
 
 JSON_TEST_FILES = \
-  test/data/script_tests.json \
-  test/data/base58_keys_valid.json \
   test/data/base58_encode_decode.json \
-  test/data/base58_keys_invalid.json \
   test/data/blockfilters.json \
+  test/data/key_io_valid.json \
+  test/data/key_io_invalid.json \
+  test/data/script_tests.json \
+  test/data/sighash.json \
   test/data/tx_invalid.json \
-  test/data/tx_valid.json \
-  test/data/sighash.json
+  test/data/tx_valid.json
 
 RAW_TEST_FILES =
 
 GENERATED_TEST_FILES = $(JSON_TEST_FILES:.json=.json.h) $(RAW_TEST_FILES:.raw=.raw.h)
 
 BITCOIN_TEST_SUITE = \
   test/jsonutil.cpp \
   test/scriptflags.cpp \
   test/sigutil.cpp \
   test/test_bitcoin_main.cpp \
   test/test_bitcoin.h \
   test/test_bitcoin.cpp
 
 # test_bitcoin binary #
 BITCOIN_TESTS =\
   test/scriptnum10.h \
   test/activation_tests.cpp \
   test/addrman_tests.cpp \
   test/allocator_tests.cpp \
   test/amount_tests.cpp \
   test/arith_uint256_tests.cpp \
   test/avalanche_tests.cpp \
   test/base32_tests.cpp \
   test/base58_tests.cpp \
   test/base64_tests.cpp \
   test/bip32_tests.cpp \
   test/blockchain_tests.cpp \
   test/blockcheck_tests.cpp \
   test/blockencodings_tests.cpp \
   test/blockfilter_tests.cpp \
   test/blockindex_tests.cpp \
   test/blockstatus_tests.cpp \
   test/bloom_tests.cpp \
   test/bswap_tests.cpp \
   test/cashaddr_tests.cpp \
   test/cashaddrenc_tests.cpp \
   test/checkdatasig_tests.cpp \
   test/checkpoints_tests.cpp \
   test/checkqueue_tests.cpp \
   test/coins_tests.cpp \
   test/compress_tests.cpp \
   test/config_tests.cpp \
   test/core_io_tests.cpp \
   test/crypto_tests.cpp \
   test/cuckoocache_tests.cpp \
   test/dbwrapper_tests.cpp \
   test/denialofservice_tests.cpp \
   test/dstencode_tests.cpp \
   test/excessiveblock_tests.cpp \
   test/feerate_tests.cpp \
   test/finalization_tests.cpp \
   test/getarg_tests.cpp \
   test/hash_tests.cpp \
   test/inv_tests.cpp \
   test/jsonutil.h \
+  test/key_io_tests.cpp \
   test/key_tests.cpp \
   test/lcg_tests.cpp \
   test/lcg.h \
   test/limitedmap_tests.cpp \
   test/main_tests.cpp \
   test/mempool_tests.cpp \
   test/merkle_tests.cpp \
   test/miner_tests.cpp \
   test/monolith_opcodes_tests.cpp \
   test/multisig_tests.cpp \
   test/net_tests.cpp \
   test/netbase_tests.cpp \
   test/pmt_tests.cpp \
   test/policyestimator_tests.cpp \
   test/pow_tests.cpp \
   test/prevector_tests.cpp \
   test/radix_tests.cpp \
   test/raii_event_tests.cpp \
   test/random_tests.cpp \
   test/rcu_tests.cpp \
   test/reverselock_tests.cpp \
   test/rpc_tests.cpp \
   test/rpc_server_tests.cpp \
   test/rwcollection_tests.cpp \
   test/sanity_tests.cpp \
   test/scheduler_tests.cpp \
   test/schnorr_tests.cpp \
   test/script_commitment_tests.cpp \
   test/script_p2sh_tests.cpp \
   test/script_standard_tests.cpp \
   test/script_tests.cpp \
   test/scriptflags.h \
   test/scriptnum_tests.cpp \
   test/serialize_tests.cpp \
   test/sigcache_tests.cpp \
   test/sigencoding_tests.cpp \
   test/sighash_tests.cpp \
   test/sighashtype_tests.cpp \
   test/sigopcount_tests.cpp \
   test/sigutil.h \
   test/skiplist_tests.cpp \
   test/streams_tests.cpp \
   test/sync_tests.cpp \
   test/timedata_tests.cpp \
   test/torcontrol_tests.cpp \
   test/transaction_tests.cpp \
   test/txindex_tests.cpp \
   test/txvalidationcache_tests.cpp \
   test/uint256_tests.cpp \
   test/undo_tests.cpp \
   test/univalue_tests.cpp \
   test/util_tests.cpp \
   test/validation_block_tests.cpp \
   test/validation_tests.cpp \
   test/work_comparator_tests.cpp \
   rpc/test/server_tests.cpp
 
 if ENABLE_WALLET
 BITCOIN_TESTS += \
   wallet/test/accounting_tests.cpp \
   wallet/test/wallet_tests.cpp \
   wallet/test/walletdb_tests.cpp \
   wallet/test/wallet_crypto_tests.cpp \
   wallet/test/coinselector_tests.cpp
 
 BITCOIN_TEST_SUITE += \
   wallet/test/wallet_test_fixture.cpp \
   wallet/test/wallet_test_fixture.h
 endif
 
 test_test_bitcoin_SOURCES = $(BITCOIN_TEST_SUITE) $(BITCOIN_TESTS) $(JSON_TEST_FILES) $(RAW_TEST_FILES)
 test_test_bitcoin_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) $(TESTDEFS) $(EVENT_CFLAGS)
 test_test_bitcoin_LDADD =
 if ENABLE_WALLET
 test_test_bitcoin_LDADD += $(LIBBITCOIN_WALLET)
 endif
 
 test_test_bitcoin_LDADD += $(LIBBITCOIN_SERVER) $(LIBBITCOIN_CLI) $(LIBBITCOIN_COMMON) $(LIBBITCOIN_UTIL) $(LIBBITCOIN_CONSENSUS) $(LIBBITCOIN_CRYPTO) $(LIBUNIVALUE) \
   $(LIBLEVELDB) $(LIBLEVELDB_SSE42) $(LIBMEMENV) $(BOOST_LIBS) $(BOOST_UNIT_TEST_FRAMEWORK_LIB) $(LIBSECP256K1) $(EVENT_LIBS) $(EVENT_PTHREADS_LIBS)
 test_test_bitcoin_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
 
 test_test_bitcoin_LDADD += $(LIBBITCOIN_CONSENSUS) $(BDB_LIBS) $(SSL_LIBS) $(CRYPTO_LIBS) $(MINIUPNPC_LIBS)
 test_test_bitcoin_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS) -static
 
 if ENABLE_ZMQ
 test_test_bitcoin_LDADD += $(ZMQ_LIBS)
 endif
 #
 
 # test_bitcoin_fuzzy binary #
 test_test_bitcoin_fuzzy_SOURCES = test/test_bitcoin_fuzzy.cpp
 test_test_bitcoin_fuzzy_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES)
 test_test_bitcoin_fuzzy_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
 test_test_bitcoin_fuzzy_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
 
 test_test_bitcoin_fuzzy_LDADD = \
   $(LIBUNIVALUE) \
   $(LIBBITCOIN_SERVER) \
   $(LIBBITCOIN_COMMON) \
   $(LIBBITCOIN_UTIL) \
   $(LIBBITCOIN_CONSENSUS) \
   $(LIBBITCOIN_CRYPTO) \
   $(LIBSECP256K1)
 
 test_test_bitcoin_fuzzy_LDADD += $(BOOST_LIBS) $(CRYPTO_LIBS)
 #
 
 nodist_test_test_bitcoin_SOURCES = $(GENERATED_TEST_FILES)
 
 $(BITCOIN_TESTS): $(GENERATED_TEST_FILES)
 
 CLEAN_BITCOIN_TEST = test/*.gcda test/*.gcno $(GENERATED_TEST_FILES)
 
 CLEANFILES += $(CLEAN_BITCOIN_TEST)
 
 bitcoin_test: $(TEST_BINARY)
 
 bitcoin_test_check: $(TEST_BINARY) FORCE
 	$(MAKE) check-TESTS TESTS=$^
 
 bitcoin_test_clean : FORCE
 	rm -f $(CLEAN_BITCOIN_TEST) $(test_test_bitcoin_OBJECTS) $(TEST_BINARY)
 
 check-local: $(BITCOIN_TESTS:.cpp=.cpp.test)
 	@echo "Running test/util/bitcoin-util-test.py..."
 	$(top_builddir)/test/util/bitcoin-util-test.py
 	$(AM_V_at)$(MAKE) $(AM_MAKEFLAGS) -C secp256k1 check
 if EMBEDDED_UNIVALUE
 	$(AM_V_at)$(MAKE) $(AM_MAKEFLAGS) -C univalue check
 endif
 
 %.cpp.test: %.cpp
 	@echo Running tests: `cat $< | grep "BOOST_FIXTURE_TEST_SUITE(\|BOOST_AUTO_TEST_SUITE(" | cut -d '(' -f 2 | cut -d ',' -f 1 | cut -d ')' -f 1` from $<
 	$(AM_V_at)$(TEST_BINARY) -l test_suite -t "`cat $< | grep "BOOST_FIXTURE_TEST_SUITE(\|BOOST_AUTO_TEST_SUITE(" | cut -d '(' -f 2 | cut -d ',' -f 1 | cut -d ')' -f 1`" > $@.log 2>&1 || (cat $@.log && false)
 
 %.json.h: %.json
 	@$(MKDIR_P) $(@D)
 	@{ \
 	 echo "namespace json_tests{" && \
 	 echo "static unsigned const char $(*F)[] = {" && \
 	 $(HEXDUMP) -v -e '8/1 "0x%02x, "' -e '"\n"' $< | $(SED) -e 's/0x  ,//g' && \
 	 echo "};};"; \
 	} > "$@.new" && mv -f "$@.new" "$@"
 	@echo "Generated $@"
diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
index 930ef51f3..d531813a1 100644
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -1,177 +1,178 @@
 # Copyright (c) 2018 The Bitcoin developers
 
 project(bitcoin-test)
 
 # Process json files.
 file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/data")
 
 find_program(PYTHON python)
 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}
 			ARGS
 				"${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/script_tests.json
-	data/base58_keys_valid.json
 	data/base58_encode_decode.json
-	data/base58_keys_invalid.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
-	data/sighash.json
 )
 
 include(TestSuite)
 create_test_suite(bitcoin)
 add_dependencies(check check-bitcoin)
 
 add_test_to_suite(bitcoin test_bitcoin
 	activation_tests.cpp
 	addrman_tests.cpp
 	allocator_tests.cpp
 	amount_tests.cpp
 	arith_uint256_tests.cpp
 	avalanche_tests.cpp
 	base32_tests.cpp
 	base58_tests.cpp
 	base64_tests.cpp
 	bip32_tests.cpp
 	blockchain_tests.cpp
 	blockcheck_tests.cpp
 	blockencodings_tests.cpp
 	blockfilter_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
 	dstencode_tests.cpp
 	excessiveblock_tests.cpp
 	feerate_tests.cpp
 	finalization_tests.cpp
 	getarg_tests.cpp
 	hash_tests.cpp
 	inv_tests.cpp
 	jsonutil.cpp
+	key_io_tests.cpp
 	key_tests.cpp
 	lcg_tests.cpp
 	limitedmap_tests.cpp
 	main_tests.cpp
 	mempool_tests.cpp
 	merkle_tests.cpp
 	miner_tests.cpp
 	monolith_opcodes_tests.cpp
 	multisig_tests.cpp
 	net_tests.cpp
 	netbase_tests.cpp
 	pmt_tests.cpp
 	policyestimator_tests.cpp
 	pow_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_commitment_tests.cpp
 	script_p2sh_tests.cpp
 	script_standard_tests.cpp
 	script_tests.cpp
 	scriptflags.cpp
 	scriptnum_tests.cpp
 	serialize_tests.cpp
 	sigcache_tests.cpp
 	sigencoding_tests.cpp
 	sighash_tests.cpp
 	sighashtype_tests.cpp
 	sigopcount_tests.cpp
 	sigutil.cpp
 	skiplist_tests.cpp
 	streams_tests.cpp
 	sync_tests.cpp
 	test_bitcoin.cpp
 	test_bitcoin_main.cpp
 	timedata_tests.cpp
 	torcontrol_tests.cpp
 	transaction_tests.cpp
 	txindex_tests.cpp
 	txvalidationcache_tests.cpp
 	uint256_tests.cpp
 	undo_tests.cpp
 	univalue_tests.cpp
 	util_tests.cpp
 	validation_block_tests.cpp
 	validation_tests.cpp
 	work_comparator_tests.cpp
 
 	# RPC Tests
 	../rpc/test/server_tests.cpp
 
 	# Tests generated from JSON
 	${JSON_HEADERS}
 )
 
 find_package(Boost 1.58 REQUIRED unit_test_framework)
 
 target_link_libraries(test_bitcoin Boost::unit_test_framework rpcclient server)
 
 # We need to detect if the BOOST_TEST_DYN_LINK flag is required.
 set(CMAKE_REQUIRED_LIBRARIES Boost::unit_test_framework)
 check_cxx_source_compiles("
 	#define BOOST_TEST_DYN_LINK
 	#define BOOST_TEST_MAIN
 	#include <boost/test/unit_test.hpp>
 " BOOST_TEST_DYN_LINK)
 
 if(BOOST_TEST_DYN_LINK)
 	target_compile_definitions(test_bitcoin PRIVATE BOOST_TEST_DYN_LINK)
 endif(BOOST_TEST_DYN_LINK)
 
 if(BUILD_BITCOIN_WALLET)
 	target_sources(test_bitcoin
 		PRIVATE
 			../wallet/test/wallet_test_fixture.cpp
 			../wallet/test/accounting_tests.cpp
 			../wallet/test/wallet_tests.cpp
 			../wallet/test/walletdb_tests.cpp
 			../wallet/test/wallet_crypto_tests.cpp
 			../wallet/test/coinselector_tests.cpp
 	)
 endif()
diff --git a/src/test/base58_tests.cpp b/src/test/base58_tests.cpp
index e5d4cced2..f3ac15eae 100644
--- a/src/test/base58_tests.cpp
+++ b/src/test/base58_tests.cpp
@@ -1,234 +1,77 @@
 // Copyright (c) 2011-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 <base58.h>
-
-#include <chainparams.h> // For Params()
-#include <key.h>
-#include <key_io.h>
-#include <script/script.h>
-#include <uint256.h>
-#include <util.h>
-#include <utilstrencodings.h>
-
 #include <test/data/base58_encode_decode.json.h>
-#include <test/data/base58_keys_invalid.json.h>
-#include <test/data/base58_keys_valid.json.h>
+
+#include <base58.h>
 #include <test/jsonutil.h>
 #include <test/test_bitcoin.h>
+#include <utilstrencodings.h>
 
 #include <univalue.h>
 
 #include <boost/test/unit_test.hpp>
 
 BOOST_FIXTURE_TEST_SUITE(base58_tests, BasicTestingSetup)
 
 // Goal: test low-level base58 encoding functionality
 BOOST_AUTO_TEST_CASE(base58_EncodeBase58) {
     UniValue tests =
         read_json(std::string(json_tests::base58_encode_decode,
                               json_tests::base58_encode_decode +
                                   sizeof(json_tests::base58_encode_decode)));
     for (unsigned int idx = 0; idx < tests.size(); idx++) {
         UniValue test = tests[idx];
         std::string strTest = test.write();
         // Allow for extra stuff (useful for comments)
         if (test.size() < 2) {
             BOOST_ERROR("Bad test: " << strTest);
             continue;
         }
         std::vector<uint8_t> sourcedata = ParseHex(test[0].get_str());
         std::string base58string = test[1].get_str();
         BOOST_CHECK_MESSAGE(
             EncodeBase58(sourcedata.data(),
                          sourcedata.data() + sourcedata.size()) == base58string,
             strTest);
     }
 }
 
 // Goal: test low-level base58 decoding functionality
 BOOST_AUTO_TEST_CASE(base58_DecodeBase58) {
     UniValue tests =
         read_json(std::string(json_tests::base58_encode_decode,
                               json_tests::base58_encode_decode +
                                   sizeof(json_tests::base58_encode_decode)));
     std::vector<uint8_t> result;
 
     for (unsigned int idx = 0; idx < tests.size(); idx++) {
         UniValue test = tests[idx];
         std::string strTest = test.write();
         // Allow for extra stuff (useful for comments)
         if (test.size() < 2) {
             BOOST_ERROR("Bad test: " << strTest);
             continue;
         }
         std::vector<uint8_t> expected = ParseHex(test[0].get_str());
         std::string base58string = test[1].get_str();
         BOOST_CHECK_MESSAGE(DecodeBase58(base58string, result), strTest);
         BOOST_CHECK_MESSAGE(
             result.size() == expected.size() &&
                 std::equal(result.begin(), result.end(), expected.begin()),
             strTest);
     }
 
     BOOST_CHECK(!DecodeBase58("invalid", result));
 
     // check that DecodeBase58 skips whitespace, but still fails with unexpected
     // non-whitespace at the end.
     BOOST_CHECK(!DecodeBase58(" \t\n\v\f\r skip \r\f\v\n\t a", result));
     BOOST_CHECK(DecodeBase58(" \t\n\v\f\r skip \r\f\v\n\t ", result));
     std::vector<uint8_t> expected = ParseHex("971a55");
     BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(),
                                   expected.begin(), expected.end());
 }
 
-// Goal: check that parsed keys match test payload
-BOOST_AUTO_TEST_CASE(base58_keys_valid_parse) {
-    UniValue tests = read_json(std::string(
-        json_tests::base58_keys_valid,
-        json_tests::base58_keys_valid + sizeof(json_tests::base58_keys_valid)));
-    CKey privkey;
-    CTxDestination destination;
-    SelectParams(CBaseChainParams::MAIN);
-
-    for (unsigned int idx = 0; idx < tests.size(); idx++) {
-        UniValue test = tests[idx];
-        std::string strTest = test.write();
-        // Allow for extra stuff (useful for comments)
-        if (test.size() < 3) {
-            BOOST_ERROR("Bad test: " << strTest);
-            continue;
-        }
-        std::string exp_base58string = test[0].get_str();
-        std::vector<uint8_t> exp_payload = ParseHex(test[1].get_str());
-        const UniValue &metadata = test[2].get_obj();
-        bool isPrivkey = find_value(metadata, "isPrivkey").get_bool();
-        SelectParams(find_value(metadata, "chain").get_str());
-        bool try_case_flip =
-            find_value(metadata, "tryCaseFlip").isNull()
-                ? false
-                : find_value(metadata, "tryCaseFlip").get_bool();
-        if (isPrivkey) {
-            bool isCompressed = find_value(metadata, "isCompressed").get_bool();
-            // Must be valid private key
-            privkey = DecodeSecret(exp_base58string);
-            BOOST_CHECK_MESSAGE(privkey.IsValid(), "!IsValid:" + strTest);
-            BOOST_CHECK_MESSAGE(privkey.IsCompressed() == isCompressed,
-                                "compressed mismatch:" + strTest);
-            BOOST_CHECK_MESSAGE(privkey.size() == exp_payload.size() &&
-                                    std::equal(privkey.begin(), privkey.end(),
-                                               exp_payload.begin()),
-                                "key mismatch:" + strTest);
-
-            // Private key must be invalid public key
-            destination = DecodeLegacyAddr(exp_base58string, Params());
-            BOOST_CHECK_MESSAGE(!IsValidDestination(destination),
-                                "IsValid privkey as pubkey:" + strTest);
-        } else {
-            // Must be valid public key
-            destination = DecodeLegacyAddr(exp_base58string, Params());
-            CScript script = GetScriptForDestination(destination);
-            BOOST_CHECK_MESSAGE(IsValidDestination(destination),
-                                "!IsValid:" + strTest);
-            BOOST_CHECK_EQUAL(HexStr(script), HexStr(exp_payload));
-
-            // Try flipped case version
-            for (char &c : exp_base58string) {
-                if (c >= 'a' && c <= 'z') {
-                    c = (c - 'a') + 'A';
-                } else if (c >= 'A' && c <= 'Z') {
-                    c = (c - 'A') + 'a';
-                }
-            }
-            destination = DecodeDestination(exp_base58string, Params());
-            BOOST_CHECK_MESSAGE(IsValidDestination(destination) ==
-                                    try_case_flip,
-                                "!IsValid case flipped:" + strTest);
-            if (IsValidDestination(destination)) {
-                script = GetScriptForDestination(destination);
-                BOOST_CHECK_EQUAL(HexStr(script), HexStr(exp_payload));
-            }
-
-            // Public key must be invalid private key
-            privkey = DecodeSecret(exp_base58string);
-            BOOST_CHECK_MESSAGE(!privkey.IsValid(),
-                                "IsValid pubkey as privkey:" + strTest);
-        }
-    }
-}
-
-// Goal: check that generated keys match test vectors
-BOOST_AUTO_TEST_CASE(base58_keys_valid_gen) {
-    UniValue tests = read_json(std::string(
-        json_tests::base58_keys_valid,
-        json_tests::base58_keys_valid + sizeof(json_tests::base58_keys_valid)));
-
-    for (unsigned int idx = 0; idx < tests.size(); idx++) {
-        UniValue test = tests[idx];
-        std::string strTest = test.write();
-        // Allow for extra stuff (useful for comments)
-        if (test.size() < 3) {
-            BOOST_ERROR("Bad test: " << strTest);
-            continue;
-        }
-        std::string exp_base58string = test[0].get_str();
-        std::vector<uint8_t> exp_payload = ParseHex(test[1].get_str());
-        const UniValue &metadata = test[2].get_obj();
-        bool isPrivkey = find_value(metadata, "isPrivkey").get_bool();
-        SelectParams(find_value(metadata, "chain").get_str());
-        if (isPrivkey) {
-            bool isCompressed = find_value(metadata, "isCompressed").get_bool();
-            CKey key;
-            key.Set(exp_payload.begin(), exp_payload.end(), isCompressed);
-            assert(key.IsValid());
-            BOOST_CHECK_MESSAGE(EncodeSecret(key) == exp_base58string,
-                                "result mismatch: " + strTest);
-        } else {
-            CTxDestination dest;
-            CScript exp_script(exp_payload.begin(), exp_payload.end());
-            ExtractDestination(exp_script, dest);
-            std::string address = EncodeLegacyAddr(dest, Params());
-            BOOST_CHECK_EQUAL(address, exp_base58string);
-        }
-    }
-
-    SelectParams(CBaseChainParams::MAIN);
-}
-
-// Goal: check that base58 parsing code is robust against a variety of corrupted
-// data
-BOOST_AUTO_TEST_CASE(base58_keys_invalid) {
-    // Negative testcases
-    UniValue tests =
-        read_json(std::string(json_tests::base58_keys_invalid,
-                              json_tests::base58_keys_invalid +
-                                  sizeof(json_tests::base58_keys_invalid)));
-    CKey privkey;
-    CTxDestination destination;
-
-    for (unsigned int idx = 0; idx < tests.size(); idx++) {
-        UniValue test = tests[idx];
-        std::string strTest = test.write();
-        // Allow for extra stuff (useful for comments)
-        if (test.size() < 1) {
-            BOOST_ERROR("Bad test: " << strTest);
-            continue;
-        }
-        std::string exp_base58string = test[0].get_str();
-
-        // must be invalid as public and as private key
-        for (auto chain : {CBaseChainParams::MAIN, CBaseChainParams::TESTNET,
-                           CBaseChainParams::REGTEST}) {
-            SelectParams(chain);
-            destination = DecodeLegacyAddr(exp_base58string, Params());
-            BOOST_CHECK_MESSAGE(!IsValidDestination(destination),
-                                "IsValid pubkey:" + strTest);
-            privkey = DecodeSecret(exp_base58string);
-            BOOST_CHECK_MESSAGE(!privkey.IsValid(),
-                                "IsValid privkey:" + strTest);
-        }
-    }
-}
-
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/data/base58_keys_invalid.json b/src/test/data/key_io_invalid.json
similarity index 100%
rename from src/test/data/base58_keys_invalid.json
rename to src/test/data/key_io_invalid.json
diff --git a/src/test/data/base58_keys_valid.json b/src/test/data/key_io_valid.json
similarity index 100%
rename from src/test/data/base58_keys_valid.json
rename to src/test/data/key_io_valid.json
diff --git a/src/test/base58_tests.cpp b/src/test/key_io_tests.cpp
similarity index 63%
copy from src/test/base58_tests.cpp
copy to src/test/key_io_tests.cpp
index e5d4cced2..2836f3b8a 100644
--- a/src/test/base58_tests.cpp
+++ b/src/test/key_io_tests.cpp
@@ -1,234 +1,171 @@
 // Copyright (c) 2011-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 <base58.h>
+#include <test/data/key_io_invalid.json.h>
+#include <test/data/key_io_valid.json.h>
 
-#include <chainparams.h> // For Params()
+#include <chainparams.h>
 #include <key.h>
 #include <key_io.h>
 #include <script/script.h>
-#include <uint256.h>
-#include <util.h>
-#include <utilstrencodings.h>
-
-#include <test/data/base58_encode_decode.json.h>
-#include <test/data/base58_keys_invalid.json.h>
-#include <test/data/base58_keys_valid.json.h>
-#include <test/jsonutil.h>
 #include <test/test_bitcoin.h>
-
-#include <univalue.h>
+#include <utilstrencodings.h>
 
 #include <boost/test/unit_test.hpp>
 
-BOOST_FIXTURE_TEST_SUITE(base58_tests, BasicTestingSetup)
-
-// Goal: test low-level base58 encoding functionality
-BOOST_AUTO_TEST_CASE(base58_EncodeBase58) {
-    UniValue tests =
-        read_json(std::string(json_tests::base58_encode_decode,
-                              json_tests::base58_encode_decode +
-                                  sizeof(json_tests::base58_encode_decode)));
-    for (unsigned int idx = 0; idx < tests.size(); idx++) {
-        UniValue test = tests[idx];
-        std::string strTest = test.write();
-        // Allow for extra stuff (useful for comments)
-        if (test.size() < 2) {
-            BOOST_ERROR("Bad test: " << strTest);
-            continue;
-        }
-        std::vector<uint8_t> sourcedata = ParseHex(test[0].get_str());
-        std::string base58string = test[1].get_str();
-        BOOST_CHECK_MESSAGE(
-            EncodeBase58(sourcedata.data(),
-                         sourcedata.data() + sourcedata.size()) == base58string,
-            strTest);
-    }
-}
-
-// Goal: test low-level base58 decoding functionality
-BOOST_AUTO_TEST_CASE(base58_DecodeBase58) {
-    UniValue tests =
-        read_json(std::string(json_tests::base58_encode_decode,
-                              json_tests::base58_encode_decode +
-                                  sizeof(json_tests::base58_encode_decode)));
-    std::vector<uint8_t> result;
-
-    for (unsigned int idx = 0; idx < tests.size(); idx++) {
-        UniValue test = tests[idx];
-        std::string strTest = test.write();
-        // Allow for extra stuff (useful for comments)
-        if (test.size() < 2) {
-            BOOST_ERROR("Bad test: " << strTest);
-            continue;
-        }
-        std::vector<uint8_t> expected = ParseHex(test[0].get_str());
-        std::string base58string = test[1].get_str();
-        BOOST_CHECK_MESSAGE(DecodeBase58(base58string, result), strTest);
-        BOOST_CHECK_MESSAGE(
-            result.size() == expected.size() &&
-                std::equal(result.begin(), result.end(), expected.begin()),
-            strTest);
-    }
+#include <univalue.h>
 
-    BOOST_CHECK(!DecodeBase58("invalid", result));
+extern UniValue read_json(const std::string &jsondata);
 
-    // check that DecodeBase58 skips whitespace, but still fails with unexpected
-    // non-whitespace at the end.
-    BOOST_CHECK(!DecodeBase58(" \t\n\v\f\r skip \r\f\v\n\t a", result));
-    BOOST_CHECK(DecodeBase58(" \t\n\v\f\r skip \r\f\v\n\t ", result));
-    std::vector<uint8_t> expected = ParseHex("971a55");
-    BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(),
-                                  expected.begin(), expected.end());
-}
+BOOST_FIXTURE_TEST_SUITE(key_io_tests, BasicTestingSetup)
 
 // Goal: check that parsed keys match test payload
-BOOST_AUTO_TEST_CASE(base58_keys_valid_parse) {
+BOOST_AUTO_TEST_CASE(key_io_valid_parse) {
     UniValue tests = read_json(std::string(
-        json_tests::base58_keys_valid,
-        json_tests::base58_keys_valid + sizeof(json_tests::base58_keys_valid)));
+        json_tests::key_io_valid,
+        json_tests::key_io_valid + sizeof(json_tests::key_io_valid)));
     CKey privkey;
     CTxDestination destination;
     SelectParams(CBaseChainParams::MAIN);
 
     for (unsigned int idx = 0; idx < tests.size(); idx++) {
         UniValue test = tests[idx];
         std::string strTest = test.write();
         // Allow for extra stuff (useful for comments)
         if (test.size() < 3) {
             BOOST_ERROR("Bad test: " << strTest);
             continue;
         }
         std::string exp_base58string = test[0].get_str();
         std::vector<uint8_t> exp_payload = ParseHex(test[1].get_str());
         const UniValue &metadata = test[2].get_obj();
         bool isPrivkey = find_value(metadata, "isPrivkey").get_bool();
         SelectParams(find_value(metadata, "chain").get_str());
         bool try_case_flip =
             find_value(metadata, "tryCaseFlip").isNull()
                 ? false
                 : find_value(metadata, "tryCaseFlip").get_bool();
         if (isPrivkey) {
             bool isCompressed = find_value(metadata, "isCompressed").get_bool();
             // Must be valid private key
             privkey = DecodeSecret(exp_base58string);
             BOOST_CHECK_MESSAGE(privkey.IsValid(), "!IsValid:" + strTest);
             BOOST_CHECK_MESSAGE(privkey.IsCompressed() == isCompressed,
                                 "compressed mismatch:" + strTest);
             BOOST_CHECK_MESSAGE(privkey.size() == exp_payload.size() &&
                                     std::equal(privkey.begin(), privkey.end(),
                                                exp_payload.begin()),
                                 "key mismatch:" + strTest);
 
             // Private key must be invalid public key
             destination = DecodeLegacyAddr(exp_base58string, Params());
             BOOST_CHECK_MESSAGE(!IsValidDestination(destination),
                                 "IsValid privkey as pubkey:" + strTest);
         } else {
             // Must be valid public key
             destination = DecodeLegacyAddr(exp_base58string, Params());
             CScript script = GetScriptForDestination(destination);
             BOOST_CHECK_MESSAGE(IsValidDestination(destination),
                                 "!IsValid:" + strTest);
             BOOST_CHECK_EQUAL(HexStr(script), HexStr(exp_payload));
 
             // Try flipped case version
             for (char &c : exp_base58string) {
                 if (c >= 'a' && c <= 'z') {
                     c = (c - 'a') + 'A';
                 } else if (c >= 'A' && c <= 'Z') {
                     c = (c - 'A') + 'a';
                 }
             }
-            destination = DecodeDestination(exp_base58string, Params());
+            destination = DecodeLegacyAddr(exp_base58string, Params());
             BOOST_CHECK_MESSAGE(IsValidDestination(destination) ==
                                     try_case_flip,
                                 "!IsValid case flipped:" + strTest);
             if (IsValidDestination(destination)) {
                 script = GetScriptForDestination(destination);
                 BOOST_CHECK_EQUAL(HexStr(script), HexStr(exp_payload));
             }
 
             // Public key must be invalid private key
             privkey = DecodeSecret(exp_base58string);
             BOOST_CHECK_MESSAGE(!privkey.IsValid(),
                                 "IsValid pubkey as privkey:" + strTest);
         }
     }
 }
 
 // Goal: check that generated keys match test vectors
-BOOST_AUTO_TEST_CASE(base58_keys_valid_gen) {
+BOOST_AUTO_TEST_CASE(key_io_valid_gen) {
     UniValue tests = read_json(std::string(
-        json_tests::base58_keys_valid,
-        json_tests::base58_keys_valid + sizeof(json_tests::base58_keys_valid)));
+        json_tests::key_io_valid,
+        json_tests::key_io_valid + sizeof(json_tests::key_io_valid)));
 
     for (unsigned int idx = 0; idx < tests.size(); idx++) {
         UniValue test = tests[idx];
         std::string strTest = test.write();
         // Allow for extra stuff (useful for comments)
         if (test.size() < 3) {
             BOOST_ERROR("Bad test: " << strTest);
             continue;
         }
         std::string exp_base58string = test[0].get_str();
         std::vector<uint8_t> exp_payload = ParseHex(test[1].get_str());
         const UniValue &metadata = test[2].get_obj();
         bool isPrivkey = find_value(metadata, "isPrivkey").get_bool();
         SelectParams(find_value(metadata, "chain").get_str());
         if (isPrivkey) {
             bool isCompressed = find_value(metadata, "isCompressed").get_bool();
             CKey key;
             key.Set(exp_payload.begin(), exp_payload.end(), isCompressed);
             assert(key.IsValid());
             BOOST_CHECK_MESSAGE(EncodeSecret(key) == exp_base58string,
                                 "result mismatch: " + strTest);
         } else {
             CTxDestination dest;
             CScript exp_script(exp_payload.begin(), exp_payload.end());
             ExtractDestination(exp_script, dest);
             std::string address = EncodeLegacyAddr(dest, Params());
+
             BOOST_CHECK_EQUAL(address, exp_base58string);
         }
     }
 
     SelectParams(CBaseChainParams::MAIN);
 }
 
 // Goal: check that base58 parsing code is robust against a variety of corrupted
 // data
-BOOST_AUTO_TEST_CASE(base58_keys_invalid) {
+BOOST_AUTO_TEST_CASE(key_io_invalid) {
     // Negative testcases
-    UniValue tests =
-        read_json(std::string(json_tests::base58_keys_invalid,
-                              json_tests::base58_keys_invalid +
-                                  sizeof(json_tests::base58_keys_invalid)));
+    UniValue tests = read_json(std::string(
+        json_tests::key_io_invalid,
+        json_tests::key_io_invalid + sizeof(json_tests::key_io_invalid)));
     CKey privkey;
     CTxDestination destination;
 
     for (unsigned int idx = 0; idx < tests.size(); idx++) {
         UniValue test = tests[idx];
         std::string strTest = test.write();
         // Allow for extra stuff (useful for comments)
         if (test.size() < 1) {
             BOOST_ERROR("Bad test: " << strTest);
             continue;
         }
         std::string exp_base58string = test[0].get_str();
 
         // must be invalid as public and as private key
         for (auto chain : {CBaseChainParams::MAIN, CBaseChainParams::TESTNET,
                            CBaseChainParams::REGTEST}) {
             SelectParams(chain);
             destination = DecodeLegacyAddr(exp_base58string, Params());
             BOOST_CHECK_MESSAGE(!IsValidDestination(destination),
-                                "IsValid pubkey:" + strTest);
+                                "IsValid pubkey in mainnet:" + strTest);
             privkey = DecodeSecret(exp_base58string);
             BOOST_CHECK_MESSAGE(!privkey.IsValid(),
-                                "IsValid privkey:" + strTest);
+                                "IsValid privkey in mainnet:" + strTest);
         }
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()