Dashboard: detect and offer to fix Kubo Addresses.Announce (win.18)

chopperbriano · claude · chopperbriano · commit 7e10ddc83c0b · 2026-04-10T10:01:46.000-05:00
Kubo's AutoNAT in 0.40.x often fails to converge on home routers even
when port 4001 is forwarded correctly — the node knows it's listening,
peers can reach it, but Kubo never publishes a direct /ip4/WAN/tcp/4001
address in /id. DigiAsset Core then falls back to the relay address we
added in win.15/16, which works but adds a hop per PSP verification.

Add automatic detection and a one-keystroke repair:

1. Background check on startup and every 10 minutes:
   - Query local IPFS /id, see whether it already lists our WAN IP
   - If not, probe port 4001 via ifconfig.co/port/4001 to confirm the
     router forward is actually live
2. When the fixable condition is detected (port open + not announced),
   show a yellow IPFS hint line on the dashboard and add a yellow
   [F] Fix IPFS entry to the help bar
3. Pressing F POSTs to the local Kubo HTTP API to set:
     Addresses.Announce = ["/ip4/WAN/tcp/4001","/ip4/WAN/udp/4001/quic-v1"]
   then logs a reminder to restart IPFS Desktop so the new announce
   list takes effect
4. Once IPFS Desktop is restarted and /id contains the direct address,
   the hint auto-clears and the next DigiAssetCore keepalive switches
   from the relay multiaddr to the direct one via tier 1 in
   findPublicAddress — no user action required

The fix is gated: it won't run if the port isn't externally reachable
(would otherwise advertise a dead address), it won't run if IPFS is
already announcing directly (nothing to do), and it won't run before
the initial diagnosis completes.

This is specifically for NAT'd Windows users — the most common
deployment — and addresses the repeated user feedback that "most
Windows users are behind NAT."

Co-Authored-By: Claude Opus 4.6 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/CMakeLists.txt b/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 17)
+SET(WIN_BUILD 18)
 
 # Add source directory
 include_directories(src)
diff --git a/src/ConsoleDashboard.cpp b/src/ConsoleDashboard.cpp
@@ -4,6 +4,7 @@
 
 #include "ConsoleDashboard.h"
 #include "AppMain.h"
+#include "Config.h"
 #include "CurlHandler.h"
 #include "Log.h"
 #include "Version.h"
@@ -158,6 +159,15 @@ void ConsoleDashboard::processInput() {
                     }
                 }
                 break;
+            case 'f':
+            case 'F':
+                // Fix IPFS Addresses.Announce when we've detected the fixable condition
+                {
+                    Log* log = Log::GetInstance();
+                    log->addMessage("Attempting to fix IPFS announce list...");
+                    std::thread([this]() { applyIpfsAnnounceFix(); }).detach();
+                }
+                break;
             case 'h':
             case 'H':
             case '?':
@@ -183,7 +193,7 @@ void ConsoleDashboard::processInput() {
                             log->addMessage("External IP: " + ip);
                         }
                     }
-                    log->addMessage("Keys: Q=Quit  A=Assets  P=Port check  L=Log level  H=This info");
+                    log->addMessage("Keys: Q=Quit  A=Assets  P=Port check  L=Log level  F=Fix IPFS announce  H=This info");
                 }
                 break;
             default:
@@ -232,6 +242,18 @@ void ConsoleDashboard::render() {
             std::thread([this]() { checkPspRegistration(); }).detach();
         }
     }
+    // Run IPFS announce diagnosis in background (at startup + every 10 min)
+    {
+        auto now = std::chrono::steady_clock::now();
+        auto elapsed = std::chrono::duration<double>(now - _lastIpfsAnnounceCheck).count();
+        if (elapsed >= 600.0 || !_ipfsAnnounceChecked) {
+            // Only run once WebServer has had time to resolve external IP
+            WebServer* ws = app->getWebServerIfSet();
+            if (ws && !ws->getExternalIP().empty() && ws->getExternalIP() != "unknown") {
+                std::thread([this]() { checkIpfsAnnounce(); }).detach();
+            }
+        }
+    }
 
     ChainAnalyzer* analyzer = app->getChainAnalyzerIfSet();
     if (analyzer) {
@@ -390,6 +412,15 @@ void ConsoleDashboard::render() {
         out << "\n"; totalRows++;
     }
 
+    // IPFS announce hint — shown only when there's actionable advice
+    {
+        std::lock_guard<std::mutex> lock(_ipfsAnnounceMutex);
+        if (!_ipfsAnnounceHint.empty()) {
+            out << ERASE_LINE << "  IPFS: " << FG_YELLOW << _ipfsAnnounceHint << RESET << "\n";
+            totalRows++;
+        }
+    }
+
     // Row 5: separator
     out << ERASE_LINE << std::string(w, '-') << "\n"; totalRows++;
 
@@ -482,7 +513,17 @@ void ConsoleDashboard::render() {
     }
 
     // Help bar (cursor is already on the right line after the \n above)
-    out << ERASE_LINE << DIM << " [Q] Quit  [A] Assets  [P] Ports  [L] Log Level  [H] Info" << RESET;
+    // Include [F] only when the fix is applicable, to avoid cluttering the UI.
+    bool showFixKey = false;
+    {
+        std::lock_guard<std::mutex> lock(_ipfsAnnounceMutex);
+        showFixKey = !_ipfsAnnouncedDirectly && _ipfsPort4001Open && _ipfsAnnounceChecked;
+    }
+    out << ERASE_LINE << DIM << " [Q] Quit  [A] Assets  [P] Ports  [L] Log Level";
+    if (showFixKey) {
+        out << "  " << RESET << FG_YELLOW << "[F] Fix IPFS" << RESET << DIM;
+    }
+    out << "  [H] Info" << RESET;
 
     // Write everything in one shot to minimize flicker
     std::cout << out.str() << std::flush;
@@ -574,6 +615,166 @@ void ConsoleDashboard::loadPayoutInfo() {
     }
 }
 
+// ---- IPFS announce detection & repair --------------------------------------
+
+namespace {
+    std::string urlEncodeComponent(const std::string& s) {
+        std::string out;
+        out.reserve(s.size() * 3);
+        for (unsigned char c : s) {
+            if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
+                (c >= '0' && c <= '9') || c == '-' || c == '_' || c == '.' || c == '~') {
+                out += (char)c;
+            } else {
+                char buf[4];
+                snprintf(buf, sizeof(buf), "%%%02X", c);
+                out += buf;
+            }
+        }
+        return out;
+    }
+
+    // Read ipfspath from config.cfg, default to Kubo's standard HTTP API.
+    std::string getIpfsApiBase() {
+        try {
+            Config config("config.cfg");
+            std::string p = config.getString("ipfspath", "http://localhost:5001/api/v0/");
+            if (!p.empty() && p.back() != '/') p += '/';
+            return p;
+        } catch (...) {
+            return "http://localhost:5001/api/v0/";
+        }
+    }
+}
+
+void ConsoleDashboard::checkIpfsAnnounce() {
+    // Snapshot the WAN IP from the web server (already resolved via ipify at startup)
+    AppMain* app = AppMain::GetInstance();
+    WebServer* ws = app->getWebServerIfSet();
+    std::string wanIp;
+    if (ws) wanIp = ws->getExternalIP();
+    if (wanIp.empty() || wanIp == "unknown") {
+        std::lock_guard<std::mutex> lock(_ipfsAnnounceMutex);
+        _ipfsAnnounceHint.clear();
+        return;
+    }
+
+    std::string apiBase = getIpfsApiBase();
+
+    // Step 1: does IPFS /id already list an address containing our WAN IP?
+    bool announced = false;
+    try {
+        std::string idJson = CurlHandler::post(apiBase + "id", {}, 5000);
+        // Cheap substring check — we don't need full JSON parsing for this.
+        if (idJson.find(wanIp) != std::string::npos) {
+            announced = true;
+        }
+    } catch (...) {
+        // IPFS API unreachable — can't diagnose, bail out quietly
+        std::lock_guard<std::mutex> lock(_ipfsAnnounceMutex);
+        _ipfsAnnounceHint.clear();
+        _ipfsAnnounceChecked = false;
+        return;
+    }
+
+    // Step 2: if not announced, probe port 4001 externally to see whether
+    // fixing is even possible. If the port isn't reachable, setting
+    // Addresses.Announce would advertise a dead address.
+    bool portOpen = false;
+    if (!announced) {
+        try {
+            std::string resp = CurlHandler::get("http://ifconfig.co/port/4001", 10000);
+            if (resp.find("\"reachable\": true") != std::string::npos ||
+                resp.find("\"reachable\":true") != std::string::npos) {
+                portOpen = true;
+            }
+        } catch (...) {
+            // leave portOpen = false
+        }
+    }
+
+    std::lock_guard<std::mutex> lock(_ipfsAnnounceMutex);
+    _ipfsAnnouncedDirectly = announced;
+    _ipfsPort4001Open = portOpen;
+    _ipfsAnnounceChecked = true;
+    _lastIpfsAnnounceCheck = std::chrono::steady_clock::now();
+
+    if (announced) {
+        _ipfsAnnounceHint.clear(); // nothing to fix
+    } else if (portOpen) {
+        _ipfsAnnounceHint = "Port 4001 is open but IPFS isn't announcing it — press [F] to fix";
+    } else {
+        _ipfsAnnounceHint.clear(); // NAT'd with no port forward — relay path is the right answer
+    }
+}
+
+bool ConsoleDashboard::applyIpfsAnnounceFix() {
+    Log* log = Log::GetInstance();
+    AppMain* app = AppMain::GetInstance();
+
+    // Must have a known WAN IP to announce
+    WebServer* ws = app->getWebServerIfSet();
+    std::string wanIp;
+    if (ws) wanIp = ws->getExternalIP();
+    if (wanIp.empty() || wanIp == "unknown") {
+        log->addMessage("Fix aborted: external IP not known yet", Log::WARNING);
+        return false;
+    }
+
+    // Sanity check: only run if our diagnosis said the port is open. This
+    // prevents setting Announce to a dead address on a NAT'd box.
+    {
+        std::lock_guard<std::mutex> lock(_ipfsAnnounceMutex);
+        if (!_ipfsAnnounceChecked) {
+            log->addMessage("Fix aborted: diagnosis hasn't run yet, please wait a moment", Log::WARNING);
+            return false;
+        }
+        if (_ipfsAnnouncedDirectly) {
+            log->addMessage("Nothing to fix: IPFS is already announcing a direct address");
+            return false;
+        }
+        if (!_ipfsPort4001Open) {
+            log->addMessage("Fix aborted: port 4001 is NOT reachable from the internet. "
+                            "Forward TCP 4001 on your router first (press [P] to recheck).",
+                            Log::WARNING);
+            return false;
+        }
+    }
+
+    // Build the JSON array argument: ["/ip4/<wan>/tcp/4001","/ip4/<wan>/udp/4001/quic-v1"]
+    std::string jsonArray = "[\"/ip4/" + wanIp + "/tcp/4001\",\"/ip4/" + wanIp + "/udp/4001/quic-v1\"]";
+
+    // Build the IPFS config URL: POST .../config?arg=Addresses.Announce&arg=<encoded>&json=true
+    std::string apiBase = getIpfsApiBase();
+    std::string url = apiBase + "config?arg=Addresses.Announce&arg="
+                      + urlEncodeComponent(jsonArray) + "&json=true";
+
+    log->addMessage("Setting Kubo Addresses.Announce = " + jsonArray);
+    try {
+        std::string response = CurlHandler::post(url, {}, 10000);
+        // Kubo echoes the new config on success; look for our WAN IP in the response.
+        if (response.find(wanIp) == std::string::npos) {
+            log->addMessage("IPFS config set returned unexpected response: " + response.substr(0, 200),
+                            Log::WARNING);
+            return false;
+        }
+    } catch (const std::exception& e) {
+        log->addMessage(std::string("IPFS config set failed: ") + e.what(), Log::WARNING);
+        return false;
+    }
+
+    log->addMessage("Addresses.Announce updated successfully.");
+    log->addMessage("IMPORTANT: restart IPFS Desktop (tray icon -> Quit, relaunch) "
+                    "to activate the new announce list.", Log::WARNING);
+    log->addMessage("After IPFS restart, DigiAssetCore will automatically pick up "
+                    "the direct address on the next keepalive cycle.");
+
+    // Mark as applied so the hint goes away until next check
+    std::lock_guard<std::mutex> lock(_ipfsAnnounceMutex);
+    _ipfsAnnounceHint = "Addresses.Announce set — restart IPFS Desktop to activate";
+    return true;
+}
+
 // ---- Port checking ----------------------------------------------------------
 
 void ConsoleDashboard::checkPorts() {
diff --git a/src/ConsoleDashboard.h b/src/ConsoleDashboard.h
@@ -94,6 +94,17 @@ class ConsoleDashboard {
     bool _portCheckDone = false;
     void checkPorts();
 
+    // IPFS announce detection/repair (for NAT'd users who have port forwarded
+    // but Kubo's AutoNAT hasn't yet published a direct address in /id)
+    std::mutex _ipfsAnnounceMutex;
+    bool _ipfsAnnouncedDirectly = false;   // /id lists an address containing our WAN IP
+    bool _ipfsPort4001Open = false;         // ifconfig.co reports 4001 reachable
+    bool _ipfsAnnounceChecked = false;      // we've completed at least one check
+    std::string _ipfsAnnounceHint;          // dashboard status line, empty if all good
+    std::chrono::steady_clock::time_point _lastIpfsAnnounceCheck;
+    void checkIpfsAnnounce();               // background: diagnose state, set hint
+    bool applyIpfsAnnounceFix();            // [F] handler: POST to IPFS config API
+
     // Console dimensions
     int _width = 80;
     int _height = 25;
