Phase 2 dial-back verification + Phase 3 payout pipeline + peerId fix + UI polish (win.33)

Phase 2: dial-back verification (verified working overnight — 413/413 probes passed)

New PoolVerifier class runs a background thread every 60 seconds that walks
the nodes table, pulls up to 10 least-recently-verified peerIds, and for each
one calls the local IPFS node's /api/v0/swarm/connect. Success = the peer is
findable and reachable via IPFS. Failure increments verifyFails. Nodes with
3+ consecutive failures are excluded from /nodes.json and from Phase 3 payouts.

Self-detection: when the pool server and client run on the same machine, the
verifier detects that the peer's multiaddr contains the local IPFS node's own
peerId and auto-verifies without attempting swarm/connect (which would fail
due to NAT hairpinning on most consumer routers).

Schema migration: ALTER TABLE adds lastVerifyOk and verifyFails columns to
the nodes table. Existing pool.db files get the migration automatically; fresh
databases get all columns in the initial CREATE TABLE.

Phase 3: operator-approved payout pipeline (code complete, untested with real DGB)

[P] key shows a payout preview: count of verified nodes, pool budget from
poolspendperperiod config key, per-node share, and each eligible payout address.
Read-only — safe to press at any time.

[E] key executes a payout with explicit Y/N confirmation. Guards refuse to
execute if poolpayouts=0, poolspendperperiod is missing/zero, no verified
nodes, or rpcuser not configured. On confirmation, calls sendtoaddress on the
local DigiByte Core wallet via JSON-RPC for each eligible node, logs each txid
or error, and records in the payouts_ledger table. Dashboard Payouts row shows
real paid-total from the ledger instead of a placeholder.

New pool.cfg keys for Phase 3: rpcuser, rpcpassword, rpcport (wallet RPC
credentials), poolspendperperiod (DGB to distribute per [E] press).

PeerId bug fix

IPFS::getPeerId now filters the /id response's address list to only include
entries whose trailing /p2p/<id> segment matches the local node's own ID field.
Previously, findPublicAddress could return a bootstrap node's multiaddr
(104.131.131.82/QmaCpDMG...) as if it were ours. New extractIdField() helper
pulls the ID from the /id JSON response. If the filter removes all addresses,
falls back to the bare peerId string.

Confirmed working: the keepalive log now shows the real peerId
/ip4/64.182.71.30/tcp/4001/p2p/12D3KooWQ5wFb1PLNb3i6BET6R... instead of the
DigitalOcean bootstrap's Qm-prefixed address.

UI polish

- DigiAssetCore [H] help rewritten as numbered sub-menus: press H for a 3-line
  topic index, then 1-6 for detail sections that fit on one screen. No more
  40-line dump that scrolls off the log area.
- Pool server dashboard now uses the same cell() fixed-column helper as the
  main exe for aligned two-column status rows. Same COL1_LABEL_W / COL1_VALUE_W
  / COL2_LABEL_W constants.
- Pool server header shows version string matching the main exe's format.
- Pool server log area dynamically sizes from terminal height (no blank gap).
- Pool server uptime format matches the main exe (N sec / N min / N.N hours).
- Pool server [H] handler prints a concise 6-line help block.
- Phase 3 keys [P] [E] are dimmed in the key-hints bar since payouts default off.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: chopperbriano

CMakeLists.txt

@@ -40,7 +40,7 @@ SET(PATCH_VERSION 0)
 SET(SO_VERSION    0)
 
 # Windows port build number (increment for each Windows-specific release)
-SET(WIN_BUILD 32)
+SET(WIN_BUILD 33)
 
 # Add source directory
 include_directories(src)

pool/CMakeLists.txt

@@ -29,13 +29,15 @@ set(HEADER_FILES
         PoolDatabase.h
         PoolServer.h
         PoolDashboard.h
+        PoolVerifier.h
         )
 
 set(SOURCE_FILES
         main.cpp
         PoolDatabase.cpp
         PoolServer.cpp
         PoolDashboard.cpp
+        PoolVerifier.cpp
         # Borrow sqlite3.c and curl_stubs.cpp from the main src/ tree so the
         # pool server doesn't need its own copies. sqlite for the pool db,
         # curl_stubs for the first-run HTTP snapshot of mctrivia's /permanent.

pool/PoolDashboard.cpp

@@ -20,10 +20,14 @@
 
 class PoolDatabase;
 class PoolServer;
+class PoolVerifier;
 
 class PoolDashboard {
 public:
-    PoolDashboard(PoolDatabase& db, PoolServer& server);
+    // configPath = path to pool.cfg, re-read on each [E] press so
+    // the operator can adjust poolspendperperiod without restarting.
+    PoolDashboard(PoolDatabase& db, PoolServer& server, PoolVerifier& verifier,
+                  const std::string& configPath = "pool.cfg");
     ~PoolDashboard();
 
     // Enable VT100 escape sequences on the Windows console. Returns true if
@@ -41,14 +45,21 @@ class PoolDashboard {
 private:
     PoolDatabase& _db;
     PoolServer& _server;
+    PoolVerifier& _verifier;
+    std::string _configPath;
     std::atomic<bool> _running{false};
+    std::atomic<bool> _awaitingPayoutConfirm{false};
     std::atomic<bool> _quit{false};
     std::thread _thread;
     std::chrono::system_clock::time_point _startTime;
 
     std::mutex _logMutex;
     std::deque<std::string> _logLines;
-    static constexpr size_t MAX_LOG_LINES = 20;
+    static constexpr size_t MAX_LOG_LINES = 200;
+
+    int _width = 120;
+    int _height = 40;
+    void updateConsoleSize();
 
     void refreshLoop();
     void render();

pool/PoolDashboard.h

@@ -88,6 +88,21 @@ void PoolDatabase::buildSchema() {
         ");"
     );
 
+    // Schema migration: win.33 adds dial-back verification columns. These
+    // ALTER TABLEs fail silently if the columns already exist (sqlite's
+    // ALTER doesn't have IF NOT EXISTS; we catch the error and move on).
+    auto tryAddColumn = [this](const char* sql) {
+        char* errMsg = nullptr;
+        int rc = sqlite3_exec(_db, sql, nullptr, nullptr, &errMsg);
+        if (rc != SQLITE_OK && errMsg) {
+            // Ignore "duplicate column name" - that just means the migration
+            // already ran on a previous launch against this pool.db.
+            sqlite3_free(errMsg);
+        }
+    };
+    tryAddColumn("ALTER TABLE nodes ADD COLUMN lastVerifyOk INTEGER NOT NULL DEFAULT 0;");
+    tryAddColumn("ALTER TABLE nodes ADD COLUMN verifyFails  INTEGER NOT NULL DEFAULT 0;");
+
     // permanent_assets rows are imported from the first-run snapshot of
     // mctrivia's /permanent/<page>.json or added later by the operator.
     // Primary key includes cid because a single assetId can reference
@@ -169,6 +184,150 @@ void PoolDatabase::upsertNode(const std::string& peerId,
     }
 }
 
+void PoolDatabase::recordVerifySuccess(const std::string& peerId) {
+    std::lock_guard<std::mutex> lk(_mutex);
+    int64_t now = nowUnix();
+    const char* sql =
+        "UPDATE nodes SET lastVerifyOk = ?, verifyFails = 0 WHERE peerId = ?;";
+    sqlite3_stmt* stmt = nullptr;
+    if (sqlite3_prepare_v2(_db, sql, -1, &stmt, nullptr) != SQLITE_OK) return;
+    sqlite3_bind_int64(stmt, 1, now);
+    sqlite3_bind_text(stmt, 2, peerId.c_str(), -1, SQLITE_TRANSIENT);
+    sqlite3_step(stmt);
+    sqlite3_finalize(stmt);
+}
+
+void PoolDatabase::recordVerifyFailure(const std::string& peerId) {
+    std::lock_guard<std::mutex> lk(_mutex);
+    const char* sql =
+        "UPDATE nodes SET verifyFails = verifyFails + 1 WHERE peerId = ?;";
+    sqlite3_stmt* stmt = nullptr;
+    if (sqlite3_prepare_v2(_db, sql, -1, &stmt, nullptr) != SQLITE_OK) return;
+    sqlite3_bind_text(stmt, 1, peerId.c_str(), -1, SQLITE_TRANSIENT);
+    sqlite3_step(stmt);
+    sqlite3_finalize(stmt);
+}
+
+std::vector<std::string> PoolDatabase::getPeerIdsForVerification(unsigned int limit) {
+    std::lock_guard<std::mutex> lk(_mutex);
+    // Least-recently-verified first. Also favors nodes we've never verified
+    // (lastVerifyOk = 0 puts them at the top of the order). Still seen in
+    // the last week, so we don't waste time probing ghosts.
+    int64_t cutoff = nowUnix() - 7 * 24 * 60 * 60;
+    std::vector<std::string> out;
+    const char* sql =
+        "SELECT peerId FROM nodes WHERE lastSeen >= ? "
+        "ORDER BY lastVerifyOk ASC LIMIT ?;";
+    sqlite3_stmt* stmt = nullptr;
+    if (sqlite3_prepare_v2(_db, sql, -1, &stmt, nullptr) == SQLITE_OK) {
+        sqlite3_bind_int64(stmt, 1, cutoff);
+        sqlite3_bind_int(stmt, 2, (int) limit);
+        while (sqlite3_step(stmt) == SQLITE_ROW) {
+            const unsigned char* p = sqlite3_column_text(stmt, 0);
+            if (p) out.emplace_back(reinterpret_cast<const char*>(p));
+        }
+        sqlite3_finalize(stmt);
+    }
+    return out;
+}
+
+unsigned int PoolDatabase::countVerifiedSince(int64_t unixSeconds) {
+    std::lock_guard<std::mutex> lk(_mutex);
+    const char* sql = "SELECT COUNT(*) FROM nodes WHERE lastVerifyOk >= ?;";
+    sqlite3_stmt* stmt = nullptr;
+    unsigned int count = 0;
+    if (sqlite3_prepare_v2(_db, sql, -1, &stmt, nullptr) == SQLITE_OK) {
+        sqlite3_bind_int64(stmt, 1, unixSeconds);
+        if (sqlite3_step(stmt) == SQLITE_ROW) count = (unsigned int) sqlite3_column_int(stmt, 0);
+        sqlite3_finalize(stmt);
+    }
+    return count;
+}
+
+unsigned int PoolDatabase::countFailedOut() {
+    std::lock_guard<std::mutex> lk(_mutex);
+    const char* sql = "SELECT COUNT(*) FROM nodes WHERE verifyFails >= 3;";
+    sqlite3_stmt* stmt = nullptr;
+    unsigned int count = 0;
+    if (sqlite3_prepare_v2(_db, sql, -1, &stmt, nullptr) == SQLITE_OK) {
+        if (sqlite3_step(stmt) == SQLITE_ROW) count = (unsigned int) sqlite3_column_int(stmt, 0);
+        sqlite3_finalize(stmt);
+    }
+    return count;
+}
+
+std::vector<PoolDatabase::PayoutTarget> PoolDatabase::getVerifiedPayoutTargets() {
+    std::lock_guard<std::mutex> lk(_mutex);
+    int64_t now = nowUnix();
+    int64_t seenCutoff = now - 7 * 24 * 60 * 60;   // seen in last 7 days
+    int64_t verifyCutoff = now - 24 * 60 * 60;       // verified in last 24h
+
+    std::vector<PayoutTarget> out;
+    const char* sql =
+        "SELECT peerId, payoutAddress FROM nodes "
+        "WHERE lastSeen >= ? AND lastVerifyOk >= ? AND verifyFails < 3 "
+        "ORDER BY peerId;";
+    sqlite3_stmt* stmt = nullptr;
+    if (sqlite3_prepare_v2(_db, sql, -1, &stmt, nullptr) == SQLITE_OK) {
+        sqlite3_bind_int64(stmt, 1, seenCutoff);
+        sqlite3_bind_int64(stmt, 2, verifyCutoff);
+        while (sqlite3_step(stmt) == SQLITE_ROW) {
+            PayoutTarget t;
+            const unsigned char* p = sqlite3_column_text(stmt, 0);
+            const unsigned char* a = sqlite3_column_text(stmt, 1);
+            if (p) t.peerId = (const char*) p;
+            if (a) t.payoutAddress = (const char*) a;
+            if (!t.payoutAddress.empty()) out.push_back(t);
+        }
+        sqlite3_finalize(stmt);
+    }
+    return out;
+}
+
+void PoolDatabase::recordPayout(const std::string& payoutAddress, int64_t amountDgbSat,
+                                const std::string& txid) {
+    std::lock_guard<std::mutex> lk(_mutex);
+    int64_t now = nowUnix();
+    const char* sql =
+        "INSERT INTO payouts_ledger (payoutAddress, amountDgbSat, owedAt, paidTxid, paidAt) "
+        "VALUES (?, ?, ?, ?, ?);";
+    sqlite3_stmt* stmt = nullptr;
+    if (sqlite3_prepare_v2(_db, sql, -1, &stmt, nullptr) != SQLITE_OK) return;
+    sqlite3_bind_text(stmt, 1, payoutAddress.c_str(), -1, SQLITE_TRANSIENT);
+    sqlite3_bind_int64(stmt, 2, amountDgbSat);
+    sqlite3_bind_int64(stmt, 3, now);
+    sqlite3_bind_text(stmt, 4, txid.c_str(), -1, SQLITE_TRANSIENT);
+    sqlite3_bind_int64(stmt, 5, now);
+    sqlite3_step(stmt);
+    sqlite3_finalize(stmt);
+}
+
+double PoolDatabase::getPaidTotalDgb() {
+    std::lock_guard<std::mutex> lk(_mutex);
+    const char* sql = "SELECT COALESCE(SUM(amountDgbSat), 0) FROM payouts_ledger WHERE paidTxid IS NOT NULL;";
+    sqlite3_stmt* stmt = nullptr;
+    double total = 0.0;
+    if (sqlite3_prepare_v2(_db, sql, -1, &stmt, nullptr) == SQLITE_OK) {
+        if (sqlite3_step(stmt) == SQLITE_ROW) {
+            total = sqlite3_column_int64(stmt, 0) / 100000000.0;
+        }
+        sqlite3_finalize(stmt);
+    }
+    return total;
+}
+
+unsigned int PoolDatabase::getPaidCount() {
+    std::lock_guard<std::mutex> lk(_mutex);
+    const char* sql = "SELECT COUNT(*) FROM payouts_ledger WHERE paidTxid IS NOT NULL;";
+    sqlite3_stmt* stmt = nullptr;
+    unsigned int count = 0;
+    if (sqlite3_prepare_v2(_db, sql, -1, &stmt, nullptr) == SQLITE_OK) {
+        if (sqlite3_step(stmt) == SQLITE_ROW) count = (unsigned int) sqlite3_column_int(stmt, 0);
+        sqlite3_finalize(stmt);
+    }
+    return count;
+}
+
 void PoolDatabase::insertPermanentAsset(const std::string& assetId,
                                         const std::string& txHash,
                                         const std::string& cid,
@@ -301,11 +460,16 @@ std::string PoolDatabase::buildPermanentPageJson(unsigned int page) {
 
 std::string PoolDatabase::buildNodesJson() {
     std::lock_guard<std::mutex> lk(_mutex);
-    // 7-day window: any node we've seen in the last week is "online enough"
-    // to list on /nodes.json.
+    // 7-day window, AND exclude nodes that have failed dial-back
+    // verification 3+ times in a row. Failed-out nodes are ghosts — they
+    // keep sending keepalive pings but the pool operator can't actually
+    // reach them via IPFS, so other clients shouldn't see them either.
     int64_t cutoff = nowUnix() - 7 * 24 * 60 * 60;
 
-    const char* sql = "SELECT peerId FROM nodes WHERE lastSeen >= ? ORDER BY lastSeen DESC;";
+    const char* sql =
+        "SELECT peerId FROM nodes "
+        "WHERE lastSeen >= ? AND verifyFails < 3 "
+        "ORDER BY lastSeen DESC;";
     sqlite3_stmt* stmt = nullptr;
     std::ostringstream json;
     json << "[";

pool/PoolDatabase.cpp

@@ -29,6 +29,22 @@ class PoolDatabase {
     void upsertNode(const std::string& peerId,
                     const std::string& payoutAddress);
 
+    // Dial-back verification state. The PoolVerifier thread calls these
+    // after each probe attempt.
+    //   recordVerifySuccess: bumps lastVerifyOk, resets verifyFails to 0
+    //   recordVerifyFailure: increments verifyFails (lastVerifyOk unchanged)
+    void recordVerifySuccess(const std::string& peerId);
+    void recordVerifyFailure(const std::string& peerId);
+
+    // Returns up to `limit` peerIds the verifier should probe next,
+    // ordered by lastVerifyOk ascending (least-recently-verified first).
+    // Used by PoolVerifier to pick work each iteration.
+    std::vector<std::string> getPeerIdsForVerification(unsigned int limit);
+
+    // Counts for the dashboard Verified: row.
+    unsigned int countVerifiedSince(int64_t unixSeconds);
+    unsigned int countFailedOut(); // nodes with verifyFails >= 3
+
     // Permanent assets (one row per (assetId, txHash, cid) tuple).
     // Used by the first-run snapshot and, later, operator-added entries.
     void insertPermanentAsset(const std::string& assetId,
@@ -62,6 +78,23 @@ class PoolDatabase {
     unsigned int countPermanentAssets();
     unsigned int countPermanentPages();
 
+    // Phase 3: payout support.
+    // Returns (peerId, payoutAddress) pairs for nodes eligible for payout:
+    // lastVerifyOk within last 24h AND verifyFails < 3 AND lastSeen within 7 days.
+    struct PayoutTarget {
+        std::string peerId;
+        std::string payoutAddress;
+    };
+    std::vector<PayoutTarget> getVerifiedPayoutTargets();
+
+    // Record a completed payout in the ledger.
+    void recordPayout(const std::string& payoutAddress, int64_t amountDgbSat,
+                      const std::string& txid);
+
+    // Ledger totals for dashboard display.
+    double getPaidTotalDgb();        // sum of all paid-out DGB
+    unsigned int getPaidCount();     // number of payout transactions
+
     // Pool-local config key/value store (separate from the operator's
     // editable pool.cfg; this is runtime state like "last snapshot time").
     void setConfig(const std::string& key, const std::string& value);