pool: hoist ban/whitelist subsystem into pool::SharechainNode (kill node.cpp drift, slice 1) (#758)

node.cpp is copy-pasted across ltc/btc/bch/dgb. This introduces the
intermediate layer pool::SharechainNode<Config,ShareChain,Peer> between
pool::BaseNode and each coin's NodeImpl, and hoists the FIRST byte-identical,
coin-agnostic, non-consensus block into it: the peer ban-list + whitelist
subsystem.

Hoisted (verified byte-identical across all four coins, coin namespace aside):
  is_banned, is_whitelisted, set_ban_duration, set_whitelist_path,
  load_whitelist_from_disk, save_whitelist_to_disk,
  admin_list_bans, admin_ban_ip, admin_unban_ip, admin_list_whitelist,
  admin_whitelist_remove, and the build_bans_json/build_whitelist_json helpers,
  plus the members m_ban_list, m_ip_ban_list, m_ban_duration,
  m_whitelist_ips, m_whitelist_hosts, m_whitelist_path.

This slice is deliberately limited to the self-contained ban/whitelist surface:
every hoisted method touches ONLY members that move with it, so no dependent-base
qualification is needed and no consensus/sharechain-timing state is involved. The
bodies are relocated unchanged — pure de-duplication, behaviour identical.

The connection-coupled admin endpoints (admin_whitelist_add, admin_list_peers,
admin_drop_peer, admin_dial_peer) stay in NodeImpl for now: they reach into
BaseNode's connection maps and the outbound-dial members, so they belong to a
later slice that also hoists the outbound-connection manager.

DASH (still the 668-line skeleton, no ban/whitelist block yet) is untouched and
continues to derive from pool::BaseNode directly; it inherits this layer for free
once its node quick-wire lands and gives it the same block.

Net: -688 lines across the four coins, +243-line shared header (one source of
truth for four copies).

Regression evidence (this environment, system Boost/leveldb):
  - c2pool-{ltc,btc,bch,dgb,dash} all build green.
  - test_ltc_node: PASS.
  - core_test: 56/56 PASS (incl. version-gate transition suite).
  - ltc_pool_test harness constructs the node through the new base and enters the
    run loop with no crash.

Co-authored-by: integrator <integrator@morisguide.com>

Author: frstrtr

src/impl/bch/node.cpp

@@ -2175,155 +2175,18 @@ void NodeImpl::clean_tracker()
     }); // end of m_think_pool lambda
 }
 
-bool NodeImpl::is_whitelisted(const NetService& addr) const
-{
-    const std::string ip = addr.address();
-    if (m_whitelist_ips.contains(ip)) return true;
-    if (m_whitelist_hosts.contains(addr)) return true;
-    return false;
-}
 
-bool NodeImpl::is_banned(const NetService& addr) const
-{
-    // Whitelist bypass: permanent dial targets are immune to bans.
-    if (is_whitelisted(addr)) return false;
-
-    auto now = std::chrono::steady_clock::now();
-    auto it = m_ban_list.find(addr);
-    if (it != m_ban_list.end() && it->second > now) return true;
-
-    auto ip_it = m_ip_ban_list.find(addr.address());
-    if (ip_it != m_ip_ban_list.end() && ip_it->second > now) return true;
-
-    return false;
-}
 
 // ── Admin API implementation ──────────────────────────────────────────
 
-void NodeImpl::set_whitelist_path(const std::string& path)
-{
-    m_whitelist_path = path;
-    if (!path.empty()) load_whitelist_from_disk();
-}
 
-void NodeImpl::load_whitelist_from_disk()
-{
-    if (m_whitelist_path.empty()) return;
-    std::ifstream f(m_whitelist_path);
-    if (!f) return;
-    try {
-        nlohmann::json j;
-        f >> j;
-        if (!j.contains("entries") || !j["entries"].is_array()) return;
-        for (const auto& e : j["entries"]) {
-            if (!e.contains("host") || !e.contains("port")) continue;
-            std::string host = e["host"].get<std::string>();
-            uint16_t port = e["port"].get<uint16_t>();
-            m_whitelist_ips.insert(host);
-            m_whitelist_hosts.insert(NetService(host, port));
-        }
-        LOG_INFO << "[Pool] Loaded " << m_whitelist_hosts.size()
-                 << " whitelist entries from " << m_whitelist_path;
-    } catch (const std::exception& e) {
-        LOG_WARNING << "[Pool] Failed to parse whitelist " << m_whitelist_path
-                    << ": " << e.what();
-    }
-}
 
-void NodeImpl::save_whitelist_to_disk() const
-{
-    if (m_whitelist_path.empty()) return;
-    try {
-        nlohmann::json j;
-        j["version"] = 1;
-        auto arr = nlohmann::json::array();
-        auto now_unix = std::chrono::duration_cast<std::chrono::seconds>(
-            std::chrono::system_clock::now().time_since_epoch()).count();
-        for (const auto& host : m_whitelist_hosts) {
-            arr.push_back({
-                {"host", host.address()},
-                {"port", host.port()},
-                {"added_unix", now_unix}
-            });
-        }
-        j["entries"] = arr;
-        std::string tmp = m_whitelist_path + ".new";
-        {
-            std::ofstream f(tmp);
-            f << j.dump(2);
-        }
-        std::filesystem::rename(tmp, m_whitelist_path);
-    } catch (const std::exception& e) {
-        LOG_WARNING << "[Pool] Failed to persist whitelist: " << e.what();
-    }
-}
 
-static nlohmann::json build_bans_json(
-    const std::map<NetService, std::chrono::steady_clock::time_point>& peer_bans,
-    const std::map<std::string, std::chrono::steady_clock::time_point>& ip_bans)
-{
-    auto now = std::chrono::steady_clock::now();
-    auto arr = nlohmann::json::array();
-    for (const auto& [addr, expiry] : peer_bans) {
-        if (expiry <= now) continue;
-        auto secs = std::chrono::duration_cast<std::chrono::seconds>(expiry - now).count();
-        arr.push_back({{"host", addr.address()}, {"port", addr.port()},
-                       {"expires_in_sec", secs}, {"source", "auto"}});
-    }
-    for (const auto& [ip, expiry] : ip_bans) {
-        if (expiry <= now) continue;
-        auto secs = std::chrono::duration_cast<std::chrono::seconds>(expiry - now).count();
-        arr.push_back({{"host", ip}, {"port", 0},
-                       {"expires_in_sec", secs}, {"source", "admin"}});
-    }
-    return arr;
-}
 
-static nlohmann::json build_whitelist_json(const std::set<NetService>& hosts)
-{
-    auto arr = nlohmann::json::array();
-    for (const auto& h : hosts)
-        arr.push_back({{"host", h.address()}, {"port", h.port()}});
-    return arr;
-}
 
-nlohmann::json NodeImpl::admin_list_bans() const
-{
-    return {{"ok", true}, {"bans", build_bans_json(m_ban_list, m_ip_ban_list)}};
-}
 
-nlohmann::json NodeImpl::admin_ban_ip(const std::string& ip, int duration_sec)
-{
-    if (ip.empty())
-        return {{"ok", false}, {"error", "ip required"}};
-    int dur = duration_sec > 0 ? duration_sec : static_cast<int>(m_ban_duration.count());
-    auto expiry = std::chrono::steady_clock::now() + std::chrono::seconds(dur);
-    m_ip_ban_list[ip] = expiry;
-    LOG_INFO << "[Pool] Admin ban: " << ip << " for " << dur << "s";
-    return {{"ok", true}, {"action", "ban"}, {"target", ip},
-            {"duration_sec", dur},
-            {"bans", build_bans_json(m_ban_list, m_ip_ban_list)}};
-}
 
-nlohmann::json NodeImpl::admin_unban_ip(const std::string& ip)
-{
-    if (ip.empty())
-        return {{"ok", false}, {"error", "ip required"}};
-    size_t removed = m_ip_ban_list.erase(ip);
-    for (auto it = m_ban_list.begin(); it != m_ban_list.end(); ) {
-        if (it->first.address() == ip) { it = m_ban_list.erase(it); ++removed; }
-        else ++it;
-    }
-    LOG_INFO << "[Pool] Admin unban: " << ip << " (" << removed << " entries removed)";
-    return {{"ok", true}, {"action", "unban"}, {"target", ip},
-            {"removed", removed},
-            {"bans", build_bans_json(m_ban_list, m_ip_ban_list)}};
-}
 
-nlohmann::json NodeImpl::admin_list_whitelist() const
-{
-    return {{"ok", true}, {"whitelist", build_whitelist_json(m_whitelist_hosts)}};
-}
 
 nlohmann::json NodeImpl::admin_whitelist_add(const std::string& host, uint16_t port)
 {
@@ -2352,23 +2215,6 @@ nlohmann::json NodeImpl::admin_whitelist_add(const std::string& host, uint16_t p
             {"whitelist", build_whitelist_json(m_whitelist_hosts)}};
 }
 
-nlohmann::json NodeImpl::admin_whitelist_remove(const std::string& host, uint16_t port)
-{
-    if (host.empty() || port == 0)
-        return {{"ok", false}, {"error", "host and port required"}};
-    NetService addr(host, port);
-    size_t removed_h = m_whitelist_hosts.erase(addr);
-    // Only remove the IP from whitelist if no other host:port remains for it.
-    bool other_on_same_ip = std::any_of(
-        m_whitelist_hosts.begin(), m_whitelist_hosts.end(),
-        [&](const NetService& n) { return n.address() == host; });
-    if (!other_on_same_ip) m_whitelist_ips.erase(host);
-    if (removed_h) save_whitelist_to_disk();
-    LOG_INFO << "[Pool] De-whitelisted " << addr.to_string();
-    return {{"ok", true}, {"action", "whitelist_remove"},
-            {"target", addr.to_string()}, {"removed", removed_h},
-            {"whitelist", build_whitelist_json(m_whitelist_hosts)}};
-}
 
 nlohmann::json NodeImpl::admin_list_peers() const
 {

src/impl/bch/node.hpp

@@ -28,6 +28,7 @@
 #include <core/version_gate.hpp>   // SSOT: core::version_gate::is_v36_active
 
 #include <pool/node.hpp>
+#include <pool/sharechain_node.hpp>
 #include <pool/protocol.hpp>
 #include <core/message.hpp>
 #include <core/reply_matcher.hpp>
@@ -53,8 +54,10 @@ struct ShareReplyData
     std::vector<chain::RawShare> m_raw_items;
 };
 
-class NodeImpl : public pool::BaseNode<bch::Config, bch::ShareChain, bch::Peer>
+class NodeImpl : public pool::SharechainNode<bch::Config, bch::ShareChain, bch::Peer>
 {
+
+    using base_t = pool::SharechainNode<bch::Config, bch::ShareChain, bch::Peer>;
     // Async share downloader:
     // ID = uint256 (matches sharereq id to sharereply id)
     // RESPONSE = parsed shares plus their original raw payloads
@@ -592,7 +595,6 @@ class NodeImpl : public pool::BaseNode<bch::Config, bch::ShareChain, bch::Peer>
     void set_max_peers(size_t count) { m_max_peers = count; }
 
     /// Set P2P ban duration (seconds).
-    void set_ban_duration(int seconds) { m_ban_duration = std::chrono::seconds(seconds); }
 
     /// Set cache size limits for memory control.
     void set_cache_limits(size_t max_shared, size_t max_known_txs, size_t max_raw) {
@@ -681,30 +683,22 @@ class NodeImpl : public pool::BaseNode<bch::Config, bch::ShareChain, bch::Peer>
     }
 
     /// Check whether a peer address is currently banned.
-    bool is_banned(const NetService& addr) const;
 
     /// ── Runtime admin API (pool peer bans + whitelist) ─────────────────
     /// All methods assumed to run on the io_context thread — callers
     /// (web_server HTTP handlers) dispatch via thread_safe_wrap().
     ///
     /// Returned JSON uses the shape:
     ///   {"ok": true|false, "error"?: "...", "bans": [...], "whitelist": [...]}
-    nlohmann::json admin_list_bans() const;
-    nlohmann::json admin_ban_ip(const std::string& ip, int duration_sec);
-    nlohmann::json admin_unban_ip(const std::string& ip);
-    nlohmann::json admin_list_whitelist() const;
     nlohmann::json admin_whitelist_add(const std::string& host, uint16_t port);
-    nlohmann::json admin_whitelist_remove(const std::string& host, uint16_t port);
     nlohmann::json admin_list_peers() const;
     nlohmann::json admin_drop_peer(const std::string& ip);
     nlohmann::json admin_dial_peer(const std::string& host, uint16_t port);
 
     /// Path to persisted whitelist file (~/.c2pool/pool_whitelist.json).
     /// Set by c2pool_refactored.cpp before start(); empty = no persistence.
-    void set_whitelist_path(const std::string& path);
 
     /// True if addr's IP matches a whitelist entry (IP or host:port).
-    bool is_whitelisted(const NetService& addr) const;
 
 protected:
     std::string m_software_version = "/c2pool:0.1/";  // overridden by set_software_version()
@@ -750,21 +744,13 @@ class NodeImpl : public pool::BaseNode<bch::Config, bch::ShareChain, bch::Peer>
     std::set<NetService> m_outbound_addrs;     // successfully connected outbound peers
 
     // Peer banning: maps address → ban expiry time
-    std::map<NetService, std::chrono::steady_clock::time_point> m_ban_list;
-    std::chrono::seconds m_ban_duration{300}; // 5 minutes (configurable)
 
     // IP-only manual bans (admin endpoint). Keyed by IP string so the
     // operator can ban/unban without knowing the peer's source port.
-    std::map<std::string, std::chrono::steady_clock::time_point> m_ip_ban_list;
 
     // Whitelist: IPs that bypass is_banned() and host:port entries kept as
     // permanent dial targets. Persists across restart via m_whitelist_path.
-    std::set<std::string> m_whitelist_ips;
-    std::set<NetService> m_whitelist_hosts;
-    std::string m_whitelist_path;
 
-    void load_whitelist_from_disk();
-    void save_whitelist_to_disk() const;
 
     // Rate-limiting no longer needed: think() runs on a dedicated compute
     // thread (m_think_pool), serialized by m_think_running atomic flag.