dgb: M3 §7b MTP monotonicity ingest guard (nTime > median-of-last-11)

Add the daemon-independent, Scrypt-only-walk-safe half of header time
validation: a Scrypt header's nTime must be STRICTLY GREATER than the median
timestamp of the tip and its (up to) 10 nearest ancestors (DigiByte Core
ContextualCheckBlockHeader "time-too-old"). This is the monotonicity floor
the demoted nBits re-derivation gate used to imply, recovered without any
difficulty recompute -- it reads only timestamps already in the local header
chain, so it is safe on a Scrypt-only walk and needs no V4-MultiShield
multi-algo window.

median_time_past() walks ALL appended headers regardless of algo, mirroring
DGB Core's GetMedianTimePast over the block index: continuity (non-Scrypt)
headers DO contribute their timestamps to the median even though their PoW is
never validated and they are never rejected on the gate (accept-by-continuity
is preserved). Genesis (empty chain) returns INT64_MIN -> unconstrained. A
rejection never mutates the chain (checked before push_back).

+4 tests INTO header_chain_test (no new gtest target -> no build.yml
allowlist change, #143 trap avoided): genesis-unconstrained, strict-greater
rejection at/below median, continuity timestamps feed the median, continuity
header itself bypasses the gate. header_chain_test 25/25 PASS, build EXIT=0.

(cherry picked from commit b084acd)

Author: frstrtr

src/impl/dgb/coin/header_chain.hpp

@@ -39,9 +39,11 @@
 // following slice — its inputs are pinned here so the multiply cannot reach a
 // continuity header.
 
+#include <algorithm>
 #include <cstddef>
 #include <cstdint>
 #include <functional>
+#include <limits>
 #include <vector>
 
 #include <impl/dgb/coin/dgb_arith256.hpp>
@@ -253,6 +255,20 @@ class HeaderChain {
             // gate would only deepen the wrong single-algo retarget model). See
             // V37 backlog: full V4 MultiShield recompute.
 
+            // MTP monotonicity (DigiByte Core ContextualCheckBlockHeader
+            // "time-too-old"): a Scrypt header's nTime must be STRICTLY GREATER
+            // than the median timestamp of the tip and its (up to) 10 nearest
+            // ancestors. This is the daemon-independent, Scrypt-only-walk-SAFE
+            // half of header time validation -- it reads ONLY timestamps already
+            // in the local header chain, with no difficulty re-derivation (the
+            // demoted V4-MultiShield recompute). It is also the standard
+            // anti-timewarp monotonicity floor the demoted nBits gate used to
+            // imply. Genesis (empty chain) is unconstrained: median_time_past()
+            // returns INT64_MIN, so the first header always passes. A rejection
+            // never mutates the chain (checked before push_back).
+            if (h.n_time <= median_time_past())
+                return IngestResult::REJECTED;
+
             m_chain.push_back(h);
             m_cumulative_work += work_from_target(h.target);  // credited
             return IngestResult::VALIDATED_SCRYPT;
@@ -305,6 +321,31 @@ class HeaderChain {
     uint64_t    cumulative_work() const { return m_cumulative_work; }
     std::size_t size()            const { return m_chain.size(); }
 
+    // Bitcoin/DigiByte median-time-past span (ContextualCheckBlockHeader uses
+    // the tip + its 10 nearest ancestors == 11 timestamps).
+    static constexpr std::size_t MEDIAN_TIME_SPAN = 11;
+
+    // MedianTimePast: median nTime over the tip and its (up to) MEDIAN_TIME_SPAN
+    // nearest ancestors. Walks ALL appended headers regardless of algo --
+    // DigiByte Core's GetMedianTimePast walks the block index, which interleaves
+    // every algo, so continuity (non-Scrypt) headers DO contribute their
+    // timestamps to the median even though their PoW is never validated. Sorts a
+    // small fixed-size (<= 11) window and returns the upper-middle element
+    // (sorted[n/2]), matching DGB Core. Returns INT64_MIN for an empty chain so
+    // the genesis header is unconstrained.
+    int64_t median_time_past() const
+    {
+        if (m_chain.empty())
+            return std::numeric_limits<int64_t>::min();
+        const std::size_t n = std::min(m_chain.size(), MEDIAN_TIME_SPAN);
+        std::vector<int64_t> times;
+        times.reserve(n);
+        for (std::size_t i = 0; i < n; ++i)
+            times.push_back(m_chain[m_chain.size() - 1 - i].n_time);
+        std::sort(times.begin(), times.end());
+        return times[times.size() / 2];
+    }
+
 private:
     // Work proxy: inversely proportional to the target. The full-width field
     // narrows to low64() for the proxy, keeping cumulative_work byte-identical

src/impl/dgb/test/header_chain_test.cpp

@@ -22,6 +22,7 @@
 
 #include <cstdint>
 #include <cstring>
+#include <limits>
 
 #include <gtest/gtest.h>
 
@@ -560,3 +561,88 @@ TEST(HeaderChainValidate, RealScryptDigestFeedsSatisfactionGate)
     EXPECT_EQ(hc.validate_and_append(weak), IngestResult::REJECTED);
     EXPECT_EQ(hc.size(), 1u);        // unchanged
 }
+
+// ---------------------------------------------------------------------------
+// MTP MONOTONICITY INGEST GUARD (M3 7b -- ContextualCheckBlockHeader
+// "time-too-old"). A Scrypt header's nTime must be STRICTLY GREATER than the
+// median timestamp of the tip and its (up to) 10 nearest ancestors. This is the
+// daemon-independent, Scrypt-only-walk-safe half of header time validation: it
+// reads only timestamps already in the local header chain, no difficulty
+// re-derivation (the demoted V4-MultiShield recompute). Every appended header of
+// EVERY algo contributes to the median exactly as DGB Core's block index does,
+// but only the Scrypt-validated path is rejected on it -- continuity headers are
+// accept-by-continuity and bypass the gate.
+// ---------------------------------------------------------------------------
+TEST(HeaderChainMtp, GenesisIsUnconstrained)
+{
+    // Empty chain -> median_time_past() == INT64_MIN -> any nTime accepted.
+    HeaderChain hc;
+    EXPECT_EQ(hc.median_time_past(), std::numeric_limits<int64_t>::min());
+    EXPECT_EQ(hc.validate_and_append({SCRYPT, 1, 100}),
+              IngestResult::VALIDATED_SCRYPT);
+    EXPECT_EQ(hc.size(), 1u);
+}
+
+TEST(HeaderChainMtp, RejectsTimeNotStrictlyAboveMedian)
+{
+    // Seed 5 monotone Scrypt headers; MTP over the last 5 is sorted[2] == 1200.
+    HeaderChain hc;
+    for (int64_t t : {1000, 1100, 1200, 1300, 1400})
+        ASSERT_EQ(hc.validate_and_append({SCRYPT, t, 100}),
+                  IngestResult::VALIDATED_SCRYPT);
+    EXPECT_EQ(hc.median_time_past(), 1200);
+
+    const std::size_t size_before = hc.size();
+    const uint64_t    work_before = hc.cumulative_work();
+
+    // nTime == median: NOT strictly greater -> reject, no mutation.
+    EXPECT_EQ(hc.validate_and_append({SCRYPT, 1200, 100}),
+              IngestResult::REJECTED);
+    // nTime below median -> reject.
+    EXPECT_EQ(hc.validate_and_append({SCRYPT, 1150, 100}),
+              IngestResult::REJECTED);
+    EXPECT_EQ(hc.size(),            size_before);
+    EXPECT_EQ(hc.cumulative_work(), work_before);
+
+    // nTime strictly above median -> accepted.
+    EXPECT_EQ(hc.validate_and_append({SCRYPT, 1500, 100}),
+              IngestResult::VALIDATED_SCRYPT);
+    EXPECT_EQ(hc.size(), size_before + 1);
+}
+
+TEST(HeaderChainMtp, ContinuityTimestampsContributeToMedian)
+{
+    // A continuity header is NOT MTP-checked (accept-by-continuity), but its
+    // timestamp DOES enter the median window -- DGB Core's GetMedianTimePast
+    // walks every block of every algo.
+    HeaderChain hc;
+    ASSERT_EQ(hc.validate_and_append({SCRYPT,  1000, 100}),
+              IngestResult::VALIDATED_SCRYPT);
+    // Continuity header far in the future: accepted, bypasses MTP.
+    ASSERT_EQ(hc.validate_and_append({SHA256D, 5000, 100}),
+              IngestResult::ACCEPTED_CONTINUITY);
+
+    // Median over the last 2 headers (1000, 5000) is sorted[1] == 5000. A Scrypt
+    // header at 4000 is ABOVE the prior Scrypt time yet <= the continuity-lifted
+    // median, so it is rejected -- proving the continuity timestamp feeds it.
+    EXPECT_EQ(hc.median_time_past(), 5000);
+    EXPECT_EQ(hc.validate_and_append({SCRYPT, 4000, 100}),
+              IngestResult::REJECTED);
+    // Strictly above the continuity-lifted median -> accepted.
+    EXPECT_EQ(hc.validate_and_append({SCRYPT, 6000, 100}),
+              IngestResult::VALIDATED_SCRYPT);
+}
+
+TEST(HeaderChainMtp, ContinuityHeaderItselfBypassesMtp)
+{
+    // A continuity header with a time AT or BELOW the median is still accepted:
+    // the gate is Scrypt-path only.
+    HeaderChain hc;
+    ASSERT_EQ(hc.validate_and_append({SCRYPT, 2000, 100}),
+              IngestResult::VALIDATED_SCRYPT);
+    EXPECT_EQ(hc.median_time_past(), 2000);
+    // A continuity header at 1500 (below the median) is NOT rejected.
+    EXPECT_EQ(hc.validate_and_append({SKEIN, 1500, 100}),
+              IngestResult::ACCEPTED_CONTINUITY);
+    EXPECT_EQ(hc.size(), 2u);
+}