PSP: replace dead on-chain matching with /permanent/<page>.json fetcher (win.30)

The C++ mctrivia pool implemented an on-chain fee-matching protocol that was
never deployed server-side - the 14 pay-in addresses it watched have never
been paid in 4M blocks of chain history. And mctrivia's actual payment-
registration endpoint (POST /list/<floor>.json) has been returning HTTP 500
since ~July 2024, so no client of any stripe is getting paid. The pool
operator is uncontactable.

Gut serializeMetaProcessor to return "" unconditionally and strip the
14-address list + bytes budget math. Add a background permanentFetcherTask
that walks GET /permanent/<page>.json, pins every CID via local IPFS, and
persists progress to psp1permanentpage in config.cfg. A probeListEndpoint
fires every ~30 min against /list so the dashboard auto-recovers if the
server is ever fixed.

Dashboard rewritten in plain English: "Hosting pool files (unpaid)" instead
of "pinning, payment offline", and a new Payment row that explicitly tells
the user whether DGB is flowing. main.cpp emits a one-shot info block on
startup explaining the state.

Bug fixes along the way:

- RPC Server row was stuck on "Off" even though the server was listening.
  The win.26 TCP-connect probe used non-blocking connect() + select() on
  writability, which on Windows localhost sometimes times out (200ms) even
  though the 3-way handshake completed. Replaced with a simple pointer
  check - main.cpp pins RPC::Server via shared_ptr for the process lifetime
  and the accept loop catches its own exceptions, so the "dangling pointer"
  scenario the probe was guarding against hasn't happened in practice.
  Also added a "Checking..." tri-state so the row doesn't briefly flash
  red on startup.

- _secretCode now read from psp1secret and persisted on first run instead
  of regenerating every startup.

- updateBadList had an unconditional second push_back after dedupe that
  grew _badAssets/_badFiles unbounded on every poll.

- _pspStatus / _pspNodeCount now mutex-guarded. Detached background thread
  was racing with render.

- Config::refresh/write now preserve comments, blank lines, and original
  key ordering via a _rawLines vector. Previously Config round-trips
  would silently strip user comments.

- getIPFS() throws on nullptr; replaced with getIPFSIfSet() in mctrivia.cpp
  background paths so we don't crash on shutdown races.

- getPermanentStoragePoolListIfSet() added; dashboard first render runs
  BEFORE main.cpp constructs the PSP list, so the throwing getter used to
  fatal at "Not available".

- Rolling back the permanent page on error created a re-pin loop; now
  stays at the current page and retries.

- probeListEndpoint call wrapped in try/catch so a curl exception can't
  take down the fetcher thread.

Payment is still offline. This commit cannot fix that - it's a server-side
bug on uncontactable infrastructure. Users running this node are contributing
storage to the DigiByte ecosystem without compensation.

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 28)
+SET(WIN_BUILD 30)
 
 # Add source directory
 include_directories(src)

src/AppMain.h

@@ -79,6 +79,7 @@ class AppMain {
     ChainAnalyzer* getChainAnalyzerIfSet() { return _analyzer; }
     RPC::Server* getRpcServerIfSet() { return _rpcServer; }
     WebServer* getWebServerIfSet() { return _webServer; }
+    PermanentStoragePoolList* getPermanentStoragePoolListIfSet() { return _psp; }
 
     void reset();
 };

src/Config.cpp

@@ -16,6 +16,8 @@ Config::Config() {
 
 void Config::clear() {
     _values.clear();
+    _rawLines.clear();
+    _keyToLineIndex.clear();
 }
 
 void Config::refresh() {
@@ -27,17 +29,26 @@ void Config::refresh() {
     myfile.open(_fileName);
     if (myfile.fail()) throw exceptionConfigFileMissing(); //does not exist
 
-    //check lines and save to correct value
+    //read every line in order (preserving comments and blank lines), and for
+    //each `key=value` line also populate the parsed map and the index lookup.
     string line;
     while (getline(myfile, line)) {
+        // Strip trailing \r so CRLF-terminated files don't accumulate a \r per
+        // line on the next write.
+        if (!line.empty() && line.back() == '\r') line.pop_back();
+        size_t idx = _rawLines.size();
+        _rawLines.push_back(line);
+
+        if (line.empty()) continue;     //blank line - keep in _rawLines, skip parse
+        if (line[0] == '#') continue;   //comment - keep in _rawLines, skip parse
+
         istringstream is_line(line);
-        if (line.empty()) continue;   //ignore blank lines
-        if (line[0] == '#') continue; //ignore notes
         string key;
         if (getline(is_line, key, '=')) {
             string value;
             if (getline(is_line, value)) {
                 _values[key] = value;
+                _keyToLineIndex[key] = idx;
             }
         }
     }
@@ -47,14 +58,27 @@ void Config::refresh() {
 /**
  * writes the config contents to a file.  If name not set will write over existign config file
  * @param fileName
+ *
+ * Writes _rawLines verbatim so comments, blank lines, and original ordering
+ * are preserved. setString/setInteger/setBool update BOTH _values and the
+ * corresponding entry in _rawLines, so the raw-lines view is authoritative.
  */
 void Config::write(string fileName) const {
     if (fileName.empty()) fileName = _fileName;
 
     ofstream myfile(fileName);
     if (!myfile.is_open()) throw exceptionConfigFileCouldNotBeWritten();
-    for (const auto& pair: _values) {
-        myfile << pair.first << "=" << pair.second << "\n";
+
+    if (_rawLines.empty()) {
+        // Fallback path — Config was constructed via the default ctor with no
+        // file, or refresh() was never called. Dump _values as before.
+        for (const auto& pair: _values) {
+            myfile << pair.first << "=" << pair.second << "\n";
+        }
+    } else {
+        for (const auto& line: _rawLines) {
+            myfile << line << "\n";
+        }
     }
     myfile.close();
 }
@@ -217,10 +241,22 @@ map<string, bool> Config::getBoolMap(const string& keyPrefix) const {
 
 void Config::setString(const string& key, const string& value) {
     _values[key] = value;
+
+    // Keep the raw-line view in sync. If the key was already in the file,
+    // update its existing line in place (preserving position relative to
+    // comments and other keys). If it's new, append a fresh line.
+    const string newLine = key + "=" + value;
+    auto it = _keyToLineIndex.find(key);
+    if (it != _keyToLineIndex.end()) {
+        _rawLines[it->second] = newLine;
+    } else {
+        _keyToLineIndex[key] = _rawLines.size();
+        _rawLines.push_back(newLine);
+    }
 }
 
 void Config::setInteger(const string& key, int value) {
-    _values[key] = to_string(value);
+    setString(key, to_string(value));
 }
 
 void Config::setBool(const string& key, bool value) {
@@ -229,18 +265,18 @@ void Config::setBool(const string& key, bool value) {
 
 void Config::setStringMap(const string& key, const map<string, string>& values) {
     for (const auto& entry: values) {
-        _values[key + entry.first] = entry.second;
+        setString(key + entry.first, entry.second);
     }
 }
 
 void Config::setIntegerMap(const string& key, const map<string, int>& values) {
     for (const auto& entry: values) {
-        _values[key + entry.first] = to_string(entry.second);
+        setString(key + entry.first, to_string(entry.second));
     }
 }
 
 void Config::setBoolMap(const string& key, const map<string, bool>& values) {
     for (const auto& entry: values) {
-        _values[key + entry.first] = to_string(entry.second);
+        setString(key + entry.first, to_string(entry.second));
     }
 }

src/Config.h

@@ -13,6 +13,13 @@ using namespace std;
 
 class Config {
     map<string, string> _values;
+    // _rawLines stores the file's contents in original order, INCLUDING comment
+    // lines (`#...`) and blank lines. _keyToLineIndex maps each known key to
+    // the index in _rawLines where it lives. On setString we update that line
+    // in place instead of rewriting the whole file from _values, so comments
+    // and user-intended ordering survive a write().
+    vector<string> _rawLines;
+    map<string, size_t> _keyToLineIndex;
     string _fileName;
     static bool isInteger(const string& value);
     static bool isBool(const string& value);