dgb: M3 chain-identity genesis SSOT + standalone regression guard

Factor the DigiByte genesis hashes NodeRPC::check() probes out of rpc.cpp
into the rpc_request.hpp SSOT (DGB_GENESIS_MAIN/TEST + dgb_genesis_hash()
selector), mirroring how the daemon-version floor was made SSOT+guarded.
rpc.cpp now consumes them; the genesis hashes are a bucket-1 isolation
primitive (coin-identity, KEEP per-coin v36/v37, never standardized) --
pinned here only so a standalone TU can guard them.

Add test/genesis_check_test.cpp (7 cases): canonical mainnet/testnet
hashes, main != test (no copy/paste), 64-hex shape, and the IS_TESTNET
selector NodeRPC::check() relies on. Links only the pure SSOT header +
gtest -- no boost::beast transport, builds standalone (7/7 PASS).

CMake/OBJECT-lib registration of this test deferred to the post-#145 base
with the rest of the transport wiring.

Author: frstrtr

src/impl/dgb/coin/rpc.cpp

@@ -12,15 +12,10 @@ namespace dgb
 namespace coin
 {
 
-// DGB chain-identity probe: the DigiByte genesis hash (DigiByte Core v8.26.2
-// kernel/chainparams.cpp). A real digibyted answers getblockheader(genesis);
-// a wrong-coin daemon does not. mainnet/testnet selected by IS_TESTNET.
-static const char* DGB_GENESIS_MAIN =
-    "7497ea1b465eb39f1c8f507bc877078fe016d6fcb6dfad3a64c98dcc6e1e8496";
-static const char* DGB_GENESIS_TEST =
-    "308ea0711d5763be2995670dd9ca9872753561285a84da1d58be58acaa822252";
-
-// DGB_MIN_DAEMON_VERSION / make_gbt_request: see impl/dgb/coin/rpc_request.hpp (oracle SSOT).
+// DGB chain-identity genesis hashes, DGB_MIN_DAEMON_VERSION and
+// make_gbt_request: see impl/dgb/coin/rpc_request.hpp (oracle/identity SSOT).
+// check() probes getblockheader(dgb_genesis_hash(IS_TESTNET)) to confirm the
+// daemon is a real digibyted on the selected network.
 
 NodeRPC::NodeRPC(io::io_context* context, dgb::interfaces::Node* coin, bool testnet)
     : m_context(context), IS_TESTNET(testnet), m_resolver(*context), m_stream(*context),
@@ -205,7 +200,7 @@ nlohmann::json NodeRPC::CallAPIMethod(const std::string& method, const jsonrpccx
 
 bool NodeRPC::check()
 {
-	uint256 genesis = uint256S(IS_TESTNET ? DGB_GENESIS_TEST : DGB_GENESIS_MAIN);
+	uint256 genesis = uint256S(dgb_genesis_hash(IS_TESTNET));
 	bool has_block = check_blockheader(genesis);
 	bool is_main_chain = getblockchaininfo()["chain"].get<std::string>() == "main";
 	nlohmann::json blockchaininfo;

src/impl/dgb/coin/rpc_request.hpp

@@ -49,6 +49,23 @@ inline nlohmann::json make_gbt_request(const std::vector<std::string>& rules)
     return nlohmann::json::object({{"rules", rules}, {"algo", "scrypt"}});
 }
 
+// DGB chain-identity genesis hashes (DigiByte Core kernel/chainparams.cpp).
+// NodeRPC::check() probes getblockheader(genesis) to confirm it is talking to
+// a real digibyted (a wrong-coin daemon does not answer). These are a bucket-1
+// ISOLATION PRIMITIVE -- KEEP per-coin in v36 AND v37, never standardize; they
+// are pinned in this SSOT only so a standalone TU can guard against accidental
+// drift WITHOUT linking the boost::beast transport.
+inline constexpr const char* DGB_GENESIS_MAIN =
+    "7497ea1b465eb39f1c8f507bc877078fe016d6fcb6dfad3a64c98dcc6e1e8496";
+inline constexpr const char* DGB_GENESIS_TEST =
+    "308ea0711d5763be2995670dd9ca9872753561285a84da1d58be58acaa822252";
+
+// The genesis hash NodeRPC::check() probes for the selected network.
+inline const char* dgb_genesis_hash(bool testnet)
+{
+    return testnet ? DGB_GENESIS_TEST : DGB_GENESIS_MAIN;
+}
+
 } // namespace coin
 
 } // namespace dgb

src/impl/dgb/test/genesis_check_test.cpp

@@ -0,0 +1,73 @@
+// ---------------------------------------------------------------------------
+// dgb M3 chain-identity (genesis) regression guard.
+//
+// Pins the DigiByte genesis hashes that NodeRPC::check() probes via
+// getblockheader(dgb_genesis_hash(IS_TESTNET)) to confirm the external
+// digibyted is a real DigiByte node on the selected network. These are a
+// bucket-1 ISOLATION PRIMITIVE -- coin-identity, KEEP per-coin in v36 AND
+// v37, never standardized -- so this guard locks them against accidental
+// drift (a copy/paste from another coin, or main<->test swap) BEFORE the
+// deferred transport wiring lands post-#145 and rpc.cpp finally CI-links.
+//
+// Links ONLY the pure SSOT header (rpc_request.hpp) + gtest -- no
+// boost::beast/jsonrpccxx transport, so it builds standalone without
+// entering the dgb OBJECT lib.
+// ---------------------------------------------------------------------------
+
+#include <cstring>
+
+#include <gtest/gtest.h>
+
+#include <impl/dgb/coin/rpc_request.hpp>
+
+using namespace dgb::coin;
+
+// Canonical values from DigiByte Core kernel/chainparams.cpp. Independent
+// literals so the test fails loudly if the SSOT constant is ever edited.
+static const char* CANON_MAIN =
+    "7497ea1b465eb39f1c8f507bc877078fe016d6fcb6dfad3a64c98dcc6e1e8496";
+static const char* CANON_TEST =
+    "308ea0711d5763be2995670dd9ca9872753561285a84da1d58be58acaa822252";
+
+TEST(DgbGenesis, MainnetHashIsCanonical)
+{
+    EXPECT_STREQ(DGB_GENESIS_MAIN, CANON_MAIN);
+}
+
+TEST(DgbGenesis, TestnetHashIsCanonical)
+{
+    EXPECT_STREQ(DGB_GENESIS_TEST, CANON_TEST);
+}
+
+TEST(DgbGenesis, MainAndTestDiffer)
+{
+    // Guards against a copy/paste that would make both networks probe the
+    // same hash -- a wrong-coin daemon could then pass the testnet check.
+    EXPECT_STRNE(DGB_GENESIS_MAIN, DGB_GENESIS_TEST);
+}
+
+TEST(DgbGenesis, HashesAre64HexChars)
+{
+    EXPECT_EQ(std::strlen(DGB_GENESIS_MAIN), 64u);
+    EXPECT_EQ(std::strlen(DGB_GENESIS_TEST), 64u);
+    for (const char* h : {DGB_GENESIS_MAIN, DGB_GENESIS_TEST})
+        for (const char* c = h; *c; ++c)
+            EXPECT_TRUE(std::isxdigit(static_cast<unsigned char>(*c))) << "non-hex in " << h;
+}
+
+// --- Network selector NodeRPC::check() relies on ---------------------------
+
+TEST(DgbGenesis, SelectorPicksMainnet)
+{
+    EXPECT_STREQ(dgb_genesis_hash(false), DGB_GENESIS_MAIN);
+}
+
+TEST(DgbGenesis, SelectorPicksTestnet)
+{
+    EXPECT_STREQ(dgb_genesis_hash(true), DGB_GENESIS_TEST);
+}
+
+TEST(DgbGenesis, SelectorBranchesDiffer)
+{
+    EXPECT_STRNE(dgb_genesis_hash(true), dgb_genesis_hash(false));
+}