diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 36479c921..d1e4d5247 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -1,1251 +1,1247 @@
 // Copyright (c) 2010 Satoshi Nakamoto
 // Copyright (c) 2009-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 <blockvalidity.h>
 #include <cashaddrenc.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <config.h>
 #include <consensus/activation.h>
 #include <consensus/amount.h>
 #include <consensus/consensus.h>
 #include <consensus/params.h>
 #include <consensus/validation.h>
 #include <core_io.h>
 #include <key_io.h>
 #include <miner.h>
 #include <minerfund.h>
 #include <net.h>
 #include <node/context.h>
 #include <policy/policy.h>
 #include <pow/pow.h>
 #include <rpc/blockchain.h>
 #include <rpc/mining.h>
+#include <rpc/net.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <script/descriptor.h>
 #include <script/script.h>
 #include <shutdown.h>
 #include <txmempool.h>
 #include <univalue.h>
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <util/system.h>
 #include <util/translation.h>
 #include <validation.h>
 #include <validationinterface.h>
 #include <warnings.h>
 
 #include <cstdint>
 
 /**
  * Return average network hashes per second based on the last 'lookup' blocks,
  * or from the last difficulty change if 'lookup' is nonpositive. If 'height' is
  * nonnegative, compute the estimate at the time when a given block was found.
  */
 static UniValue GetNetworkHashPS(int lookup, int height,
                                  const CChain &active_chain) {
     const CBlockIndex *pb = active_chain.Tip();
 
     if (height >= 0 && height < active_chain.Height()) {
         pb = active_chain[height];
     }
 
     if (pb == nullptr || !pb->nHeight) {
         return 0;
     }
 
     // If lookup is -1, then use blocks since last difficulty change.
     if (lookup <= 0) {
         lookup = pb->nHeight %
                      Params().GetConsensus().DifficultyAdjustmentInterval() +
                  1;
     }
 
     // If lookup is larger than chain, then set it to chain length.
     if (lookup > pb->nHeight) {
         lookup = pb->nHeight;
     }
 
     const CBlockIndex *pb0 = pb;
     int64_t minTime = pb0->GetBlockTime();
     int64_t maxTime = minTime;
     for (int i = 0; i < lookup; i++) {
         pb0 = pb0->pprev;
         int64_t time = pb0->GetBlockTime();
         minTime = std::min(time, minTime);
         maxTime = std::max(time, maxTime);
     }
 
     // In case there's a situation where minTime == maxTime, we don't want a
     // divide by zero exception.
     if (minTime == maxTime) {
         return 0;
     }
 
     arith_uint256 workDiff = pb->nChainWork - pb0->nChainWork;
     int64_t timeDiff = maxTime - minTime;
 
     return workDiff.getdouble() / timeDiff;
 }
 
 static RPCHelpMan getnetworkhashps() {
     return RPCHelpMan{
         "getnetworkhashps",
         "Returns the estimated network hashes per second based on the last n "
         "blocks.\n"
         "Pass in [blocks] to override # of blocks, -1 specifies since last "
         "difficulty change.\n"
         "Pass in [height] to estimate the network speed at the time when a "
         "certain block was found.\n",
         {
             {"nblocks", RPCArg::Type::NUM, /* default */ "120",
              "The number of blocks, or -1 for blocks since last difficulty "
              "change."},
             {"height", RPCArg::Type::NUM, /* default */ "-1",
              "To estimate at the time of the given height."},
         },
         RPCResult{RPCResult::Type::NUM, "", "Hashes per second estimated"},
         RPCExamples{HelpExampleCli("getnetworkhashps", "") +
                     HelpExampleRpc("getnetworkhashps", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             LOCK(cs_main);
             return GetNetworkHashPS(
                 !request.params[0].isNull() ? request.params[0].get_int() : 120,
                 !request.params[1].isNull() ? request.params[1].get_int() : -1,
                 chainman.ActiveChain());
         },
     };
 }
 
 static bool GenerateBlock(const Config &config, ChainstateManager &chainman,
                           CBlock &block, uint64_t &max_tries,
                           unsigned int &extra_nonce, BlockHash &block_hash) {
     block_hash.SetNull();
     const uint64_t nExcessiveBlockSize = config.GetMaxBlockSize();
 
     {
         LOCK(cs_main);
         IncrementExtraNonce(&block, chainman.ActiveTip(), nExcessiveBlockSize,
                             extra_nonce);
     }
 
     const Consensus::Params &params = config.GetChainParams().GetConsensus();
 
     while (max_tries > 0 &&
            block.nNonce < std::numeric_limits<uint32_t>::max() &&
            !CheckProofOfWork(block.GetHash(), block.nBits, params) &&
            !ShutdownRequested()) {
         ++block.nNonce;
         --max_tries;
     }
     if (max_tries == 0 || ShutdownRequested()) {
         return false;
     }
     if (block.nNonce == std::numeric_limits<uint32_t>::max()) {
         return true;
     }
 
     std::shared_ptr<const CBlock> shared_pblock =
         std::make_shared<const CBlock>(block);
     if (!chainman.ProcessNewBlock(config, shared_pblock, true, nullptr)) {
         throw JSONRPCError(RPC_INTERNAL_ERROR,
                            "ProcessNewBlock, block not accepted");
     }
 
     block_hash = block.GetHash();
     return true;
 }
 
 static UniValue generateBlocks(const Config &config,
                                ChainstateManager &chainman,
                                const CTxMemPool &mempool,
                                const CScript &coinbase_script, int nGenerate,
                                uint64_t nMaxTries) {
     int nHeightEnd = 0;
     int nHeight = 0;
 
     {
         // Don't keep cs_main locked.
         LOCK(cs_main);
         nHeight = chainman.ActiveHeight();
         nHeightEnd = nHeight + nGenerate;
     }
 
     unsigned int nExtraNonce = 0;
     UniValue blockHashes(UniValue::VARR);
     while (nHeight < nHeightEnd && !ShutdownRequested()) {
         std::unique_ptr<CBlockTemplate> pblocktemplate(
             BlockAssembler(config, chainman.ActiveChainstate(), mempool)
                 .CreateNewBlock(coinbase_script));
 
         if (!pblocktemplate.get()) {
             throw JSONRPCError(RPC_INTERNAL_ERROR, "Couldn't create new block");
         }
 
         CBlock *pblock = &pblocktemplate->block;
 
         BlockHash block_hash;
         if (!GenerateBlock(config, chainman, *pblock, nMaxTries, nExtraNonce,
                            block_hash)) {
             break;
         }
 
         if (!block_hash.IsNull()) {
             ++nHeight;
             blockHashes.push_back(block_hash.GetHex());
         }
     }
     return blockHashes;
 }
 
 static bool getScriptFromDescriptor(const std::string &descriptor,
                                     CScript &script, std::string &error) {
     FlatSigningProvider key_provider;
     const auto desc =
         Parse(descriptor, key_provider, error, /* require_checksum = */ false);
     if (desc) {
         if (desc->IsRange()) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Ranged descriptor not accepted. Maybe pass "
                                "through deriveaddresses first?");
         }
 
         FlatSigningProvider provider;
         std::vector<CScript> scripts;
         if (!desc->Expand(0, key_provider, scripts, provider)) {
             throw JSONRPCError(
                 RPC_INVALID_ADDRESS_OR_KEY,
                 strprintf("Cannot derive script without private keys"));
         }
 
         // Combo descriptors can have 2 scripts, so we can't just check
         // scripts.size() == 1
         CHECK_NONFATAL(scripts.size() > 0 && scripts.size() <= 2);
 
         if (scripts.size() == 1) {
             script = scripts.at(0);
         } else {
             // Else take the 2nd script, since it is p2pkh
             script = scripts.at(1);
         }
 
         return true;
     }
 
     return false;
 }
 
 static RPCHelpMan generatetodescriptor() {
     return RPCHelpMan{
         "generatetodescriptor",
         "Mine blocks immediately to a specified descriptor (before the RPC "
         "call returns)\n",
         {
             {"num_blocks", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "How many blocks are generated immediately."},
             {"descriptor", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The descriptor to send the newly generated bitcoin to."},
             {"maxtries", RPCArg::Type::NUM,
              /* default */ ToString(DEFAULT_MAX_TRIES),
              "How many iterations to try."},
         },
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "hashes of blocks generated",
                   {
                       {RPCResult::Type::STR_HEX, "", "blockhash"},
                   }},
         RPCExamples{"\nGenerate 11 blocks to mydesc\n" +
                     HelpExampleCli("generatetodescriptor", "11 \"mydesc\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             const int num_blocks{request.params[0].get_int()};
             const uint64_t max_tries{request.params[2].isNull()
                                          ? DEFAULT_MAX_TRIES
                                          : request.params[2].get_int()};
 
             CScript coinbase_script;
             std::string error;
             if (!getScriptFromDescriptor(request.params[1].get_str(),
                                          coinbase_script, error)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, error);
             }
 
             NodeContext &node = EnsureAnyNodeContext(request.context);
             const CTxMemPool &mempool = EnsureMemPool(node);
             ChainstateManager &chainman = EnsureChainman(node);
 
             return generateBlocks(config, chainman, mempool, coinbase_script,
                                   num_blocks, max_tries);
         },
     };
 }
 
 static RPCHelpMan generate() {
     return RPCHelpMan{"generate",
                       "has been replaced by the -generate cli option. Refer to "
                       "-help for more information.",
                       {},
                       {},
                       RPCExamples{""},
                       [&](const RPCHelpMan &self, const Config &config,
                           const JSONRPCRequest &request) -> UniValue {
                           throw JSONRPCError(RPC_METHOD_NOT_FOUND,
                                              self.ToString());
                       }};
 }
 
 static RPCHelpMan generatetoaddress() {
     return RPCHelpMan{
         "generatetoaddress",
         "Mine blocks immediately to a specified address before the "
         "RPC call returns)\n",
         {
             {"nblocks", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "How many blocks are generated immediately."},
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The address to send the newly generated bitcoin to."},
             {"maxtries", RPCArg::Type::NUM,
              /* default */ ToString(DEFAULT_MAX_TRIES),
              "How many iterations to try."},
         },
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "hashes of blocks generated",
                   {
                       {RPCResult::Type::STR_HEX, "", "blockhash"},
                   }},
         RPCExamples{
             "\nGenerate 11 blocks to myaddress\n" +
             HelpExampleCli("generatetoaddress", "11 \"myaddress\"") +
             "If you are using the " PACKAGE_NAME " wallet, you can "
             "get a new address to send the newly generated bitcoin to with:\n" +
             HelpExampleCli("getnewaddress", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             const int num_blocks{request.params[0].get_int()};
             const uint64_t max_tries{request.params[2].isNull()
                                          ? DEFAULT_MAX_TRIES
                                          : request.params[2].get_int64()};
 
             CTxDestination destination = DecodeDestination(
                 request.params[1].get_str(), config.GetChainParams());
             if (!IsValidDestination(destination)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Error: Invalid address");
             }
 
             NodeContext &node = EnsureAnyNodeContext(request.context);
             const CTxMemPool &mempool = EnsureMemPool(node);
             ChainstateManager &chainman = EnsureChainman(node);
 
             CScript coinbase_script = GetScriptForDestination(destination);
 
             return generateBlocks(config, chainman, mempool, coinbase_script,
                                   num_blocks, max_tries);
         },
     };
 }
 
 static RPCHelpMan generateblock() {
     return RPCHelpMan{
         "generateblock",
         "Mine a block with a set of ordered transactions immediately to a "
         "specified address or descriptor (before the RPC call returns)\n",
         {
             {"output", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The address or descriptor to send the newly generated bitcoin "
              "to."},
             {
                 "transactions",
                 RPCArg::Type::ARR,
                 RPCArg::Optional::NO,
                 "An array of hex strings which are either txids or raw "
                 "transactions.\n"
                 "Txids must reference transactions currently in the mempool.\n"
                 "All transactions must be valid and in valid order, otherwise "
                 "the block will be rejected.",
                 {
                     {"rawtx/txid", RPCArg::Type::STR_HEX,
                      RPCArg::Optional::OMITTED, ""},
                 },
             },
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::STR_HEX, "hash", "hash of generated block"},
             }},
         RPCExamples{
             "\nGenerate a block to myaddress, with txs rawtx and "
             "mempool_txid\n" +
             HelpExampleCli("generateblock",
                            R"("myaddress" '["rawtx", "mempool_txid"]')")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             const auto address_or_descriptor = request.params[0].get_str();
             CScript coinbase_script;
             std::string error;
 
             const CChainParams &chainparams = config.GetChainParams();
 
             if (!getScriptFromDescriptor(address_or_descriptor, coinbase_script,
                                          error)) {
                 const auto destination =
                     DecodeDestination(address_or_descriptor, chainparams);
                 if (!IsValidDestination(destination)) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Error: Invalid address or descriptor");
                 }
 
                 coinbase_script = GetScriptForDestination(destination);
             }
 
             NodeContext &node = EnsureAnyNodeContext(request.context);
             const CTxMemPool &mempool = EnsureMemPool(node);
 
             std::vector<CTransactionRef> txs;
             const auto raw_txs_or_txids = request.params[1].get_array();
             for (size_t i = 0; i < raw_txs_or_txids.size(); i++) {
                 const auto str(raw_txs_or_txids[i].get_str());
 
                 uint256 hash;
                 CMutableTransaction mtx;
                 if (ParseHashStr(str, hash)) {
                     const auto tx = mempool.get(TxId(hash));
                     if (!tx) {
                         throw JSONRPCError(
                             RPC_INVALID_ADDRESS_OR_KEY,
                             strprintf("Transaction %s not in mempool.", str));
                     }
 
                     txs.emplace_back(tx);
 
                 } else if (DecodeHexTx(mtx, str)) {
                     txs.push_back(MakeTransactionRef(std::move(mtx)));
                 } else {
                     throw JSONRPCError(
                         RPC_DESERIALIZATION_ERROR,
                         strprintf("Transaction decode failed for %s", str));
                 }
             }
 
             CBlock block;
 
             ChainstateManager &chainman = EnsureChainman(node);
             {
                 LOCK(cs_main);
 
                 CTxMemPool empty_mempool;
                 std::unique_ptr<CBlockTemplate> blocktemplate(
                     BlockAssembler(config, chainman.ActiveChainstate(),
                                    empty_mempool)
                         .CreateNewBlock(coinbase_script));
                 if (!blocktemplate) {
                     throw JSONRPCError(RPC_INTERNAL_ERROR,
                                        "Couldn't create new block");
                 }
                 block = blocktemplate->block;
             }
 
             CHECK_NONFATAL(block.vtx.size() == 1);
 
             // Add transactions
             block.vtx.insert(block.vtx.end(), txs.begin(), txs.end());
 
             {
                 LOCK(cs_main);
 
                 BlockValidationState state;
                 if (!TestBlockValidity(state, chainparams,
                                        chainman.ActiveChainstate(), block,
                                        chainman.m_blockman.LookupBlockIndex(
                                            block.hashPrevBlock),
                                        BlockValidationOptions(config)
                                            .withCheckPoW(false)
                                            .withCheckMerkleRoot(false))) {
                     throw JSONRPCError(RPC_VERIFY_ERROR,
                                        strprintf("TestBlockValidity failed: %s",
                                                  state.ToString()));
                 }
             }
 
             BlockHash block_hash;
             uint64_t max_tries{DEFAULT_MAX_TRIES};
             unsigned int extra_nonce{0};
 
             if (!GenerateBlock(config, chainman, block, max_tries, extra_nonce,
                                block_hash) ||
                 block_hash.IsNull()) {
                 throw JSONRPCError(RPC_MISC_ERROR, "Failed to make block.");
             }
 
             UniValue obj(UniValue::VOBJ);
             obj.pushKV("hash", block_hash.GetHex());
             return obj;
         },
     };
 }
 
 static RPCHelpMan getmininginfo() {
     return RPCHelpMan{
         "getmininginfo",
         "Returns a json object containing mining-related "
         "information.",
         {},
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::NUM, "blocks", "The current block"},
                 {RPCResult::Type::NUM, "currentblocksize", /* optional */ true,
                  "The block size of the last assembled block (only present if "
                  "a block was ever assembled)"},
                 {RPCResult::Type::NUM, "currentblocktx", /* optional */ true,
                  "The number of block transactions of the last assembled block "
                  "(only present if a block was ever assembled)"},
                 {RPCResult::Type::NUM, "difficulty", "The current difficulty"},
                 {RPCResult::Type::NUM, "networkhashps",
                  "The network hashes per second"},
                 {RPCResult::Type::NUM, "pooledtx", "The size of the mempool"},
                 {RPCResult::Type::STR, "chain",
                  "current network name (main, test, regtest)"},
                 {RPCResult::Type::STR, "warnings",
                  "any network and blockchain warnings"},
             }},
         RPCExamples{HelpExampleCli("getmininginfo", "") +
                     HelpExampleRpc("getmininginfo", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             NodeContext &node = EnsureAnyNodeContext(request.context);
             const CTxMemPool &mempool = EnsureMemPool(node);
             ChainstateManager &chainman = EnsureChainman(node);
             LOCK(cs_main);
             const CChain &active_chain = chainman.ActiveChain();
 
             UniValue obj(UniValue::VOBJ);
             obj.pushKV("blocks", active_chain.Height());
             if (BlockAssembler::m_last_block_size) {
                 obj.pushKV("currentblocksize",
                            *BlockAssembler::m_last_block_size);
             }
             if (BlockAssembler::m_last_block_num_txs) {
                 obj.pushKV("currentblocktx",
                            *BlockAssembler::m_last_block_num_txs);
             }
             obj.pushKV("difficulty", double(GetDifficulty(active_chain.Tip())));
             obj.pushKV("networkhashps",
                        getnetworkhashps().HandleRequest(config, request));
             obj.pushKV("pooledtx", uint64_t(mempool.size()));
             obj.pushKV("chain", config.GetChainParams().NetworkIDString());
             obj.pushKV("warnings", GetWarnings(false).original);
             return obj;
         },
     };
 }
 
 // NOTE: Unlike wallet RPC (which use XEC values), mining RPCs follow GBT (BIP
 // 22) in using satoshi amounts
 static RPCHelpMan prioritisetransaction() {
     return RPCHelpMan{
         "prioritisetransaction",
         "Accepts the transaction into mined blocks at a higher "
         "(or lower) priority\n",
         {
             {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "The transaction id."},
             {"dummy", RPCArg::Type::NUM, RPCArg::Optional::OMITTED_NAMED_ARG,
              "API-Compatibility for previous API. Must be zero or null.\n"
              "                  DEPRECATED. For forward compatibility "
              "use named arguments and omit this parameter."},
             {"fee_delta", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "The fee value (in satoshis) to add (or subtract, if negative).\n"
              "                        The fee is not actually paid, only the "
              "algorithm for selecting transactions into a block\n"
              "                  considers the transaction as it would "
              "have paid a higher (or lower) fee."},
         },
         RPCResult{RPCResult::Type::BOOL, "", "Returns true"},
         RPCExamples{
             HelpExampleCli("prioritisetransaction", "\"txid\" 0.0 10000") +
             HelpExampleRpc("prioritisetransaction", "\"txid\", 0.0, 10000")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             LOCK(cs_main);
 
             TxId txid(ParseHashV(request.params[0], "txid"));
             Amount nAmount = request.params[2].get_int64() * SATOSHI;
 
             if (!(request.params[1].isNull() ||
                   request.params[1].get_real() == 0)) {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMETER,
                     "Priority is no longer supported, dummy argument to "
                     "prioritisetransaction must be 0.");
             }
 
             EnsureAnyMemPool(request.context)
                 .PrioritiseTransaction(txid, nAmount);
             return true;
         },
     };
 }
 
 // NOTE: Assumes a conclusive result; if result is inconclusive, it must be
 // handled by caller
 static UniValue BIP22ValidationResult(const Config &config,
                                       const BlockValidationState &state) {
     if (state.IsValid()) {
         return NullUniValue;
     }
 
     if (state.IsError()) {
         throw JSONRPCError(RPC_VERIFY_ERROR, state.ToString());
     }
 
     if (state.IsInvalid()) {
         std::string strRejectReason = state.GetRejectReason();
         if (strRejectReason.empty()) {
             return "rejected";
         }
         return strRejectReason;
     }
 
     // Should be impossible.
     return "valid?";
 }
 
 static RPCHelpMan getblocktemplate() {
     return RPCHelpMan{
         "getblocktemplate",
         "If the request parameters include a 'mode' key, that is used to "
         "explicitly select between the default 'template' request or a "
         "'proposal'.\n"
         "It returns data needed to construct a block to work on.\n"
         "For full specification, see BIPs 22, 23, 9, and 145:\n"
         "    "
         "https://github.com/bitcoin/bips/blob/master/"
         "bip-0022.mediawiki\n"
         "    "
         "https://github.com/bitcoin/bips/blob/master/"
         "bip-0023.mediawiki\n"
         "    "
         "https://github.com/bitcoin/bips/blob/master/"
         "bip-0009.mediawiki#getblocktemplate_changes\n"
         "    ",
         {
             {"template_request",
              RPCArg::Type::OBJ,
              "{}",
              "Format of the template",
              {
                  {"mode", RPCArg::Type::STR, /* treat as named arg */
                   RPCArg::Optional::OMITTED_NAMED_ARG,
                   "This must be set to \"template\", \"proposal\" (see BIP "
                   "23), or omitted"},
                  {
                      "capabilities",
                      RPCArg::Type::ARR,
                      /* treat as named arg */
                      RPCArg::Optional::OMITTED_NAMED_ARG,
                      "A list of strings",
                      {
                          {"support", RPCArg::Type::STR,
                           RPCArg::Optional::OMITTED,
                           "client side supported feature, 'longpoll', "
                           "'coinbasetxn', 'coinbasevalue', 'proposal', "
                           "'serverlist', 'workid'"},
                      },
                  },
              },
              "\"template_request\""},
         },
         {
             RPCResult{"If the proposal was accepted with mode=='proposal'",
                       RPCResult::Type::NONE, "", ""},
             RPCResult{"If the proposal was not accepted with mode=='proposal'",
                       RPCResult::Type::STR, "", "According to BIP22"},
             RPCResult{
                 "Otherwise",
                 RPCResult::Type::OBJ,
                 "",
                 "",
                 {
                     {RPCResult::Type::NUM, "version",
                      "The preferred block version"},
                     {RPCResult::Type::STR, "previousblockhash",
                      "The hash of current highest block"},
                     {RPCResult::Type::ARR,
                      "transactions",
                      "contents of non-coinbase transactions that should be "
                      "included in the next block",
                      {
                          {RPCResult::Type::OBJ,
                           "",
                           "",
                           {
                               {RPCResult::Type::STR_HEX, "data",
                                "transaction data encoded in hexadecimal "
                                "(byte-for-byte)"},
                               {RPCResult::Type::STR_HEX, "txid",
                                "transaction id encoded in little-endian "
                                "hexadecimal"},
                               {RPCResult::Type::STR_HEX, "hash",
                                "hash encoded in little-endian hexadecimal"},
                               {RPCResult::Type::ARR,
                                "depends",
                                "array of numbers",
                                {
                                    {RPCResult::Type::NUM, "",
                                     "transactions before this one (by 1-based "
                                     "index in 'transactions' list) that must "
                                     "be present in the final block if this one "
                                     "is"},
                                }},
                               {RPCResult::Type::NUM, "fee",
                                "difference in value between transaction inputs "
                                "and outputs (in satoshis); for coinbase "
                                "transactions, this is a negative Number of the "
                                "total collected block fees (ie, not including "
                                "the block subsidy); "
                                "if key is not present, fee is unknown and "
                                "clients MUST NOT assume there isn't one"},
                               {RPCResult::Type::NUM, "sigops",
                                "total SigOps cost, as counted for purposes of "
                                "block limits; if key is not present, sigop "
                                "cost is unknown and clients MUST NOT assume it "
                                "is zero"},
                           }},
                      }},
                     {RPCResult::Type::OBJ,
                      "coinbaseaux",
                      "data that should be included in the coinbase's scriptSig "
                      "content",
                      {
                          {RPCResult::Type::ELISION, "", ""},
                      }},
                     {RPCResult::Type::NUM, "coinbasevalue",
                      "maximum allowable input to coinbase transaction, "
                      "including the generation award and transaction fees (in "
                      "satoshis)"},
                     {RPCResult::Type::OBJ,
                      "coinbasetxn",
                      "information for coinbase transaction",
                      {
                          {RPCResult::Type::OBJ,
                           "minerfund",
                           "information related to the coinbase miner fund",
                           {
 
                               {RPCResult::Type::ARR,
                                "addresses",
                                "List of valid addresses for the miner fund "
                                "output",
                                {
                                    {RPCResult::Type::ELISION, "", ""},
                                }},
 
                               {RPCResult::Type::STR_AMOUNT, "minimumvalue",
                                "The minimum value the miner fund output must "
                                "pay"},
 
                           }},
                          {RPCResult::Type::ELISION, "", ""},
                      }},
                     {RPCResult::Type::STR, "target", "The hash target"},
                     {RPCResult::Type::NUM_TIME, "mintime",
                      "The minimum timestamp appropriate for the next block "
                      "time, expressed in " +
                          UNIX_EPOCH_TIME},
                     {RPCResult::Type::ARR,
                      "mutable",
                      "list of ways the block template may be changed",
                      {
                          {RPCResult::Type::STR, "value",
                           "A way the block template may be changed, e.g. "
                           "'time', 'transactions', 'prevblock'"},
                      }},
                     {RPCResult::Type::STR_HEX, "noncerange",
                      "A range of valid nonces"},
                     {RPCResult::Type::NUM, "sigoplimit",
                      "limit of sigops in blocks"},
                     {RPCResult::Type::NUM, "sizelimit", "limit of block size"},
                     {RPCResult::Type::NUM_TIME, "curtime",
                      "current timestamp in " + UNIX_EPOCH_TIME},
                     {RPCResult::Type::STR, "bits",
                      "compressed target of next block"},
                     {RPCResult::Type::NUM, "height",
                      "The height of the next block"},
                 }},
         },
         RPCExamples{HelpExampleCli("getblocktemplate", "") +
                     HelpExampleRpc("getblocktemplate", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             NodeContext &node = EnsureAnyNodeContext(request.context);
             ChainstateManager &chainman = EnsureChainman(node);
             LOCK(cs_main);
 
             const CChainParams &chainparams = config.GetChainParams();
 
             std::string strMode = "template";
             UniValue lpval = NullUniValue;
             std::set<std::string> setClientRules;
             CChainState &active_chainstate = chainman.ActiveChainstate();
             CChain &active_chain = active_chainstate.m_chain;
             if (!request.params[0].isNull()) {
                 const UniValue &oparam = request.params[0].get_obj();
                 const UniValue &modeval = find_value(oparam, "mode");
                 if (modeval.isStr()) {
                     strMode = modeval.get_str();
                 } else if (modeval.isNull()) {
                     /* Do nothing */
                 } else {
                     throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");
                 }
                 lpval = find_value(oparam, "longpollid");
 
                 if (strMode == "proposal") {
                     const UniValue &dataval = find_value(oparam, "data");
                     if (!dataval.isStr()) {
                         throw JSONRPCError(
                             RPC_TYPE_ERROR,
                             "Missing data String key for proposal");
                     }
 
                     CBlock block;
                     if (!DecodeHexBlk(block, dataval.get_str())) {
                         throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                            "Block decode failed");
                     }
 
                     const BlockHash hash = block.GetHash();
                     const CBlockIndex *pindex =
                         chainman.m_blockman.LookupBlockIndex(hash);
                     if (pindex) {
                         if (pindex->IsValid(BlockValidity::SCRIPTS)) {
                             return "duplicate";
                         }
                         if (pindex->nStatus.isInvalid()) {
                             return "duplicate-invalid";
                         }
                         return "duplicate-inconclusive";
                     }
 
                     CBlockIndex *const pindexPrev = active_chain.Tip();
                     // TestBlockValidity only supports blocks built on the
                     // current Tip
                     if (block.hashPrevBlock != pindexPrev->GetBlockHash()) {
                         return "inconclusive-not-best-prevblk";
                     }
                     BlockValidationState state;
                     TestBlockValidity(state, chainparams, active_chainstate,
                                       block, pindexPrev,
                                       BlockValidationOptions(config)
                                           .withCheckPoW(false)
                                           .withCheckMerkleRoot(true));
                     return BIP22ValidationResult(config, state);
                 }
             }
 
             if (strMode != "template") {
                 throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");
             }
 
-            if (!node.connman) {
-                throw JSONRPCError(
-                    RPC_CLIENT_P2P_DISABLED,
-                    "Error: Peer-to-peer functionality missing or disabled");
-            }
-
-            if (node.connman->GetNodeCount(CConnman::CONNECTIONS_ALL) == 0) {
+            const CConnman &connman = EnsureConnman(node);
+            if (connman.GetNodeCount(CConnman::CONNECTIONS_ALL) == 0) {
                 throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED,
                                    "Bitcoin is not connected!");
             }
 
             if (active_chainstate.IsInitialBlockDownload()) {
                 throw JSONRPCError(
                     RPC_CLIENT_IN_INITIAL_DOWNLOAD, PACKAGE_NAME
                     " is in initial sync and waiting for blocks...");
             }
 
             static unsigned int nTransactionsUpdatedLast;
             const CTxMemPool &mempool = EnsureMemPool(node);
 
             if (!lpval.isNull()) {
                 // Wait to respond until either the best block changes, OR a
                 // minute has passed and there are more transactions
                 uint256 hashWatchedChain;
                 std::chrono::steady_clock::time_point checktxtime;
                 unsigned int nTransactionsUpdatedLastLP;
 
                 if (lpval.isStr()) {
                     // Format: <hashBestChain><nTransactionsUpdatedLast>
                     std::string lpstr = lpval.get_str();
 
                     hashWatchedChain =
                         ParseHashV(lpstr.substr(0, 64), "longpollid");
                     nTransactionsUpdatedLastLP = atoi64(lpstr.substr(64));
                 } else {
                     // NOTE: Spec does not specify behaviour for non-string
                     // longpollid, but this makes testing easier
                     hashWatchedChain = active_chain.Tip()->GetBlockHash();
                     nTransactionsUpdatedLastLP = nTransactionsUpdatedLast;
                 }
 
                 // Release lock while waiting
                 LEAVE_CRITICAL_SECTION(cs_main);
                 {
                     checktxtime = std::chrono::steady_clock::now() +
                                   std::chrono::minutes(1);
 
                     WAIT_LOCK(g_best_block_mutex, lock);
                     while (g_best_block == hashWatchedChain && IsRPCRunning()) {
                         if (g_best_block_cv.wait_until(lock, checktxtime) ==
                             std::cv_status::timeout) {
                             // Timeout: Check transactions for update
                             // without holding the mempool look to avoid
                             // deadlocks
                             if (mempool.GetTransactionsUpdated() !=
                                 nTransactionsUpdatedLastLP) {
                                 break;
                             }
                             checktxtime += std::chrono::seconds(10);
                         }
                     }
                 }
                 ENTER_CRITICAL_SECTION(cs_main);
 
                 if (!IsRPCRunning()) {
                     throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED,
                                        "Shutting down");
                 }
                 // TODO: Maybe recheck connections/IBD and (if something wrong)
                 // send an expires-immediately template to stop miners?
             }
 
             // Update block
             static CBlockIndex *pindexPrev;
             static int64_t nStart;
             static std::unique_ptr<CBlockTemplate> pblocktemplate;
             if (pindexPrev != active_chain.Tip() ||
                 (mempool.GetTransactionsUpdated() != nTransactionsUpdatedLast &&
                  GetTime() - nStart > 5)) {
                 // Clear pindexPrev so future calls make a new block, despite
                 // any failures from here on
                 pindexPrev = nullptr;
 
                 // Store the pindexBest used before CreateNewBlock, to avoid
                 // races
                 nTransactionsUpdatedLast = mempool.GetTransactionsUpdated();
                 CBlockIndex *pindexPrevNew = active_chain.Tip();
                 nStart = GetTime();
 
                 // Create new block
                 CScript scriptDummy = CScript() << OP_TRUE;
                 pblocktemplate =
                     BlockAssembler(config, active_chainstate, mempool)
                         .CreateNewBlock(scriptDummy);
                 if (!pblocktemplate) {
                     throw JSONRPCError(RPC_OUT_OF_MEMORY, "Out of memory");
                 }
 
                 // Need to update only after we know CreateNewBlock succeeded
                 pindexPrev = pindexPrevNew;
             }
 
             CHECK_NONFATAL(pindexPrev);
             // pointer for convenience
             CBlock *pblock = &pblocktemplate->block;
 
             // Update nTime
             UpdateTime(pblock, chainparams, pindexPrev);
             pblock->nNonce = 0;
 
             UniValue aCaps(UniValue::VARR);
             aCaps.push_back("proposal");
 
             Amount coinbasevalue = Amount::zero();
 
             UniValue transactions(UniValue::VARR);
             transactions.reserve(pblock->vtx.size());
             int index_in_template = 0;
             for (const auto &it : pblock->vtx) {
                 const CTransaction &tx = *it;
                 const TxId txId = tx.GetId();
 
                 if (tx.IsCoinBase()) {
                     index_in_template++;
 
                     for (const auto &o : pblock->vtx[0]->vout) {
                         coinbasevalue += o.nValue;
                     }
 
                     continue;
                 }
 
                 UniValue entry(UniValue::VOBJ);
                 entry.reserve(5);
                 entry.__pushKV("data", EncodeHexTx(tx));
                 entry.__pushKV("txid", txId.GetHex());
                 entry.__pushKV("hash", tx.GetHash().GetHex());
                 entry.__pushKV("fee",
                                pblocktemplate->entries[index_in_template].fees /
                                    SATOSHI);
                 int64_t nTxSigOps =
                     pblocktemplate->entries[index_in_template].sigOpCount;
                 entry.__pushKV("sigops", nTxSigOps);
 
                 transactions.push_back(entry);
                 index_in_template++;
             }
 
             UniValue aux(UniValue::VOBJ);
 
             UniValue minerFundList(UniValue::VARR);
             const Consensus::Params &consensusParams =
                 chainparams.GetConsensus();
             for (auto fundDestination :
                  GetMinerFundWhitelist(consensusParams, pindexPrev)) {
                 minerFundList.push_back(
                     EncodeDestination(fundDestination, config));
             }
 
             int64_t minerFundMinValue = 0;
             if (IsAxionEnabled(consensusParams, pindexPrev)) {
                 minerFundMinValue =
                     int64_t(GetMinerFundAmount(coinbasevalue) / SATOSHI);
             }
 
             UniValue minerFund(UniValue::VOBJ);
             minerFund.pushKV("addresses", minerFundList);
             minerFund.pushKV("minimumvalue", minerFundMinValue);
 
             UniValue coinbasetxn(UniValue::VOBJ);
             coinbasetxn.pushKV("minerfund", minerFund);
 
             arith_uint256 hashTarget =
                 arith_uint256().SetCompact(pblock->nBits);
 
             UniValue aMutable(UniValue::VARR);
             aMutable.push_back("time");
             aMutable.push_back("transactions");
             aMutable.push_back("prevblock");
 
             UniValue result(UniValue::VOBJ);
             result.pushKV("capabilities", aCaps);
 
             result.pushKV("version", pblock->nVersion);
 
             result.pushKV("previousblockhash", pblock->hashPrevBlock.GetHex());
             result.pushKV("transactions", transactions);
             result.pushKV("coinbaseaux", aux);
             result.pushKV("coinbasetxn", coinbasetxn);
             result.pushKV("coinbasevalue", int64_t(coinbasevalue / SATOSHI));
             result.pushKV("longpollid",
                           active_chain.Tip()->GetBlockHash().GetHex() +
                               ToString(nTransactionsUpdatedLast));
             result.pushKV("target", hashTarget.GetHex());
             result.pushKV("mintime",
                           int64_t(pindexPrev->GetMedianTimePast()) + 1);
             result.pushKV("mutable", aMutable);
             result.pushKV("noncerange", "00000000ffffffff");
             result.pushKV("sigoplimit",
                           GetMaxBlockSigChecksCount(DEFAULT_MAX_BLOCK_SIZE));
             result.pushKV("sizelimit", DEFAULT_MAX_BLOCK_SIZE);
             result.pushKV("curtime", pblock->GetBlockTime());
             result.pushKV("bits", strprintf("%08x", pblock->nBits));
             result.pushKV("height", int64_t(pindexPrev->nHeight) + 1);
 
             return result;
         },
     };
 }
 
 class submitblock_StateCatcher final : public CValidationInterface {
 public:
     uint256 hash;
     bool found;
     BlockValidationState state;
 
     explicit submitblock_StateCatcher(const uint256 &hashIn)
         : hash(hashIn), found(false), state() {}
 
 protected:
     void BlockChecked(const CBlock &block,
                       const BlockValidationState &stateIn) override {
         if (block.GetHash() != hash) {
             return;
         }
 
         found = true;
         state = stateIn;
     }
 };
 
 static RPCHelpMan submitblock() {
     // We allow 2 arguments for compliance with BIP22. Argument 2 is ignored.
     return RPCHelpMan{
         "submitblock",
         "Attempts to submit new block to network.\n"
         "See https://en.bitcoin.it/wiki/BIP_0022 for full specification.\n",
         {
             {"hexdata", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "the hex-encoded block data to submit"},
             {"dummy", RPCArg::Type::STR, /* default */ "ignored",
              "dummy value, for compatibility with BIP22. This value is "
              "ignored."},
         },
         {
             RPCResult{"If the block was accepted", RPCResult::Type::NONE, "",
                       ""},
             RPCResult{"Otherwise", RPCResult::Type::STR, "",
                       "According to BIP22"},
         },
         RPCExamples{HelpExampleCli("submitblock", "\"mydata\"") +
                     HelpExampleRpc("submitblock", "\"mydata\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::shared_ptr<CBlock> blockptr = std::make_shared<CBlock>();
             CBlock &block = *blockptr;
             if (!DecodeHexBlk(block, request.params[0].get_str())) {
                 throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                    "Block decode failed");
             }
 
             if (block.vtx.empty() || !block.vtx[0]->IsCoinBase()) {
                 throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                    "Block does not start with a coinbase");
             }
 
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             const BlockHash hash = block.GetHash();
             {
                 LOCK(cs_main);
                 const CBlockIndex *pindex =
                     chainman.m_blockman.LookupBlockIndex(hash);
                 if (pindex) {
                     if (pindex->IsValid(BlockValidity::SCRIPTS)) {
                         return "duplicate";
                     }
                     if (pindex->nStatus.isInvalid()) {
                         return "duplicate-invalid";
                     }
                 }
             }
 
             bool new_block;
             auto sc =
                 std::make_shared<submitblock_StateCatcher>(block.GetHash());
             RegisterSharedValidationInterface(sc);
             bool accepted =
                 chainman.ProcessNewBlock(config, blockptr,
                                          /* fForceProcessing */ true,
                                          /* fNewBlock */ &new_block);
             UnregisterSharedValidationInterface(sc);
             if (!new_block && accepted) {
                 return "duplicate";
             }
 
             if (!sc->found) {
                 return "inconclusive";
             }
 
             return BIP22ValidationResult(config, sc->state);
         },
     };
 }
 
 static RPCHelpMan submitheader() {
     return RPCHelpMan{
         "submitheader",
         "Decode the given hexdata as a header and submit it as a candidate "
         "chain tip if valid."
         "\nThrows when the header is invalid.\n",
         {
             {"hexdata", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
              "the hex-encoded block header data"},
         },
         RPCResult{RPCResult::Type::NONE, "", "None"},
         RPCExamples{HelpExampleCli("submitheader", "\"aabbcc\"") +
                     HelpExampleRpc("submitheader", "\"aabbcc\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             CBlockHeader h;
             if (!DecodeHexBlockHeader(h, request.params[0].get_str())) {
                 throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
                                    "Block header decode failed");
             }
             ChainstateManager &chainman = EnsureAnyChainman(request.context);
             {
                 LOCK(cs_main);
                 if (!chainman.m_blockman.LookupBlockIndex(h.hashPrevBlock)) {
                     throw JSONRPCError(RPC_VERIFY_ERROR,
                                        "Must submit previous header (" +
                                            h.hashPrevBlock.GetHex() +
                                            ") first");
                 }
             }
 
             BlockValidationState state;
             chainman.ProcessNewBlockHeaders(config, {h}, state);
             if (state.IsValid()) {
                 return NullUniValue;
             }
             if (state.IsError()) {
                 throw JSONRPCError(RPC_VERIFY_ERROR, state.ToString());
             }
             throw JSONRPCError(RPC_VERIFY_ERROR, state.GetRejectReason());
         },
     };
 }
 
 static RPCHelpMan estimatefee() {
     return RPCHelpMan{
         "estimatefee",
         "Estimates the approximate fee per kilobyte needed for a "
         "transaction\n",
         {},
         RPCResult{RPCResult::Type::NUM, "", "estimated fee-per-kilobyte"},
         RPCExamples{HelpExampleCli("estimatefee", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             const CTxMemPool &mempool = EnsureAnyMemPool(request.context);
             return mempool.estimateFee().GetFeePerK();
         },
     };
 }
 
 void RegisterMiningRPCCommands(CRPCTable &t) {
     // clang-format off
     static const CRPCCommand commands[] = {
         //  category    actor (function)
         //  ----------  ----------------------
         {"mining",      getnetworkhashps,      },
         {"mining",      getmininginfo,         },
         {"mining",      prioritisetransaction, },
         {"mining",      getblocktemplate,      },
         {"mining",      submitblock,           },
         {"mining",      submitheader,          },
 
         {"generating",  generatetoaddress,     },
         {"generating",  generatetodescriptor,  },
         {"generating",  generateblock,         },
 
         {"util",        estimatefee,           },
 
         {"hidden",      generate,              },
     };
     // clang-format on
     for (const auto &c : commands) {
         t.appendCommand(c.name, &c);
     }
 }
diff --git a/src/rpc/net.cpp b/src/rpc/net.cpp
index 475a66540..f497a3060 100644
--- a/src/rpc/net.cpp
+++ b/src/rpc/net.cpp
@@ -1,1236 +1,1212 @@
 // Copyright (c) 2009-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 <rpc/server.h>
 
 #include <addrman.h>
 #include <avalanche/avalanche.h>
 #include <banman.h>
 #include <chainparams.h>
 #include <clientversion.h>
 #include <config.h>
 #include <net.h>
 #include <net_permissions.h>
 #include <net_processing.h>
 #include <net_types.h> // For banmap_t
 #include <netbase.h>
 #include <node/context.h>
 #include <policy/settings.h>
 #include <rpc/blockchain.h>
 #include <rpc/protocol.h>
 #include <rpc/util.h>
 #include <sync.h>
 #include <timedata.h>
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <util/system.h>
 #include <util/translation.h>
 #include <validation.h>
 #include <version.h>
 #include <warnings.h>
 
 #include <optional>
 
 #include <univalue.h>
 
+CConnman &EnsureConnman(const NodeContext &node) {
+    if (!node.connman) {
+        throw JSONRPCError(
+            RPC_CLIENT_P2P_DISABLED,
+            "Error: Peer-to-peer functionality missing or disabled");
+    }
+    return *node.connman;
+}
+
+PeerManager &EnsurePeerman(const NodeContext &node) {
+    if (!node.peerman) {
+        throw JSONRPCError(
+            RPC_CLIENT_P2P_DISABLED,
+            "Error: Peer-to-peer functionality missing or disabled");
+    }
+    return *node.peerman;
+}
+
 static RPCHelpMan getconnectioncount() {
     return RPCHelpMan{
         "getconnectioncount",
         "Returns the number of connections to other nodes.\n",
         {},
         RPCResult{RPCResult::Type::NUM, "", "The connection count"},
         RPCExamples{HelpExampleCli("getconnectioncount", "") +
                     HelpExampleRpc("getconnectioncount", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             NodeContext &node = EnsureAnyNodeContext(request.context);
-            if (!node.connman) {
-                throw JSONRPCError(
-                    RPC_CLIENT_P2P_DISABLED,
-                    "Error: Peer-to-peer functionality missing or disabled");
-            }
+            const CConnman &connman = EnsureConnman(node);
 
-            return int(node.connman->GetNodeCount(CConnman::CONNECTIONS_ALL));
+            return int(connman.GetNodeCount(CConnman::CONNECTIONS_ALL));
         },
     };
 }
 
 static RPCHelpMan ping() {
     return RPCHelpMan{
         "ping",
         "Requests that a ping be sent to all other nodes, to measure ping "
         "time.\n"
         "Results provided in getpeerinfo, pingtime and pingwait fields are "
         "decimal seconds.\n"
         "Ping command is handled in queue with all other commands, so it "
         "measures processing backlog, not just network ping.\n",
         {},
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("ping", "") + HelpExampleRpc("ping", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             NodeContext &node = EnsureAnyNodeContext(request.context);
-            if (!node.peerman) {
-                throw JSONRPCError(
-                    RPC_CLIENT_P2P_DISABLED,
-                    "Error: Peer-to-peer functionality missing or disabled");
-            }
+            PeerManager &peerman = EnsurePeerman(node);
 
             // Request that each node send a ping during next message processing
             // pass
-            node.peerman->SendPings();
+            peerman.SendPings();
             return NullUniValue;
         },
     };
 }
 
 static RPCHelpMan getpeerinfo() {
     return RPCHelpMan{
         "getpeerinfo",
         "Returns data about each connected network node as a json array of "
         "objects.\n",
         {},
         RPCResult{
             RPCResult::Type::ARR,
             "",
             "",
             {{
                 RPCResult::Type::OBJ,
                 "",
                 "",
                 {{
                     {RPCResult::Type::NUM, "id", "Peer index"},
                     {RPCResult::Type::STR, "addr",
                      "(host:port) The IP address and port of the peer"},
                     {RPCResult::Type::STR, "addrbind",
                      "(ip:port) Bind address of the connection to the peer"},
                     {RPCResult::Type::STR, "addrlocal",
                      "(ip:port) Local address as reported by the peer"},
                     {RPCResult::Type::BOOL, "addr_relay_enabled",
                      "Whether we participate in address relay with this peer"},
                     {RPCResult::Type::NUM, "addr_processed",
                      "The total number of addresses processed, excluding those "
                      "dropped due to rate limiting"},
                     {RPCResult::Type::NUM, "addr_rate_limited",
                      "The total number of addresses dropped due to rate "
                      "limiting"},
                     {RPCResult::Type::STR, "network",
                      "Network (" +
                          Join(GetNetworkNames(/* append_unroutable */ true),
                               ", ") +
                          ")"},
                     {RPCResult::Type::NUM, "mapped_as",
                      "The AS in the BGP route to the peer used for "
                      "diversifying\n"
                      "peer selection (only available if the asmap config flag "
                      "is set)\n"},
                     {RPCResult::Type::STR_HEX, "services",
                      "The services offered"},
                     {RPCResult::Type::ARR,
                      "servicesnames",
                      "the services offered, in human-readable form",
                      {{RPCResult::Type::STR, "SERVICE_NAME",
                        "the service name if it is recognised"}}},
                     {RPCResult::Type::BOOL, "relaytxes",
                      "Whether peer has asked us to relay transactions to it"},
                     {RPCResult::Type::NUM_TIME, "lastsend",
                      "The " + UNIX_EPOCH_TIME + " of the last send"},
                     {RPCResult::Type::NUM_TIME, "lastrecv",
                      "The " + UNIX_EPOCH_TIME + " of the last receive"},
                     {RPCResult::Type::NUM_TIME, "last_transaction",
                      "The " + UNIX_EPOCH_TIME +
                          " of the last valid transaction received from this "
                          "peer"},
                     {RPCResult::Type::NUM_TIME, "last_block",
                      "The " + UNIX_EPOCH_TIME +
                          " of the last block received from this peer"},
                     {RPCResult::Type::NUM, "bytessent", "The total bytes sent"},
                     {RPCResult::Type::NUM, "bytesrecv",
                      "The total bytes received"},
                     {RPCResult::Type::NUM_TIME, "conntime",
                      "The " + UNIX_EPOCH_TIME + " of the connection"},
                     {RPCResult::Type::NUM, "timeoffset",
                      "The time offset in seconds"},
                     {RPCResult::Type::NUM, "pingtime",
                      "ping time (if available)"},
                     {RPCResult::Type::NUM, "minping",
                      "minimum observed ping time (if any at all)"},
                     {RPCResult::Type::NUM, "pingwait",
                      "ping wait (if non-zero)"},
                     {RPCResult::Type::NUM, "version",
                      "The peer version, such as 70001"},
                     {RPCResult::Type::STR, "subver", "The string version"},
                     {RPCResult::Type::BOOL, "inbound",
                      "Inbound (true) or Outbound (false)"},
                     {RPCResult::Type::BOOL, "bip152_hb_to",
                      "Whether we selected peer as (compact blocks) "
                      "high-bandwidth peer"},
                     {RPCResult::Type::BOOL, "bip152_hb_from",
                      "Whether peer selected us as (compact blocks) "
                      "high-bandwidth peer"},
                     {RPCResult::Type::STR, "connection_type",
                      "Type of connection: \n" +
                          Join(CONNECTION_TYPE_DOC, ",\n") + "."},
                     {RPCResult::Type::NUM, "startingheight",
                      "The starting height (block) of the peer"},
                     {RPCResult::Type::NUM, "synced_headers",
                      "The last header we have in common with this peer"},
                     {RPCResult::Type::NUM, "synced_blocks",
                      "The last block we have in common with this peer"},
                     {RPCResult::Type::ARR,
                      "inflight",
                      "",
                      {
                          {RPCResult::Type::NUM, "n",
                           "The heights of blocks we're currently asking from "
                           "this peer"},
                      }},
                     {RPCResult::Type::NUM, "minfeefilter",
                      "The minimum fee rate for transactions this peer accepts"},
                     {RPCResult::Type::OBJ_DYN,
                      "bytessent_per_msg",
                      "",
                      {{RPCResult::Type::NUM, "msg",
                        "The total bytes sent aggregated by message type\n"
                        "When a message type is not listed in this json object, "
                        "the bytes sent are 0.\n"
                        "Only known message types can appear as keys in the "
                        "object."}}},
                     {RPCResult::Type::OBJ,
                      "bytesrecv_per_msg",
                      "",
                      {{RPCResult::Type::NUM, "msg",
                        "The total bytes received aggregated by message type\n"
                        "When a message type is not listed in this json object, "
                        "the bytes received are 0.\n"
                        "Only known message types can appear as keys in the "
                        "object and all bytes received\n"
                        "of unknown message types are listed under '" +
                            NET_MESSAGE_COMMAND_OTHER + "'."}}},
                     {RPCResult::Type::NUM, "activity_score",
                      "Avalanche activity score of this node (if any)"},
                 }},
             }},
         },
         RPCExamples{HelpExampleCli("getpeerinfo", "") +
                     HelpExampleRpc("getpeerinfo", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             NodeContext &node = EnsureAnyNodeContext(request.context);
-            if (!node.connman || !node.peerman) {
-                throw JSONRPCError(
-                    RPC_CLIENT_P2P_DISABLED,
-                    "Error: Peer-to-peer functionality missing or disabled");
-            }
+            const CConnman &connman = EnsureConnman(node);
+            const PeerManager &peerman = EnsurePeerman(node);
 
             std::vector<CNodeStats> vstats;
-            node.connman->GetNodeStats(vstats);
+            connman.GetNodeStats(vstats);
 
             UniValue ret(UniValue::VARR);
 
             for (const CNodeStats &stats : vstats) {
                 UniValue obj(UniValue::VOBJ);
                 CNodeStateStats statestats;
                 bool fStateStats =
-                    node.peerman->GetNodeStateStats(stats.nodeid, statestats);
+                    peerman.GetNodeStateStats(stats.nodeid, statestats);
                 obj.pushKV("id", stats.nodeid);
                 obj.pushKV("addr", stats.m_addr_name);
                 if (stats.addrBind.IsValid()) {
                     obj.pushKV("addrbind", stats.addrBind.ToString());
                 }
                 if (!(stats.addrLocal.empty())) {
                     obj.pushKV("addrlocal", stats.addrLocal);
                 }
                 obj.pushKV("addr_relay_enabled",
                            statestats.m_addr_relay_enabled);
                 obj.pushKV("network", GetNetworkName(stats.m_network));
                 if (stats.m_mapped_as != 0) {
                     obj.pushKV("mapped_as", uint64_t(stats.m_mapped_as));
                 }
                 obj.pushKV("services", strprintf("%016x", stats.nServices));
                 obj.pushKV("servicesnames", GetServicesNames(stats.nServices));
                 obj.pushKV("relaytxes", stats.fRelayTxes);
                 obj.pushKV("lastsend", count_seconds(stats.m_last_send));
                 obj.pushKV("lastrecv", count_seconds(stats.m_last_recv));
                 obj.pushKV("last_transaction",
                            count_seconds(stats.m_last_tx_time));
                 if (g_avalanche) {
                     obj.pushKV("last_proof",
                                count_seconds(stats.m_last_proof_time));
                 }
                 obj.pushKV("last_block",
                            count_seconds(stats.m_last_block_time));
                 obj.pushKV("bytessent", stats.nSendBytes);
                 obj.pushKV("bytesrecv", stats.nRecvBytes);
                 obj.pushKV("conntime", count_seconds(stats.m_connected));
                 obj.pushKV("timeoffset", stats.nTimeOffset);
                 if (stats.m_last_ping_time > 0us) {
                     obj.pushKV("pingtime",
                                CountSecondsDouble(stats.m_last_ping_time));
                 }
                 if (stats.m_min_ping_time < std::chrono::microseconds::max()) {
                     obj.pushKV("minping",
                                CountSecondsDouble(stats.m_min_ping_time));
                 }
                 if (fStateStats && statestats.m_ping_wait > 0s) {
                     obj.pushKV("pingwait",
                                CountSecondsDouble(statestats.m_ping_wait));
                 }
                 obj.pushKV("version", stats.nVersion);
                 // Use the sanitized form of subver here, to avoid tricksy
                 // remote peers from corrupting or modifying the JSON output by
                 // putting special characters in their ver message.
                 obj.pushKV("subver", stats.cleanSubVer);
                 obj.pushKV("inbound", stats.fInbound);
                 obj.pushKV("bip152_hb_to", stats.m_bip152_highbandwidth_to);
                 obj.pushKV("bip152_hb_from", stats.m_bip152_highbandwidth_from);
                 if (fStateStats) {
                     obj.pushKV("startingheight", statestats.m_starting_height);
                     obj.pushKV("synced_headers", statestats.nSyncHeight);
                     obj.pushKV("synced_blocks", statestats.nCommonHeight);
                     UniValue heights(UniValue::VARR);
                     for (const int height : statestats.vHeightInFlight) {
                         heights.push_back(height);
                     }
                     obj.pushKV("inflight", heights);
                     obj.pushKV("addr_processed", statestats.m_addr_processed);
                     obj.pushKV("addr_rate_limited",
                                statestats.m_addr_rate_limited);
                 }
                 UniValue permissions(UniValue::VARR);
                 for (const auto &permission :
                      NetPermissions::ToStrings(stats.m_permissionFlags)) {
                     permissions.push_back(permission);
                 }
                 obj.pushKV("permissions", permissions);
                 obj.pushKV("minfeefilter", stats.minFeeFilter);
 
                 UniValue sendPerMsgCmd(UniValue::VOBJ);
                 for (const auto &i : stats.mapSendBytesPerMsgCmd) {
                     if (i.second > 0) {
                         sendPerMsgCmd.pushKV(i.first, i.second);
                     }
                 }
                 obj.pushKV("bytessent_per_msg", sendPerMsgCmd);
 
                 UniValue recvPerMsgCmd(UniValue::VOBJ);
                 for (const auto &i : stats.mapRecvBytesPerMsgCmd) {
                     if (i.second > 0) {
                         recvPerMsgCmd.pushKV(i.first, i.second);
                     }
                 }
                 obj.pushKV("bytesrecv_per_msg", recvPerMsgCmd);
                 obj.pushKV("connection_type", stats.m_conn_type_string);
 
                 if (stats.m_availabilityScore) {
                     obj.pushKV("availability_score",
                                *stats.m_availabilityScore);
                 }
 
                 ret.push_back(obj);
             }
 
             return ret;
         },
     };
 }
 
 static RPCHelpMan addnode() {
     return RPCHelpMan{
         "addnode",
         "Attempts to add or remove a node from the addnode list.\n"
         "Or try a connection to a node once.\n"
         "Nodes added using addnode (or -connect) are protected from "
         "DoS disconnection and are not required to be\n"
         "full nodes as other outbound peers are (though such peers "
         "will not be synced from).\n",
         {
             {"node", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The node (see getpeerinfo for nodes)"},
             {"command", RPCArg::Type::STR, RPCArg::Optional::NO,
              "'add' to add a node to the list, 'remove' to remove a "
              "node from the list, 'onetry' to try a connection to the "
              "node once"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{
             HelpExampleCli("addnode", "\"192.168.0.6:8333\" \"onetry\"") +
             HelpExampleRpc("addnode", "\"192.168.0.6:8333\", \"onetry\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::string strCommand;
             if (!request.params[1].isNull()) {
                 strCommand = request.params[1].get_str();
             }
 
             if (strCommand != "onetry" && strCommand != "add" &&
                 strCommand != "remove") {
                 throw std::runtime_error(self.ToString());
             }
 
             NodeContext &node = EnsureAnyNodeContext(request.context);
-            if (!node.connman) {
-                throw JSONRPCError(
-                    RPC_CLIENT_P2P_DISABLED,
-                    "Error: Peer-to-peer functionality missing or disabled");
-            }
+            CConnman &connman = EnsureConnman(node);
 
             std::string strNode = request.params[0].get_str();
 
             if (strCommand == "onetry") {
                 CAddress addr;
-                node.connman->OpenNetworkConnection(addr, false, nullptr,
-                                                    strNode.c_str(),
-                                                    ConnectionType::MANUAL);
+                connman.OpenNetworkConnection(addr, false, nullptr,
+                                              strNode.c_str(),
+                                              ConnectionType::MANUAL);
                 return NullUniValue;
             }
 
-            if ((strCommand == "add") && (!node.connman->AddNode(strNode))) {
+            if ((strCommand == "add") && (!connman.AddNode(strNode))) {
                 throw JSONRPCError(RPC_CLIENT_NODE_ALREADY_ADDED,
                                    "Error: Node already added");
             } else if ((strCommand == "remove") &&
-                       (!node.connman->RemoveAddedNode(strNode))) {
+                       (!connman.RemoveAddedNode(strNode))) {
                 throw JSONRPCError(
                     RPC_CLIENT_NODE_NOT_ADDED,
                     "Error: Node could not be removed. It has not been "
                     "added previously.");
             }
 
             return NullUniValue;
         },
     };
 }
 
 static RPCHelpMan addconnection() {
     return RPCHelpMan{
         "addconnection",
         "\nOpen an outbound connection to a specified node. This RPC is for "
         "testing only.\n",
         {
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The IP address and port to attempt connecting to."},
             {"connection_type", RPCArg::Type::STR, RPCArg::Optional::NO,
              "Type of connection to open (\"outbound-full-relay\", "
              "\"block-relay-only\", \"addr-fetch\", \"feeler\" or "
              "\"avalanche\")."},
         },
         RPCResult{RPCResult::Type::OBJ,
                   "",
                   "",
                   {
                       {RPCResult::Type::STR, "address",
                        "Address of newly added connection."},
                       {RPCResult::Type::STR, "connection_type",
                        "Type of connection opened."},
                   }},
         RPCExamples{
             HelpExampleCli("addconnection",
                            "\"192.168.0.6:8333\" \"outbound-full-relay\"") +
             HelpExampleRpc("addconnection",
                            "\"192.168.0.6:8333\" \"outbound-full-relay\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             if (config.GetChainParams().NetworkIDString() !=
                 CBaseChainParams::REGTEST) {
                 throw std::runtime_error("addconnection is for regression "
                                          "testing (-regtest mode) only.");
             }
 
             RPCTypeCheck(request.params, {UniValue::VSTR, UniValue::VSTR});
             const std::string address = request.params[0].get_str();
             const std::string conn_type_in{
                 TrimString(request.params[1].get_str())};
             ConnectionType conn_type{};
             if (conn_type_in == "outbound-full-relay") {
                 conn_type = ConnectionType::OUTBOUND_FULL_RELAY;
             } else if (conn_type_in == "block-relay-only") {
                 conn_type = ConnectionType::BLOCK_RELAY;
             } else if (conn_type_in == "addr-fetch") {
                 conn_type = ConnectionType::ADDR_FETCH;
             } else if (conn_type_in == "feeler") {
                 conn_type = ConnectionType::FEELER;
             } else if (conn_type_in == "avalanche") {
                 if (!g_avalanche || !isAvalancheEnabled(gArgs)) {
                     throw JSONRPCError(RPC_INVALID_PARAMETER,
                                        "Error: avalanche outbound requested "
                                        "but avalanche is not enabled.");
                 }
                 conn_type = ConnectionType::AVALANCHE_OUTBOUND;
             } else {
                 throw JSONRPCError(RPC_INVALID_PARAMETER, self.ToString());
             }
 
             NodeContext &node = EnsureAnyNodeContext(request.context);
-            if (!node.connman) {
-                throw JSONRPCError(
-                    RPC_CLIENT_P2P_DISABLED,
-                    "Error: Peer-to-peer functionality missing or disabled.");
-            }
+            CConnman &connman = EnsureConnman(node);
 
-            const bool success =
-                node.connman->AddConnection(address, conn_type);
+            const bool success = connman.AddConnection(address, conn_type);
             if (!success) {
                 throw JSONRPCError(RPC_CLIENT_NODE_CAPACITY_REACHED,
                                    "Error: Already at capacity for specified "
                                    "connection type.");
             }
 
             UniValue info(UniValue::VOBJ);
             info.pushKV("address", address);
             info.pushKV("connection_type", conn_type_in);
 
             return info;
         },
     };
 }
 
 static RPCHelpMan disconnectnode() {
     return RPCHelpMan{
         "disconnectnode",
         "Immediately disconnects from the specified peer node.\n"
         "\nStrictly one out of 'address' and 'nodeid' can be provided to "
         "identify the node.\n"
         "\nTo disconnect by nodeid, either set 'address' to the empty string, "
         "or call using the named 'nodeid' argument only.\n",
         {
             {"address", RPCArg::Type::STR,
              /* default */ "fallback to nodeid",
              "The IP address/port of the node"},
             {"nodeid", RPCArg::Type::NUM,
              /* default */ "fallback to address",
              "The node ID (see getpeerinfo for node IDs)"},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("disconnectnode", "\"192.168.0.6:8333\"") +
                     HelpExampleCli("disconnectnode", "\"\" 1") +
                     HelpExampleRpc("disconnectnode", "\"192.168.0.6:8333\"") +
                     HelpExampleRpc("disconnectnode", "\"\", 1")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             NodeContext &node = EnsureAnyNodeContext(request.context);
-            if (!node.connman) {
-                throw JSONRPCError(
-                    RPC_CLIENT_P2P_DISABLED,
-                    "Error: Peer-to-peer functionality missing or disabled");
-            }
+            CConnman &connman = EnsureConnman(node);
 
             bool success;
             const UniValue &address_arg = request.params[0];
             const UniValue &id_arg = request.params[1];
 
             if (!address_arg.isNull() && id_arg.isNull()) {
                 /* handle disconnect-by-address */
-                success = node.connman->DisconnectNode(address_arg.get_str());
+                success = connman.DisconnectNode(address_arg.get_str());
             } else if (!id_arg.isNull() && (address_arg.isNull() ||
                                             (address_arg.isStr() &&
                                              address_arg.get_str().empty()))) {
                 /* handle disconnect-by-id */
                 NodeId nodeid = (NodeId)id_arg.get_int64();
-                success = node.connman->DisconnectNode(nodeid);
+                success = connman.DisconnectNode(nodeid);
             } else {
                 throw JSONRPCError(
                     RPC_INVALID_PARAMS,
                     "Only one of address and nodeid should be provided.");
             }
 
             if (!success) {
                 throw JSONRPCError(RPC_CLIENT_NODE_NOT_CONNECTED,
                                    "Node not found in connected nodes");
             }
 
             return NullUniValue;
         },
     };
 }
 
 static RPCHelpMan getaddednodeinfo() {
     return RPCHelpMan{
         "getaddednodeinfo",
         "Returns information about the given added node, or all added nodes\n"
         "(note that onetry addnodes are not listed here)\n",
         {
             {"node", RPCArg::Type::STR, /* default */ "all nodes",
              "If provided, return information about this specific node, "
              "otherwise all nodes are returned."},
         },
         RPCResult{
             RPCResult::Type::ARR,
             "",
             "",
             {
                 {RPCResult::Type::OBJ,
                  "",
                  "",
                  {
                      {RPCResult::Type::STR, "addednode",
                       "The node IP address or name (as provided to addnode)"},
                      {RPCResult::Type::BOOL, "connected", "If connected"},
                      {RPCResult::Type::ARR,
                       "addresses",
                       "Only when connected = true",
                       {
                           {RPCResult::Type::OBJ,
                            "",
                            "",
                            {
                                {RPCResult::Type::STR, "address",
                                 "The bitcoin server IP and port we're "
                                 "connected to"},
                                {RPCResult::Type::STR, "connected",
                                 "connection, inbound or outbound"},
                            }},
                       }},
                  }},
             }},
         RPCExamples{HelpExampleCli("getaddednodeinfo", "\"192.168.0.201\"") +
                     HelpExampleRpc("getaddednodeinfo", "\"192.168.0.201\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             NodeContext &node = EnsureAnyNodeContext(request.context);
-            if (!node.connman) {
-                throw JSONRPCError(
-                    RPC_CLIENT_P2P_DISABLED,
-                    "Error: Peer-to-peer functionality missing or disabled");
-            }
+            const CConnman &connman = EnsureConnman(node);
 
-            std::vector<AddedNodeInfo> vInfo = node.connman->GetAddedNodeInfo();
+            std::vector<AddedNodeInfo> vInfo = connman.GetAddedNodeInfo();
 
             if (!request.params[0].isNull()) {
                 bool found = false;
                 for (const AddedNodeInfo &info : vInfo) {
                     if (info.strAddedNode == request.params[0].get_str()) {
                         vInfo.assign(1, info);
                         found = true;
                         break;
                     }
                 }
                 if (!found) {
                     throw JSONRPCError(RPC_CLIENT_NODE_NOT_ADDED,
                                        "Error: Node has not been added.");
                 }
             }
 
             UniValue ret(UniValue::VARR);
 
             for (const AddedNodeInfo &info : vInfo) {
                 UniValue obj(UniValue::VOBJ);
                 obj.pushKV("addednode", info.strAddedNode);
                 obj.pushKV("connected", info.fConnected);
                 UniValue addresses(UniValue::VARR);
                 if (info.fConnected) {
                     UniValue address(UniValue::VOBJ);
                     address.pushKV("address", info.resolvedAddress.ToString());
                     address.pushKV("connected",
                                    info.fInbound ? "inbound" : "outbound");
                     addresses.push_back(address);
                 }
                 obj.pushKV("addresses", addresses);
                 ret.push_back(obj);
             }
 
             return ret;
         },
     };
 }
 
 static RPCHelpMan getnettotals() {
     return RPCHelpMan{
         "getnettotals",
         "Returns information about network traffic, including bytes in, "
         "bytes out,\n"
         "and current time.\n",
         {},
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::NUM, "totalbytesrecv",
                  "Total bytes received"},
                 {RPCResult::Type::NUM, "totalbytessent", "Total bytes sent"},
                 {RPCResult::Type::NUM_TIME, "timemillis",
                  "Current " + UNIX_EPOCH_TIME + " in milliseconds"},
                 {RPCResult::Type::OBJ,
                  "uploadtarget",
                  "",
                  {
                      {RPCResult::Type::NUM, "timeframe",
                       "Length of the measuring timeframe in seconds"},
                      {RPCResult::Type::NUM, "target", "Target in bytes"},
                      {RPCResult::Type::BOOL, "target_reached",
                       "True if target is reached"},
                      {RPCResult::Type::BOOL, "serve_historical_blocks",
                       "True if serving historical blocks"},
                      {RPCResult::Type::NUM, "bytes_left_in_cycle",
                       "Bytes left in current time cycle"},
                      {RPCResult::Type::NUM, "time_left_in_cycle",
                       "Seconds left in current time cycle"},
                  }},
             }},
         RPCExamples{HelpExampleCli("getnettotals", "") +
                     HelpExampleRpc("getnettotals", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             NodeContext &node = EnsureAnyNodeContext(request.context);
-            if (!node.connman) {
-                throw JSONRPCError(
-                    RPC_CLIENT_P2P_DISABLED,
-                    "Error: Peer-to-peer functionality missing or disabled");
-            }
+            const CConnman &connman = EnsureConnman(node);
 
             UniValue obj(UniValue::VOBJ);
-            obj.pushKV("totalbytesrecv", node.connman->GetTotalBytesRecv());
-            obj.pushKV("totalbytessent", node.connman->GetTotalBytesSent());
+            obj.pushKV("totalbytesrecv", connman.GetTotalBytesRecv());
+            obj.pushKV("totalbytessent", connman.GetTotalBytesSent());
             obj.pushKV("timemillis", GetTimeMillis());
 
             UniValue outboundLimit(UniValue::VOBJ);
             outboundLimit.pushKV(
-                "timeframe",
-                count_seconds(node.connman->GetMaxOutboundTimeframe()));
-            outboundLimit.pushKV("target",
-                                 node.connman->GetMaxOutboundTarget());
+                "timeframe", count_seconds(connman.GetMaxOutboundTimeframe()));
+            outboundLimit.pushKV("target", connman.GetMaxOutboundTarget());
             outboundLimit.pushKV("target_reached",
-                                 node.connman->OutboundTargetReached(false));
+                                 connman.OutboundTargetReached(false));
             outboundLimit.pushKV("serve_historical_blocks",
-                                 !node.connman->OutboundTargetReached(true));
+                                 !connman.OutboundTargetReached(true));
             outboundLimit.pushKV("bytes_left_in_cycle",
-                                 node.connman->GetOutboundTargetBytesLeft());
+                                 connman.GetOutboundTargetBytesLeft());
             outboundLimit.pushKV(
                 "time_left_in_cycle",
-                count_seconds(node.connman->GetMaxOutboundTimeLeftInCycle()));
+                count_seconds(connman.GetMaxOutboundTimeLeftInCycle()));
             obj.pushKV("uploadtarget", outboundLimit);
             return obj;
         },
     };
 }
 
 static UniValue GetNetworksInfo() {
     UniValue networks(UniValue::VARR);
     for (int n = 0; n < NET_MAX; ++n) {
         enum Network network = static_cast<enum Network>(n);
         if (network == NET_UNROUTABLE || network == NET_CJDNS ||
             network == NET_INTERNAL) {
             continue;
         }
         proxyType proxy;
         UniValue obj(UniValue::VOBJ);
         GetProxy(network, proxy);
         obj.pushKV("name", GetNetworkName(network));
         obj.pushKV("limited", !IsReachable(network));
         obj.pushKV("reachable", IsReachable(network));
         obj.pushKV("proxy", proxy.IsValid() ? proxy.proxy.ToStringIPPort()
                                             : std::string());
         obj.pushKV("proxy_randomize_credentials", proxy.randomize_credentials);
         networks.push_back(obj);
     }
     return networks;
 }
 
 static RPCHelpMan getnetworkinfo() {
     const auto &ticker = Currency::get().ticker;
     return RPCHelpMan{
         "getnetworkinfo",
         "Returns an object containing various state info regarding P2P "
         "networking.\n",
         {},
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::NUM, "version", "the server version"},
                 {RPCResult::Type::STR, "subversion",
                  "the server subversion string"},
                 {RPCResult::Type::NUM, "protocolversion",
                  "the protocol version"},
                 {RPCResult::Type::STR_HEX, "localservices",
                  "the services we offer to the network"},
                 {RPCResult::Type::ARR,
                  "localservicesnames",
                  "the services we offer to the network, in human-readable form",
                  {
                      {RPCResult::Type::STR, "SERVICE_NAME", "the service name"},
                  }},
                 {RPCResult::Type::BOOL, "localrelay",
                  "true if transaction relay is requested from peers"},
                 {RPCResult::Type::NUM, "timeoffset", "the time offset"},
                 {RPCResult::Type::NUM, "connections",
                  "the total number of connections"},
                 {RPCResult::Type::NUM, "connections_in",
                  "the number of inbound connections"},
                 {RPCResult::Type::NUM, "connections_out",
                  "the number of outbound connections"},
                 {RPCResult::Type::BOOL, "networkactive",
                  "whether p2p networking is enabled"},
                 {RPCResult::Type::ARR,
                  "networks",
                  "information per network",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::STR, "name",
                            "network (" + Join(GetNetworkNames(), ", ") + ")"},
                           {RPCResult::Type::BOOL, "limited",
                            "is the network limited using -onlynet?"},
                           {RPCResult::Type::BOOL, "reachable",
                            "is the network reachable?"},
                           {RPCResult::Type::STR, "proxy",
                            "(\"host:port\") the proxy that is used for this "
                            "network, or empty if none"},
                           {RPCResult::Type::BOOL, "proxy_randomize_credentials",
                            "Whether randomized credentials are used"},
                       }},
                  }},
                 {RPCResult::Type::NUM, "relayfee",
                  "minimum relay fee for transactions in " + ticker + "/kB"},
                 {RPCResult::Type::NUM, "excessutxocharge",
                  "minimum charge for excess utxos in " + ticker},
                 {RPCResult::Type::ARR,
                  "localaddresses",
                  "list of local addresses",
                  {
                      {RPCResult::Type::OBJ,
                       "",
                       "",
                       {
                           {RPCResult::Type::STR, "address", "network address"},
                           {RPCResult::Type::NUM, "port", "network port"},
                           {RPCResult::Type::NUM, "score", "relative score"},
                       }},
                  }},
                 {RPCResult::Type::STR, "warnings",
                  "any network and blockchain warnings"},
             }},
         RPCExamples{HelpExampleCli("getnetworkinfo", "") +
                     HelpExampleRpc("getnetworkinfo", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             LOCK(cs_main);
             UniValue obj(UniValue::VOBJ);
             obj.pushKV("version", CLIENT_VERSION);
             obj.pushKV("subversion", userAgent(config));
             obj.pushKV("protocolversion", PROTOCOL_VERSION);
             NodeContext &node = EnsureAnyNodeContext(request.context);
             if (node.connman) {
                 ServiceFlags services = node.connman->GetLocalServices();
                 obj.pushKV("localservices", strprintf("%016x", services));
                 obj.pushKV("localservicesnames", GetServicesNames(services));
             }
             if (node.peerman) {
                 obj.pushKV("localrelay", !node.peerman->IgnoresIncomingTxs());
             }
             obj.pushKV("timeoffset", GetTimeOffset());
             if (node.connman) {
                 obj.pushKV("networkactive", node.connman->GetNetworkActive());
                 obj.pushKV("connections", int(node.connman->GetNodeCount(
                                               CConnman::CONNECTIONS_ALL)));
                 obj.pushKV("connections_in", int(node.connman->GetNodeCount(
                                                  CConnman::CONNECTIONS_IN)));
                 obj.pushKV("connections_out", int(node.connman->GetNodeCount(
                                                   CConnman::CONNECTIONS_OUT)));
             }
             obj.pushKV("networks", GetNetworksInfo());
             obj.pushKV("relayfee", ::minRelayTxFee.GetFeePerK());
             obj.pushKV("excessutxocharge", config.GetExcessUTXOCharge());
             UniValue localAddresses(UniValue::VARR);
             {
                 LOCK(cs_mapLocalHost);
                 for (const std::pair<const CNetAddr, LocalServiceInfo> &item :
                      mapLocalHost) {
                     UniValue rec(UniValue::VOBJ);
                     rec.pushKV("address", item.first.ToString());
                     rec.pushKV("port", item.second.nPort);
                     rec.pushKV("score", item.second.nScore);
                     localAddresses.push_back(rec);
                 }
             }
             obj.pushKV("localaddresses", localAddresses);
             obj.pushKV("warnings", GetWarnings(false).original);
             return obj;
         },
     };
 }
 
 static RPCHelpMan setban() {
     return RPCHelpMan{
         "setban",
         "Attempts to add or remove an IP/Subnet from the banned list.\n",
         {
             {"subnet", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The IP/Subnet (see getpeerinfo for nodes IP) with an optional "
              "netmask (default is /32 = single IP)"},
             {"command", RPCArg::Type::STR, RPCArg::Optional::NO,
              "'add' to add an IP/Subnet to the list, 'remove' to remove an "
              "IP/Subnet from the list"},
             {"bantime", RPCArg::Type::NUM, /* default */ "0",
              "time in seconds how long (or until when if [absolute] is set) "
              "the IP is banned (0 or empty means using the default time of 24h "
              "which can also be overwritten by the -bantime startup argument)"},
             {"absolute", RPCArg::Type::BOOL, /* default */ "false",
              "If set, the bantime must be an absolute timestamp expressed in " +
                  UNIX_EPOCH_TIME},
         },
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{
             HelpExampleCli("setban", "\"192.168.0.6\" \"add\" 86400") +
             HelpExampleCli("setban", "\"192.168.0.0/24\" \"add\"") +
             HelpExampleRpc("setban", "\"192.168.0.6\", \"add\", 86400")},
         [&](const RPCHelpMan &help, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             std::string strCommand;
             if (!request.params[1].isNull()) {
                 strCommand = request.params[1].get_str();
             }
 
             if (strCommand != "add" && strCommand != "remove") {
                 throw std::runtime_error(help.ToString());
             }
 
             NodeContext &node = EnsureAnyNodeContext(request.context);
             if (!node.banman) {
                 throw JSONRPCError(RPC_DATABASE_ERROR,
                                    "Error: Ban database not loaded");
             }
 
             CSubNet subNet;
             CNetAddr netAddr;
             bool isSubnet = false;
 
             if (request.params[0].get_str().find('/') != std::string::npos) {
                 isSubnet = true;
             }
 
             if (!isSubnet) {
                 CNetAddr resolved;
                 LookupHost(request.params[0].get_str(), resolved, false);
                 netAddr = resolved;
             } else {
                 LookupSubNet(request.params[0].get_str(), subNet);
             }
 
             if (!(isSubnet ? subNet.IsValid() : netAddr.IsValid())) {
                 throw JSONRPCError(RPC_CLIENT_INVALID_IP_OR_SUBNET,
                                    "Error: Invalid IP/Subnet");
             }
 
             if (strCommand == "add") {
                 if (isSubnet ? node.banman->IsBanned(subNet)
                              : node.banman->IsBanned(netAddr)) {
                     throw JSONRPCError(RPC_CLIENT_NODE_ALREADY_ADDED,
                                        "Error: IP/Subnet already banned");
                 }
 
                 // Use standard bantime if not specified.
                 int64_t banTime = 0;
                 if (!request.params[2].isNull()) {
                     banTime = request.params[2].get_int64();
                 }
 
                 bool absolute = false;
                 if (request.params[3].isTrue()) {
                     absolute = true;
                 }
 
                 if (isSubnet) {
                     node.banman->Ban(subNet, banTime, absolute);
                     if (node.connman) {
                         node.connman->DisconnectNode(subNet);
                     }
                 } else {
                     node.banman->Ban(netAddr, banTime, absolute);
                     if (node.connman) {
                         node.connman->DisconnectNode(netAddr);
                     }
                 }
             } else if (strCommand == "remove") {
                 if (!(isSubnet ? node.banman->Unban(subNet)
                                : node.banman->Unban(netAddr))) {
                     throw JSONRPCError(
                         RPC_CLIENT_INVALID_IP_OR_SUBNET,
                         "Error: Unban failed. Requested address/subnet "
                         "was not previously manually banned.");
                 }
             }
             return NullUniValue;
         },
     };
 }
 
 static RPCHelpMan listbanned() {
     return RPCHelpMan{
         "listbanned",
         "List all manually banned IPs/Subnets.\n",
         {},
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "",
                   {
                       {RPCResult::Type::OBJ,
                        "",
                        "",
                        {
                            {RPCResult::Type::STR, "address", ""},
                            {RPCResult::Type::NUM_TIME, "banned_until", ""},
                            {RPCResult::Type::NUM_TIME, "ban_created", ""},
                            {RPCResult::Type::STR, "ban_reason", ""},
                        }},
                   }},
         RPCExamples{HelpExampleCli("listbanned", "") +
                     HelpExampleRpc("listbanned", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             NodeContext &node = EnsureAnyNodeContext(request.context);
             if (!node.banman) {
                 throw JSONRPCError(RPC_DATABASE_ERROR,
                                    "Error: Ban database not loaded");
             }
 
             banmap_t banMap;
             node.banman->GetBanned(banMap);
 
             UniValue bannedAddresses(UniValue::VARR);
             for (const auto &entry : banMap) {
                 const CBanEntry &banEntry = entry.second;
                 UniValue rec(UniValue::VOBJ);
                 rec.pushKV("address", entry.first.ToString());
                 rec.pushKV("banned_until", banEntry.nBanUntil);
                 rec.pushKV("ban_created", banEntry.nCreateTime);
 
                 bannedAddresses.push_back(rec);
             }
 
             return bannedAddresses;
         },
     };
 }
 
 static RPCHelpMan clearbanned() {
     return RPCHelpMan{
         "clearbanned",
         "Clear all banned IPs.\n",
         {},
         RPCResult{RPCResult::Type::NONE, "", ""},
         RPCExamples{HelpExampleCli("clearbanned", "") +
                     HelpExampleRpc("clearbanned", "")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             NodeContext &node = EnsureAnyNodeContext(request.context);
             if (!node.banman) {
                 throw JSONRPCError(
                     RPC_CLIENT_P2P_DISABLED,
                     "Error: Peer-to-peer functionality missing or disabled");
             }
 
             node.banman->ClearBanned();
 
             return NullUniValue;
         },
     };
 }
 
 static RPCHelpMan setnetworkactive() {
     return RPCHelpMan{
         "setnetworkactive",
         "Disable/enable all p2p network activity.\n",
         {
             {"state", RPCArg::Type::BOOL, RPCArg::Optional::NO,
              "true to enable networking, false to disable"},
         },
         RPCResult{RPCResult::Type::BOOL, "", "The value that was passed in"},
         RPCExamples{""},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             NodeContext &node = EnsureAnyNodeContext(request.context);
-            if (!node.banman) {
-                throw JSONRPCError(
-                    RPC_CLIENT_P2P_DISABLED,
-                    "Error: Peer-to-peer functionality missing or disabled");
-            }
+            CConnman &connman = EnsureConnman(node);
 
-            node.connman->SetNetworkActive(request.params[0].get_bool());
+            connman.SetNetworkActive(request.params[0].get_bool());
 
-            return node.connman->GetNetworkActive();
+            return connman.GetNetworkActive();
         },
     };
 }
 
 static RPCHelpMan getnodeaddresses() {
     return RPCHelpMan{
         "getnodeaddresses",
         "Return known addresses, which can potentially be used to find new "
         "nodes in the network.\n",
         {
             {"count", RPCArg::Type::NUM, /* default */ "1",
              "The maximum number of addresses to return. Specify 0 to return "
              "all known addresses."},
             {"network", RPCArg::Type::STR, "all networks",
              "Return only addresses of the specified network. Can be one of: " +
                  Join(GetNetworkNames(), ", ") + "."},
         },
         RPCResult{RPCResult::Type::ARR,
                   "",
                   "",
                   {
                       {RPCResult::Type::OBJ,
                        "",
                        "",
                        {
                            {RPCResult::Type::NUM_TIME, "time",
                             "The " + UNIX_EPOCH_TIME +
                                 " when the node was last seen"},
                            {RPCResult::Type::NUM, "services",
                             "The services offered by the node"},
                            {RPCResult::Type::STR, "address",
                             "The address of the node"},
                            {RPCResult::Type::NUM, "port",
                             "The port number of the node"},
                            {RPCResult::Type::STR, "network",
                             "The network (" + Join(GetNetworkNames(), ", ") +
                                 ") the node connected through"},
                        }},
                   }},
         RPCExamples{HelpExampleCli("getnodeaddresses", "8") +
                     HelpExampleCli("getnodeaddresses", "4 \"i2p\"") +
                     HelpExampleCli("-named getnodeaddresses",
                                    "network=onion count=12") +
                     HelpExampleRpc("getnodeaddresses", "8") +
                     HelpExampleRpc("getnodeaddresses", "4, \"i2p\"")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             NodeContext &node = EnsureAnyNodeContext(request.context);
-            if (!node.banman) {
-                throw JSONRPCError(
-                    RPC_CLIENT_P2P_DISABLED,
-                    "Error: Peer-to-peer functionality missing or disabled");
-            }
+            const CConnman &connman = EnsureConnman(node);
 
             const int count{
                 request.params[0].isNull() ? 1 : request.params[0].get_int()};
             if (count < 0) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    "Address count out of range");
             }
 
             const std::optional<Network> network{
                 request.params[1].isNull()
                     ? std::nullopt
                     : std::optional<Network>{
                           ParseNetwork(request.params[1].get_str())}};
             if (network == NET_UNROUTABLE) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER,
                                    strprintf("Network not recognized: %s",
                                              request.params[1].get_str()));
             }
             // returns a shuffled list of CAddress
             const std::vector<CAddress> vAddr{
-                node.connman->GetAddresses(count, /* max_pct */ 0, network)};
+                connman.GetAddresses(count, /* max_pct */ 0, network)};
             UniValue ret(UniValue::VARR);
 
             for (const CAddress &addr : vAddr) {
                 UniValue obj(UniValue::VOBJ);
                 obj.pushKV("time", int(addr.nTime));
                 obj.pushKV("services", uint64_t(addr.nServices));
                 obj.pushKV("address", addr.ToStringIP());
                 obj.pushKV("port", addr.GetPort());
                 obj.pushKV("network", GetNetworkName(addr.GetNetClass()));
                 ret.push_back(obj);
             }
             return ret;
         },
     };
 }
 
 static RPCHelpMan addpeeraddress() {
     return RPCHelpMan{
         "addpeeraddress",
         "Add the address of a potential peer to the address manager. This "
         "RPC is for testing only.\n",
         {
             {"address", RPCArg::Type::STR, RPCArg::Optional::NO,
              "The IP address of the peer"},
             {"port", RPCArg::Type::NUM, RPCArg::Optional::NO,
              "The port of the peer"},
             {"tried", RPCArg::Type::BOOL, "false",
              "If true, attempt to add the peer to the tried addresses table"},
         },
         RPCResult{
             RPCResult::Type::OBJ,
             "",
             "",
             {
                 {RPCResult::Type::BOOL, "success",
                  "whether the peer address was successfully added to the "
                  "address manager"},
             },
         },
         RPCExamples{
             HelpExampleCli("addpeeraddress", "\"1.2.3.4\" 8333 true") +
             HelpExampleRpc("addpeeraddress", "\"1.2.3.4\", 8333, true")},
         [&](const RPCHelpMan &self, const Config &config,
             const JSONRPCRequest &request) -> UniValue {
             NodeContext &node = EnsureAnyNodeContext(request.context);
             if (!node.addrman) {
                 throw JSONRPCError(
                     RPC_CLIENT_P2P_DISABLED,
                     "Error: Address manager functionality missing or disabled");
             }
 
             const std::string &addr_string{request.params[0].get_str()};
             const uint16_t port{
                 static_cast<uint16_t>(request.params[1].get_int())};
             const bool tried{request.params[2].isTrue()};
 
             UniValue obj(UniValue::VOBJ);
             CNetAddr net_addr;
             bool success{false};
 
             if (LookupHost(addr_string, net_addr, false)) {
                 CAddress address{{net_addr, port}, ServiceFlags(NODE_NETWORK)};
                 address.nTime = GetAdjustedTime();
                 // The source address is set equal to the address. This is
                 // equivalent to the peer announcing itself.
                 if (node.addrman->Add({address}, address)) {
                     success = true;
                     if (tried) {
                         // Attempt to move the address to the tried addresses
                         // table.
                         node.addrman->Good(address);
                     }
                 }
             }
 
             obj.pushKV("success", success);
             return obj;
         },
     };
 }
 
 void RegisterNetRPCCommands(CRPCTable &t) {
     // clang-format off
     static const CRPCCommand commands[] = {
         //  category            actor (function)
         //  ------------------  ----------------------
         { "network",            getconnectioncount,      },
         { "network",            ping,                    },
         { "network",            getpeerinfo,             },
         { "network",            addnode,                 },
         { "network",            disconnectnode,          },
         { "network",            getaddednodeinfo,        },
         { "network",            getnettotals,            },
         { "network",            getnetworkinfo,          },
         { "network",            setban,                  },
         { "network",            listbanned,              },
         { "network",            clearbanned,             },
         { "network",            setnetworkactive,        },
         { "network",            getnodeaddresses,        },
         { "hidden",             addconnection,           },
         { "hidden",             addpeeraddress,          },
     };
     // clang-format on
     for (const auto &c : commands) {
         t.appendCommand(c.name, &c);
     }
 }
diff --git a/src/rpc/net.h b/src/rpc/net.h
new file mode 100644
index 000000000..fd0a877f1
--- /dev/null
+++ b/src/rpc/net.h
@@ -0,0 +1,15 @@
+// Copyright (c) 2021 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_RPC_NET_H
+#define BITCOIN_RPC_NET_H
+
+class CConnman;
+class PeerManager;
+struct NodeContext;
+
+CConnman &EnsureConnman(const NodeContext &node);
+PeerManager &EnsurePeerman(const NodeContext &node);
+
+#endif // BITCOIN_RPC_NET_H