diff --git a/src/addrdb.h b/src/addrdb.h
index eb14ac8cc..bf6146df5 100644
--- a/src/addrdb.h
+++ b/src/addrdb.h
@@ -1,80 +1,79 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_ADDRDB_H
 #define BITCOIN_ADDRDB_H
 
 #include <fs.h>
+#include <net_types.h> // For banmap_t
 #include <serialize.h>
 
 #include <map>
 #include <string>
 
 class CSubNet;
 class CAddrMan;
 class CDataStream;
 class CChainParams;
 
 class CBanEntry {
 public:
     static const int CURRENT_VERSION = 1;
     int nVersion;
     int64_t nCreateTime;
     int64_t nBanUntil;
 
     CBanEntry() { SetNull(); }
 
     explicit CBanEntry(int64_t nCreateTimeIn) {
         SetNull();
         nCreateTime = nCreateTimeIn;
     }
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream &s, Operation ser_action) {
         //! For backward compatibility
         uint8_t ban_reason = 2;
         READWRITE(this->nVersion);
         READWRITE(nCreateTime);
         READWRITE(nBanUntil);
         READWRITE(ban_reason);
     }
 
     void SetNull() {
         nVersion = CBanEntry::CURRENT_VERSION;
         nCreateTime = 0;
         nBanUntil = 0;
     }
 };
 
-typedef std::map<CSubNet, CBanEntry> banmap_t;
-
 /** Access to the (IP) address database (peers.dat) */
 class CAddrDB {
 private:
     fs::path pathAddr;
     const CChainParams &chainParams;
 
 public:
     explicit CAddrDB(const CChainParams &chainParams);
     bool Write(const CAddrMan &addr);
     bool Read(CAddrMan &addr);
     bool Read(CAddrMan &addr, CDataStream &ssPeers);
 };
 
 /** Access to the banlist database (banlist.dat) */
 class CBanDB {
 private:
     const fs::path m_ban_list_path;
     const CChainParams &chainParams;
 
 public:
     CBanDB(fs::path ban_list_path, const CChainParams &_chainParams);
     bool Write(const banmap_t &banSet);
     bool Read(banmap_t &banSet);
 };
 
 #endif // BITCOIN_ADDRDB_H
diff --git a/src/banman.h b/src/banman.h
index 71dd79e88..f12a10083 100644
--- a/src/banman.h
+++ b/src/banman.h
@@ -1,100 +1,101 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2017 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #ifndef BITCOIN_BANMAN_H
 #define BITCOIN_BANMAN_H
 
 #include <addrdb.h>
 #include <bloom.h>
 #include <fs.h>
+#include <net_types.h> // For banmap_t
 #include <sync.h>
 
 #include <chrono>
 #include <cstdint>
 #include <memory>
 
 // Default 24-hour ban.
 // NOTE: When adjusting this, update rpcnet:setban's help ("24h")
 static constexpr unsigned int DEFAULT_MISBEHAVING_BANTIME = 60 * 60 * 24;
 // How often to dump addresses to banlist.dat
 static constexpr std::chrono::minutes DUMP_BANS_INTERVAL{15};
 
 class CClientUIInterface;
 class CNetAddr;
 class CSubNet;
 
 // Banman manages two related but distinct concepts:
 //
 // 1. Banning. This is configured manually by the user, through the setban RPC.
 // If an address or subnet is banned, we never accept incoming connections from
 // it and never create outgoing connections to it. We won't gossip its address
 // to other peers in addr messages. Banned addresses and subnets are stored to
 // banlist.dat on shutdown and reloaded on startup. Banning can be used to
 // prevent connections with spy nodes or other griefers.
 //
 // 2. Discouragement. If a peer misbehaves enough (see Misbehaving() in
 // net_processing.cpp), we'll mark that address as discouraged. We still allow
 // incoming connections from them, but they're preferred for eviction when
 // we receive new incoming connections. We never make outgoing connections to
 // them, and do not gossip their address to other peers. This is implemented as
 // a bloom filter. We can (probabilistically) test for membership, but can't
 // list all discouraged addresses or unmark them as discouraged. Discouragement
 // can prevent our limited connection slots being used up by incompatible
 // or broken peers.
 //
 // Neither banning nor discouragement are protections against denial-of-service
 // attacks, since if an attacker has a way to waste our resources and we
 // disconnect from them and ban that address, it's trivial for them to
 // reconnect from another IP address.
 //
 // Attempting to automatically disconnect or ban any class of peer carries the
 // risk of splitting the network. For example, if we banned/disconnected for a
 // transaction that fails a policy check and a future version changes the
 // policy check so the transaction is accepted, then that transaction could
 // cause the network to split between old nodes and new nodes.
 
 class BanMan {
 public:
     ~BanMan();
     BanMan(fs::path ban_file, const CChainParams &chainparams,
            CClientUIInterface *client_interface, int64_t default_ban_time);
     void Ban(const CNetAddr &net_addr, int64_t ban_time_offset = 0,
              bool since_unix_epoch = false);
     void Ban(const CSubNet &sub_net, int64_t ban_time_offset = 0,
              bool since_unix_epoch = false);
     void Discourage(const CNetAddr &net_addr);
     void ClearBanned();
 
     //! Return whether net_addr is banned
     bool IsBanned(const CNetAddr &net_addr);
 
     //! Return whether sub_net is exactly banned
     bool IsBanned(const CSubNet &sub_net);
 
     //! Return whether net_addr is discouraged.
     bool IsDiscouraged(const CNetAddr &net_addr);
 
     bool Unban(const CNetAddr &net_addr);
     bool Unban(const CSubNet &sub_net);
     void GetBanned(banmap_t &banmap);
     void DumpBanlist();
 
 private:
     void SetBanned(const banmap_t &banmap);
     bool BannedSetIsDirty();
     //! set the "dirty" flag for the banlist
     void SetBannedSetDirty(bool dirty = true);
     //! clean unused entries (if bantime has expired)
     void SweepBanned();
 
     RecursiveMutex m_cs_banned;
     banmap_t m_banned GUARDED_BY(m_cs_banned);
     bool m_is_dirty GUARDED_BY(m_cs_banned);
     CClientUIInterface *m_client_interface = nullptr;
     CBanDB m_ban_db;
     const int64_t m_default_ban_time;
     CRollingBloomFilter m_discouraged GUARDED_BY(m_cs_banned){50000, 0.000001};
 };
 
 #endif // BITCOIN_BANMAN_H
diff --git a/src/interfaces/node.h b/src/interfaces/node.h
index e312eda4f..f0b67b36a 100644
--- a/src/interfaces/node.h
+++ b/src/interfaces/node.h
@@ -1,289 +1,290 @@
 // Copyright (c) 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.
 
 #ifndef BITCOIN_INTERFACES_NODE_H
 #define BITCOIN_INTERFACES_NODE_H
 
-#include <addrdb.h>                    // For banmap_t
-#include <amount.h>                    // For Amount
-#include <net.h>                       // For CConnman::NumConnections
-#include <netaddress.h>                // For Network
+#include <amount.h>     // For Amount
+#include <net.h>        // For CConnman::NumConnections
+#include <net_types.h>  // For banmap_t
+#include <netaddress.h> // For Network
+
 #include <support/allocators/secure.h> // For SecureString
 
 #include <cstddef>
 #include <cstdint>
 #include <functional>
 #include <memory>
 #include <string>
 #include <tuple>
 #include <vector>
 
 class BanMan;
 class CCoinControl;
 class CFeeRate;
 struct CNodeStateStats;
 struct CNodeStats;
 class Coin;
 class Config;
 class HTTPRPCRequestProcessor;
 struct NodeContext;
 class proxyType;
 class RPCServer;
 class RPCTimerInterface;
 class UniValue;
 enum class WalletCreationStatus;
 
 namespace interfaces {
 class Handler;
 class Wallet;
 
 //! Top-level interface for a bitcoin node (bitcoind process).
 class Node {
 public:
     virtual ~Node() {}
 
     //! Send init error.
     virtual void initError(const std::string &message) = 0;
 
     //! Set command line arguments.
     virtual bool parseParameters(int argc, const char *const argv[],
                                  std::string &error) = 0;
 
     //! Set a command line argument if it doesn't already have a value
     virtual bool softSetArg(const std::string &arg,
                             const std::string &value) = 0;
 
     //! Set a command line boolean argument if it doesn't already have a value
     virtual bool softSetBoolArg(const std::string &arg, bool value) = 0;
 
     //! Load settings from configuration file.
     virtual bool readConfigFiles(std::string &error) = 0;
 
     //! Choose network parameters.
     virtual void selectParams(const std::string &network) = 0;
 
     //! Get the (assumed) blockchain size.
     virtual uint64_t getAssumedBlockchainSize() = 0;
 
     //! Get the (assumed) chain state size.
     virtual uint64_t getAssumedChainStateSize() = 0;
 
     //! Get network name.
     virtual std::string getNetwork() = 0;
 
     //! Init logging.
     virtual void initLogging() = 0;
 
     //! Init parameter interaction.
     virtual void initParameterInteraction() = 0;
 
     //! Get warnings.
     virtual std::string getWarnings(const std::string &type) = 0;
 
     //! Initialize app dependencies.
     virtual bool baseInitialize(Config &config) = 0;
 
     //! Start node.
     virtual bool
     appInitMain(Config &config, RPCServer &rpcServer,
                 HTTPRPCRequestProcessor &httpRPCRequestProcessor) = 0;
 
     //! Stop node.
     virtual void appShutdown() = 0;
 
     //! Start shutdown.
     virtual void startShutdown() = 0;
 
     //! Return whether shutdown was requested.
     virtual bool shutdownRequested() = 0;
 
     //! Setup arguments
     virtual void setupServerArgs() = 0;
 
     //! Map port.
     virtual void mapPort(bool use_upnp) = 0;
 
     //! Get proxy.
     virtual bool getProxy(Network net, proxyType &proxy_info) = 0;
 
     //! Get number of connections.
     virtual size_t getNodeCount(CConnman::NumConnections flags) = 0;
 
     //! Get stats for connected nodes.
     using NodesStats =
         std::vector<std::tuple<CNodeStats, bool, CNodeStateStats>>;
     virtual bool getNodesStats(NodesStats &stats) = 0;
 
     //! Get ban map entries.
     virtual bool getBanned(banmap_t &banmap) = 0;
 
     //! Ban node.
     virtual bool ban(const CNetAddr &net_addr, int64_t ban_time_offset) = 0;
 
     //! Unban node.
     virtual bool unban(const CSubNet &ip) = 0;
 
     //! Disconnect node by address.
     virtual bool disconnect(const CNetAddr &net_addr) = 0;
 
     //! Disconnect node by id.
     virtual bool disconnect(NodeId id) = 0;
 
     //! Get total bytes recv.
     virtual int64_t getTotalBytesRecv() = 0;
 
     //! Get total bytes sent.
     virtual int64_t getTotalBytesSent() = 0;
 
     //! Get mempool size.
     virtual size_t getMempoolSize() = 0;
 
     //! Get mempool dynamic usage.
     virtual size_t getMempoolDynamicUsage() = 0;
 
     //! Get header tip height and time.
     virtual bool getHeaderTip(int &height, int64_t &block_time) = 0;
 
     //! Get num blocks.
     virtual int getNumBlocks() = 0;
 
     //! Get last block time.
     virtual int64_t getLastBlockTime() = 0;
 
     //! Get verification progress.
     virtual double getVerificationProgress() = 0;
 
     //! Is initial block download.
     virtual bool isInitialBlockDownload() = 0;
 
     //! Get reindex.
     virtual bool getReindex() = 0;
 
     //! Get importing.
     virtual bool getImporting() = 0;
 
     //! Set network active.
     virtual void setNetworkActive(bool active) = 0;
 
     //! Get network active.
     virtual bool getNetworkActive() = 0;
 
     //! Estimate smart fee.
     virtual CFeeRate estimateSmartFee() = 0;
 
     //! Get dust relay fee.
     virtual CFeeRate getDustRelayFee() = 0;
 
     //! Execute rpc command.
     virtual UniValue executeRpc(Config &config, const std::string &command,
                                 const UniValue &params,
                                 const std::string &uri) = 0;
 
     //! List rpc commands.
     virtual std::vector<std::string> listRpcCommands() = 0;
 
     //! Set RPC timer interface if unset.
     virtual void rpcSetTimerInterfaceIfUnset(RPCTimerInterface *iface) = 0;
 
     //! Unset RPC timer interface.
     virtual void rpcUnsetTimerInterface(RPCTimerInterface *iface) = 0;
 
     //! Get unspent outputs associated with a transaction.
     virtual bool getUnspentOutput(const COutPoint &output, Coin &coin) = 0;
 
     //! Return default wallet directory.
     virtual std::string getWalletDir() = 0;
 
     //! Return available wallets in wallet directory.
     virtual std::vector<std::string> listWalletDir() = 0;
 
     //! Return interfaces for accessing wallets (if any).
     virtual std::vector<std::unique_ptr<Wallet>> getWallets() = 0;
 
     //! Attempts to load a wallet from file or directory.
     //! The loaded wallet is also notified to handlers previously registered
     //! with handleLoadWallet.
     virtual std::unique_ptr<Wallet>
     loadWallet(const CChainParams &params, const std::string &name,
                std::string &error,
                std::vector<std::string> &warnings) const = 0;
 
     //! Create a wallet from file
     virtual WalletCreationStatus
     createWallet(const CChainParams &params, const SecureString &passphrase,
                  uint64_t wallet_creation_flags, const std::string &name,
                  std::string &error, std::vector<std::string> &warnings,
                  std::unique_ptr<Wallet> &result) = 0;
 
     //! Register handler for init messages.
     using InitMessageFn = std::function<void(const std::string &message)>;
     virtual std::unique_ptr<Handler> handleInitMessage(InitMessageFn fn) = 0;
 
     //! Register handler for message box messages.
     using MessageBoxFn =
         std::function<bool(const std::string &message,
                            const std::string &caption, unsigned int style)>;
     virtual std::unique_ptr<Handler> handleMessageBox(MessageBoxFn fn) = 0;
 
     //! Register handler for question messages.
     using QuestionFn = std::function<bool(
         const std::string &message, const std::string &non_interactive_message,
         const std::string &caption, unsigned int style)>;
     virtual std::unique_ptr<Handler> handleQuestion(QuestionFn fn) = 0;
 
     //! Register handler for progress messages.
     using ShowProgressFn = std::function<void(
         const std::string &title, int progress, bool resume_possible)>;
     virtual std::unique_ptr<Handler> handleShowProgress(ShowProgressFn fn) = 0;
 
     //! Register handler for load wallet messages.
     using LoadWalletFn = std::function<void(std::unique_ptr<Wallet> wallet)>;
     virtual std::unique_ptr<Handler> handleLoadWallet(LoadWalletFn fn) = 0;
 
     //! Register handler for number of connections changed messages.
     using NotifyNumConnectionsChangedFn =
         std::function<void(int new_num_connections)>;
     virtual std::unique_ptr<Handler>
     handleNotifyNumConnectionsChanged(NotifyNumConnectionsChangedFn fn) = 0;
 
     //! Register handler for network active messages.
     using NotifyNetworkActiveChangedFn =
         std::function<void(bool network_active)>;
     virtual std::unique_ptr<Handler>
     handleNotifyNetworkActiveChanged(NotifyNetworkActiveChangedFn fn) = 0;
 
     //! Register handler for notify alert messages.
     using NotifyAlertChangedFn = std::function<void()>;
     virtual std::unique_ptr<Handler>
     handleNotifyAlertChanged(NotifyAlertChangedFn fn) = 0;
 
     //! Register handler for ban list messages.
     using BannedListChangedFn = std::function<void()>;
     virtual std::unique_ptr<Handler>
     handleBannedListChanged(BannedListChangedFn fn) = 0;
 
     //! Register handler for block tip messages.
     using NotifyBlockTipFn =
         std::function<void(bool initial_download, int height,
                            int64_t block_time, double verification_progress)>;
     virtual std::unique_ptr<Handler>
     handleNotifyBlockTip(NotifyBlockTipFn fn) = 0;
 
     //! Register handler for header tip messages.
     using NotifyHeaderTipFn =
         std::function<void(bool initial_download, int height,
                            int64_t block_time, double verification_progress)>;
     virtual std::unique_ptr<Handler>
     handleNotifyHeaderTip(NotifyHeaderTipFn fn) = 0;
 
     //! Return pointer to internal chain interface, useful for testing.
     virtual NodeContext *context() { return nullptr; }
 };
 
 //! Return implementation of Node interface.
 std::unique_ptr<Node> MakeNode();
 
 } // namespace interfaces
 
 #endif // BITCOIN_INTERFACES_NODE_H
diff --git a/src/net_types.h b/src/net_types.h
new file mode 100644
index 000000000..d55a8cde6
--- /dev/null
+++ b/src/net_types.h
@@ -0,0 +1,15 @@
+// Copyright (c) 2019 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_NET_TYPES_H
+#define BITCOIN_NET_TYPES_H
+
+#include <map>
+
+class CBanEntry;
+class CSubNet;
+
+using banmap_t = std::map<CSubNet, CBanEntry>;
+
+#endif // BITCOIN_NET_TYPES_H
diff --git a/src/qt/bantablemodel.cpp b/src/qt/bantablemodel.cpp
index caa7b1691..b1c9ec7a2 100644
--- a/src/qt/bantablemodel.cpp
+++ b/src/qt/bantablemodel.cpp
@@ -1,167 +1,167 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <qt/bantablemodel.h>
 
-#include <qt/clientmodel.h>
-
 #include <interfaces/node.h>
+#include <net_types.h> // For banmap_t
+#include <qt/clientmodel.h>
 
 #include <algorithm>
 
 #include <QDebug>
 #include <QList>
 
 bool BannedNodeLessThan::operator()(const CCombinedBan &left,
                                     const CCombinedBan &right) const {
     const CCombinedBan *pLeft = &left;
     const CCombinedBan *pRight = &right;
 
     if (order == Qt::DescendingOrder) {
         std::swap(pLeft, pRight);
     }
 
     switch (column) {
         case BanTableModel::Address:
             return pLeft->subnet.ToString().compare(pRight->subnet.ToString()) <
                    0;
         case BanTableModel::Bantime:
             return pLeft->banEntry.nBanUntil < pRight->banEntry.nBanUntil;
     }
 
     return false;
 }
 
 // private implementation
 class BanTablePriv {
 public:
     /** Local cache of peer information */
     QList<CCombinedBan> cachedBanlist;
     /** Column to sort nodes by (default to unsorted) */
     int sortColumn{-1};
     /** Order (ascending or descending) to sort nodes by */
     Qt::SortOrder sortOrder;
 
     /** Pull a full list of banned nodes from CNode into our cache */
     void refreshBanlist(interfaces::Node &node) {
         banmap_t banMap;
         node.getBanned(banMap);
 
         cachedBanlist.clear();
         cachedBanlist.reserve(banMap.size());
         for (const auto &entry : banMap) {
             CCombinedBan banEntry;
             banEntry.subnet = entry.first;
             banEntry.banEntry = entry.second;
             cachedBanlist.append(banEntry);
         }
 
         if (sortColumn >= 0) {
             // sort cachedBanlist (use stable sort to prevent rows jumping
             // around unnecessarily)
             std::stable_sort(cachedBanlist.begin(), cachedBanlist.end(),
                              BannedNodeLessThan(sortColumn, sortOrder));
         }
     }
 
     int size() const { return cachedBanlist.size(); }
 
     CCombinedBan *index(int idx) {
         if (idx >= 0 && idx < cachedBanlist.size()) {
             return &cachedBanlist[idx];
         }
 
         return nullptr;
     }
 };
 
 BanTableModel::BanTableModel(interfaces::Node &node, ClientModel *parent)
     : QAbstractTableModel(parent), m_node(node), clientModel(parent) {
     columns << tr("IP/Netmask") << tr("Banned Until");
     priv.reset(new BanTablePriv());
 
     // load initial data
     refresh();
 }
 
 BanTableModel::~BanTableModel() {
     // Intentionally left empty
 }
 
 int BanTableModel::rowCount(const QModelIndex &parent) const {
     Q_UNUSED(parent);
     return priv->size();
 }
 
 int BanTableModel::columnCount(const QModelIndex &parent) const {
     Q_UNUSED(parent);
     return columns.length();
 }
 
 QVariant BanTableModel::data(const QModelIndex &index, int role) const {
     if (!index.isValid()) {
         return QVariant();
     }
 
     CCombinedBan *rec = static_cast<CCombinedBan *>(index.internalPointer());
 
     if (role == Qt::DisplayRole) {
         switch (index.column()) {
             case Address:
                 return QString::fromStdString(rec->subnet.ToString());
             case Bantime:
                 QDateTime date = QDateTime::fromMSecsSinceEpoch(0);
                 date = date.addSecs(rec->banEntry.nBanUntil);
                 return date.toString(Qt::SystemLocaleLongDate);
         }
     }
 
     return QVariant();
 }
 
 QVariant BanTableModel::headerData(int section, Qt::Orientation orientation,
                                    int role) const {
     if (orientation == Qt::Horizontal) {
         if (role == Qt::DisplayRole && section < columns.size()) {
             return columns[section];
         }
     }
     return QVariant();
 }
 
 Qt::ItemFlags BanTableModel::flags(const QModelIndex &index) const {
     if (!index.isValid()) {
         return Qt::NoItemFlags;
     }
 
     Qt::ItemFlags retval = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
     return retval;
 }
 
 QModelIndex BanTableModel::index(int row, int column,
                                  const QModelIndex &parent) const {
     Q_UNUSED(parent);
     CCombinedBan *data = priv->index(row);
 
     if (data) {
         return createIndex(row, column, data);
     }
     return QModelIndex();
 }
 
 void BanTableModel::refresh() {
     Q_EMIT layoutAboutToBeChanged();
     priv->refreshBanlist(m_node);
     Q_EMIT layoutChanged();
 }
 
 void BanTableModel::sort(int column, Qt::SortOrder order) {
     priv->sortColumn = column;
     priv->sortOrder = order;
     refresh();
 }
 
 bool BanTableModel::shouldShow() {
     return priv->size() > 0;
 }
diff --git a/src/rpc/net.cpp b/src/rpc/net.cpp
index d656950c4..4f501edcd 100644
--- a/src/rpc/net.cpp
+++ b/src/rpc/net.cpp
@@ -1,911 +1,912 @@
 // 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 <banman.h>
 #include <clientversion.h>
 #include <config.h>
 #include <core_io.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/system.h>
 #include <validation.h>
 #include <version.h>
 #include <warnings.h>
 
 #include <univalue.h>
 
 static UniValue getconnectioncount(const Config &config,
                                    const JSONRPCRequest &request) {
     RPCHelpMan{
         "getconnectioncount",
         "Returns the number of connections to other nodes.\n",
         {},
         RPCResult{"n          (numeric) The connection count\n"},
         RPCExamples{HelpExampleCli("getconnectioncount", "") +
                     HelpExampleRpc("getconnectioncount", "")},
     }
         .Check(request);
 
     if (!g_rpc_node->connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     return int(g_rpc_node->connman->GetNodeCount(CConnman::CONNECTIONS_ALL));
 }
 
 static UniValue ping(const Config &config, const JSONRPCRequest &request) {
     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",
         {},
         RPCResults{},
         RPCExamples{HelpExampleCli("ping", "") + HelpExampleRpc("ping", "")},
     }
         .Check(request);
 
     if (!g_rpc_node->connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     // Request that each node send a ping during next message processing pass
     g_rpc_node->connman->ForEachNode(
         [](CNode *pnode) { pnode->fPingQueued = true; });
     return NullUniValue;
 }
 
 static UniValue getpeerinfo(const Config &config,
                             const JSONRPCRequest &request) {
     RPCHelpMan{
         "getpeerinfo",
         "Returns data about each connected network node as a json array of "
         "objects.\n",
         {},
         RPCResult{
             "[\n"
             "  {\n"
             "    \"id\": n,                   (numeric) Peer index\n"
             "    \"addr\":\"host:port\",      (string) The IP address and port "
             "of the peer\n"
             "    \"addrbind\":\"ip:port\",    (string) Bind address of the "
             "connection to the peer\n"
             "    \"addrlocal\":\"ip:port\",   (string) Local address as "
             "reported by the peer\n"
             "    \"services\":\"xxxxxxxxxxxxxxxx\",   (string) The services "
             "offered\n"
             "    \"relaytxes\":true|false,    (boolean) Whether peer has asked "
             "us to relay transactions to it\n"
             "    \"lastsend\": ttt,           (numeric) The time in seconds "
             "since epoch (Jan 1 1970 GMT) of the last send\n"
             "    \"lastrecv\": ttt,           (numeric) The time in seconds "
             "since epoch (Jan 1 1970 GMT) of the last receive\n"
             "    \"bytessent\": n,            (numeric) The total bytes sent\n"
             "    \"bytesrecv\": n,            (numeric) The total bytes "
             "received\n"
             "    \"conntime\": ttt,           (numeric) The connection time in "
             "seconds since epoch (Jan 1 1970 GMT)\n"
             "    \"timeoffset\": ttt,         (numeric) The time offset in "
             "seconds\n"
             "    \"pingtime\": n,             (numeric) ping time (if "
             "available)\n"
             "    \"minping\": n,              (numeric) minimum observed ping "
             "time (if any at all)\n"
             "    \"pingwait\": n,             (numeric) ping wait (if "
             "non-zero)\n"
             "    \"version\": v,              (numeric) The peer version, such "
             "as 70001\n"
             "    \"subver\": \"/Satoshi:0.8.5/\",  (string) The string "
             "version\n"
             "    \"inbound\": true|false,     (boolean) Inbound (true) or "
             "Outbound (false)\n"
             "    \"addnode\": true|false,     (boolean) Whether connection was "
             "due to addnode/-connect or if it was an automatic/inbound "
             "connection\n"
             "    \"startingheight\": n,       (numeric) The starting height "
             "(block) of the peer\n"
             "    \"banscore\": n,             (numeric) The ban score\n"
             "    \"synced_headers\": n,       (numeric) The last header we "
             "have in common with this peer\n"
             "    \"synced_blocks\": n,        (numeric) The last block we have "
             "in common with this peer\n"
             "    \"inflight\": [\n"
             "       n,                        (numeric) The heights of blocks "
             "we're currently asking from this peer\n"
             "       ...\n"
             "    ],\n"
             "    \"whitelisted\": true|false, (boolean) Whether the peer is "
             "whitelisted\n"
             "    \"minfeefilter\": n,         (numeric) The minimum fee rate "
             "for transactions this peer accepts\n"
             "    \"bytessent_per_msg\": {\n"
             "       \"msg\": n,               (numeric) 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.\n"
             "       ...\n"
             "    },\n"
             "    \"bytesrecv_per_msg\": {\n"
             "       \"msg\": n,               (numeric) 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 of unknown "
             "message types are listed under '" +
             NET_MESSAGE_COMMAND_OTHER +
             "'.\n"
             "       ...\n"
             "    }\n"
             "  }\n"
             "  ,...\n"
             "]\n"},
         RPCExamples{HelpExampleCli("getpeerinfo", "") +
                     HelpExampleRpc("getpeerinfo", "")},
     }
         .Check(request);
 
     if (!g_rpc_node->connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     std::vector<CNodeStats> vstats;
     g_rpc_node->connman->GetNodeStats(vstats);
 
     UniValue ret(UniValue::VARR);
 
     for (const CNodeStats &stats : vstats) {
         UniValue obj(UniValue::VOBJ);
         CNodeStateStats statestats;
         bool fStateStats = GetNodeStateStats(stats.nodeid, statestats);
         obj.pushKV("id", stats.nodeid);
         obj.pushKV("addr", stats.addrName);
         if (!(stats.addrLocal.empty())) {
             obj.pushKV("addrlocal", stats.addrLocal);
         }
         if (stats.addrBind.IsValid()) {
             obj.pushKV("addrbind", stats.addrBind.ToString());
         }
         obj.pushKV("services", strprintf("%016x", stats.nServices));
         obj.pushKV("relaytxes", stats.fRelayTxes);
         obj.pushKV("lastsend", stats.nLastSend);
         obj.pushKV("lastrecv", stats.nLastRecv);
         obj.pushKV("bytessent", stats.nSendBytes);
         obj.pushKV("bytesrecv", stats.nRecvBytes);
         obj.pushKV("conntime", stats.nTimeConnected);
         obj.pushKV("timeoffset", stats.nTimeOffset);
         if (stats.m_ping_usec > 0) {
             obj.pushKV("pingtime", double(stats.m_ping_usec) / 1e6);
         }
         if (stats.m_min_ping_usec < std::numeric_limits<int64_t>::max()) {
             obj.pushKV("minping", double(stats.m_min_ping_usec) / 1e6);
         }
         if (stats.m_ping_wait_usec > 0) {
             obj.pushKV("pingwait", double(stats.m_ping_wait_usec) / 1e6);
         }
         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("addnode", stats.m_manual_connection);
         obj.pushKV("startingheight", stats.nStartingHeight);
         if (fStateStats) {
             obj.pushKV("banscore", statestats.nMisbehavior);
             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("whitelisted", stats.m_legacyWhitelisted);
         UniValue permissions(UniValue::VARR);
         for (const auto &permission :
              NetPermissions::ToStrings(stats.m_permissionFlags)) {
             permissions.push_back(permission);
         }
         obj.pushKV("permissions", permissions);
         obj.pushKV("minfeefilter", ValueFromAmount(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);
 
         ret.push_back(obj);
     }
 
     return ret;
 }
 
 static UniValue addnode(const Config &config, const JSONRPCRequest &request) {
     std::string strCommand;
     if (!request.params[1].isNull()) {
         strCommand = request.params[1].get_str();
     }
 
     if (request.fHelp || request.params.size() != 2 ||
         (strCommand != "onetry" && strCommand != "add" &&
          strCommand != "remove")) {
         throw std::runtime_error(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"},
             },
             RPCResults{},
             RPCExamples{
                 HelpExampleCli("addnode", "\"192.168.0.6:8333\" \"onetry\"") +
                 HelpExampleRpc("addnode", "\"192.168.0.6:8333\", \"onetry\"")},
         }
                                      .ToString());
     }
 
     if (!g_rpc_node->connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     std::string strNode = request.params[0].get_str();
 
     if (strCommand == "onetry") {
         CAddress addr;
         g_rpc_node->connman->OpenNetworkConnection(
             addr, false, nullptr, strNode.c_str(), false, false, true);
         return NullUniValue;
     }
 
     if ((strCommand == "add") && (!g_rpc_node->connman->AddNode(strNode))) {
         throw JSONRPCError(RPC_CLIENT_NODE_ALREADY_ADDED,
                            "Error: Node already added");
     } else if ((strCommand == "remove") &&
                (!g_rpc_node->connman->RemoveAddedNode(strNode))) {
         throw JSONRPCError(RPC_CLIENT_NODE_NOT_ADDED,
                            "Error: Node has not been added.");
     }
 
     return NullUniValue;
 }
 
 static UniValue disconnectnode(const Config &config,
                                const JSONRPCRequest &request) {
     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)"},
         },
         RPCResults{},
         RPCExamples{HelpExampleCli("disconnectnode", "\"192.168.0.6:8333\"") +
                     HelpExampleCli("disconnectnode", "\"\" 1") +
                     HelpExampleRpc("disconnectnode", "\"192.168.0.6:8333\"") +
                     HelpExampleRpc("disconnectnode", "\"\", 1")},
     }
         .Check(request);
 
     if (!g_rpc_node->connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     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 = g_rpc_node->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 = g_rpc_node->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 UniValue getaddednodeinfo(const Config &config,
                                  const JSONRPCRequest &request) {
     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{
             "[\n"
             "  {\n"
             "    \"addednode\" : \"192.168.0.201\",   (string) The node IP "
             "address or name (as provided to addnode)\n"
             "    \"connected\" : true|false,          (boolean) If connected\n"
             "    \"addresses\" : [                    (list of objects) Only "
             "when connected = true\n"
             "       {\n"
             "         \"address\" : \"192.168.0.201:8333\",  (string) The "
             "bitcoin server IP and port we're connected to\n"
             "         \"connected\" : \"outbound\"           (string) "
             "connection, inbound or outbound\n"
             "       }\n"
             "     ]\n"
             "  }\n"
             "  ,...\n"
             "]\n"},
         RPCExamples{HelpExampleCli("getaddednodeinfo", "\"192.168.0.201\"") +
                     HelpExampleRpc("getaddednodeinfo", "\"192.168.0.201\"")},
     }
         .Check(request);
 
     if (!g_rpc_node->connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     std::vector<AddedNodeInfo> vInfo = g_rpc_node->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 UniValue getnettotals(const Config &config,
                              const JSONRPCRequest &request) {
     RPCHelpMan{
         "getnettotals",
         "Returns information about network traffic, including bytes in, "
         "bytes out,\n"
         "and current time.\n",
         {},
         RPCResult{"{\n"
                   "  \"totalbytesrecv\": n,   (numeric) Total bytes received\n"
                   "  \"totalbytessent\": n,   (numeric) Total bytes sent\n"
                   "  \"timemillis\": t,       (numeric) Current UNIX time in "
                   "milliseconds\n"
                   "  \"uploadtarget\":\n"
                   "  {\n"
                   "    \"timeframe\": n,                         (numeric) "
                   "Length of the measuring timeframe in seconds\n"
                   "    \"target\": n,                            (numeric) "
                   "Target in bytes\n"
                   "    \"target_reached\": true|false,           (boolean) "
                   "True if target is reached\n"
                   "    \"serve_historical_blocks\": true|false,  (boolean) "
                   "True if serving historical blocks\n"
                   "    \"bytes_left_in_cycle\": t,               (numeric) "
                   "Bytes left in current time cycle\n"
                   "    \"time_left_in_cycle\": t                 (numeric) "
                   "Seconds left in current time cycle\n"
                   "  }\n"
                   "}\n"},
         RPCExamples{HelpExampleCli("getnettotals", "") +
                     HelpExampleRpc("getnettotals", "")},
     }
         .Check(request);
 
     if (!g_rpc_node->connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("totalbytesrecv", g_rpc_node->connman->GetTotalBytesRecv());
     obj.pushKV("totalbytessent", g_rpc_node->connman->GetTotalBytesSent());
     obj.pushKV("timemillis", GetTimeMillis());
 
     UniValue outboundLimit(UniValue::VOBJ);
     outboundLimit.pushKV("timeframe",
                          g_rpc_node->connman->GetMaxOutboundTimeframe());
     outboundLimit.pushKV("target", g_rpc_node->connman->GetMaxOutboundTarget());
     outboundLimit.pushKV("target_reached",
                          g_rpc_node->connman->OutboundTargetReached(false));
     outboundLimit.pushKV("serve_historical_blocks",
                          !g_rpc_node->connman->OutboundTargetReached(true));
     outboundLimit.pushKV("bytes_left_in_cycle",
                          g_rpc_node->connman->GetOutboundTargetBytesLeft());
     outboundLimit.pushKV("time_left_in_cycle",
                          g_rpc_node->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_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 UniValue getnetworkinfo(const Config &config,
                                const JSONRPCRequest &request) {
     RPCHelpMan{
         "getnetworkinfo",
         "Returns an object containing various state info regarding P2P "
         "networking.\n",
         {},
         RPCResult{"{\n"
                   "  \"version\": xxxxx,                      (numeric) the "
                   "server version\n"
                   "  \"subversion\": \"/Satoshi:x.x.x/\",     (string) the "
                   "server subversion string\n"
                   "  \"protocolversion\": xxxxx,              (numeric) the "
                   "protocol version\n"
                   "  \"localservices\": \"xxxxxxxxxxxxxxxx\", (string) the "
                   "services we offer to the network\n"
                   "  \"localrelay\": true|false,              (bool) true if "
                   "transaction relay is requested from peers\n"
                   "  \"timeoffset\": xxxxx,                   (numeric) the "
                   "time offset\n"
                   "  \"connections\": xxxxx,                  (numeric) the "
                   "number of connections\n"
                   "  \"networkactive\": true|false,           (bool) whether "
                   "p2p networking is enabled\n"
                   "  \"networks\": [                          (array) "
                   "information per network\n"
                   "  {\n"
                   "    \"name\": \"xxx\",                     (string) network "
                   "(ipv4, ipv6 or onion)\n"
                   "    \"limited\": true|false,               (boolean) is the "
                   "network limited using -onlynet?\n"
                   "    \"reachable\": true|false,             (boolean) is the "
                   "network reachable?\n"
                   "    \"proxy\": \"host:port\"               (string) the "
                   "proxy that is used for this network, or empty if none\n"
                   "    \"proxy_randomize_credentials\": true|false,  (string) "
                   "Whether randomized credentials are used\n"
                   "  }\n"
                   "  ,...\n"
                   "  ],\n"
                   "  \"relayfee\": x.xxxxxxxx,                (numeric) "
                   "minimum relay fee for transactions in " +
                   CURRENCY_UNIT +
                   "/kB\n"
                   "  \"excessutxocharge\": x.xxxxxxxx,        (numeric) "
                   "minimum charge for excess utxos in " +
                   CURRENCY_UNIT +
                   "\n"
                   "  \"localaddresses\": [                    (array) list of "
                   "local addresses\n"
                   "  {\n"
                   "    \"address\": \"xxxx\",                 (string) network "
                   "address\n"
                   "    \"port\": xxx,                         (numeric) "
                   "network port\n"
                   "    \"score\": xxx                         (numeric) "
                   "relative score\n"
                   "  }\n"
                   "  ,...\n"
                   "  ]\n"
                   "  \"warnings\": \"...\"                    (string) any "
                   "network and blockchain warnings\n"
                   "}\n"},
         RPCExamples{HelpExampleCli("getnetworkinfo", "") +
                     HelpExampleRpc("getnetworkinfo", "")},
     }
         .Check(request);
 
     LOCK(cs_main);
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("version", CLIENT_VERSION);
     obj.pushKV("subversion", userAgent(config));
     obj.pushKV("protocolversion", PROTOCOL_VERSION);
     if (g_rpc_node->connman) {
         obj.pushKV("localservices",
                    strprintf("%016x", g_rpc_node->connman->GetLocalServices()));
     }
     obj.pushKV("localrelay", g_relay_txes);
     obj.pushKV("timeoffset", GetTimeOffset());
     if (g_rpc_node->connman) {
         obj.pushKV("networkactive", g_rpc_node->connman->GetNetworkActive());
         obj.pushKV("connections", int(g_rpc_node->connman->GetNodeCount(
                                       CConnman::CONNECTIONS_ALL)));
     }
     obj.pushKV("networks", GetNetworksInfo());
     obj.pushKV("relayfee", ValueFromAmount(::minRelayTxFee.GetFeePerK()));
     obj.pushKV("excessutxocharge",
                ValueFromAmount(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("statusbar"));
     return obj;
 }
 
 static UniValue setban(const Config &config, const JSONRPCRequest &request) {
     const RPCHelpMan help{
         "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 in seconds "
              "since epoch (Jan 1 1970 GMT)"},
         },
         RPCResults{},
         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")},
     };
 
     std::string strCommand;
     if (!request.params[1].isNull()) {
         strCommand = request.params[1].get_str();
     }
 
     if (request.fHelp || !help.IsValidNumArgs(request.params.size()) ||
         (strCommand != "add" && strCommand != "remove")) {
         throw std::runtime_error(help.ToString());
     }
 
     if (!g_rpc_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().c_str(), resolved, false);
         netAddr = resolved;
     } else {
         LookupSubNet(request.params[0].get_str().c_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 ? g_rpc_node->banman->IsBanned(subNet)
                      : g_rpc_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) {
             g_rpc_node->banman->Ban(subNet, banTime, absolute);
             if (g_rpc_node->connman) {
                 g_rpc_node->connman->DisconnectNode(subNet);
             }
         } else {
             g_rpc_node->banman->Ban(netAddr, banTime, absolute);
             if (g_rpc_node->connman) {
                 g_rpc_node->connman->DisconnectNode(netAddr);
             }
         }
     } else if (strCommand == "remove") {
         if (!(isSubnet ? g_rpc_node->banman->Unban(subNet)
                        : g_rpc_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 UniValue listbanned(const Config &config,
                            const JSONRPCRequest &request) {
     RPCHelpMan{
         "listbanned",
         "List all manually banned IPs/Subnets.\n",
         {},
         RPCResults{},
         RPCExamples{HelpExampleCli("listbanned", "") +
                     HelpExampleRpc("listbanned", "")},
     }
         .Check(request);
 
     if (!g_rpc_node->banman) {
         throw JSONRPCError(RPC_DATABASE_ERROR,
                            "Error: Ban database not loaded");
     }
 
     banmap_t banMap;
     g_rpc_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 UniValue clearbanned(const Config &config,
                             const JSONRPCRequest &request) {
     RPCHelpMan{
         "clearbanned",
         "Clear all banned IPs.\n",
         {},
         RPCResults{},
         RPCExamples{HelpExampleCli("clearbanned", "") +
                     HelpExampleRpc("clearbanned", "")},
     }
         .Check(request);
 
     if (!g_rpc_node->banman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     g_rpc_node->banman->ClearBanned();
 
     return NullUniValue;
 }
 
 static UniValue setnetworkactive(const Config &config,
                                  const JSONRPCRequest &request) {
     RPCHelpMan{
         "setnetworkactive",
         "Disable/enable all p2p network activity.\n",
         {
             {"state", RPCArg::Type::BOOL, RPCArg::Optional::NO,
              "true to enable networking, false to disable"},
         },
         RPCResults{},
         RPCExamples{""},
     }
         .Check(request);
 
     if (!g_rpc_node->connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     g_rpc_node->connman->SetNetworkActive(request.params[0].get_bool());
 
     return g_rpc_node->connman->GetNetworkActive();
 }
 
 static UniValue getnodeaddresses(const Config &config,
                                  const JSONRPCRequest &request) {
     RPCHelpMan{
         "getnodeaddresses",
         "Return known addresses which can potentially be used to find new "
         "nodes in the network\n",
         {
             {"count", RPCArg::Type::NUM, /* default */ "1",
              "How many addresses to return. Limited to the smaller of " +
                  std::to_string(ADDRMAN_GETADDR_MAX) + " or " +
                  std::to_string(ADDRMAN_GETADDR_MAX_PCT) +
                  "% of all known addresses."},
         },
         RPCResult{
             "[\n"
             "  {\n"
             "    \"time\": ttt,                (numeric) Timestamp in seconds "
             "since epoch (Jan 1 1970 GMT) keeping track of when the node was "
             "last seen\n"
             "    \"services\": n,              (numeric) The services offered\n"
             "    \"address\": \"host\",        (string) The address of the "
             "node\n"
             "    \"port\": n                   (numeric) The port of the node\n"
             "  }\n"
             "  ,....\n"
             "]\n"},
         RPCExamples{HelpExampleCli("getnodeaddresses", "8") +
                     HelpExampleRpc("getnodeaddresses", "8")},
     }
         .Check(request);
 
     if (!g_rpc_node->connman) {
         throw JSONRPCError(
             RPC_CLIENT_P2P_DISABLED,
             "Error: Peer-to-peer functionality missing or disabled");
     }
 
     int count = 1;
     if (!request.params[0].isNull()) {
         count = request.params[0].get_int();
         if (count <= 0) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Address count out of range");
         }
     }
     // returns a shuffled list of CAddress
     std::vector<CAddress> vAddr = g_rpc_node->connman->GetAddresses();
     UniValue ret(UniValue::VARR);
 
     int address_return_count = std::min<int>(count, vAddr.size());
     for (int i = 0; i < address_return_count; ++i) {
         UniValue obj(UniValue::VOBJ);
         const CAddress &addr = vAddr[i];
         obj.pushKV("time", int(addr.nTime));
         obj.pushKV("services", uint64_t(addr.nServices));
         obj.pushKV("address", addr.ToStringIP());
         obj.pushKV("port", addr.GetPort());
         ret.push_back(obj);
     }
     return ret;
 }
 
 // clang-format off
 static const CRPCCommand commands[] = {
     //  category            name                      actor (function)        argNames
     //  ------------------- ------------------------  ----------------------  ----------
     { "network",            "getconnectioncount",     getconnectioncount,     {} },
     { "network",            "ping",                   ping,                   {} },
     { "network",            "getpeerinfo",            getpeerinfo,            {} },
     { "network",            "addnode",                addnode,                {"node","command"} },
     { "network",            "disconnectnode",         disconnectnode,         {"address", "nodeid"} },
     { "network",            "getaddednodeinfo",       getaddednodeinfo,       {"node"} },
     { "network",            "getnettotals",           getnettotals,           {} },
     { "network",            "getnetworkinfo",         getnetworkinfo,         {} },
     { "network",            "setban",                 setban,                 {"subnet", "command", "bantime", "absolute"} },
     { "network",            "listbanned",             listbanned,             {} },
     { "network",            "clearbanned",            clearbanned,            {} },
     { "network",            "setnetworkactive",       setnetworkactive,       {"state"} },
     { "network",            "getnodeaddresses",       getnodeaddresses,       {"count"} },
 };
 // clang-format on
 
 void RegisterNetRPCCommands(CRPCTable &t) {
     for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {
         t.appendCommand(commands[vcidx].name, &commands[vcidx]);
     }
 }