Dashboard Serving/Asset index rows, getnodestats RPC, FIX RPC actually listens (win.31)

Three features plus a discovery of a massive pre-existing bug.

FEATURES

- Part A: new "Serving:" dashboard row polls IPFS bitswap stats every 30s
  (POST /api/v0/stats/bitswap) and displays BlocksSent total, rate per minute,
  and DataSent as a human-readable byte count. Proves to the operator that
  their node is actually serving content out to IPFS peers instead of just
  pinning it. Wired through a new NodeStats singleton so the getnodestats
  RPC method can report the same numbers without doing its own HTTP call.

- Part B: new "Asset index:" dashboard row cross-checks the local assets
  table against mctrivia's /permanent/<page>.json list (every asset
  mctrivia's permanent storage pool tracks). Reports local count + tracked
  count + coverage percentage. A 100% result is strong evidence the chain
  analyzer is not missing any issuances, because PSP-enrolled and
  non-PSP-enrolled assets go through the same parse path. Missing assetIds
  are logged at WARNING level so they're visible without flipping to DEBUG.

- Part C: new getnodestats RPC method returns a snapshot of buildVersion,
  syncHeight, assetCount, bitswap stats, and permanent-list coverage as
  JSON. Intended for two-node side-by-side comparison:
    DigiAssetCore-cli.exe getnodestats
  Run it on two nodes; if assetCount differs at the same syncHeight, one
  chain analyzer has a bug.

- Expanded [H] info key: pressing H now prints a multi-section plain-English
  explanation of every dashboard row, what the numbers mean, and what the
  node is doing. Readable by a first-time operator with no DigiAsset
  background.

FIX: RPC server actually listens now. The big one.

src/boost/asio.hpp in this fork was a hand-written NO-OP STUB that
silently emulated boost::asio's API with empty implementations:

  class acceptor {
      void open(int) {}
      void set_option(const reuse_address&) {}
      void bind(const endpoint&) {}
      void listen() {}
      void accept(socket&) {
          std::this_thread::sleep_for(std::chrono::seconds(1));
      }
  };

Because <boost/asio.hpp> at src/ was shadowed by this stub (src/ is on
the include path), RPC::Server compiled against it. Every bind/listen/
accept call was a no-op. The "RPC Server listening on port 14024" log
line was logged after the no-op listen() returned. The "RPC call # received"
DEBUG lines we had been staring at for hours were the stub's accept() loop
spinning once per second, NOT real inbound connections. netstat never
showed port 14024 bound because no socket was ever created.

DigiAssetCore-cli.exe has never worked on this Windows fork for any RPC
command. Not version, not getblockcount, not listassets, nothing. It
always failed with a libcurl-like error because there was no server.

Upstream CMakeLists.txt explicitly hacked around this for WebServer.cpp
with a per-source COMPILE_FLAGS /I to the real boost path, acknowledging
that "WebServer.cpp needs real Boost Beast headers (not the stub in
src/boost/)" -- but nothing else got the fix.

The fix, minimal but enough:

- include_directories(BEFORE ...) in src/CMakeLists.txt puts the real
  boost 1.82 at packages/boost.1.82.0/lib/native/include AT THE FRONT of
  the include path, so <boost/asio.hpp> resolves to the real header for
  every source file globally. The stub at src/boost/asio.hpp becomes dead.
- RPC/Server.h and RPC/Server.cpp switch from <boost/asio.hpp> to the
  specific sub-headers <boost/asio/io_context.hpp>, <boost/asio/ip/tcp.hpp>,
  <boost/asio/executor_work_guard.hpp>, <boost/asio/post.hpp>, and
  <boost/asio/write.hpp>. Sub-headers aren't shadowed by the stub so this
  also works independently.
- cli/main.cpp drops its unused #include "RPC/Server.h" so the cli build
  doesn't need real boost headers at all.

With real boost in the build, two latent bugs in Server::Server surfaced
and needed fixing to compile:

- _workGuard must be a MEMBER of Server, not a local in the ctor body.
  Previously it was `auto work = boost::asio::make_work_guard(_io);` which
  went out of scope the moment the ctor returned, leaving _io with no
  outstanding work and the 16 thread-pool threads exiting immediately.
  (This was invisible against the stub because the stub's run() was a
  no-op anyway; against real boost the thread pool would have been empty
  for the entire lifetime of Server.) Now a member initialized in the
  init list.
- _acceptor must be initialized with an executor in the init list. Real
  boost::asio::basic_socket_acceptor has no default constructor.

Plus defensive improvements in case accept() ever does exit in the
future:

- Server::start() now logs CRITICAL and calls
  AppMain::GetInstance()->setRpcServer(nullptr) when accept() returns,
  so the dashboard's RPC probe reflects reality instead of a dangling
  raw pointer from a destroyed Server object.
- DigiByteCore::makeConnection() optionally prints the RPC URL to stderr
  when DGBCORE_DEBUG_URL=1 is set, for debugging cases where libcurl
  reports "couldn't resolve host" but the URL is valid.
- ConsoleDashboard's spawn-race guard for the bitswap poll and the
  coverage scan no longer ORs against _probed / _checked. The
  _lastBitswapPoll / _lastCoverageCheck fields are epoch-initialized, so
  the first render fires immediately because `elapsed > threshold` is
  trivially true, and subsequent renders skip until the next interval
  elapses. Previously the `|| !_bitswapProbed` fallback caused every
  render during the first probe's in-flight window (~500ms) to spawn a
  duplicate probe thread.

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

cli/main.cpp

@@ -1,7 +1,6 @@
 #include "Config.h"
 #include "Database.h"
 #include "DigiByteCore.h"
-#include "RPC/Server.h"
 #include <iostream>
 #include <jsonrpccpp/client.h>
 #include <regex>

src/CMakeLists.txt

@@ -65,6 +65,15 @@ find_package(CURL)
 include_directories("${CMAKE_SOURCE_DIR}/jsoncpp/install/include")
 include_directories("${CMAKE_SOURCE_DIR}/libjson-rpc-cpp/install/include")
 
+# Real boost headers. Without this, any file that includes <boost/asio/*.hpp>
+# (Server.cpp, WebServer.cpp, etc.) can't find the headers at all, and files
+# that include <boost/asio.hpp> silently resolve to the no-op stub at
+# src/boost/asio.hpp — which for the RPC server silently no-op'd every
+# socket operation and meant the server never actually listened.
+if(WIN32 AND MSVC)
+    include_directories(BEFORE "${CMAKE_SOURCE_DIR}/packages/boost.1.82.0/lib/native/include")
+endif()
+
 #add_library(ldigibyteapi STATIC IMPORTED)
 add_library(lsqlite3 STATIC IMPORTED)
 add_library(llibcurl STATIC IMPORTED)
@@ -105,6 +114,7 @@ set(HEADER_FILES
         AppMain.h
         CurlHandler.h
         ConsoleDashboard.h
+        NodeStats.h
         WebServer.h
         Version.h
         OldStream.h
@@ -148,6 +158,7 @@ set(SOURCE_FILES
         AppMain.cpp
         CurlHandler.cpp
         ConsoleDashboard.cpp
+        NodeStats.cpp
         WebServer.cpp
         OldStream.cpp
         UniqueTaskQueue.cpp
@@ -168,9 +179,12 @@ set(SOURCE_FILES
 
 add_executable(DigiAssetCore main.cpp ${SOURCE_FILES} ${HEADER_FILES} ${RPC_METHODS_FILES})
 
-# WebServer.cpp needs real Boost Beast headers (not the stub in src/boost/)
+# WebServer.cpp AND RPC/Server.cpp both need real Boost Beast / boost::asio
+# headers, not the no-op stub in src/boost/. The stub makes everything compile
+# but silently never binds any sockets — which is how RPC on the Windows port
+# looked green on the dashboard but never actually listened on 14024.
 if(WIN32 AND MSVC)
-  set_source_files_properties(WebServer.cpp PROPERTIES
+  set_source_files_properties(WebServer.cpp RPC/Server.cpp PROPERTIES
     COMPILE_FLAGS "/I\"${CMAKE_SOURCE_DIR}/packages/boost.1.82.0/lib/native/include\"")
 endif()
 

src/ConsoleDashboard.cpp

@@ -83,6 +83,33 @@ class ConsoleDashboard {
     std::chrono::steady_clock::time_point _lastPspCheck;
     void checkPspRegistration();
 
+    // IPFS bitswap stats: are we actually serving content out to peers?
+    // pollBitswapStats() POSTs to <ipfspath>stats/bitswap every ~30s from a
+    // detached thread. BlocksSent is a monotonic counter — we diff against
+    // the previous reading to compute the rate.
+    std::mutex _bitswapMutex;
+    bool _bitswapProbed = false;
+    bool _bitswapAvailable = false; // false if IPFS API unreachable
+    uint64_t _bitswapBlocksSent = 0;
+    uint64_t _bitswapDataSent = 0;
+    uint64_t _bitswapBlocksSentPrev = 0;
+    std::chrono::steady_clock::time_point _bitswapPrevTime;
+    double _bitswapBlocksPerMin = 0.0;
+    std::chrono::steady_clock::time_point _lastBitswapPoll;
+    void pollBitswapStats();
+
+    // Permanent-list coverage check: download mctrivia's /permanent/<page>.json
+    // pages 0..N, extract every assetId mctrivia tracks, and query the local
+    // assets table to count how many we have. A healthy node should have
+    // 100% coverage — every PSP-enrolled issuance on-chain should appear in
+    // both lists. Missing assetIds indicate a chain-analyzer bug or lost sync.
+    std::mutex _coverageMutex;
+    bool _coverageChecked = false;
+    unsigned int _coverageTrackedCount = 0;   // total assetIds in mctrivia's permanent pages
+    unsigned int _coverageHaveCount = 0;      // of those, how many are in our local db
+    std::chrono::steady_clock::time_point _lastCoverageCheck;
+    void checkPermanentCoverage();
+
     // Cached asset count (refreshed every 5 seconds)
     uint64_t _assetCount = 0;
     std::chrono::steady_clock::time_point _lastAssetCountTime;

src/ConsoleDashboard.h

@@ -90,11 +90,25 @@ void DigiByteCore::makeConnection() {
 
     //see if core is online and config if valid
     try {
-        httpClient.reset(new jsonrpc::HttpClient(
+        // Build the JSON-RPC URL separately so we can log it at DEBUG, and so
+        // the cli can `-v` itself by enabling DEBUG-level output. libcurl
+        // error 6 ("couldn't resolve host") against this URL usually means
+        // rpcbind, rpcuser, or rpcpassword has a character that breaks the
+        // libcurl URL parser — worth seeing the exact string in the log.
+        std::string rpcUrl =
                 "http://" + config.getString("rpcuser") + ":" +
                 config.getString("rpcpassword") + "@" +
                 config.getString("rpcbind", "127.0.0.1") + ":" +
-                std::to_string(_useAssetPort ? config.getInteger("rpcassetport", 14024) : config.getInteger("rpcport", 14022))));
+                std::to_string(_useAssetPort ? config.getInteger("rpcassetport", 14024) : config.getInteger("rpcport", 14022));
+        // Diagnostic hook: set DGBCORE_DEBUG_URL=1 to print the JSON-RPC URL
+        // to stderr on connect. Useful when debugging libcurl errors like
+        // "couldn't resolve host" that usually mean a character in
+        // rpcuser/rpcpassword/rpcbind broke the URL parser. Using cerr
+        // directly (not Log) because the cli doesn't link Log.cpp.
+        if (std::getenv("DGBCORE_DEBUG_URL")) {
+            std::cerr << "DGBCORE_URL=" << rpcUrl << std::endl;
+        }
+        httpClient.reset(new jsonrpc::HttpClient(rpcUrl));
         client.reset(new jsonrpc::Client(*httpClient, jsonrpc::JSONRPC_CLIENT_V1));
         httpClient->SetTimeout(config.getInteger("rpctimeout", 50000));
         if (!_useAssetPort) getblockcount();

src/DigiByteCore.cpp

@@ -0,0 +1,38 @@
+#include "NodeStats.h"
+
+NodeStats& NodeStats::instance() {
+    static NodeStats s;
+    return s;
+}
+
+void NodeStats::setBitswap(bool available, uint64_t blocksSent, uint64_t dataSent, double blocksPerMin) {
+    std::lock_guard<std::mutex> lk(_m);
+    _bitswapProbed = true;
+    _bitswapAvailable = available;
+    if (available) {
+        _blocksSent = blocksSent;
+        _dataSent = dataSent;
+        _blocksPerMin = blocksPerMin;
+    }
+}
+
+void NodeStats::setCoverage(unsigned int tracked, unsigned int have) {
+    std::lock_guard<std::mutex> lk(_m);
+    _coverageChecked = true;
+    _coverageTracked = tracked;
+    _coverageHave = have;
+}
+
+NodeStats::Snapshot NodeStats::snapshot() {
+    std::lock_guard<std::mutex> lk(_m);
+    Snapshot s;
+    s.bitswapProbed = _bitswapProbed;
+    s.bitswapAvailable = _bitswapAvailable;
+    s.blocksSent = _blocksSent;
+    s.dataSent = _dataSent;
+    s.blocksPerMin = _blocksPerMin;
+    s.coverageChecked = _coverageChecked;
+    s.coverageTracked = _coverageTracked;
+    s.coverageHave = _coverageHave;
+    return s;
+}

src/NodeStats.cpp

@@ -0,0 +1,54 @@
+//
+// NodeStats - shared process-wide cache of slow-to-compute stats so that
+// the dashboard and the RPC method getnodestats can both report the same
+// numbers without either one duplicating the HTTP calls or holding up the
+// RPC thread on slow network fetches.
+//
+// The dashboard is the writer: pollBitswapStats() and checkPermanentCoverage()
+// in ConsoleDashboard.cpp populate these fields as they complete. The RPC
+// method getnodestats.cpp is the reader. All accessors are mutex-guarded.
+//
+
+#ifndef DIGIASSET_CORE_NODESTATS_H
+#define DIGIASSET_CORE_NODESTATS_H
+
+#include <cstdint>
+#include <mutex>
+#include <string>
+
+class NodeStats {
+    std::mutex _m;
+    bool _bitswapProbed = false;
+    bool _bitswapAvailable = false;
+    uint64_t _blocksSent = 0;
+    uint64_t _dataSent = 0;
+    double _blocksPerMin = 0.0;
+
+    bool _coverageChecked = false;
+    unsigned int _coverageTracked = 0;
+    unsigned int _coverageHave = 0;
+
+    NodeStats() = default;
+
+public:
+    NodeStats(const NodeStats&) = delete;
+    NodeStats& operator=(const NodeStats&) = delete;
+    static NodeStats& instance();
+
+    void setBitswap(bool available, uint64_t blocksSent, uint64_t dataSent, double blocksPerMin);
+    void setCoverage(unsigned int tracked, unsigned int have);
+
+    struct Snapshot {
+        bool bitswapProbed;
+        bool bitswapAvailable;
+        uint64_t blocksSent;
+        uint64_t dataSent;
+        double blocksPerMin;
+        bool coverageChecked;
+        unsigned int coverageTracked;
+        unsigned int coverageHave;
+    };
+    Snapshot snapshot();
+};
+
+#endif // DIGIASSET_CORE_NODESTATS_H

src/NodeStats.h

@@ -20,6 +20,7 @@ namespace RPC {
         {"getencryptedkey", Methods::getencryptedkey},
         {"getexchangerates", Methods::getexchangerates},
         {"getipfscount", Methods::getipfscount},
+        {"getnodestats", Methods::getnodestats},
         {"getoldstreamkey", Methods::getoldstreamkey},
         {"getpsp", Methods::getpsp},
         {"getrandom", Methods::getrandom},

src/RPC/MethodList.cpp

@@ -26,6 +26,7 @@ namespace RPC {
         extern const Response getencryptedkey(const Json::Value& params);
         extern const Response getexchangerates(const Json::Value& params);
         extern const Response getipfscount(const Json::Value& params);
+        extern const Response getnodestats(const Json::Value& params);
         extern const Response getoldstreamkey(const Json::Value& params);
         extern const Response getpsp(const Json::Value& params);
         extern const Response getrandom(const Json::Value& params);