dash(embedded): fix CR-1 cold-start dial wedge + CR-2 dormant daemon-disjointness

Review of the CoinPeerManager port (#794) required two fixes, both in the new
--coin-p2p-discover opt-in path.

CR-1 — daemonless cold-start dial wedge: CoinClient::connect() early-returned on
an empty target list without arming the reconnect loop, and update_dial_targets()
ignored empty lists. So --coin-p2p-discover WITHOUT --coin-p2p-connect on a first
run with DNS unavailable (empty initial dial) armed nothing and wedged until
restart. Fix: connect() arms the 30s reconnect loop unconditionally (empty-plan
guard on the tick so current()/advance() never throw), and update_dial_targets()
kicks an immediate dial on the empty->non-empty transition — so the arm connects
as soon as fixed seeds (t+60s) / HTTP seeds (t+90s) arrive. Extracted
arm_reconnect_timer() helper. Regression pin added
(empty_connect_arms_without_wedging).

CR-2 — overlap filter + coind -20 penalty were dormant as wired: main_dash never
called set_getpeerinfo_fn, so m_coind_peers stayed empty and no peer was ever
Source::coind — the active daemon-disjointness never engaged (only passive
independence). Fix: added NodeRPC::getpeerinfo() to the DASH RPC (parses each
entry's addr, IPv6-bracket aware) and wired it in the discover path when a dashd
RPC is armed, so the -20 penalty + overlap filter engage in the connect+discover
/ oracle-shadow deployment. Absent RPC (fully daemonless) = seeds-only passive
independence. Mirrors main_ltc.cpp getpeerinfo wiring.

Nits: pinned target no longer duplicated in the dial list (pinned keys passed as
the get_peers_to_connect exclusion set); dead is_daemon_overlap_peer() removed;
declaration/destruction order corrected so the manager outlives the client and
refresh timer that borrow it.

Build clean; full test_dash_p2p_node target 23/23 (was 22 + CR-1 pin);
--selftest unchanged.

Author: frstrtr

src/c2pool/main_dash.cpp

@@ -731,12 +731,15 @@ int run_node(bool testnet, const std::string& rpc_endpoint,
     // layers, never conflated. The client rides the SAME ioc as the
     // sharechain node and stratum; declared after config/coin_state (both of
     // which it borrows), so it is destroyed before them at scope exit.
-    std::unique_ptr<dash::coin::p2p::CoinClient<dash::Config>> coin_p2p;
     // DASH-ISOLATED scored/diverse peer discovery (--coin-p2p-discover). Owns
     // its own peer table + seed bootstrap + scoring; feeds the single embedded
-    // connection an INDEPENDENT (non-dashd) diverse peer set. Declared BEFORE
-    // coin_p2p so it outlives the client that borrows it (reverse-destruction).
+    // connection an INDEPENDENT (non-dashd) diverse peer set. Declared FIRST of
+    // the three so it is destroyed LAST — the CoinClient's callbacks and the
+    // refresh timer both capture it by raw pointer, so it must outlive both.
     std::unique_ptr<dash::coin::DashCoinPeerManager> coin_peer_mgr;
+    std::unique_ptr<dash::coin::p2p::CoinClient<dash::Config>> coin_p2p;
+    // Refresh timer declared LAST -> destroyed FIRST: it stops (and its lambda
+    // stops capturing coin_p2p / coin_peer_mgr) before either is torn down.
     std::unique_ptr<core::Timer> coin_dial_refresh_timer;
     if (!coin_p2p_targets.empty() || coin_p2p_discover) {
         config.coin()->m_testnet = testnet;
@@ -770,6 +773,25 @@ int run_node(bool testnet, const std::string& rpc_endpoint,
             }
             coin_peer_mgr->set_dns_seeds(dash::coin::dash_dns_seeds(testnet));
             coin_peer_mgr->set_fixed_seeds(dash::coin::dash_fixed_seeds(testnet));
+
+            // ── ACTIVE daemon-disjointness (connect+discover / oracle-shadow) ──
+            // When a local dashd RPC is armed, feed its getpeerinfo so the
+            // manager tracks the daemon's OWN peers (m_coind_peers). That is
+            // what makes the coind-source -20 penalty AND the daemon-peer
+            // overlap filter engage — without it those ported mechanisms stay
+            // dormant (m_coind_peers empty => no peer ever Source::coind) and
+            // only passive independence holds. Mirrors main_ltc.cpp:5484.
+            // Absent RPC (fully daemonless) => seeds-only, passive independence.
+            if (rpc) {
+                coin_peer_mgr->set_getpeerinfo_fn(
+                    [rp = rpc.get()]() -> std::vector<NetService> {
+                        try { return rp->getpeerinfo(); }
+                        catch (...) { return {}; }
+                    });
+                std::cout << "[run]       daemon-disjointness ACTIVE: dashd getpeerinfo "
+                             "wired -> coind -20 penalty + overlap filter engage\n";
+            }
+
             coin_peer_mgr->start();
 
             // addr-crawl discoveries feed back into the manager (source-scored
@@ -787,11 +809,18 @@ int run_node(bool testnet, const std::string& rpc_endpoint,
                     mgr->notify_disconnected(s.to_string());
                 });
 
+            // Pinned keys: passed to get_peers_to_connect() as the "already
+            // handled" set so the protected pinned node (score 999999, always
+            // ranked first) is NOT also appended by the scorer — the pinned
+            // entries are prepended explicitly, so this dedups them out.
+            std::set<std::string> pinned_keys;
+            for (auto& t : coin_p2p_targets) pinned_keys.insert(t.to_string());
+
             // Initial dial plan: pinned local dashd first (preferred), then the
-            // top scored+diverse discovered peers.
+            // top scored+diverse discovered peers (pinned excluded from that set).
             std::vector<NetService> dial;
             for (auto& t : coin_p2p_targets) dial.push_back(t);
-            for (auto& ep : coin_peer_mgr->get_peers_to_connect({}))
+            for (auto& ep : coin_peer_mgr->get_peers_to_connect(pinned_keys))
                 dial.push_back(ep.to_net_service());
             coin_p2p->connect(dial);
 
@@ -801,9 +830,10 @@ int run_node(bool testnet, const std::string& rpc_endpoint,
             coin_dial_refresh_timer = std::make_unique<core::Timer>(&ioc, /*repeat=*/true);
             coin_dial_refresh_timer->start(60, [cp = coin_p2p.get(),
                                                 mgr = coin_peer_mgr.get(),
-                                                pinned = coin_p2p_targets]() {
-                std::vector<NetService> refreshed = pinned; // pinned always preferred
-                for (auto& ep : mgr->get_peers_to_connect({}))
+                                                pinned = coin_p2p_targets,
+                                                pinned_keys]() {
+                std::vector<NetService> refreshed = pinned; // pinned always preferred, first
+                for (auto& ep : mgr->get_peers_to_connect(pinned_keys))
                     refreshed.push_back(ep.to_net_service());
                 cp->update_dial_targets(std::move(refreshed));
             });

src/impl/dash/coin/coin_peer_manager.hpp

@@ -467,15 +467,6 @@ class DashCoinPeerManager
         return static_cast<int>(m_peers.size()) < m_config.max_peers;
     }
 
-    /// Whether a given peer key is the daemon's own peer (overlap filter).
-    /// Exposed so the dialer can prefer independent (non-overlapping) peers —
-    /// the crux of "different peers → independent mempool/relay view".
-    bool is_daemon_overlap_peer(const std::string& key) const
-    {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        return m_coind_peers.count(key) > 0;
-    }
-
     /// Remove peers that are exhausted (max attempts reached, not protected).
     void prune_dead_peers()
     {

src/impl/dash/coin/p2p_client.hpp

@@ -235,25 +235,27 @@ class CoinClient : public core::ICommunicator, public core::INetwork, public cor
 
     /// Dial the given targets with automatic reconnection (30s interval,
     /// round-robin over the target list on each retry).
+    ///
+    /// An EMPTY target list is legal in the --coin-p2p-discover cold-start case
+    /// (fresh peer-db + DNS unavailable): the reconnect loop is armed anyway and
+    /// simply idles (the empty-plan guard below), so when update_dial_targets()
+    /// later delivers seed-discovered peers (fixed seeds at t+60s / HTTP at
+    /// t+90s) the dial starts — no restart needed. Without this, an initially
+    /// empty discover peer set would wedge permanently.
     void connect(std::vector<NetService> targets)
     {
-        if (targets.empty()) return;
         m_dial_plan.set_targets(std::move(targets));
         m_reconnect_enabled = true;
-        LOG_INFO << "[" << m_chain_label << "] dialing "
-                 << m_dial_plan.current().to_string()
-                 << " (" << m_dial_plan.size() << " target[s] in plan)";
-        core::Factory<core::Client>::connect(m_dial_plan.current());
-
-        m_reconnect_timer = std::make_unique<core::Timer>(m_context, /*repeat=*/true);
-        m_reconnect_timer->start(RECONNECT_INTERVAL_SEC, [this]() {
-            if (!m_peer && m_reconnect_enabled) {
-                const auto& target = m_dial_plan.advance();
-                LOG_INFO << "[" << m_chain_label << "] reconnecting to "
-                         << target.to_string() << "...";
-                core::Factory<core::Client>::connect(target);
-            }
-        });
+        if (!m_dial_plan.empty()) {
+            LOG_INFO << "[" << m_chain_label << "] dialing "
+                     << m_dial_plan.current().to_string()
+                     << " (" << m_dial_plan.size() << " target[s] in plan)";
+            core::Factory<core::Client>::connect(m_dial_plan.current());
+        } else {
+            LOG_INFO << "[" << m_chain_label << "] no initial dial targets; "
+                        "reconnect loop armed, awaiting seed discovery";
+        }
+        arm_reconnect_timer();
     }
 
     /// Refresh the reconnect dial plan in place WITHOUT tearing the current
@@ -263,12 +265,24 @@ class CoinClient : public core::ICommunicator, public core::INetwork, public cor
     /// reconnect the single embedded connection rotates onto an INDEPENDENT
     /// peer — the mechanism that graduates the embedded arm to a network-
     /// standalone witness. Empty target lists are ignored (never wedge redial).
+    ///
+    /// Cold-start kick: if the plan was EMPTY (the discover daemonless case) and
+    /// we are currently disconnected with the reconnect loop armed, dial the
+    /// first new target immediately rather than waiting up to 30s for the next
+    /// reconnect tick — so the arm connects as soon as seeds arrive.
     void update_dial_targets(std::vector<NetService> targets)
     {
         if (targets.empty()) return;
+        bool was_empty = m_dial_plan.empty();
         m_dial_plan.set_targets(std::move(targets));
         LOG_DEBUG_COIND << "[" << m_chain_label << "] dial plan refreshed ("
                         << m_dial_plan.size() << " scored target[s])";
+        if (was_empty && !m_peer && m_reconnect_enabled) {
+            LOG_INFO << "[" << m_chain_label << "] cold-start dial "
+                     << m_dial_plan.current().to_string()
+                     << " (first seed-discovered target)";
+            core::Factory<core::Client>::connect(m_dial_plan.current());
+        }
     }
 
     // INetwork
@@ -460,6 +474,24 @@ class CoinClient : public core::ICommunicator, public core::INetwork, public cor
     }
 
 private:
+    /// Arm the 30s round-robin reconnect loop. The empty-plan guard makes it
+    /// safe to arm before any target exists (--coin-p2p-discover cold start):
+    /// the tick no-ops until update_dial_targets() supplies seed-discovered
+    /// peers, then rotates over them. current()/advance() on an empty plan
+    /// would throw, hence the guard.
+    void arm_reconnect_timer()
+    {
+        m_reconnect_timer = std::make_unique<core::Timer>(m_context, /*repeat=*/true);
+        m_reconnect_timer->start(RECONNECT_INTERVAL_SEC, [this]() {
+            if (!m_peer && m_reconnect_enabled && !m_dial_plan.empty()) {
+                const auto& target = m_dial_plan.advance();
+                LOG_INFO << "[" << m_chain_label << "] reconnecting to "
+                         << target.to_string() << "...";
+                core::Factory<core::Client>::connect(target);
+            }
+        });
+    }
+
     void ensure_timeout_timer()
     {
         if (!m_timeout_timer)

src/impl/dash/coin/rpc.cpp

@@ -528,6 +528,40 @@ std::string NodeRPC::getbestblockhash()
     return {};
 }
 
+// getpeerinfo -> the dashd's own connected-peer addresses. Each entry's "addr"
+// is "host:port" (IPv6 as "[::1]:9999"); parsed to NetService. Empty on a
+// non-array/absent result. Validation (routable/port) is the peer manager's.
+std::vector<NetService> NodeRPC::getpeerinfo()
+{
+    std::vector<NetService> peers;
+    auto result = CallAPIMethod("getpeerinfo");
+    if (!result.is_array())
+        return peers;
+    for (auto& entry : result)
+    {
+        if (!entry.contains("addr") || !entry["addr"].is_string())
+            continue;
+        std::string addr = entry["addr"].get<std::string>();
+        auto colon = addr.rfind(':');
+        if (colon == std::string::npos)
+            continue;
+        std::string host = addr.substr(0, colon);
+        uint16_t port = 0;
+        try {
+            port = static_cast<uint16_t>(std::stoul(addr.substr(colon + 1)));
+        } catch (...) {
+            continue;
+        }
+        // Strip IPv6 brackets: "[2001:db8::1]" -> "2001:db8::1".
+        if (host.size() >= 2 && host.front() == '[' && host.back() == ']')
+            host = host.substr(1, host.size() - 2);
+        if (host.empty() || port == 0)
+            continue;
+        peers.emplace_back(host, port);
+    }
+    return peers;
+}
+
 // verbose: true -- json result, false -- hex-encode result;
 nlohmann::json NodeRPC::getblockheader(uint256 header, bool verbose)
 {

src/impl/dash/coin/rpc.hpp

@@ -165,6 +165,14 @@ class NodeRPC : public jsonrpccxx::IClientConnector
     // template refresh without waiting on the 30 s staleness TTL. Empty string
     // on a null/absent result.
     std::string getbestblockhash();
+    // getpeerinfo -> the dashd's OWN connected-peer addresses (the "addr" field
+    // of each entry), parsed to NetService. Feeds the embedded
+    // DashCoinPeerManager's daemon-peer overlap filter + coind-source -20 score
+    // penalty so the embedded arm actively avoids mirroring the local dashd's
+    // peers (network-view disjointness). Returns empty on a null/absent result;
+    // transport errors propagate (the caller swallows them). No dashd config
+    // change required (getpeerinfo is a default RPC).
+    std::vector<NetService> getpeerinfo();
     // verbose: true -- json result, false -- hex-encode result;
     nlohmann::json getblockheader(uint256 header, bool verbose = true);
     // verbosity: 0 for hex-encoded data, 1 for a json object, and 2 for json object with transaction data

test/test_dash_coin_p2p_client.cpp

@@ -173,6 +173,23 @@ struct ClientRig
     }
 };
 
+// ── (b') Cold-start empty dial plan (daemonless --coin-p2p-discover) ────────
+//
+// Regression pin for the discover cold-start wedge: connect() with an EMPTY
+// target list (fresh peer-db + DNS unavailable) must NOT early-return into a
+// dead state — it arms the reconnect loop and idles, leaving the client
+// safely disconnected (no throw, no session) until seed-discovered peers land
+// via update_dial_targets(). An empty update is a safe no-op.
+TEST(DashCoinP2PClient, empty_connect_arms_without_wedging)
+{
+    ClientRig rig;
+    EXPECT_NO_THROW(rig.client.connect({}));      // empty initial dial plan
+    EXPECT_FALSE(rig.client.is_connected());
+    EXPECT_FALSE(rig.client.is_handshake_complete());
+    EXPECT_NO_THROW(rig.client.update_dial_targets({}));   // empty refresh: no-op
+    EXPECT_FALSE(rig.client.is_connected());
+}
+
 TEST(DashCoinP2PClient, client_completes_handshake_and_captures_peer_metadata)
 {
     ClientRig rig;