dgb: M3 RPC request-shape SSOT + standalone regression guard

Factor the two oracle-pinned external-RPC contract values out of rpc.cpp
into a pure, dependency-light header (coin/rpc_request.hpp) so they have a
single source of truth and can be guarded by a standalone test that does
NOT link the boost::beast/jsonrpccxx transport (never enters the dgb
OBJECT lib):

  - DGB_MIN_DAEMON_VERSION / daemon_version_acceptable(): getnetworkinfo
    [version] accept floor, conformed to oracle frstrtr/p2pool-dgb-scrypt
    VERSION_CHECK == 82202 (DigiByte Core 7.17.2).
  - make_gbt_request(): getblocktemplate body {rules:[...],algo:scrypt} --
    segwit rule mandatory, scrypt is a SEPARATE algo param, never a rule.

rpc.cpp now consumes the header (behaviour-identical: version compare and
GBT body unchanged on the wire). Adds test/rpc_request_test.cpp (8 gtest
cases) pinning the floor accept/reject boundary (82202 ok / 82201,71700
reject) and the GBT shape incl. the Path-A scrypt-as-rule regression.

Standalone build-verified: g++ -std=c++20, link libgtest -> 8/8 PASS;
rpc.cpp -fsyntax-only EXIT=0. No CMake/OBJECT-lib wiring (deferred post
land-stack); additive coin-layer source only.

Author: frstrtr

src/impl/dgb/coin/rpc.cpp

@@ -2,6 +2,7 @@
 
 #include <impl/dgb/config_pool.hpp>
 #include <impl/dgb/coin/softfork_check.hpp>
+#include <impl/dgb/coin/rpc_request.hpp>
 
 #include <core/log.hpp>
 #include <core/hash.hpp>
@@ -19,12 +20,7 @@ static const char* DGB_GENESIS_MAIN =
 static const char* DGB_GENESIS_TEST =
     "308ea0711d5763be2995670dd9ca9872753561285a84da1d58be58acaa822252";
 
-// Minimum acceptable digibyted getnetworkinfo[\"version\"] int.
-// Floor conformed to oracle frstrtr/p2pool-dgb-scrypt networks/digibyte.py:
-//   VERSION_CHECK = lambda v: None if 82202 <= v else \"...Upgrade to 7.17.2 or newer!\"
-// i.e. DigiByte Core 7.17.2 (oracle HEAD 22761e7). Same getnetworkinfo version field
-// the oracle gates on, so the comparison below is byte-for-byte oracle-equivalent.
-static constexpr int DGB_MIN_DAEMON_VERSION = 82202;
+// DGB_MIN_DAEMON_VERSION / make_gbt_request: see impl/dgb/coin/rpc_request.hpp (oracle SSOT).
 
 NodeRPC::NodeRPC(io::io_context* context, dgb::interfaces::Node* coin, bool testnet)
     : m_context(context), IS_TESTNET(testnet), m_resolver(*context), m_stream(*context),
@@ -223,7 +219,7 @@ bool NodeRPC::check()
 	try
     {
 		auto networkinfo = getnetworkinfo();
-		bool version_check_result = (DGB_MIN_DAEMON_VERSION <= networkinfo["version"].get<int>());
+		bool version_check_result = daemon_version_acceptable(networkinfo["version"].get<int>());
 		if (!version_check_result)
 		{
 			LOG_ERROR << "DigiByte daemon too old! Upgrade!";
@@ -408,10 +404,8 @@ bool NodeRPC::submit_block_hex(const std::string& block_hex, bool ignore_failure
 
 nlohmann::json NodeRPC::getblocktemplate(std::vector<std::string> rules)
 {
-	// DGB GBT: segwit rule set is mandatory (digibyted rejects otherwise), and
-	// the mining algorithm is a separate top-level param. V36 is Scrypt-only.
-	nlohmann::json j = nlohmann::json::object({{"rules", rules}, {"algo", "scrypt"}});
-	return CallAPIMethod("getblocktemplate", {j});
+	// Body shape (segwit rule + separate Scrypt algo param) is the rpc_request.hpp SSOT.
+	return CallAPIMethod("getblocktemplate", {make_gbt_request(rules)});
 }
 
 nlohmann::json NodeRPC::getnetworkinfo()

src/impl/dgb/coin/rpc_request.hpp

@@ -0,0 +1,54 @@
+#pragma once
+
+// ---------------------------------------------------------------------------
+// dgb::coin -- M3 RPC request-shape SSOT (pure, dependency-light).
+//
+// Single source of truth for the two oracle-pinned external-RPC contract
+// values that NodeRPC::check()/getwork() depend on, factored out of rpc.cpp
+// so a standalone test TU can guard them WITHOUT linking the boost::beast /
+// jsonrpccxx transport (i.e. without entering the dgb OBJECT lib):
+//
+//   1. DGB_MIN_DAEMON_VERSION -- the getnetworkinfo["version"] accept floor,
+//      conformed to oracle frstrtr/p2pool-dgb-scrypt networks/digibyte.py
+//      VERSION_CHECK (82202 == DigiByte Core 7.17.2, oracle HEAD 22761e7).
+//   2. make_gbt_request() -- DigiByte getblocktemplate body. DGB GBT requires
+//      the "segwit" rule AND a SEPARATE top-level "algo" param; V36 is
+//      Scrypt-only so algo is always "scrypt". "scrypt" is the mining
+//      algorithm, NOT a BIP9 rule -- the prior Path-A stub note rules=
+//      ["scrypt"] was wrong; the shape is {"rules":[...],"algo":"scrypt"}.
+//
+// Header-only + nlohmann-only: includes nothing from the transport stack, so
+// it builds on master today and the guard test is a clean standalone link.
+// ---------------------------------------------------------------------------
+
+#include <string>
+#include <vector>
+
+#include <nlohmann/json.hpp>
+
+namespace dgb
+{
+
+namespace coin
+{
+
+// Minimum acceptable digibyted getnetworkinfo["version"] int (oracle-equivalent
+// to p2pool-dgb-scrypt VERSION_CHECK: floor 82202 == DigiByte Core 7.17.2).
+inline constexpr int DGB_MIN_DAEMON_VERSION = 82202;
+
+// True iff a daemon advertising getnetworkinfo["version"]==v clears the floor.
+inline bool daemon_version_acceptable(int version)
+{
+    return DGB_MIN_DAEMON_VERSION <= version;
+}
+
+// Build the DigiByte getblocktemplate request body: segwit rule(s) plus the
+// mandatory separate Scrypt algo param. V36 c2pool-dgb is Scrypt-only.
+inline nlohmann::json make_gbt_request(const std::vector<std::string>& rules)
+{
+    return nlohmann::json::object({{"rules", rules}, {"algo", "scrypt"}});
+}
+
+} // namespace coin
+
+} // namespace dgb

src/impl/dgb/test/rpc_request_test.cpp

@@ -0,0 +1,84 @@
+// ---------------------------------------------------------------------------
+// dgb M3 RPC request-shape regression guard.
+//
+// Pins the two oracle-conformed external-RPC contract values that NodeRPC
+// depends on, BEFORE the deferred wiring (CMake + OBJECT-lib reg + ctor swap)
+// lands post-#145 and rpc.cpp finally CI-links. Guards against silent drift of:
+//
+//   1. the getnetworkinfo["version"] accept floor (oracle p2pool-dgb-scrypt
+//      VERSION_CHECK == 82202, DigiByte Core 7.17.2), and
+//   2. the getblocktemplate body shape: DGB requires the "segwit" rule AND a
+//      SEPARATE top-level "algo":"scrypt" param -- "scrypt" must NOT leak into
+//      the rules array (the prior Path-A stub bug rules=["scrypt"]).
+//
+// Links ONLY the pure SSOT header (rpc_request.hpp) + nlohmann + gtest -- no
+// boost::beast/jsonrpccxx transport, so it builds standalone without entering
+// the dgb OBJECT lib.
+// ---------------------------------------------------------------------------
+
+#include <gtest/gtest.h>
+
+#include <impl/dgb/coin/rpc_request.hpp>
+
+using namespace dgb::coin;
+
+// --- Daemon-version accept floor (oracle VERSION_CHECK 82202) ---------------
+
+TEST(DgbRpcRequest, VersionFloorIsOracleValue)
+{
+    EXPECT_EQ(DGB_MIN_DAEMON_VERSION, 82202);  // DigiByte Core 7.17.2
+}
+
+TEST(DgbRpcRequest, VersionAtFloorAccepts)
+{
+    EXPECT_TRUE(daemon_version_acceptable(82202));
+}
+
+TEST(DgbRpcRequest, VersionAboveFloorAccepts)
+{
+    EXPECT_TRUE(daemon_version_acceptable(82203));
+    EXPECT_TRUE(daemon_version_acceptable(90000));
+}
+
+TEST(DgbRpcRequest, VersionBelowFloorRejects)
+{
+    EXPECT_FALSE(daemon_version_acceptable(82201));
+    EXPECT_FALSE(daemon_version_acceptable(71700));  // old placeholder floor
+    EXPECT_FALSE(daemon_version_acceptable(0));
+}
+
+// --- getblocktemplate request body shape ------------------------------------
+
+TEST(DgbRpcRequest, GbtCarriesSeparateScryptAlgo)
+{
+    auto j = make_gbt_request({"segwit"});
+    ASSERT_TRUE(j.contains("algo"));
+    EXPECT_EQ(j["algo"].get<std::string>(), "scrypt");
+}
+
+TEST(DgbRpcRequest, GbtRulesContainSegwit)
+{
+    auto j = make_gbt_request({"segwit"});
+    ASSERT_TRUE(j.contains("rules"));
+    ASSERT_TRUE(j["rules"].is_array());
+    ASSERT_EQ(j["rules"].size(), 1u);
+    EXPECT_EQ(j["rules"][0].get<std::string>(), "segwit");
+}
+
+TEST(DgbRpcRequest, ScryptIsAlgoNotRule)
+{
+    // Regression guard for the Path-A bug: "scrypt" is the mining algorithm,
+    // NOT a BIP9 rule -- it must never appear in the rules array.
+    auto j = make_gbt_request({"segwit"});
+    for (const auto& r : j["rules"])
+        EXPECT_NE(r.get<std::string>(), "scrypt");
+}
+
+TEST(DgbRpcRequest, GbtPreservesCallerRulesAndForcesScrypt)
+{
+    auto j = make_gbt_request({"segwit", "!extra"});
+    ASSERT_EQ(j["rules"].size(), 2u);
+    EXPECT_EQ(j["rules"][0].get<std::string>(), "segwit");
+    EXPECT_EQ(j["rules"][1].get<std::string>(), "!extra");
+    EXPECT_EQ(j["algo"].get<std::string>(), "scrypt");
+}