dgb(#82): construct dgb::Node sharechain peer + bind P2P listener (--run)

Second stacked run-loop slice. main_dgb.cpp --run now constructs the real
dgb::Config + dgb::Node (pool::NodeBridge<NodeImpl, Legacy, Actual>) on the
spine io_context, opens the sharechain LevelDB, and binds the P2P listener on
PoolConfig::P2P_PORT (5024) — the sharechain peer is live, not just the
io_context spine.

Config is set directly from the p2pool-dgb-scrypt oracle constants (PREFIX
1c0553f2..., IDENTIFIER 4b62545b...), skipping Config::init() yaml load, the
same contract main_btc.cpp uses. DEFAULT_BOOTSTRAP_HOSTS is empty until DGB
p2pool nodes come online, so there are no outbound seeds to dial this slice;
the node listens and waits for inbound peers. The per-coin net dir is digibyte/
(bucket-1 isolation).

Constructing the node pulls BaseNode::connected (boost::log) and the NodeImpl
TU, so the c2pool-dgb exe must link the real dgb pool runtime, not just the
header-only score path. Wire the exe to link the dgb OBJECT lib + dgb_coin +
core/pool/sharechain/storage base, mirroring the c2pool-btc link set;
c2pool_merged_mining is pulled for symbol resolution of the core web_server
tangle only (same as c2pool-btc) and does NOT enable -DAUX_DOGE — DGB default
build stays standalone. Only the c2pool-dgb target stanza changes; per-coin
isolation holds.

Build EXIT=0. Smoke: --run binds 0.0.0.0:5024 (ss-confirmed), SIGINT ->
graceful shutdown -> clean exit 0, LevelDB closed cleanly; --selftest still
drives the live score() path; --version OK.

SEAM (next slice): stand up the Stratum work source + bind
make_on_block_found(reconstruct_won_block, p2p_sink) into m_on_block_found
to close the #82 embedded P2P relay path (submitblock RPC fallback at
rpc.cpp:387 is already real, not a stub).

Author: frstrtr

src/c2pool/CMakeLists.txt

@@ -183,14 +183,31 @@ target_link_libraries(c2pool-btc
 # json/Boost. Per-coin isolation held. The embedded run-loop (NodeBridge over
 # digibyted P2P + Stratum) and its pool-runtime link land in a later Phase B
 # slice.
-add_executable(c2pool-dgb
-    main_dgb.cpp
-    ${CMAKE_SOURCE_DIR}/src/core/uint256.cpp
-)
+# RUN-LOOP slice (#82): main_dgb.cpp --run now constructs dgb::Config + the
+# dgb::Node sharechain peer (pool::NodeBridge<NodeImpl,...>) and binds its P2P
+# listener, so the exe must link the real dgb pool runtime — not just the
+# header-only score path. We link the `dgb` OBJECT lib (node.cpp + protocol
+# handlers) and the shared core/pool/sharechain/storage base it sits on,
+# mirroring the c2pool-btc link set. c2pool_merged_mining is pulled for SYMBOL
+# RESOLUTION of the core web_server/stratum tangle ONLY (same reason c2pool-btc
+# links it) — it does NOT enable -DAUX_DOGE; DGB default build stays standalone
+# (no DOGE aux). core provides core/uint256.cpp, so the explicit source is
+# dropped to avoid a duplicate-symbol link. Per-coin isolation holds: only the
+# c2pool-dgb target stanza changes.
+add_executable(c2pool-dgb main_dgb.cpp)
 target_compile_definitions(c2pool-dgb PRIVATE C2POOL_VERSION="${C2POOL_GIT_VERSION}")
 target_link_libraries(c2pool-dgb
-    btclibs  # STATIC util lib: HexStr/HexDigit (strencodings) for base_uint hex - pure utility, no pool runtime
-    yaml-cpp::yaml-cpp  # config_{coin,pool}.hpp -> core/netaddress.hpp -> <yaml-cpp/yaml.h>
+    c2pool_payout
+    c2pool_merged_mining  # symbol resolution for core web_server tangle (NOT -DAUX_DOGE)
+    c2pool_hashrate
+    core
+    dgb        # DGB pool-layer OBJECT lib: node.cpp NodeImpl + protocol handlers
+    dgb_coin   # DGB coin-layer: embedded P2P + mempool + transaction ctors
+    pool
+    sharechain
+    c2pool_storage
+    btclibs
+    yaml-cpp::yaml-cpp
     nlohmann_json::nlohmann_json
     ${Boost_LIBRARIES}
 )

src/c2pool/main_dgb.cpp

@@ -26,12 +26,17 @@
 
 #include <impl/dgb/node.hpp>
 
+#include <core/filesystem.hpp>
+#include <btclibs/util/strencodings.h>
+
 #include <boost/asio.hpp>
 
 #include <cstdint>
 #include <cstring>
+#include <filesystem>
 #include <iostream>
 #include <string>
+#include <system_error>
 
 #ifndef C2POOL_VERSION
 #define C2POOL_VERSION "dev"
@@ -93,28 +98,54 @@ int run_selftest(const core::CoinParams& params)
     return 0;
 }
 
-// Run-loop SPINE. Stands up the io_context that every node subsystem
-// (sharechain peer dgb::Node, embedded digibyted P2P, Stratum acceptor) and
-// the #82 won-block dispatch handler will hang off, plus an explicit graceful
-// shutdown driven from boost::asio::signal_set.
+// Run-loop SPINE + sharechain peer bring-up. Stands up the io_context that
+// every node subsystem hangs off, an explicit graceful shutdown driven from
+// boost::asio::signal_set, and (this slice) constructs the dgb::Config +
+// dgb::Node sharechain peer and binds its P2P listener.
 //
 // Why signal_set and not std::signal: std::signal handlers run in the
 // async-signal-only delivery context; io_context::stop is thread-safe but not
 // documented signal-safe. signal_set delivers SIGINT/SIGTERM as an ordinary
 // async callback on the io_context thread, so the shutdown path can do real
 // work (stop the stratum acceptor, close sessions) before ioc.stop() drains
-// the rest — mirrors main_btc.cpp s teardown contract.
+// the rest — mirrors main_btc.cpp's teardown contract.
 //
-// SEAM (next stacked slice): construct dgb::Config + dgb::Node(&ioc, &config),
-// listen on the sharechain P2P port, stand up the Stratum work source, and
-// bind make_on_block_found(reconstruct_won_block, p2p_sink) into
-// m_on_block_found so a won share reaches the network (closes #82). Those
-// subsystems open LevelDB + bind sockets, so they land as their own
-// build-verified increment rather than inline here.
-int run_node(const core::CoinParams& params)
+// SEAM (next stacked slice): stand up the Stratum work source and bind
+// make_on_block_found(reconstruct_won_block, p2p_sink) into m_on_block_found
+// so a won share reaches the network (closes #82's embedded P2P relay path);
+// the submitblock RPC fallback (rpc.cpp:387, already real — NOT a stub) is the
+// second arm of the dual-path broadcaster gate.
+int run_node(const core::CoinParams& params, bool testnet)
 {
     io::io_context ioc;
 
+    // Per-coin config root: ~/.c2pool/<net>/ (sharechain LevelDB + addrs.json
+    // open underneath). Bucket-1 isolation primitive: DGB never shares LTC's
+    // net dir — keep the subdir per-coin in v36 AND v37.
+    const std::string net_subdir = testnet ? "digibyte_testnet" : "digibyte";
+    const std::filesystem::path net_dir =
+        core::filesystem::config_path() / net_subdir;
+    std::error_code mkdir_ec;
+    std::filesystem::create_directories(net_dir, mkdir_ec);  // best effort
+
+    // dgb::Config = core::Config<PoolConfig, CoinConfig>. Skip Config::init()
+    // (it would load pool.yaml + coin.yaml from disk); set the sharechain
+    // identity directly from the oracle-sourced constants instead — the same
+    // contract main_btc.cpp uses for its net smoke. prefix/identifier come from
+    // the p2pool-dgb-scrypt oracle (PREFIX 1c0553f2…, IDENTIFIER 4b62545b…).
+    dgb::Config config(net_subdir);
+    config.pool()->m_prefix = ParseHexBytes(dgb::PoolConfig::DEFAULT_PREFIX_HEX);
+    config.m_testnet        = testnet;
+    // DEFAULT_BOOTSTRAP_HOSTS is empty until DGB p2pool nodes come online, so
+    // there are no outbound seeds to dial this slice — the node binds its
+    // listener and waits for inbound sharechain peers.
+    for (const auto& host : dgb::PoolConfig::DEFAULT_BOOTSTRAP_HOSTS) {
+        const std::string addr = host.find(':') == std::string::npos
+            ? host + ":" + std::to_string(dgb::PoolConfig::P2P_PORT)
+            : host;
+        config.pool()->m_bootstrap_addrs.emplace_back(addr);
+    }
+
     bool shutdown_initiated = false;
     io::signal_set signals(ioc, SIGINT, SIGTERM);
     signals.async_wait(
@@ -126,13 +157,29 @@ int run_node(const core::CoinParams& params)
             std::cout << "[DGB] received signal " << signo
                       << " — initiating graceful shutdown" << std::endl;
             // Next slice: stop stratum acceptor + close sessions here BEFORE
-            // ioc.stop(), so their pending async ops cancel cleanly.
+            // ioc.stop(), so their pending async ops cancel cleanly. The
+            // sharechain peer's sockets close when p2p_node destructs at scope
+            // exit after ioc.run() returns.
             ioc.stop();
         });
 
-    std::cout << "[DGB] run-loop spine up: " << network_summary(params) << "\n";
+    // Sharechain peer node: pool::NodeBridge<NodeImpl, Legacy, Actual>. The
+    // NodeImpl ctor opens ~/.c2pool/<net>/sharechain_leveldb and seeds the addr
+    // store from m_bootstrap_addrs, so config must be populated BEFORE
+    // construction (above).
+    dgb::Node p2p_node(&ioc, &config);
+    p2p_node.set_target_outbound_peers(4);
+    p2p_node.core::Server::listen(dgb::PoolConfig::P2P_PORT);
+    std::cout << "[DGB] sharechain peer listening on port "
+              << dgb::PoolConfig::P2P_PORT
+              << " — proto adv=" << dgb::PoolConfig::ADVERTISED_PROTOCOL_VERSION
+              << " min=" << dgb::PoolConfig::MINIMUM_PROTOCOL_VERSION
+              << " prefix=" << dgb::PoolConfig::DEFAULT_PREFIX_HEX << std::endl;
+    p2p_node.start_outbound_connections();  // no-op until seed hosts exist
+
+    std::cout << "[DGB] run-loop up: " << network_summary(params) << "\n";
     std::cout << "[DGB] io_context running. Ctrl-C to stop. "
-              << "(node/stratum/P2P + won-block dispatch bind in the next slice)"
+              << "(Stratum work source + won-block dispatch bind in the next slice)"
               << std::endl;
 
     ioc.run();
@@ -166,7 +213,7 @@ int main(int argc, char** argv)
 
     // --run: stand up the run-loop spine (io_context + graceful shutdown).
     if (want_run)
-        return run_node(params);
+        return run_node(params, /*testnet=*/false);
 
     // --selftest, or a bare invocation: drive the live score path so the
     // binary exercises real consensus code, then exit cleanly.