diff --git a/src/test/fuzz/CMakeLists.txt b/src/test/fuzz/CMakeLists.txt
--- a/src/test/fuzz/CMakeLists.txt
+++ b/src/test/fuzz/CMakeLists.txt
@@ -88,6 +88,7 @@
 	hex
 	integer
 	key
+	key_io
 	locale
 	net_permissions
 	p2p_transport_deserializer
diff --git a/src/test/fuzz/hex.cpp b/src/test/fuzz/hex.cpp
--- a/src/test/fuzz/hex.cpp
+++ b/src/test/fuzz/hex.cpp
@@ -2,8 +2,14 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <core_io.h>
+#include <primitives/block.h>
+#include <rpc/util.h>
+#include <uint256.h>
 #include <util/strencodings.h>
 
+#include <univalue.h>
+
 #include <test/fuzz/fuzz.h>
 
 #include <cassert>
@@ -18,4 +24,14 @@
     if (IsHex(random_hex_string)) {
         assert(ToLower(random_hex_string) == hex_data);
     }
+    (void)IsHexNumber(random_hex_string);
+    uint256 result;
+    (void)ParseHashStr(random_hex_string, result);
+    (void)uint256S(random_hex_string);
+    try {
+        (void)HexToPubKey(random_hex_string);
+    } catch (const UniValue &) {
+    }
+    CBlockHeader block_header;
+    (void)DecodeHexBlockHeader(block_header, random_hex_string);
 }
diff --git a/src/test/fuzz/integer.cpp b/src/test/fuzz/integer.cpp
--- a/src/test/fuzz/integer.cpp
+++ b/src/test/fuzz/integer.cpp
@@ -23,6 +23,7 @@
 #include <serialize.h>
 #include <streams.h>
 #include <uint256.h>
+#include <util/moneystr.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 #include <util/time.h>
@@ -74,6 +75,13 @@
     (void)DecompressAmount(u64);
     (void)FormatISO8601Date(i64);
     (void)FormatISO8601DateTime(i64);
+    // FormatMoney(i) not defined when i == std::numeric_limits<int64_t>::min()
+    if (i64 != std::numeric_limits<int64_t>::min()) {
+        Amount parsed_money;
+        if (ParseMoney(FormatMoney(i64 * SATOSHI), parsed_money)) {
+            assert(parsed_money == i64 * SATOSHI);
+        }
+    }
     (void)GetSizeOfCompactSize(u64);
     (void)GetSpecialScriptSize(u32);
     // function defined only for a subset of int64_t inputs
@@ -81,6 +89,7 @@
     // function defined only for a subset of int64_t/uint32_t inputs
     // ()GetVirtualTransactionSize(i64, i64, u32);
     (void)HexDigit(ch);
+    (void)MoneyRange(i64 * SATOSHI);
     (void)i64tostr(i64);
     (void)IsDigit(ch);
     (void)IsSpace(ch);
@@ -106,6 +115,16 @@
     (void)SipHashUint256(u64, u64, u256);
     (void)SipHashUint256Extra(u64, u64, u256, u32);
     (void)ToLower(ch);
+    (void)ToUpper(ch);
+    // ValueFromAmount(i) not defined when i ==
+    // std::numeric_limits<int64_t>::min()
+    if (i64 != std::numeric_limits<int64_t>::min()) {
+        Amount parsed_money;
+        if (ParseMoney(ValueFromAmount(i64 * SATOSHI).getValStr(),
+                       parsed_money)) {
+            assert(parsed_money == i64 * SATOSHI);
+        }
+    }
 
     const arith_uint256 au256 = UintToArith256(u256);
     assert(ArithToUint256(au256) == u256);
diff --git a/src/test/fuzz/key_io.cpp b/src/test/fuzz/key_io.cpp
new file mode 100644
--- /dev/null
+++ b/src/test/fuzz/key_io.cpp
@@ -0,0 +1,50 @@
+// 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 <key_io.h>
+#include <rpc/util.h>
+#include <script/signingprovider.h>
+#include <script/standard.h>
+
+#include <test/fuzz/fuzz.h>
+
+#include <cassert>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+void initialize() {
+    SelectParams(CBaseChainParams::REGTEST);
+}
+
+void test_one_input(const std::vector<uint8_t> &buffer) {
+    const std::string random_string(buffer.begin(), buffer.end());
+
+    const CKey key = DecodeSecret(random_string);
+    if (key.IsValid()) {
+        assert(key == DecodeSecret(EncodeSecret(key)));
+    }
+
+    const CExtKey ext_key = DecodeExtKey(random_string);
+    if (ext_key.key.size() == 32) {
+        assert(ext_key == DecodeExtKey(EncodeExtKey(ext_key)));
+    }
+
+    const CExtPubKey ext_pub_key = DecodeExtPubKey(random_string);
+    if (ext_pub_key.pubkey.size() == CPubKey::COMPRESSED_SIZE) {
+        assert(ext_pub_key == DecodeExtPubKey(EncodeExtPubKey(ext_pub_key)));
+    }
+
+    const CChainParams &params = GetConfig().GetChainParams();
+    const CTxDestination tx_destination =
+        DecodeDestination(random_string, params);
+    (void)DescribeAddress(tx_destination);
+    (void)GetKeyForDestination(/* store */ {}, tx_destination);
+    (void)GetScriptForDestination(tx_destination);
+    (void)IsValidDestination(tx_destination);
+
+    (void)IsValidDestinationString(random_string, params);
+}
diff --git a/src/test/fuzz/script.cpp b/src/test/fuzz/script.cpp
--- a/src/test/fuzz/script.cpp
+++ b/src/test/fuzz/script.cpp
@@ -14,21 +14,38 @@
 #include <script/signingprovider.h>
 #include <script/standard.h>
 #include <streams.h>
+
 #include <test/fuzz/fuzz.h>
 
+#include <univalue.h>
+
 #include <memory>
 
 void initialize() {
     // Fuzzers using pubkey must hold an ECCVerifyHandle.
     static const auto verify_handle = std::make_unique<ECCVerifyHandle>();
+
+    SelectParams(CBaseChainParams::REGTEST);
 }
 
 void test_one_input(const std::vector<uint8_t> &buffer) {
     const CScript script(buffer.begin(), buffer.end());
 
     std::vector<uint8_t> compressed;
-    (void)CompressScript(script, compressed);
+    if (CompressScript(script, compressed)) {
+        const unsigned int size = compressed[0];
+        assert(size >= 0 && size <= 5);
+        CScript decompressed_script;
+        const bool ok = DecompressScript(decompressed_script, size, compressed);
+        assert(ok);
+    }
 
+    for (unsigned int size = 0; size < 6; ++size) {
+        std::vector<uint8_t> vch(GetSpecialScriptSize(size), 0x00);
+        vch.insert(vch.end(), buffer.begin(), buffer.end());
+        CScript decompressed_script;
+        (void)DecompressScript(decompressed_script, size, vch);
+    }
     CTxDestination address;
     (void)ExtractDestination(script, address);
 
@@ -56,4 +73,18 @@
     (void)script.IsPayToScriptHash();
     (void)script.IsPushOnly();
     (void)script.IsUnspendable();
+    (void)script.IsWitnessProgram();
+
+    (void)FormatScript(script);
+    (void)ScriptToAsmStr(script, false);
+    (void)ScriptToAsmStr(script, true);
+
+    UniValue o1(UniValue::VOBJ);
+    ScriptPubKeyToUniv(script, o1, true);
+    UniValue o2(UniValue::VOBJ);
+    ScriptPubKeyToUniv(script, o2, false);
+    UniValue o3(UniValue::VOBJ);
+    ScriptToUniv(script, o3, true);
+    UniValue o4(UniValue::VOBJ);
+    ScriptToUniv(script, o4, false);
 }
diff --git a/src/test/fuzz/transaction.cpp b/src/test/fuzz/transaction.cpp
--- a/src/test/fuzz/transaction.cpp
+++ b/src/test/fuzz/transaction.cpp
@@ -17,8 +17,14 @@
 #include <validation.h>
 #include <version.h>
 
+#include <univalue.h>
+
 #include <cassert>
 
+void initialize() {
+    SelectParams(CBaseChainParams::REGTEST);
+}
+
 void test_one_input(const std::vector<uint8_t> &buffer) {
     CDataStream ds(buffer, SER_NETWORK, INIT_PROTO_VERSION);
     try {
@@ -83,4 +89,21 @@
                                      1024, 0);
     (void)IsStandardTx(tx, reason);
     (void)RecursiveDynamicUsage(tx);
+
+    CCoinsView coins_view;
+    const CCoinsViewCache coins_view_cache(&coins_view);
+    (void)AreInputsStandard(tx, coins_view_cache, STANDARD_SCRIPT_VERIFY_FLAGS);
+
+    UniValue u(UniValue::VOBJ);
+    // ValueFromAmount(i) not defined when i ==
+    // std::numeric_limits<int64_t>::min()
+    bool skip_tx_to_univ = false;
+    for (const CTxOut &txout : tx.vout) {
+        if (txout.nValue == std::numeric_limits<int64_t>::min() * SATOSHI) {
+            skip_tx_to_univ = true;
+        }
+    }
+    if (!skip_tx_to_univ) {
+        TxToUniv(tx, /* hashBlock */ {}, u);
+    }
 }