dgb: M3 §7b ingest-gate scrypt(header) PoW-satisfaction check

CheckProofOfWork second half: the VALIDATE_SCRYPT path now rejects a
header whose scrypt(header) digest exceeds its declared target
(hash > target). Half 1 (target <= pow_limit) already landed; this
closes the missing PoW-satisfaction guard that was a placeholder.

HeaderSample gains a uint64 pow_hash proxy (mirrors ltc coin/header_chain
hash field). Context-free check, run after the pow_limit ceiling and
before the contextual nBits-equality gate, mirroring DigiByte Core
if (UintToArith256(hash) > bnTarget) return false. pow_hash == 0 is the
standalone default (trivially satisfies any target) so every existing
vector is unchanged; the embedded-daemon port fills the real digest into
the same field shape.

+1 vector folded INTO header_chain_test (no new gtest target, #143 trap
avoided): rejects pow_hash > target, accepts == and < boundary, and
confirms a continuity header short-circuits before the PoW check.
header_chain_test 20/20 PASS, build EXIT=0.

Author: frstrtr

src/impl/dgb/coin/header_chain.hpp

@@ -62,14 +62,18 @@ using ::dgb::coin::u256;
 // Minimal header sample the Scrypt-only retarget body consumes. The embedded
 // DigiByte Core port (M3+) carries the full CBlockHeader; the validate() +
 // retarget path needs only the algo bits (disposition + work-credit), the
-// timestamp (timespan), and the expanded difficulty target (averaging).
-// `target` is a fixed-width proxy for the standalone CI guard; the per-algo
-// DigiShield slice swaps arith_uint256 in with the SAME field shape, so the
-// averaging/timespan assembly below is unchanged when the real width lands.
+// timestamp (timespan), the expanded difficulty target (averaging), and the
+// scrypt(header) PoW digest (`pow_hash`, the CheckProofOfWork hash <= target
+// check). `target` and `pow_hash` are fixed-width proxies for the standalone CI
+// guard; the per-algo DigiShield slice swaps arith_uint256 in with the SAME
+// field shape, so the averaging/timespan assembly below is unchanged when the
+// real width lands. pow_hash == 0 is the proxy default for "scrypt(header) not
+// evaluated here" (trivially satisfies any target); the daemon port fills it.
 struct HeaderSample {
     int32_t  n_version = 0;
     int64_t  n_time    = 0;
     uint64_t target    = 0;   // expanded PoW target (smaller == more work)
+    uint64_t pow_hash  = 0;   // scrypt(header) digest; hash <= target == valid PoW
 };
 
 // Outcome of validating + ingesting one header.
@@ -195,9 +199,8 @@ class HeaderChain {
         case HeaderDisposition::VALIDATE_SCRYPT:
         {
             // PoW validate path. A zero target is not a validatable Scrypt
-            // header (the embedded daemon's full scrypt(header) <= target
-            // check lands with the daemon port; the structural guard here is
-            // that a malformed target never credits work).
+            // header (the structural guard here is that a malformed target
+            // never credits work).
             if (h.target == 0)
                 return IngestResult::REJECTED;
 
@@ -213,6 +216,19 @@ class HeaderChain {
             if (m_ds_params.pow_limit != 0 && h.target > m_ds_params.pow_limit)
                 return IngestResult::REJECTED;
 
+            // PoW satisfaction (DigiByte Core CheckProofOfWork second half):
+            // the header's scrypt(header) digest must SATISFY its declared
+            // target -- hash <= target. A header claiming work it does not meet
+            // is consensus-invalid. This is the CONTEXT-FREE PoW check (mirrors
+            // `if (UintToArith256(hash) > bnTarget) return false`), run before
+            // the contextual nBits-equality gate below. pow_hash == 0 is the
+            // standalone proxy for "scrypt(header) not evaluated here" and
+            // trivially satisfies any target, so the chain-helper tests stay
+            // unconstrained; the embedded-daemon port fills pow_hash with the
+            // real Scrypt digest and this gate goes live with the SAME shape.
+            if (h.pow_hash > h.target)
+                return IngestResult::REJECTED;
+
             // Consensus retarget gate: the declared target must equal the
             // DigiShield next-target computed over the Scrypt-only window
             // ending at the CURRENT tip (assembled BEFORE h is appended).

src/impl/dgb/test/header_chain_test.cpp

@@ -272,6 +272,46 @@ TEST(HeaderChainValidate, IngestGateRejectsTargetAbovePowLimit)
               IngestResult::VALIDATED_SCRYPT);
 }
 
+// Ingest-path PoW satisfaction (DigiByte Core CheckProofOfWork second half):
+// a Scrypt header whose scrypt(header) digest is NUMERICALLY GREATER than its
+// declared target does not meet the work it claims and is consensus-invalid --
+// rejected without mutating the chain, independent of the retarget/ceiling
+// gates. Mirrors `if (UintToArith256(hash) > bnTarget) return false`. The
+// pow_hash field defaults to 0 (every brace-init vector above), which trivially
+// satisfies any target, so all chain-helper tests run unchanged; here we set it
+// explicitly to drive the gate. A default-ctor chain leaves the retarget gate
+// and pow_limit ceiling unconfigured, so ONLY this PoW check can fire.
+TEST(HeaderChainValidate, IngestGateRejectsInsufficientScryptPoW)
+{
+    HeaderChain hc;   // gate + ceiling unconfigured: only the PoW check can fire
+
+    // pow_hash strictly ABOVE the declared target: the header does not satisfy
+    // its own difficulty. REJECT, no work credited, chain not extended.
+    HeaderSample weak{SCRYPT, 1000, 100};
+    weak.pow_hash = 101;
+    EXPECT_EQ(hc.validate_and_append(weak), IngestResult::REJECTED);
+    EXPECT_EQ(hc.size(), 0u);
+    EXPECT_EQ(hc.cumulative_work(), 0u);
+
+    // pow_hash == target is the boundary: hash <= target satisfies the work.
+    HeaderSample exact{SCRYPT, 1000, 100};
+    exact.pow_hash = 100;
+    EXPECT_EQ(hc.validate_and_append(exact), IngestResult::VALIDATED_SCRYPT);
+
+    // pow_hash strictly below target also satisfies (more work than required).
+    HeaderSample strong{SCRYPT, 1075, 100};
+    strong.pow_hash = 1;
+    EXPECT_EQ(hc.validate_and_append(strong), IngestResult::VALIDATED_SCRYPT);
+    EXPECT_EQ(hc.size(), 2u);
+
+    // A continuity (non-Scrypt) header never reaches the PoW check: its
+    // disposition short-circuits to ACCEPT_BY_CONTINUITY even with a huge
+    // pow_hash, confirming the gate is Scrypt-path only.
+    HeaderSample cont{SHA256D, 1090, 100};
+    cont.pow_hash = UINT64_MAX;
+    EXPECT_EQ(hc.validate_and_append(cont), IngestResult::ACCEPTED_CONTINUITY);
+}
+
 // ---------------------------------------------------------------------------
 // 256-BIT BOUNDARY (M3 §7b — arith_uint256 swap). Proves, not assumes, that
 // the DigiShield damped multiply runs at TRUE 256-bit width: a uint64/__int128