diff --git a/src/Makefile.test.include b/src/Makefile.test.include
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -8,14 +8,14 @@
 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 =
 
@@ -71,6 +71,7 @@
   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 \
diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -30,14 +30,14 @@
 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)
@@ -84,6 +84,7 @@
 	hash_tests.cpp
 	inv_tests.cpp
 	jsonutil.cpp
+	key_io_tests.cpp
 	key_tests.cpp
 	lcg_tests.cpp
 	limitedmap_tests.cpp
diff --git a/src/test/base58_tests.cpp b/src/test/base58_tests.cpp
--- a/src/test/base58_tests.cpp
+++ b/src/test/base58_tests.cpp
@@ -2,21 +2,12 @@
 // 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>
 
@@ -83,152 +74,4 @@
                                   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
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
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
copy from src/test/base58_tests.cpp
copy to src/test/key_io_tests.cpp
--- a/src/test/base58_tests.cpp
+++ b/src/test/key_io_tests.cpp
@@ -2,92 +2,29 @@
 // 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);
@@ -141,7 +78,7 @@
                     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);
@@ -159,10 +96,10 @@
 }
 
 // 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];
@@ -189,6 +126,7 @@
             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);
         }
     }
@@ -198,12 +136,11 @@
 
 // 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;
 
@@ -223,10 +160,10 @@
             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);
         }
     }
 }