From fa7e191f44d9dee7a3d7bfea80fbf452353ae60d Mon Sep 17 00:00:00 2001
From: AlphaPool <noreply@alphapool.tech>
Date: Sat, 17 Oct 2026 02:14:42 +0000
Subject: [PATCH 1/4] consensus: Keep rolling coinbase maturity until RDTS
 expiry

Reuse the RDTS parent-MTP expiry on mainnet, preserving testnet4 and existing policy. Bound revalidation by parent MTP while still rewinding unchecked pre-expiry history on upgrades after expiry. Add synthetic expiry parameters and boundary/marker units.
---
 src/chainparams.cpp                           |  29 +++-
 src/chainparamsbase.cpp                       |   3 +-
 src/consensus/params.h                        |  18 ++-
 src/kernel/chainparams.cpp                    |  11 +-
 src/kernel/chainparams.h                      |   2 +
 src/rpc/blockchain.cpp                        |  14 +-
 src/rpc/mining.cpp                            |   2 +-
 src/test/coinbase_maturity_tests.cpp          | 145 ++++++++++++-----
 .../validation_chainstatemanager_tests.cpp    | 151 ++++++++++++++++--
 src/validation.cpp                            |  30 +++-
 .../mempool_long_coinbase_maturity.py         |  11 +-
 11 files changed, 338 insertions(+), 78 deletions(-)

diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index e2851d88c986..1a2c3243f4d9 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -103,31 +103,50 @@ void ReadRegTestArgs(const ArgsManager& args, CChainParams::RegTestOptions& opti
 
     if (const auto arg{args.GetArg("-testcoinbasematuritylong")}; arg) {
         const auto values{SplitString(*arg, ':')};
-        if (values.size() != 3) {
-            throw std::runtime_error(strprintf("Invalid format (%s) for -testcoinbasematuritylong=<start_height>:<enforce_height>:<release_height>.", *arg));
+        if (values.size() < 3 || values.size() > 4) {
+            throw std::runtime_error(strprintf("Invalid format (%s) for -testcoinbasematuritylong=<start_height>:<enforce_height>:<release_height>[:<maturity>].", *arg));
         }
 
         int32_t start_height;
         int32_t enforce_height;
         int32_t release_height;
         if (!ParseInt32(values[0], &start_height) || start_height < 0 || start_height >= std::numeric_limits<int>::max()) {
-            throw std::runtime_error(strprintf("Invalid start height (%s) for -testcoinbasematuritylong=<start_height>:<enforce_height>:<release_height>.", values[0]));
+            throw std::runtime_error(strprintf("Invalid start height (%s) for -testcoinbasematuritylong=<start_height>:<enforce_height>:<release_height>[:<maturity>].", values[0]));
         }
         if (!ParseInt32(values[1], &enforce_height) || enforce_height < 2 || enforce_height >= std::numeric_limits<int>::max()) {
-            throw std::runtime_error(strprintf("Invalid enforce height (%s) for -testcoinbasematuritylong=<start_height>:<enforce_height>:<release_height>.", values[1]));
+            throw std::runtime_error(strprintf("Invalid enforce height (%s) for -testcoinbasematuritylong=<start_height>:<enforce_height>:<release_height>[:<maturity>].", values[1]));
         }
         if (!ParseInt32(values[2], &release_height) || release_height <= start_height || release_height <= enforce_height || release_height >= std::numeric_limits<int>::max()) {
-            throw std::runtime_error(strprintf("Invalid release height (%s) for -testcoinbasematuritylong=<start_height>:<enforce_height>:<release_height>.", values[2]));
+            throw std::runtime_error(strprintf("Invalid release height (%s) for -testcoinbasematuritylong=<start_height>:<enforce_height>:<release_height>[:<maturity>].", values[2]));
         }
         if (release_height - start_height <= COINBASE_MATURITY) {
             throw std::runtime_error(strprintf("Invalid height range (%s) for -testcoinbasematuritylong=<start_height>:<enforce_height>:<release_height>: release_height - start_height must exceed COINBASE_MATURITY.", *arg));
         }
 
+        if (values.size() == 4) {
+            int32_t maturity;
+            if (!ParseInt32(values[3], &maturity) || maturity < COINBASE_MATURITY || maturity >= std::numeric_limits<int>::max()) {
+                throw std::runtime_error(strprintf("Invalid maturity (%s) for -testcoinbasematuritylong.", values[3]));
+            }
+            options.coinbase_maturity_long_maturity = maturity;
+        }
+
         options.coinbase_maturity_long_start_height = start_height;
         options.coinbase_maturity_long_enforce_height = enforce_height;
         options.coinbase_maturity_long_release_height = release_height;
     }
 
+    if (const auto arg{args.GetArg("-testcoinbasematuritylongexpiry")}; arg) {
+        int64_t expiry;
+        if (!options.coinbase_maturity_long_start_height || !ParseInt64(*arg, &expiry) || expiry <= 1296688602) {
+            throw std::runtime_error("Invalid expiry for -testcoinbasematuritylongexpiry: requires -testcoinbasematuritylong and a time after regtest genesis (1296688602).");
+        }
+        if (options.rdts_expiry_time && *options.rdts_expiry_time != expiry) {
+            throw std::runtime_error("-testcoinbasematuritylongexpiry must match -rdtsexpiry when both are specified.");
+        }
+        options.coinbase_maturity_long_expiry_time = expiry;
+    }
+
     for (const std::string& strDeployment : args.GetArgs("-vbparams")) {
         std::vector<std::string> vDeploymentParams = SplitString(strDeployment, ':');
         if (vDeploymentParams.size() < 3 || 7 < vDeploymentParams.size()) {
diff --git a/src/chainparamsbase.cpp b/src/chainparamsbase.cpp
index de5a866c7c4f..88bebb86dbfd 100644
--- a/src/chainparamsbase.cpp
+++ b/src/chainparamsbase.cpp
@@ -19,7 +19,8 @@ void SetupChainParamsBaseOptions(ArgsManager& argsman)
     argsman.AddArg("-testactivationheight=name@height.", "Set the activation height of 'name' (segwit, bip34, dersig, cltv, csv, blake2b). (regtest-only)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-rdtsexpiry=<time>", "Schedule the RDTS expiry: RDTS rules apply to blocks from the blake2b activation height until the parent block's median-time-past reaches <time>. Requires -testactivationheight=blake2b@<height>. (regtest-only)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-blake2b_headline=<headline>", "Specify consensus-critical proof-of-time news headline. Requires -testactivationheight=blake2b@<height>. (regtest-only)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
-    argsman.AddArg("-testcoinbasematuritylong=<start_height>:<enforce_height>:<release_height>", "Set long coinbase maturity parameters. Note that <start_height> must not be changed once used with a chainstate. (regtest-only)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
+    argsman.AddArg("-testcoinbasematuritylongexpiry=<time>", "Set the parent median time past releasing long coinbase consensus maturity to 100; requires -testcoinbasematuritylong. Policy and wallet retain the long depth. Must match -rdtsexpiry if set. (regtest-only)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
+    argsman.AddArg("-testcoinbasematuritylong=<start_height>:<enforce_height>:<release_height>[:<maturity>]", "Set the original long coinbase maturity schedule, continuing the same rolling depth until RDTS expiry. Optional <maturity> overrides the original depth for synthetic boundary tests. Use -testcoinbasematuritylongexpiry to set the expiry (otherwise -rdtsexpiry, or no expiry if neither is set). Note that <start_height> must not be changed once used with a chainstate. (regtest-only)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-testnet", "Use the testnet3 chain. Equivalent to -chain=test. Support for testnet3 is deprecated and will be removed in an upcoming release. Consider moving to testnet4 now by using -testnet4.", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
     argsman.AddArg("-testnet4", "Use the testnet4 chain. Equivalent to -chain=testnet4.", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
     argsman.AddArg("-vbparams=deployment:start:end[:min_activation_height]", "Use given start/end times and min_activation_height for specified version bits deployment (regtest-only)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CHAINPARAMS);
diff --git a/src/consensus/params.h b/src/consensus/params.h
index 45ef3291eedf..6f03f05aa3fe 100644
--- a/src/consensus/params.h
+++ b/src/consensus/params.h
@@ -107,6 +107,8 @@ struct ChainstateRevalidationDeployment {
     int start_height{std::numeric_limits<int>::max()};
     /** Last block height whose cached validation may be invalidated. */
     int stop_height{std::numeric_limits<int>::max()};
+    /** Exclude blocks whose parent median time past has reached this time. */
+    int64_t stop_time{std::numeric_limits<int64_t>::max()};
 };
 
 /**
@@ -153,13 +155,25 @@ struct Params {
      * behaviour is unchanged on chains that do not set it.
      */
     int64_t RdtsExpiryTime{std::numeric_limits<int64_t>::min()};
+    // Only opted-in chains continue rolling maturity until RDTS expires.
     int CoinbaseMaturityLong{COINBASE_MATURITY};
+    bool CoinbaseMaturityLongUntilRdts{false};
     int CoinbaseMaturityLongStartHeight{std::numeric_limits<int>::max()};
     int CoinbaseMaturityLongEnforceHeight{std::numeric_limits<int>::max()};
     int CoinbaseMaturityLongReleaseHeight{std::numeric_limits<int>::max()};
-    bool CoinbaseMaturityLongActiveAt(int height) const
+    int CoinbaseMaturityLongAt(int height, int64_t mtp_prev) const
     {
-        return height >= CoinbaseMaturityLongEnforceHeight && height < CoinbaseMaturityLongReleaseHeight;
+        if (height < CoinbaseMaturityLongEnforceHeight) return COINBASE_MATURITY;
+        if (CoinbaseMaturityLongUntilRdts) return mtp_prev < RdtsExpiryTime ? CoinbaseMaturityLong : COINBASE_MATURITY;
+        return height < CoinbaseMaturityLongReleaseHeight ? CoinbaseMaturityLong : COINBASE_MATURITY;
+    }
+    bool CoinbaseMaturityLongActiveAt(int height, int64_t mtp_prev) const
+    {
+        return CoinbaseMaturityLongAt(height, mtp_prev) > COINBASE_MATURITY;
+    }
+    int CoinbaseMaturityAt(int coin_height, int spend_height, int64_t mtp_prev) const
+    {
+        return coin_height >= CoinbaseMaturityLongStartHeight ? CoinbaseMaturityLongAt(spend_height, mtp_prev) : COINBASE_MATURITY;
     }
     std::vector<ChainstateRevalidationDeployment> chainstate_revalidation_deployments;
     /** Don't warn about unknown BIP 9 activations below this height.
diff --git a/src/kernel/chainparams.cpp b/src/kernel/chainparams.cpp
index 5c2279555ea7..66a87b647a48 100644
--- a/src/kernel/chainparams.cpp
+++ b/src/kernel/chainparams.cpp
@@ -82,7 +82,11 @@ static void AddLongCoinbaseMaturityRevalidationDeployment(Consensus::Params& con
     consensus.chainstate_revalidation_deployments.push_back({
         .name = "long_coinbase_maturity",
         .start_height = consensus.CoinbaseMaturityLongEnforceHeight,
-        .stop_height = consensus.CoinbaseMaturityLongReleaseHeight - 1,
+        // Extending the existing marker makes #419 nodes revalidate from
+        // the old release height, even on upgrade after expiry. With no marker,
+        // start at enforcement. Expired blocks still inherit demoted ancestors.
+        .stop_height = consensus.CoinbaseMaturityLongUntilRdts ? std::numeric_limits<int>::max() : consensus.CoinbaseMaturityLongReleaseHeight - 1,
+        .stop_time = consensus.CoinbaseMaturityLongUntilRdts ? consensus.RdtsExpiryTime : std::numeric_limits<int64_t>::max(),
     });
 }
 
@@ -143,6 +147,7 @@ class CMainParams : public CChainParams {
         consensus.CoinbaseMaturityLongStartHeight = 973440;
         consensus.CoinbaseMaturityLongEnforceHeight = 973440;
         consensus.CoinbaseMaturityLongReleaseHeight = 979920;
+        consensus.CoinbaseMaturityLongUntilRdts = true;
         consensus.CoinbaseMaturityLong = consensus.CoinbaseMaturityLongReleaseHeight - consensus.CoinbaseMaturityLongStartHeight;
         AddLongCoinbaseMaturityRevalidationDeployment(consensus);
 
@@ -690,7 +695,9 @@ class CRegTestParams : public CChainParams
             consensus.CoinbaseMaturityLongStartHeight = *opts.coinbase_maturity_long_start_height;
             consensus.CoinbaseMaturityLongEnforceHeight = *opts.coinbase_maturity_long_enforce_height;
             consensus.CoinbaseMaturityLongReleaseHeight = *opts.coinbase_maturity_long_release_height;
-            consensus.CoinbaseMaturityLong = consensus.CoinbaseMaturityLongReleaseHeight - consensus.CoinbaseMaturityLongStartHeight;
+            consensus.CoinbaseMaturityLong = opts.coinbase_maturity_long_maturity.value_or(consensus.CoinbaseMaturityLongReleaseHeight - consensus.CoinbaseMaturityLongStartHeight);
+            consensus.CoinbaseMaturityLongUntilRdts = true;
+            consensus.RdtsExpiryTime = opts.coinbase_maturity_long_expiry_time.value_or(opts.rdts_expiry_time.value_or(std::numeric_limits<int64_t>::max()));
             AddLongCoinbaseMaturityRevalidationDeployment(consensus);
         }
 
diff --git a/src/kernel/chainparams.h b/src/kernel/chainparams.h
index 34734a6fb48b..e1a6d691ba72 100644
--- a/src/kernel/chainparams.h
+++ b/src/kernel/chainparams.h
@@ -174,6 +174,8 @@ class CChainParams
         std::optional<int> coinbase_maturity_long_start_height{};
         std::optional<int> coinbase_maturity_long_enforce_height{};
         std::optional<int> coinbase_maturity_long_release_height{};
+        std::optional<int> coinbase_maturity_long_maturity{};
+        std::optional<int64_t> coinbase_maturity_long_expiry_time{};
     };
 
     static std::unique_ptr<const CChainParams> RegTest(const RegTestOptions& options);
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 8af7a86aae01..a910271a9091 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -1911,9 +1911,9 @@ namespace {
 const std::vector<RPCResult> RPCHelpForDeployment{
     {RPCResult::Type::STR, "type", "one of \"buried\", \"bip9\", \"flagday\""},
     {RPCResult::Type::NUM, "height", /*optional=*/true, "height of the first block which enforces the rules (only for \"buried\" and \"flagday\" types, or \"bip9\" type with \"active\" status)"},
-    {RPCResult::Type::NUM, "height_end", /*optional=*/true, "height of the last block which enforces the rules (only for temporary deployments)"},
+    {RPCResult::Type::NUM, "height_end", /*optional=*/true, "height of the last block which enforces the rules (only for temporary deployments with a height-based release)"},
     {RPCResult::Type::NUM, "coinbase_start_height", /*optional=*/true, "height of the first generated coin covered by the long coinbase maturity rule (only for \"long_coinbase_maturity\")"},
-    {RPCResult::Type::NUM, "maturity", /*optional=*/true, "required coinbase maturity depth for covered generated coins (only for \"long_coinbase_maturity\")"},
+    {RPCResult::Type::NUM, "maturity", /*optional=*/true, "configured long coinbase maturity depth for covered generated coins (policy and wallet may retain this depth after consensus expiry) (only for \"long_coinbase_maturity\")"},
     {RPCResult::Type::BOOL, "active", "true if the consensus rules are enforced for the next block (policy may enforce related rules independently of this flag)"},
     {RPCResult::Type::NUM_TIME, "expiry_time", /*optional=*/true, "median time past at and after which the rules are no longer enforced (only for \"flagday\" type; a block is past expiry when its parent's median time past has reached this value)"},
     {RPCResult::Type::OBJ, "bip9", /*optional=*/true, "status of bip9 softforks (only for \"bip9\" type)",
@@ -1964,15 +1964,19 @@ void RdtsFlagDayDescPushBack(const CBlockIndex* blockindex, UniValue& softforks,
 void LongCoinbaseMaturityDescPushBack(const CBlockIndex* blockindex, UniValue& softforks, const ChainstateManager& chainman)
 {
     const Consensus::Params& params{chainman.GetConsensus()};
-    if (params.CoinbaseMaturityLongReleaseHeight == std::numeric_limits<int>::max()) return;
+    if (params.CoinbaseMaturityLongStartHeight == std::numeric_limits<int>::max()) return;
 
     UniValue rv(UniValue::VOBJ);
     rv.pushKV("type", "flagday");
     rv.pushKV("height", params.CoinbaseMaturityLongEnforceHeight);
-    rv.pushKV("height_end", params.CoinbaseMaturityLongReleaseHeight - 1);
+    if (params.CoinbaseMaturityLongUntilRdts) {
+        rv.pushKV("expiry_time", params.RdtsExpiryTime);
+    } else {
+        rv.pushKV("height_end", params.CoinbaseMaturityLongReleaseHeight - 1);
+    }
     rv.pushKV("coinbase_start_height", params.CoinbaseMaturityLongStartHeight);
     rv.pushKV("maturity", params.CoinbaseMaturityLong);
-    rv.pushKV("active", params.CoinbaseMaturityLongActiveAt(blockindex->nHeight + 1));
+    rv.pushKV("active", params.CoinbaseMaturityLongActiveAt(blockindex->nHeight + 1, blockindex->GetMedianTimePast()));
     softforks.pushKV("long_coinbase_maturity", std::move(rv));
 }
 
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 61565468fe05..9fe9aa69d295 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -1084,7 +1084,7 @@ static UniValue TemplateToJSON(const Consensus::Params& consensusParams, const C
     if (rdts_active) {
         aRules.push_back("reduced_data");
     }
-    if (pindexPrev != nullptr && consensusParams.CoinbaseMaturityLongActiveAt(pindexPrev->nHeight + 1)) {
+    if (pindexPrev != nullptr && consensusParams.CoinbaseMaturityLongActiveAt(pindexPrev->nHeight + 1, pindexPrev->GetMedianTimePast())) {
         aRules.push_back("long_coinbase_maturity");
     }
 
diff --git a/src/test/coinbase_maturity_tests.cpp b/src/test/coinbase_maturity_tests.cpp
index 490c3ea8d38a..6bfd1a1f59db 100644
--- a/src/test/coinbase_maturity_tests.cpp
+++ b/src/test/coinbase_maturity_tests.cpp
@@ -3,8 +3,12 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chainparams.h>
+#include <coins.h>
 #include <consensus/consensus.h>
 #include <consensus/params.h>
+#include <consensus/tx_verify.h>
+#include <consensus/validation.h>
+#include <test/util/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
@@ -12,56 +16,117 @@
 
 BOOST_AUTO_TEST_SUITE(coinbase_maturity_tests)
 
-BOOST_AUTO_TEST_CASE(long_maturity_window_boundaries)
-{
-    Consensus::Params params;
-    params.CoinbaseMaturityLongEnforceHeight = 200;
-    params.CoinbaseMaturityLongReleaseHeight = 300;
-
-    BOOST_CHECK(!params.CoinbaseMaturityLongActiveAt(199));
-    BOOST_CHECK(params.CoinbaseMaturityLongActiveAt(200));
-    BOOST_CHECK(params.CoinbaseMaturityLongActiveAt(299));
-    BOOST_CHECK(!params.CoinbaseMaturityLongActiveAt(300));
-    BOOST_CHECK(!params.CoinbaseMaturityLongActiveAt(std::numeric_limits<int>::max()));
-}
-
-BOOST_AUTO_TEST_CASE(long_maturity_derived_from_schedule)
+BOOST_AUTO_TEST_CASE(until_rdts_schedule_boundaries)
 {
     const auto main{CChainParams::Main()};
+    const auto& p{main->GetConsensus()};
+    BOOST_CHECK_EQUAL(p.CoinbaseMaturityLongStartHeight, 973440);
+    BOOST_CHECK_EQUAL(p.CoinbaseMaturityLongEnforceHeight, 973440);
+    BOOST_CHECK_EQUAL(p.CoinbaseMaturityLongReleaseHeight, 979920);
+    BOOST_CHECK(!p.CoinbaseMaturityLongActiveAt(973439, 0));
+    for (const int height : {973440, 979919, 979920, 979921, 2000000, std::numeric_limits<int>::max()}) {
+        BOOST_CHECK(p.CoinbaseMaturityLongActiveAt(height, 0));
+        BOOST_CHECK_EQUAL(p.CoinbaseMaturityAt(973439, height, 0), 100);
+        BOOST_CHECK_EQUAL(p.CoinbaseMaturityAt(973440, height, 0), 6480);
+        BOOST_CHECK_EQUAL(p.CoinbaseMaturityAt(973441, height, 0), 6480);
+    }
+    for (const int height : {973440, 979919, 979920, 979921, 2000000}) {
+        for (const int64_t mtp : {p.RdtsExpiryTime - 1, p.RdtsExpiryTime, p.RdtsExpiryTime + 1}) {
+            BOOST_CHECK_EQUAL(p.CoinbaseMaturityLongAt(height, mtp), mtp < p.RdtsExpiryTime ? 6480 : 100);
+            BOOST_CHECK_EQUAL(p.CoinbaseMaturityAt(973439, height, mtp), 100);
+        }
+    }
     const auto testnet4{CChainParams::TestNet4()};
-    for (const auto* params : {main.get(), testnet4.get()}) {
-        const auto& consensus{params->GetConsensus()};
-        BOOST_CHECK_EQUAL(consensus.CoinbaseMaturityLong, consensus.CoinbaseMaturityLongReleaseHeight - consensus.CoinbaseMaturityLongStartHeight);
-        BOOST_CHECK_GT(consensus.CoinbaseMaturityLong, COINBASE_MATURITY);
-        BOOST_REQUIRE_EQUAL(consensus.chainstate_revalidation_deployments.size(), 1);
-        const auto& deployment{consensus.chainstate_revalidation_deployments.front()};
-        BOOST_CHECK_EQUAL(deployment.name, "long_coinbase_maturity");
-        BOOST_CHECK_EQUAL(deployment.start_height, consensus.CoinbaseMaturityLongEnforceHeight);
-        BOOST_CHECK_EQUAL(deployment.stop_height, consensus.CoinbaseMaturityLongReleaseHeight - 1);
+    const auto& t{testnet4->GetConsensus()};
+    BOOST_CHECK_EQUAL(t.CoinbaseMaturityLongAt(158110, 0), 6705);
+    BOOST_CHECK_EQUAL(t.CoinbaseMaturityLongAt(158111, 0), 100);
+    BOOST_CHECK_EQUAL(t.CoinbaseMaturityLongAt(2000000, 0), 100);
+    for (const auto* chain : {main.get(), testnet4.get()}) {
+        const auto& c{chain->GetConsensus()};
+        BOOST_REQUIRE_EQUAL(c.chainstate_revalidation_deployments.size(), 1);
+        const auto& d{c.chainstate_revalidation_deployments.front()};
+        BOOST_CHECK_EQUAL(d.name, "long_coinbase_maturity");
+        BOOST_CHECK_EQUAL(d.start_height, c.CoinbaseMaturityLongEnforceHeight);
+        BOOST_CHECK_EQUAL(d.stop_height, chain == main.get() ? std::numeric_limits<int>::max() : 158110);
+        BOOST_CHECK_EQUAL(d.stop_time, chain == main.get() ? c.RdtsExpiryTime : std::numeric_limits<int64_t>::max());
     }
+    const auto testnet3{CChainParams::TestNet()};
+    const auto signet{CChainParams::SigNet({})};
+    const auto regtest{CChainParams::RegTest({})};
+    for (const auto* chain : {testnet3.get(), signet.get(), regtest.get()}) {
+        BOOST_CHECK_EQUAL(chain->GetConsensus().CoinbaseMaturityAt(1000, 1000000, 0), 100);
+        BOOST_CHECK(chain->GetConsensus().chainstate_revalidation_deployments.empty());
+    }
+}
 
-    const auto regtest_default{CChainParams::RegTest({})};
-    const auto& default_consensus{regtest_default->GetConsensus()};
-    BOOST_CHECK_EQUAL(default_consensus.CoinbaseMaturityLong, COINBASE_MATURITY);
-    BOOST_CHECK(!default_consensus.CoinbaseMaturityLongActiveAt(0));
-    BOOST_CHECK(default_consensus.chainstate_revalidation_deployments.empty());
-
+BOOST_AUTO_TEST_CASE(regtest_schedule)
+{
     CChainParams::RegTestOptions options;
     options.coinbase_maturity_long_start_height = 10;
     options.coinbase_maturity_long_enforce_height = 20;
     options.coinbase_maturity_long_release_height = 150;
     const auto regtest{CChainParams::RegTest(options)};
-    const auto& consensus{regtest->GetConsensus()};
-    BOOST_CHECK_EQUAL(consensus.CoinbaseMaturityLong, 140);
-    BOOST_CHECK(!consensus.CoinbaseMaturityLongActiveAt(19));
-    BOOST_CHECK(consensus.CoinbaseMaturityLongActiveAt(20));
-    BOOST_CHECK(consensus.CoinbaseMaturityLongActiveAt(149));
-    BOOST_CHECK(!consensus.CoinbaseMaturityLongActiveAt(150));
-    BOOST_REQUIRE_EQUAL(consensus.chainstate_revalidation_deployments.size(), 1);
-    const auto& deployment{consensus.chainstate_revalidation_deployments.front()};
-    BOOST_CHECK_EQUAL(deployment.name, "long_coinbase_maturity");
-    BOOST_CHECK_EQUAL(deployment.start_height, 20);
-    BOOST_CHECK_EQUAL(deployment.stop_height, 149);
+    const auto& p{regtest->GetConsensus()};
+    BOOST_CHECK_EQUAL(p.CoinbaseMaturityLongAt(19, 0), 100);
+    BOOST_CHECK_EQUAL(p.CoinbaseMaturityLongAt(20, 0), 140);
+    BOOST_CHECK_EQUAL(p.CoinbaseMaturityLongAt(149, 0), 140);
+    BOOST_CHECK_EQUAL(p.CoinbaseMaturityLongAt(150, 0), 140);
+    BOOST_CHECK_EQUAL(p.chainstate_revalidation_deployments.front().stop_height, std::numeric_limits<int>::max());
+    options.coinbase_maturity_long_expiry_time = 1800000000;
+    const auto expiring{CChainParams::RegTest(options)};
+    BOOST_CHECK_EQUAL(expiring->GetConsensus().CoinbaseMaturityLongAt(150, 1799999999), 140);
+    BOOST_CHECK_EQUAL(expiring->GetConsensus().CoinbaseMaturityLongAt(150, 1800000000), 100);
+    BOOST_CHECK_EQUAL(expiring->GetConsensus().chainstate_revalidation_deployments.front().stop_time, 1800000000);
+    options.coinbase_maturity_long_maturity = 6480;
+    const auto synthetic{CChainParams::RegTest(options)};
+    BOOST_CHECK_EQUAL(synthetic->GetConsensus().CoinbaseMaturityLongAt(20, 0), 6480);
+}
+
+BOOST_FIXTURE_TEST_CASE(until_rdts_input_depth_boundaries, BasicTestingSetup)
+{
+    const auto chain{CChainParams::Main()};
+    const auto& p{chain->GetConsensus()};
+    for (const int coin_height : {973439, 973440, 973441, 979919, 979920, 2000000}) {
+        CCoinsView base;
+        CCoinsViewCache coins{&base};
+        const COutPoint prevout{Txid::FromUint256(uint256::ONE), 0};
+        coins.AddCoin(prevout, Coin{CTxOut{10000, CScript{} << OP_TRUE}, coin_height, true}, false);
+        CMutableTransaction tx;
+        tx.vin.emplace_back(prevout);
+        tx.vout.emplace_back(9000, CScript{} << OP_TRUE);
+        for (const int64_t mtp : {p.RdtsExpiryTime - 1, p.RdtsExpiryTime, p.RdtsExpiryTime + 1}) {
+            for (const int depth : {99, 100, 6479, 6480, 6481}) {
+                const int height{coin_height + depth};
+                const bool expected{depth >= (coin_height < 973440 || mtp >= p.RdtsExpiryTime ? 100 : 6480)};
+                TxValidationState state;
+                CAmount fee{0};
+                BOOST_CHECK_EQUAL(Consensus::CheckTxInputs(CTransaction{tx}, state, coins, height, fee, CheckTxInputsRules::None,
+                                                         p.CoinbaseMaturityLongAt(height, mtp), p.CoinbaseMaturityLongStartHeight), expected);
+                if (expected) BOOST_CHECK_EQUAL(fee, 1000);
+                else BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-txns-premature-spend-of-coinbase");
+            }
+        }
+    }
+}
+
+BOOST_FIXTURE_TEST_CASE(testnet4_release_unchanged, BasicTestingSetup)
+{
+    const auto chain{CChainParams::TestNet4()};
+    const auto& p{chain->GetConsensus()};
+    CCoinsView base;
+    CCoinsViewCache coins{&base};
+    const COutPoint prevout{Txid::FromUint256(uint256::ONE), 0};
+    coins.AddCoin(prevout, Coin{CTxOut{10000, CScript{} << OP_TRUE}, 151632, true}, false);
+    CMutableTransaction tx;
+    tx.vin.emplace_back(prevout);
+    tx.vout.emplace_back(9000, CScript{} << OP_TRUE);
+    TxValidationState state;
+    CAmount fee{0};
+    // At depth 6479, #419 releases this testnet4 reward in block 158111.
+    BOOST_CHECK(Consensus::CheckTxInputs(CTransaction{tx}, state, coins, 158111, fee, CheckTxInputsRules::None,
+                                        p.CoinbaseMaturityLongAt(158111, 0), p.CoinbaseMaturityLongStartHeight));
+    BOOST_CHECK_EQUAL(fee, 1000);
+    BOOST_CHECK_EQUAL(p.chainstate_revalidation_deployments.front().stop_height, 158110);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/validation_chainstatemanager_tests.cpp b/src/test/validation_chainstatemanager_tests.cpp
index b7cce4a4f0b7..c9f288bed1e0 100644
--- a/src/test/validation_chainstatemanager_tests.cpp
+++ b/src/test/validation_chainstatemanager_tests.cpp
@@ -669,7 +669,7 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_snapshot_init, SnapshotTestSetup)
 
 struct SnapshotRevalidationTestSetup : SnapshotTestSetup {
     SnapshotRevalidationTestSetup()
-        : SnapshotTestSetup{{"-testcoinbasematuritylong=1:2:103"}}
+        : SnapshotTestSetup{{"-testcoinbasematuritylong=1:2:150"}}
     {
     }
 };
@@ -684,27 +684,156 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_snapshot_revalidation_waits_for_backgr
         return chainman.m_blockman.m_block_tree_db->ReadChainstateRevalidationMarker("long_coinbase_maturity", marker);
     };
 
-    // The deployment ends before the snapshot base, so the active snapshot
-    // chainstate must not claim to have revalidated it. The background
-    // chainstate is responsible for validating pre-snapshot history.
-    BOOST_CHECK(!WITH_LOCK(::cs_main, return has_marker()));
+    // Simulate #419's bounded, post-snapshot marker. Background validation
+    // has not reached the snapshot base yet and cannot certify older history.
+    auto* background = chainman.GetAll().front();
+    {
+        DisconnectedBlockTransactions pool{MAX_DISCONNECTED_TX_POOL_BYTES};
+        BlockValidationState state;
+        LOCK2(::cs_main, background->MempoolMutex());
+        BOOST_REQUIRE(background->DisconnectTip(state, &pool));
+        pool.clear();
+        // Direct DisconnectTip bypasses ActivateBestChain candidate maintenance.
+        background->setBlockIndexCandidates.insert(background->m_chain.Tip());
+        BOOST_CHECK_EQUAL(background->m_chain.Height(), 109);
+        marker = {.start_height = 111, .stop_height = 149,
+                  .block_hash = chainman.ActiveChain()[149]->GetBlockHash()};
+        BOOST_REQUIRE(chainman.m_blockman.m_block_tree_db->WriteChainstateRevalidationMarker("long_coinbase_maturity", marker));
+    }
 
     bilingual_str error;
-    BOOST_CHECK(chainman.ActiveChainstate().RewindForChainstateRevalidation(error));
+    {
+        ASSERT_DEBUG_LOG("(height 149)");
+        BOOST_REQUIRE(chainman.ActiveChainstate().RewindForChainstateRevalidation(error));
+    }
     BOOST_CHECK(error.empty());
     BOOST_CHECK_EQUAL(WITH_LOCK(::cs_main, return chainman.ActiveHeight()), 210);
-    BOOST_CHECK(!WITH_LOCK(::cs_main, return has_marker()));
+    BOOST_CHECK_EQUAL(WITH_LOCK(::cs_main, return background->m_chain.Height()), 109);
+    BOOST_REQUIRE(WITH_LOCK(::cs_main, return has_marker()));
+    BOOST_CHECK_EQUAL(marker.start_height, 111);
+    BOOST_CHECK_EQUAL(marker.stop_height, 210);
+    BOOST_CHECK_EQUAL(WITH_LOCK(::cs_main, return chainman.MaybeCompleteSnapshotValidation()), SnapshotCompletionResult::SKIPPED);
 
-    SnapshotCompletionResult res;
-    res = WITH_LOCK(::cs_main, return chainman.MaybeCompleteSnapshotValidation());
-    BOOST_CHECK_EQUAL(res, SnapshotCompletionResult::SUCCESS);
+    // The extended post-snapshot marker survives another startup rewind check.
+    BOOST_REQUIRE(chainman.ActiveChainstate().RewindForChainstateRevalidation(error));
+    BOOST_CHECK_EQUAL(WITH_LOCK(::cs_main, return chainman.ActiveHeight()), 210);
+    BlockValidationState state;
+    BOOST_REQUIRE(background->ActivateBestChain(state));
+    if (!WITH_LOCK(::cs_main, return chainman.IsSnapshotValidated())) {
+        BOOST_CHECK_EQUAL(WITH_LOCK(::cs_main, return chainman.MaybeCompleteSnapshotValidation()), SnapshotCompletionResult::SUCCESS);
+    }
+    BOOST_CHECK(WITH_LOCK(::cs_main, return chainman.IsSnapshotValidated()));
     BOOST_REQUIRE(WITH_LOCK(::cs_main, return has_marker()));
     BOOST_CHECK_EQUAL(marker.start_height, 2);
-    BOOST_CHECK_EQUAL(marker.stop_height, 102);
+    BOOST_CHECK_EQUAL(marker.stop_height, 210);
     const uint256 marker_block_hash = WITH_LOCK(::cs_main, return chainman.ActiveChain()[marker.stop_height]->GetBlockHash());
     BOOST_CHECK_EQUAL(marker.block_hash, marker_block_hash);
 }
 
+struct RollingRevalidationTestSetup : TestChain100Setup {
+    RollingRevalidationTestSetup()
+        : TestChain100Setup{ChainType::REGTEST, {.extra_args = {"-testcoinbasematuritylong=2:2:103"}}}
+    {
+        mineBlocks(20);
+    }
+};
+
+BOOST_FIXTURE_TEST_CASE(chainstatemanager_extends_bounded_maturity_marker, RollingRevalidationTestSetup)
+{
+    auto& chainman{*m_node.chainman};
+    const auto* tip{WITH_LOCK(::cs_main, return chainman.ActiveTip())};
+    {
+        LOCK(::cs_main);
+        const node::ChainstateRevalidationMarker old_marker{
+            .start_height = 2, .stop_height = 102,
+            .block_hash = chainman.ActiveChain()[102]->GetBlockHash()};
+        BOOST_REQUIRE(chainman.m_blockman.m_block_tree_db->WriteChainstateRevalidationMarker("long_coinbase_maturity", old_marker));
+    }
+    bilingual_str error;
+    {
+        ASSERT_DEBUG_LOG("(height 102)");
+        BOOST_REQUIRE(chainman.ActiveChainstate().RewindForChainstateRevalidation(error));
+    }
+    BOOST_CHECK(error.empty());
+    BOOST_CHECK_EQUAL(WITH_LOCK(::cs_main, return chainman.ActiveTip()), tip);
+    node::ChainstateRevalidationMarker marker;
+    BOOST_REQUIRE(WITH_LOCK(::cs_main, return chainman.m_blockman.m_block_tree_db->ReadChainstateRevalidationMarker("long_coinbase_maturity", marker)));
+    BOOST_CHECK_EQUAL(marker.start_height, 2);
+    BOOST_CHECK_EQUAL(marker.stop_height, 120);
+    BOOST_CHECK_EQUAL(marker.block_hash, tip->GetBlockHash());
+    BOOST_REQUIRE(chainman.ActiveChainstate().RewindForChainstateRevalidation(error));
+    BOOST_CHECK_EQUAL(WITH_LOCK(::cs_main, return chainman.ActiveTip()), tip);
+}
+
+struct ExpiringRevalidationTestSetup : TestChain100Setup {
+    ExpiringRevalidationTestSetup()
+        : TestChain100Setup{ChainType::REGTEST, {.extra_args = {
+              "-testcoinbasematuritylong=2:2:103", "-testcoinbasematuritylongexpiry=1598888058"}}}
+    {
+        mineBlocks(20);
+    }
+};
+
+BOOST_FIXTURE_TEST_CASE(chainstatemanager_expiry_bounds_marker_and_rewind, ExpiringRevalidationTestSetup)
+{
+    auto& chainman{*m_node.chainman};
+    auto& active{chainman.ActiveChainstate()};
+    const auto* tip{WITH_LOCK(::cs_main, return chainman.ActiveTip())};
+    const auto expiry{chainman.GetConsensus().RdtsExpiryTime};
+    int last_required{0};
+    {
+        LOCK(::cs_main);
+        for (int height{2}; height <= tip->nHeight; ++height) {
+            if (chainman.ActiveChain()[height]->pprev->GetMedianTimePast() < expiry) last_required = height;
+        }
+        BOOST_REQUIRE_GT(last_required, 102);
+        BOOST_REQUIRE_LT(last_required, tip->nHeight);
+        BOOST_CHECK_EQUAL(chainman.ActiveChain()[last_required]->pprev->GetMedianTimePast(), expiry - 1);
+        BOOST_CHECK_EQUAL(chainman.ActiveChain()[last_required + 1]->pprev->GetMedianTimePast(), expiry);
+        const node::ChainstateRevalidationMarker old_marker{
+            .start_height = 2, .stop_height = 102,
+            .block_hash = chainman.ActiveChain()[102]->GetBlockHash()};
+        BOOST_REQUIRE(chainman.m_blockman.m_block_tree_db->WriteChainstateRevalidationMarker("long_coinbase_maturity", old_marker));
+    }
+    bilingual_str error;
+    {
+        // Upgrade after expiry must still rewind pre-expiry history.
+        ASSERT_DEBUG_LOG("(height 102)");
+        BOOST_REQUIRE(active.RewindForChainstateRevalidation(error));
+    }
+    auto check_marker = [&](int height) {
+        LOCK(::cs_main);
+        node::ChainstateRevalidationMarker marker;
+        BOOST_REQUIRE(chainman.m_blockman.m_block_tree_db->ReadChainstateRevalidationMarker("long_coinbase_maturity", marker));
+        BOOST_CHECK_EQUAL(marker.start_height, 2);
+        BOOST_CHECK_EQUAL(marker.stop_height, height);
+        BOOST_CHECK_EQUAL(marker.block_hash, chainman.ActiveChain()[height]->GetBlockHash());
+    };
+    BOOST_CHECK_EQUAL(WITH_LOCK(::cs_main, return chainman.ActiveTip()), tip);
+    check_marker(last_required);
+    BOOST_REQUIRE(active.RewindForChainstateRevalidation(error));
+    check_marker(last_required);
+    {
+        DisconnectedBlockTransactions pool{MAX_DISCONNECTED_TX_POOL_BYTES};
+        BlockValidationState state;
+        LOCK2(::cs_main, active.MempoolMutex());
+        while (active.m_chain.Height() >= last_required) BOOST_REQUIRE(active.DisconnectTip(state, &pool));
+        pool.clear();
+        active.setBlockIndexCandidates.insert(active.m_chain.Tip());
+    }
+    // Across expiry backwards: shared validated ancestry prevents a spurious rewind.
+    BOOST_CHECK_EQUAL(WITH_LOCK(::cs_main, return active.m_chain.Height()), last_required - 1);
+    BOOST_REQUIRE(active.RewindForChainstateRevalidation(error));
+    BOOST_CHECK_EQUAL(WITH_LOCK(::cs_main, return chainman.ActiveTip()), tip);
+    BlockValidationState state;
+    BOOST_REQUIRE(active.ActivateBestChain(state));
+    BOOST_CHECK_EQUAL(WITH_LOCK(::cs_main, return chainman.ActiveTip()), tip);
+    check_marker(last_required);
+    // More expired blocks must not extend the marker.
+    mineBlocks(3);
+    check_marker(last_required);
+}
+
 BOOST_FIXTURE_TEST_CASE(chainstatemanager_snapshot_completion, SnapshotTestSetup)
 {
     this->SetupSnapshot();
diff --git a/src/validation.cpp b/src/validation.cpp
index 26661fbee5aa..37133cc56a97 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -3009,8 +3009,7 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
         }
     }
 
-    const bool long_maturity_consensus_active{consensusParams.CoinbaseMaturityLongActiveAt(pindex->nHeight)};
-    const int long_maturity_start_height{long_maturity_consensus_active ? consensusParams.CoinbaseMaturityLongStartHeight : std::numeric_limits<int>::max()};
+    const int long_maturity{consensusParams.CoinbaseMaturityLongAt(pindex->nHeight, pindex->pprev->GetMedianTimePast())};
 
     std::vector<int> prevheights;
     CAmount nFees = 0;
@@ -3030,8 +3029,8 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
             CAmount txfee = 0;
             TxValidationState tx_state;
             if (!Consensus::CheckTxInputs(tx, tx_state, view, pindex->nHeight, txfee, chk_input_rules,
-                                          consensusParams.CoinbaseMaturityLong,
-                                          long_maturity_start_height)) {
+                                          long_maturity,
+                                          consensusParams.CoinbaseMaturityLongStartHeight)) {
                 // Any transaction validation failure in ConnectBlock is a block consensus failure
                 state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                               tx_state.GetRejectReason(),
@@ -5652,6 +5651,21 @@ bool ChainstateManager::ContinuesSha256dPastFork(const CBlockIndex& index) const
     return fork_block != nullptr && !fork_block->m_header_v2;
 }
 
+namespace {
+int RevalidationStopHeight(const CChain& chain, const Consensus::ChainstateRevalidationDeployment& deployment)
+{
+    int last{std::min(chain.Height(), deployment.stop_height)};
+    if (deployment.stop_time == std::numeric_limits<int64_t>::max()) return last;
+    int first{std::max(1, deployment.start_height)};
+    while (first <= last) {
+        const int mid{first + (last - first) / 2};
+        if (chain[mid]->pprev->GetMedianTimePast() < deployment.stop_time) first = mid + 1;
+        else last = mid - 1;
+    }
+    return last;
+}
+} // namespace
+
 bool Chainstate::UpdateChainstateRevalidationMarkers(BlockValidationState& state)
 {
     AssertLockHeld(cs_main);
@@ -5669,10 +5683,9 @@ bool Chainstate::UpdateChainstateRevalidationMarkers(BlockValidationState& state
     }
     for (const auto& deployment : m_chainman.GetConsensus().chainstate_revalidation_deployments) {
         if (tip.nHeight < deployment.start_height) continue;
-        if (deployment.stop_height < first_validated_height) continue;
-
+        const int checked_height{RevalidationStopHeight(m_chain, deployment)};
         const int start_height{std::max(deployment.start_height, first_validated_height)};
-        const int checked_height{std::min(tip.nHeight, deployment.stop_height)};
+        if (checked_height < start_height) continue;
         const CBlockIndex* checked_block{m_chain[checked_height]};
         node::ChainstateRevalidationMarker marker{
             .start_height = start_height,
@@ -5682,7 +5695,7 @@ bool Chainstate::UpdateChainstateRevalidationMarkers(BlockValidationState& state
 
         auto current_marker{m_blockman.m_chainstate_revalidation_markers.find(deployment.name)};
         if (current_marker != m_blockman.m_chainstate_revalidation_markers.end()) {
-            if (current_marker->second.stop_height > checked_height) {
+            if (current_marker->second.stop_height > checked_height && deployment.stop_time == std::numeric_limits<int64_t>::max()) {
                 const auto& current_stop_block_index{m_chain[current_marker->second.stop_height]};
                 if (current_stop_block_index && current_marker->second.block_hash == current_stop_block_index->GetBlockHash()) {
                     // A newer version enforced the rule longer. Don't undo that
@@ -5777,6 +5790,7 @@ bool Chainstate::RewindForChainstateRevalidation(bilingual_str& error)
                         const auto& deployment{deployments.at(deployment_n)};
                         if (block_index.nHeight < deployment.start_height) continue;
                         if (block_index.nHeight > deployment.stop_height) continue;
+                        if (block_index.pprev->GetMedianTimePast() >= deployment.stop_time) continue;
 
                         if (m_chain.Contains(&block_index)) {
                             const auto& valid_range{valid_in_main_chain.at(deployment_n)};
diff --git a/test/functional/mempool_long_coinbase_maturity.py b/test/functional/mempool_long_coinbase_maturity.py
index d35ac1617529..bd5bd15bf0a5 100755
--- a/test/functional/mempool_long_coinbase_maturity.py
+++ b/test/functional/mempool_long_coinbase_maturity.py
@@ -51,7 +51,8 @@ def assert_deployment(self, active):
         deployment = node.getdeploymentinfo()["deployments"][DEPLOYMENT]
         assert_equal(deployment["type"], "flagday")
         assert_equal(deployment["height"], LONG_ENFORCE_HEIGHT)
-        assert_equal(deployment["height_end"], LONG_RELEASE_HEIGHT - 1)
+        assert "height_end" not in deployment
+        assert_equal(deployment["expiry_time"], 9223372036854775807)
         assert_equal(deployment["coinbase_start_height"], LONG_START_HEIGHT)
         assert_equal(deployment["maturity"], LONG_MATURITY)
         assert_equal(deployment["active"], active)
@@ -119,13 +120,17 @@ def run_test(self):
             block = self.create_next_block()
             assert_equal(node.submitblock(block.serialize().hex()), None)
         assert_equal(node.getblockcount(), LONG_RELEASE_HEIGHT - 1)
-        self.assert_deployment(active=False)
+        self.assert_deployment(active=True)
 
-        self.log.info("Consensus accepts covered rewards at the release height")
+        self.log.info("Covered rewards keep their individual long maturity at the former release")
         coinbase_txid = node.getblock(node.getblockhash(LONG_START_HEIGHT))["tx"][0]
         release_spend = wallet.create_self_transfer(utxo_to_spend=wallet.get_utxo(txid=coinbase_txid))
         node.sendrawtransaction(release_spend["hex"])
         block = self.create_next_block([release_spend["tx"], coinbase_spend["tx"]])
+        assert_equal(node.submitblock(block.serialize().hex()), "bad-txns-premature-spend-of-coinbase")
+        self.generate(wallet, 2)
+        node.sendrawtransaction(coinbase_spend["hex"])
+        block = self.create_next_block([coinbase_spend["tx"]])
         assert_equal(node.submitblock(block.serialize().hex()), None)
 
 

From 2831c4ae190e23bd204a5407088456aa98be287d Mon Sep 17 00:00:00 2001
From: AlphaPool <noreply@alphapool.tech>
Date: Sat, 17 Oct 2026 02:14:43 +0000
Subject: [PATCH 2/4] rpc: Describe applicable coinbase maturity in wallet help

---
 src/wallet/rpc/transactions.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/wallet/rpc/transactions.cpp b/src/wallet/rpc/transactions.cpp
index 648fdd5d9bbf..1bdfcaa11753 100644
--- a/src/wallet/rpc/transactions.cpp
+++ b/src/wallet/rpc/transactions.cpp
@@ -468,8 +468,8 @@ RPCHelpMan listtransactions()
                             {RPCResult::Type::STR, "category", "The transaction category.\n"
                                 "\"send\"                  Transactions sent.\n"
                                 "\"receive\"               Non-coinbase transactions received.\n"
-                                "\"generate\"              Coinbase transactions received with more than 100 confirmations.\n"
-                                "\"immature\"              Coinbase transactions received with 100 or fewer confirmations.\n"
+                                "\"generate\"              Coinbase transactions received with more confirmations than the applicable coinbase maturity.\n"
+                                "\"immature\"              Coinbase transactions received with confirmations at or below the applicable coinbase maturity.\n"
                                 "\"orphan\"                Orphaned coinbase transactions received."},
                             {RPCResult::Type::STR_AMOUNT, "amount", "The amount in " + CURRENCY_UNIT + ". This is negative for the 'send' category, and is positive\n"
                                 "for all other categories"},
@@ -582,8 +582,8 @@ RPCHelpMan listsinceblock()
                                 {RPCResult::Type::STR, "category", "The transaction category.\n"
                                     "\"send\"                  Transactions sent.\n"
                                     "\"receive\"               Non-coinbase transactions received.\n"
-                                    "\"generate\"              Coinbase transactions received with more than 100 confirmations.\n"
-                                    "\"immature\"              Coinbase transactions received with 100 or fewer confirmations.\n"
+                                    "\"generate\"              Coinbase transactions received with more confirmations than the applicable coinbase maturity.\n"
+                                    "\"immature\"              Coinbase transactions received with confirmations at or below the applicable coinbase maturity.\n"
                                     "\"orphan\"                Orphaned coinbase transactions received."},
                                 {RPCResult::Type::STR_AMOUNT, "amount", "The amount in " + CURRENCY_UNIT + ". This is negative for the 'send' category, and is positive\n"
                                     "for all other categories"},
@@ -729,8 +729,8 @@ RPCHelpMan gettransaction()
                                 {RPCResult::Type::STR, "category", "The transaction category.\n"
                                     "\"send\"                  Transactions sent.\n"
                                     "\"receive\"               Non-coinbase transactions received.\n"
-                                    "\"generate\"              Coinbase transactions received with more than 100 confirmations.\n"
-                                    "\"immature\"              Coinbase transactions received with 100 or fewer confirmations.\n"
+                                    "\"generate\"              Coinbase transactions received with more confirmations than the applicable coinbase maturity.\n"
+                                    "\"immature\"              Coinbase transactions received with confirmations at or below the applicable coinbase maturity.\n"
                                     "\"orphan\"                Orphaned coinbase transactions received."},
                                 {RPCResult::Type::STR_AMOUNT, "amount", "The amount in " + CURRENCY_UNIT},
                                 {RPCResult::Type::STR, "label", /*optional=*/true, "A comment for the address/transaction, if any"},

From 416eb90d4b2b79cc9f737151caf19019d600dc33 Mon Sep 17 00:00:00 2001
From: AlphaPool <noreply@alphapool.tech>
Date: Sat, 17 Oct 2026 02:14:43 +0000
Subject: [PATCH 3/4] test: Exercise rolling maturity through expiry and
 upgrades

Adapt the permanent-series boundary, wallet, GBT, reorg, pruning and mixed-binary tests. Cover parent MTP below/at expiry, pre-expiry and post-expiry rewards at depth 100, policy and wallet conservatism, and an upgrade after expiry with a pre-expiry violation.
---
 .../feature_coinbase_maturity_pruned.py       |  43 +++
 .../feature_coinbase_maturity_rolling.py      | 321 ++++++++++++++++++
 .../feature_coinbase_maturity_upgrade.py      | 177 ++++++++++
 test/functional/test_runner.py                |   9 +
 .../wallet_coinbase_maturity_policy.py        |  70 ++++
 5 files changed, 620 insertions(+)
 create mode 100755 test/functional/feature_coinbase_maturity_pruned.py
 create mode 100755 test/functional/feature_coinbase_maturity_rolling.py
 create mode 100755 test/functional/feature_coinbase_maturity_upgrade.py
 create mode 100755 test/functional/wallet_coinbase_maturity_policy.py

diff --git a/test/functional/feature_coinbase_maturity_pruned.py b/test/functional/feature_coinbase_maturity_pruned.py
new file mode 100755
index 000000000000..360004182c45
--- /dev/null
+++ b/test/functional/feature_coinbase_maturity_pruned.py
@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026 The Bitcoin Knots developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Refuse a maturity upgrade needing pruned history before disconnecting."""
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.test_node import ErrorMatch
+from test_framework.util import assert_equal
+from test_framework.wallet import MiniWallet
+
+
+class PrunedCoinbaseMaturityTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 1
+        self.setup_clean_chain = True
+        self.extra_args = [["-prune=1", "-fastprune"]]
+
+    def run_test(self):
+        node = self.nodes[0]
+        self.generate(MiniWallet(node), 1200)
+        tip = node.getbestblockhash()
+        node.pruneblockchain(900)
+        assert node.getblockchaininfo()["pruneheight"] > 103
+        self.stop_node(0)
+        # A node without a deployment marker must revalidate from enforcement.
+        # Pruning has removed required history, although the tip data survives.
+        with node.assert_debug_log(
+            ["required block or undo data has been pruned"],
+            unexpected_msgs=["Chainstate revalidation: rewinding"],
+        ):
+            node.assert_start_raises_init_error(
+                extra_args=self.extra_args[0] + ["-testcoinbasematuritylong=2:2:103"],
+                expected_msg=r"required block data has been pruned[\s\S]*Please restart with -reindex to recover",
+                match=ErrorMatch.PARTIAL_REGEX,
+            )
+        # The failed startup must leave the original active chain untouched.
+        self.start_node(0)
+        assert_equal(node.getbestblockhash(), tip)
+        assert_equal(node.getblockcount(), 1200)
+
+
+if __name__ == "__main__":
+    PrunedCoinbaseMaturityTest(__file__).main()
diff --git a/test/functional/feature_coinbase_maturity_rolling.py b/test/functional/feature_coinbase_maturity_rolling.py
new file mode 100755
index 000000000000..17effe026a99
--- /dev/null
+++ b/test/functional/feature_coinbase_maturity_rolling.py
@@ -0,0 +1,321 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026 The Bitcoin Knots developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Rolling coinbase maturity, policy, wallet, GBT and reorg boundaries.
+
+The default synthetic schedule is small enough for routine CI. --full-depth
+uses mainnet's 6480-block depth. --before-boundary moves the old release later
+to exercise successful spends before that boundary, which cannot occur for
+covered mainnet rewards before 979920.
+"""
+from decimal import Decimal
+
+from test_framework.blocktools import add_witness_commitment, create_block, create_coinbase
+from test_framework.messages import COIN
+from test_framework.script import CScript
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.test_node import ErrorMatch
+from test_framework.util import assert_equal, assert_raises_rpc_error
+from test_framework.wallet import MiniWallet
+
+START = 2
+SMALL_MATURITY = 120
+T0 = 1_800_000_000
+EXPIRY = 1_819_756_800
+REJECT = "bad-txns-premature-spend-of-coinbase"
+DEPLOYMENT = "long_coinbase_maturity"
+
+
+class RollingCoinbaseMaturityTest(BitcoinTestFramework):
+    def add_options(self, parser):
+        self.add_wallet_options(parser)
+        parser.add_argument("--before-boundary", action="store_true")
+        parser.add_argument("--full-depth", action="store_true", help="Exercise the mainnet 6480-block depth (extended suite)")
+
+    def set_test_params(self):
+        self.num_nodes = 1
+        self.setup_clean_chain = True
+        # Reindexing roughly 20,000 blocks can hold the chain lock for longer
+        # than the default RPC timeout.
+        self.rpc_timeout = 600
+        self.enable_wallet_if_possible()
+        self.maturity = 6480 if self.options.full_depth else SMALL_MATURITY
+        self.release = (7000 if self.options.full_depth else 160) if self.options.before_boundary else START + self.maturity
+        self.args = [
+            f"-testcoinbasematuritylong={START}:{START}:{self.release}:{self.maturity}",
+            f"-testcoinbasematuritylongexpiry={EXPIRY}",
+            f"-mocktime={T0}",
+            "-checkmempool=1",
+        ]
+        self.extra_args = [self.args]
+
+    def mine(self, count):
+        node = self.nodes[0]
+        blocks = []
+        while count:
+            chunk = min(count, 256)
+            now = node.getblockheader(node.getbestblockhash())["time"] + chunk + 1
+            node.setmocktime(now)
+            blocks.extend(self.generatetodescriptor(node, chunk, self.wallet.get_descriptor(), sync_fun=self.no_op))
+            count -= chunk
+        return blocks
+
+    def mine_to(self, height):
+        self.mine(height - self.nodes[0].getblockcount())
+
+    def block(self, txs=(), *, timestamp=None, fees=0, script=None):
+        node = self.nodes[0]
+        tip = node.getbestblockhash()
+        height = node.getblockcount() + 1
+        self.block_counter = getattr(self, "block_counter", 0) + 1
+        coinbase = create_coinbase(height, fees=fees, script_pubkey=script)
+        coinbase.vin[0].scriptSig = CScript(bytes(coinbase.vin[0].scriptSig) + bytes(CScript([self.block_counter])))
+        block = create_block(
+            int(tip, 16),
+            coinbase,
+            timestamp or node.getblockheader(tip)["time"] + 1,
+            height=height,
+            txlist=list(txs),
+        )
+        add_witness_commitment(block)
+        block.solve()
+        return block
+
+    def submit(self, block, expected=None):
+        assert_equal(self.nodes[0].submitblock(block.serialize().hex()), expected)
+
+    def spend(self, height, **kwargs):
+        node = self.nodes[0]
+        self.wallet.rescan_utxos()
+        txid = node.getblock(node.getblockhash(height))["tx"][0]
+        return self.wallet.create_self_transfer(utxo_to_spend=next(utxo for utxo in self.wallet.get_utxos(include_immature_coinbase=True) if utxo["txid"] == txid), **kwargs)
+
+    def check_spend(self, tx, *, allowed, policy_allowed=None):
+        node = self.nodes[0]
+        if policy_allowed is None:
+            policy_allowed = allowed
+        result = node.testmempoolaccept([tx["hex"]], 0)[0]
+        assert result["allowed"] == policy_allowed, result
+        if not policy_allowed:
+            assert_equal(result["reject-reason"], REJECT)
+            assert_raises_rpc_error(-26, REJECT, node.sendrawtransaction, tx["hex"])
+        proposal = self.block([tx["tx"]])
+        assert_equal(node.getblocktemplate({"mode": "proposal", "data": proposal.serialize().hex(), "rules": ["segwit"]}), None if allowed else REJECT)
+        if not allowed:
+            self.submit(proposal, REJECT)
+
+    def deployment(self, *, active, maturity):
+        node = self.nodes[0]
+        deployment = node.getdeploymentinfo()["deployments"][DEPLOYMENT]
+        assert_equal(deployment["height"], START)
+        assert_equal(deployment["coinbase_start_height"], START)
+        assert_equal(deployment["expiry_time"], EXPIRY)
+        assert_equal(deployment["maturity"], maturity)
+        assert_equal(deployment["active"], active)
+        assert "height_end" not in deployment
+        assert_equal(DEPLOYMENT in node.getblocktemplate({"rules": ["segwit"]})["rules"], active)
+
+    def wallet_balance(self, *, trusted, immature):
+        if self.is_wallet_compiled():
+            balance = self.nodes[0].getbalances()["mine"]
+            assert_equal(balance["trusted"], trusted)
+            assert_equal(balance["immature"], immature)
+
+    def check_options(self):
+        node = self.nodes[0]
+        self.stop_node(0)
+        for args, message in [
+            (["-testcoinbasematuritylongexpiry=bad"], "Invalid expiry"),
+            (["-testcoinbasematuritylongexpiry=1296688602"], "Invalid expiry"),
+            (["-testcoinbasematuritylong=2:2:6482", "-testcoinbasematuritylongexpiry=1800000000", "-testactivationheight=blake2b@200000", "-rdtsexpiry=1800000001"], "must match"),
+            (["-testcoinbasematuritylong=2:2:6482:bad"], "Invalid maturity"),
+            (["-testcoinbasematuritylong=2:2:6482:99"], "Invalid maturity"),
+            (["-testcoinbasematuritylong=2:2:6482:2147483647"], "Invalid maturity"),
+            (["-testcoinbasematuritylong=2:2:6482:6480:extra"], "Invalid format"),
+        ]:
+            node.assert_start_raises_init_error(extra_args=args, expected_msg=message, match=ErrorMatch.PARTIAL_REGEX)
+        self.start_node(0, extra_args=self.args.copy())
+
+    def run_test(self):
+        self.check_options()
+        if self.is_wallet_compiled():
+            for rpc in ("listtransactions", "listsinceblock", "gettransaction"):
+                help_text = self.nodes[0].help(rpc)
+                assert "applicable coinbase maturity" in help_text
+                assert "100 confirmations" not in help_text
+        node = self.nodes[0]
+        self.wallet = MiniWallet(node)
+        self.mine(2)
+        self.deployment(active=True, maturity=self.maturity)
+        if self.is_wallet_compiled():
+            self.generatetoaddress(node, 1, node.getnewaddress())
+        else:
+            self.mine(1)
+        self.mine_to(99)
+        self.log.info("Pre-start consensus maturity is 100; unchanged policy requires the long depth")
+        pre_start = self.spend(1)
+        self.check_spend(pre_start, allowed=False)
+        self.mine(1)
+        self.check_spend(pre_start, allowed=True, policy_allowed=False)
+
+        self.mine_to(START + self.maturity - 2)
+        self.log.info("Depth maturity-1 fails; maturity succeeds, including before the synthetic old boundary")
+        first = self.spend(START, fee=Decimal("1"))
+        self.check_spend(first, allowed=False)
+        self.mine(1)
+        self.check_spend(first, allowed=True)
+        assert_equal(node.sendrawtransaction(first["hex"], 0), first["txid"])
+        child = self.wallet.create_self_transfer(utxo_to_spend=first["new_utxo"])
+        node.sendrawtransaction(child["hex"])
+        maturity_parent = node.getbestblockhash()
+        boundary_block = self.block([first["tx"]], fees=COIN, script=self.wallet.get_output_script())
+        self.submit(boundary_block)
+        self.wallet_balance(trusted=0, immature=50)
+        self.mine(1)
+        self.wallet_balance(trusted=50, immature=0)
+
+        self.log.info("Reorg across maturity evicts the spend and reverses wallet balances")
+        node.invalidateblock(maturity_parent)
+        assert_equal(node.getblockcount(), START + self.maturity - 2)
+        assert_equal(node.getrawmempool(), [])
+        self.wallet_balance(trusted=0, immature=50)
+        self.check_spend(first, allowed=False)
+        node.reconsiderblock(maturity_parent)
+        assert_equal(node.getblockcount(), START + self.maturity + 1)
+        self.wallet_balance(trusted=50, immature=0)
+
+        if node.getblockcount() < self.release:
+            self.mine_to(self.release - 1)
+            funding = self.spend(12, fee=Decimal("1"))
+            self.submit(self.block([funding["tx"]], fees=COIN, script=self.wallet.get_output_script()))
+            self.mine(1)
+        self.deployment(active=True, maturity=self.maturity)
+        self.log.info("The old release has no 100-block window; rolling depth still controls")
+        after_height = self.release - self.maturity + 3
+        after = self.spend(after_height)
+        self.check_spend(after, allowed=False)
+        self.mine(1)
+        self.check_spend(after, allowed=True)
+        node.sendrawtransaction(after["hex"])
+        after_block = self.block([after["tx"]])
+        self.submit(after_block)
+
+        self.log.info("Reorg across the old release keeps the rolling rule in force")
+        old_boundary = node.getblockhash(self.release)
+        node.invalidateblock(old_boundary)
+        assert_equal(node.getblockcount(), self.release - 1)
+        # With mainnet's relative schedule the first spend was mined at the
+        # old release and is still mature for the next block after the reorg.
+        expected_pool = {first["txid"], child["txid"]} if self.release == START + self.maturity else {funding["txid"]}
+        assert_equal(set(node.getrawmempool()), expected_pool)
+        self.deployment(active=True, maturity=self.maturity)
+        self.check_spend(after, allowed=False)
+        node.reconsiderblock(old_boundary)
+        assert_equal(node.getbestblockhash(), after_block.hash)
+
+        self.log.info("Coinbases mined at the old release retain the long depth")
+        self.check_depth_pair(self.release)
+
+        self.check_expiry()
+
+        self.log.info("Reindex preserves expiry and the selected chain")
+        tip = node.getbestblockhash()
+        now = node.getblockheader(tip)["time"] + 1000
+        self.stop_node(0)
+        node.start(self.args + ["-reindex", f"-mocktime={now}"])
+        node.wait_for_rpc_connection(wait_for_import=False)
+        self.wait_until(lambda: node.getmempoolinfo()["loaded"], timeout=600)
+        assert_equal(node.getbestblockhash(), tip)
+        self.deployment(active=False, maturity=self.maturity)
+
+    def check_expiry(self):
+        node = self.nodes[0]
+        self.log.info("Parent MTP just below expiry still enforces long depth, even when candidate MTP reaches expiry")
+        # Fund a young reward explicitly: full-depth regtest has exhausted its subsidy.
+        funding = self.spend(16, fee=Decimal("1"))
+        self.submit(self.block([funding["tx"]], fees=COIN, script=self.wallet.get_output_script()))
+        self.mine(89)
+        height = node.getblockcount()
+        edge = self.spend(height - 89)
+        node.setmocktime(EXPIRY + 10000)
+        wallet_reward = None
+        wallet_value = 0
+        for offset in range(10):
+            kwargs = {"script": self.wallet.get_output_script()}
+            txs = []
+            if offset in (0, 1):
+                funding = self.spend(13 + offset, fee=Decimal("1"))
+                txs = [funding["tx"]]
+                kwargs["fees"] = COIN
+            if offset == 0 and self.is_wallet_compiled():
+                kwargs["script"] = CScript(bytes.fromhex(node.getaddressinfo(node.getnewaddress())["scriptPubKey"]))
+            block = self.block(txs, timestamp=EXPIRY - 5 + offset, **kwargs)
+            self.submit(block)
+            if offset == 0:
+                wallet_reward = block.vtx[0].hash
+                wallet_value = Decimal(block.vtx[0].vout[0].nValue) / COIN
+        fresh_height = height + 2  # Reward mined four seconds before expiry.
+        assert_equal(node.getblockheader(node.getbestblockhash())["mediantime"], EXPIRY - 1)
+        assert_equal(node.getblockcount() + 1 - (height - 89), 100)
+        self.deployment(active=True, maturity=self.maturity)
+        self.check_spend(edge, allowed=False)
+        crossing = self.block(timestamp=EXPIRY + 5)
+        self.submit(crossing)
+        assert_equal(node.getblockheader(crossing.hash)["mediantime"], EXPIRY)
+        self.deployment(active=False, maturity=self.maturity)
+        self.check_spend(edge, allowed=True, policy_allowed=False)
+        self.submit(self.block([edge["tx"]]))
+
+        self.log.info("Pre-expiry reward spends after expiry at depth 100, with stricter relay and wallet maturity")
+        self.mine_to(fresh_height + 98)
+        fresh = self.spend(fresh_height)
+        self.check_spend(fresh, allowed=False)
+        self.mine(1)
+        self.check_spend(fresh, allowed=True, policy_allowed=False)
+        self.submit(self.block([fresh["tx"]]))
+        if self.is_wallet_compiled():
+            assert_equal(node.gettransaction(wallet_reward)["details"][0]["category"], "immature")
+            assert all(utxo["txid"] != wallet_reward for utxo in node.listunspent())
+            self.wallet_balance(trusted=50, immature=wallet_value)
+        tip = node.getbestblockhash()
+        self.log.info("Reorg backwards across expiry restores long consensus depth; forwards releases again")
+        node.invalidateblock(crossing.hash)
+        assert_equal(node.getblockheader(node.getbestblockhash())["mediantime"], EXPIRY - 1)
+        assert_equal(node.getrawmempool(), [])
+        self.deployment(active=True, maturity=self.maturity)
+        self.check_spend(edge, allowed=False)
+        node.reconsiderblock(crossing.hash)
+        assert_equal(node.getbestblockhash(), tip)
+        self.deployment(active=False, maturity=self.maturity)
+        assert_equal(node.getrawmempool(), [])
+        self.log.info("Post-expiry rewards also spend at depth 100, while relay still uses long depth")
+        funding = self.spend(15, fee=Decimal("1"))
+        self.submit(self.block([funding["tx"]], fees=COIN, script=self.wallet.get_output_script()))
+        late_height = node.getblockcount()
+        self.mine_to(late_height + 98)
+        late = self.spend(late_height)
+        self.check_spend(late, allowed=False)
+        self.mine(1)
+        self.check_spend(late, allowed=True, policy_allowed=False)
+        self.submit(self.block([late["tx"]]))
+
+    def check_depth_pair(self, coin_height):
+        node = self.nodes[0]
+        self.mine_to(coin_height + 98)
+        tx = self.spend(coin_height)
+        self.check_spend(tx, allowed=False)
+        self.mine(1)
+        self.check_spend(tx, allowed=False)
+        self.mine_to(coin_height + self.maturity - 2)
+        assert_equal(node.getblockcount() + 1 - coin_height, self.maturity - 1)
+        self.check_spend(tx, allowed=False)
+        self.mine(1)
+        assert_equal(node.getblockcount() + 1 - coin_height, self.maturity)
+        self.check_spend(tx, allowed=True)
+        node.sendrawtransaction(tx["hex"])
+        self.submit(self.block([tx["tx"]]))
+
+
+if __name__ == "__main__":
+    RollingCoinbaseMaturityTest(__file__).main()
diff --git a/test/functional/feature_coinbase_maturity_upgrade.py b/test/functional/feature_coinbase_maturity_upgrade.py
new file mode 100755
index 000000000000..3035bb852b87
--- /dev/null
+++ b/test/functional/feature_coinbase_maturity_upgrade.py
@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026 The Bitcoin Knots developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Test an actual #419-compatible binary and rolling-maturity upgrade.
+
+Pass --old-bitcoind=/path/to/bitcoind built from #419 or its target branch
+before this patch. All shared new-rule blocks must be accepted by the old
+node. On upgrade, its height-limited marker must trigger a rewind to the old
+release minus one, revalidate stale side branches, and reject premature spends.
+"""
+from pathlib import Path
+
+from test_framework.blocktools import add_witness_commitment, create_block, create_coinbase
+from test_framework.test_framework import BitcoinTestFramework, SkipTest
+from test_framework.util import assert_equal, assert_raises_rpc_error
+from test_framework.wallet import MiniWallet
+
+START = 2
+RELEASE = START + 6480
+T0 = 1_800_000_000
+EXPIRY = T0 + 20000
+REJECT = "bad-txns-premature-spend-of-coinbase"
+
+
+class RollingCoinbaseMaturityUpgradeTest(BitcoinTestFramework):
+    def add_options(self, parser):
+        parser.add_argument("--after-expiry", action="store_true", help="Upgrade with an expired active tip containing a pre-expiry violation")
+        parser.add_argument("--old-bitcoind", help="Unmodified #419-compatible bitcoind (never downloaded by this test)")
+
+    def set_test_params(self):
+        self.num_nodes = 2
+        self.setup_clean_chain = True
+        common = ["-checkmempool=1", f"-mocktime={T0 + 10000}"]
+        self.old_args = common + [f"-testcoinbasematuritylong={START}:{START}:{RELEASE}"]
+        self.new_args = self.old_args + [f"-testcoinbasematuritylongexpiry={EXPIRY}"]
+        self.extra_args = [self.old_args, self.new_args]
+
+    def skip_test_if_missing_module(self):
+        if not self.options.old_bitcoind:
+            raise SkipTest("--old-bitcoind is required for old/new binary compatibility")
+        assert Path(self.options.old_bitcoind).is_file()
+
+    def setup_nodes(self):
+        self.add_nodes(2, self.extra_args, binary=[self.options.old_bitcoind, self.options.bitcoind])
+        self.start_nodes()
+
+    def block(self, node, txs=(), timestamp=None):
+        tip = node.getbestblockhash()
+        height = node.getblockcount() + 1
+        result = create_block(int(tip, 16), create_coinbase(height), timestamp or node.getblockheader(tip)["time"] + 1, height=height, txlist=list(txs))
+        add_witness_commitment(result)
+        result.solve()
+        return result
+
+    def submit(self, node, block, expected=None):
+        assert_equal(node.submitblock(block.serialize().hex()), expected)
+
+    def status(self, node, block_hash):
+        return next(tip["status"] for tip in node.getchaintips() if tip["hash"] == block_hash)
+
+    def run_test(self):
+        old, new = self.nodes
+        wallet = MiniWallet(new)
+        for node in self.nodes:
+            node.setmocktime(T0 + 10000)
+        self.generate(wallet, RELEASE - 1)
+        assert_equal(old.getbestblockhash(), new.getbestblockhash())
+        assert_equal(old.getdeploymentinfo()["deployments"]["long_coinbase_maturity"]["active"], False)
+        assert_equal(new.getdeploymentinfo()["deployments"]["long_coinbase_maturity"]["active"], True)
+        self.disconnect_nodes(1, 0)
+        common_tip = new.getbestblockhash()
+        coinbase = new.getblock(new.getblockhash(3))["tx"][0]
+        spend = wallet.create_self_transfer(utxo_to_spend=wallet.get_utxo(txid=coinbase))
+        assert_equal(new.testmempoolaccept([spend["hex"]])[0]["reject-reason"], REJECT)
+        bad = self.block(new, [spend["tx"]])
+        self.log.info("At the old release, #419 accepts the premature spend that the new node rejects")
+        self.submit(new, bad, REJECT)
+        self.submit(old, bad)
+        bad_tip = self.block(old)
+        self.submit(old, bad_tip)
+
+        self.log.info("The old node accepts every block of the stricter node's longer valid branch")
+        for _ in range(3):
+            good = self.block(new)
+            self.submit(new, good)
+            assert old.submitblock(good.serialize().hex()) in (None, "inconclusive")
+        assert_equal(old.getbestblockhash(), new.getbestblockhash())
+        assert_equal(self.status(old, bad_tip.hash), "valid-fork")
+
+        # Keep another invalid active branch and an equal-work valid fork in
+        # the old database so startup must actually revalidate cached blocks.
+        wallet.rescan_utxos()
+        # Keep this reward below policy maturity even after the expiry blocks.
+        # Height 100 also predates regtest's subsidy halvings to zero.
+        later_coin_height = 100
+        coinbase = new.getblock(new.getblockhash(later_coin_height))["tx"][0]
+        later_spend = wallet.create_self_transfer(utxo_to_spend=wallet.get_utxo(txid=coinbase))
+        result = old.testmempoolaccept([later_spend["hex"]])[0]
+        assert_equal(result["allowed"], False)
+        assert_equal(result["reject-reason"], REJECT)
+        self.log.info("#419 rejects spend %s from height %s at depth %s in policy: %s; accepts it in a block", later_spend["txid"], later_coin_height, old.getblockcount() + 1 - later_coin_height, REJECT)
+        later_bad = self.block(old, [later_spend["tx"]])
+        self.submit(new, later_bad, REJECT)
+        self.submit(old, later_bad)
+        later_bad_tip = self.block(old)
+        self.submit(old, later_bad_tip)
+        for _ in range(2):
+            good = self.block(new)
+            self.submit(new, good)
+            assert old.submitblock(good.serialize().hex()) in (None, "inconclusive")
+        assert_equal(old.getbestblockhash(), later_bad_tip.hash)
+        if self.options.after_expiry:
+            self.log.info("Both branches cross expiry, but the old active branch contains a pre-expiry violation")
+            self.new_args = [arg for arg in self.new_args if not arg.startswith("-mocktime=")] + [f"-mocktime={EXPIRY + 10000}"]
+            for node in self.nodes:
+                node.setmocktime(EXPIRY + 10000)
+            for offset in range(11):
+                self.submit(old, self.block(old, timestamp=EXPIRY + offset))
+                good = self.block(new, timestamp=EXPIRY + offset)
+                self.submit(new, good)
+                assert old.submitblock(good.serialize().hex()) in (None, "inconclusive")
+            assert old.getblockheader(old.getbestblockhash())["mediantime"] >= EXPIRY
+            assert new.getblockheader(new.getbestblockhash())["mediantime"] >= EXPIRY
+        good_tip = new.getbestblockhash()
+
+        self.log.info("Upgrade the old binary: rewind exactly to release-1 and select the revalidated fork")
+        self.stop_node(0)
+        old.binary = self.options.bitcoind
+        old.args[0] = self.options.bitcoind
+        rewind_height = RELEASE - 1
+        with old.assert_debug_log(expected_msgs=["Chainstate revalidation: rewinding", f"(height {rewind_height})"]):
+            self.start_node(0, extra_args=self.new_args)
+        assert_equal(old.getbestblockhash(), good_tip)
+        # Shorter stale forks are demoted; they need not be connected until
+        # they acquire enough work to compete with the active chain.
+        assert_equal(self.status(old, bad_tip.hash), "valid-headers")
+        # In the after-expiry variant this is an internal block, not a tip.
+        if not self.options.after_expiry:
+            assert_equal(self.status(old, later_bad_tip.hash), "invalid")
+        else:
+            assert old.getblockheader(later_bad_tip.hash)["confirmations"] == -1
+        # The first rejected spend has reached 6480 depth by this tip.
+        assert_equal(set(old.getrawmempool()), {spend["txid"]})
+        if self.options.after_expiry:
+            depth = old.getblockcount() + 1 - later_coin_height
+            assert 100 <= depth < 6480
+            for node in self.nodes:
+                result = node.testmempoolaccept([later_spend["hex"]])[0]
+                assert_equal(result["allowed"], False)
+                assert_equal(result["reject-reason"], REJECT)
+                assert_raises_rpc_error(-26, REJECT, node.sendrawtransaction, later_spend["hex"])
+            self.log.info("After expiry, spend %s from height %s at depth %s is rejected by policy: %s", later_spend["txid"], later_coin_height, depth, REJECT)
+        assert_equal(new.getblockheader(common_tip)["height"], rewind_height)
+        self.log.info("The persisted marker prevents a second rewind")
+        with old.assert_debug_log(expected_msgs=[], unexpected_msgs=["Chainstate revalidation: rewinding"]):
+            self.restart_node(0, extra_args=self.new_args)
+        assert_equal(old.getbestblockhash(), good_tip)
+        assert_equal(set(old.getrawmempool()), {spend["txid"]})
+        # Reconnecting peers does not automatically announce an old mempool.
+        assert_equal(new.sendrawtransaction(spend["hex"]), spend["txid"])
+        if self.options.after_expiry:
+            self.log.info("Mine the policy-rejected spend after expiry to prove consensus validity")
+            released = self.block(new, [later_spend["tx"]])
+            self.submit(new, released)
+            assert_equal(new.gettxout(coinbase, 0), None)
+        self.connect_nodes(1, 0)
+        self.sync_all()
+        if self.options.after_expiry:
+            assert_equal(old.getbestblockhash(), released.hash)
+            assert_equal(old.gettxout(coinbase, 0), None)
+        assert_equal(set(old.getrawmempool()), {spend["txid"]})
+        self.log.info("Idempotent restart and peer block/mempool resynchronization passed")
+
+
+if __name__ == "__main__":
+    RollingCoinbaseMaturityUpgradeTest(__file__).main()
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 337d66721045..8f6cd4db6f55 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -81,6 +81,10 @@
 TEST_FRAMEWORK_UNIT_TESTS = 'feature_framework_unit_tests.py'
 
 EXTENDED_SCRIPTS = [
+    'feature_coinbase_maturity_rolling.py --descriptors --full-depth',
+    'feature_coinbase_maturity_rolling.py --descriptors --full-depth --before-boundary',
+    'feature_coinbase_maturity_upgrade.py',
+    'feature_coinbase_maturity_upgrade.py --after-expiry',
     # These tests are not run by default.
     # Longest test should go first, to favor running tests in parallel
     'feature_pruning.py',
@@ -223,7 +227,12 @@
     'p2p_1p1c_network.py',
     'interface_rest.py',
     'feature_chainstate_revalidation.py',
+    'feature_coinbase_maturity_pruned.py',
+    'wallet_coinbase_maturity_policy.py --descriptors',
+    'wallet_coinbase_maturity_policy.py --descriptors --after-expiry',
     'mempool_long_coinbase_maturity.py',
+    'feature_coinbase_maturity_rolling.py --descriptors',
+    'feature_coinbase_maturity_rolling.py --descriptors --before-boundary',
     'mempool_spend_coinbase.py',
     'wallet_avoid_mixing_output_types.py --descriptors',
     'mempool_reorg.py',
diff --git a/test/functional/wallet_coinbase_maturity_policy.py b/test/functional/wallet_coinbase_maturity_policy.py
new file mode 100755
index 000000000000..08c7bbab70fb
--- /dev/null
+++ b/test/functional/wallet_coinbase_maturity_policy.py
@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026 The Bitcoin Knots developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Pre-start wallet rewards must respect the unchanged long-maturity policy."""
+from decimal import Decimal
+
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import assert_equal, assert_raises_rpc_error
+from test_framework.wallet import MiniWallet
+
+
+class CoinbaseMaturityPolicyTest(BitcoinTestFramework):
+    def add_options(self, parser):
+        self.add_wallet_options(parser)
+        parser.add_argument("--after-expiry", action="store_true")
+
+    def set_test_params(self):
+        self.num_nodes = 1
+        self.setup_clean_chain = True
+        self.extra_args = [["-testcoinbasematuritylong=2:2:122:120"]]
+        if self.options.after_expiry:
+            self.extra_args[0] += ["-testcoinbasematuritylongexpiry=1800000000", "-mocktime=1800010000"]
+
+    def skip_test_if_missing_module(self):
+        self.skip_if_no_wallet()
+
+    def run_test(self):
+        node = self.nodes[0]
+        node.createwallet("pre_start")
+        wallet = node.get_wallet_rpc("pre_start")
+        miner = MiniWallet(node)
+        if self.options.after_expiry:
+            # Move beyond both activation and the time expiry, then mine a covered wallet reward.
+            self.generate(miner, 11)
+            assert node.getblockheader(node.getbestblockhash())["mediantime"] >= 1800000000
+            assert_equal(node.getdeploymentinfo()["deployments"]["long_coinbase_maturity"]["active"], False)
+        reward = self.generatetoaddress(node, 1, wallet.getnewaddress())[0]
+        coinbase = node.getblock(reward)["tx"][0]
+        self.generate(miner, 100)
+        target = wallet.getnewaddress()
+        raw = wallet.createrawtransaction([{"txid": coinbase, "vout": 0}], {target: Decimal("49.999")})
+        signed = wallet.signrawtransactionwithwallet(raw)["hex"]
+
+        self.log.info("At depth 101, pre-start reward stays immature while policy rejects it")
+        assert_equal(wallet.getbalances()["mine"]["trusted"], 0)
+        assert_equal(wallet.getbalances()["mine"]["immature"], 50)
+        assert_equal(wallet.listunspent(), [])
+        assert_equal(node.testmempoolaccept([signed])[0]["allowed"], False)
+        assert_raises_rpc_error(-6, "Insufficient funds", wallet.sendtoaddress, target, 1)
+        assert_equal(node.getrawmempool(), [])
+        assert_equal(wallet.getbalances()["mine"]["immature"], 50)
+
+        self.generate(miner, 19)
+        assert_equal(node.testmempoolaccept([signed])[0]["allowed"], True)
+        assert_equal(wallet.getbalances()["mine"]["trusted"], 0)
+        self.generate(miner, 1)
+        self.log.info("At depth 121, every available reward can enter the mempool")
+        assert_equal(wallet.getbalances()["mine"]["trusted"], 50)
+        assert_equal(wallet.getbalances()["mine"]["immature"], 0)
+        coins = wallet.listunspent()
+        assert_equal(len(coins), 1)
+        assert_equal(coins[0]["spendable"], True)
+        assert_equal(node.testmempoolaccept([signed])[0]["allowed"], True)
+        txid = wallet.sendtoaddress(target, 1)
+        assert_equal(node.getrawmempool(), [txid])
+
+
+if __name__ == "__main__":
+    CoinbaseMaturityPolicyTest(__file__).main()

From 681d35b2d2a60a4c4cde19c25cd223b14df09ac4 Mon Sep 17 00:00:00 2001
From: AlphaPool <noreply@alphapool.tech>
Date: Sat, 17 Oct 2026 02:14:44 +0000
Subject: [PATCH 4/4] doc: Describe rolling coinbase maturity until RDTS expiry

---
 doc/release-notes-coinbase-rolling.md | 32 +++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 doc/release-notes-coinbase-rolling.md

diff --git a/doc/release-notes-coinbase-rolling.md b/doc/release-notes-coinbase-rolling.md
new file mode 100644
index 000000000000..c6c7d0869371
--- /dev/null
+++ b/doc/release-notes-coinbase-rolling.md
@@ -0,0 +1,32 @@
+Rolling coinbase maturity until RDTS expiry
+------------------------------------------
+
+On mainnet, rewards mined from height 973440 require a rolling 6480-block
+maturity while the spending block's parent median time past is below
+`RdtsExpiryTime` (2027-09-01 00:00 UTC). Every reward matures individually;
+there is no hold until expiry. At expiry, consensus maturity returns to
+100 for all rewards, including rewards mined immediately before expiry.
+Until expiry, the rule matches #419 before height 979920 and only restricts
+#419's valid-block set from 979920 onward. Testnet4 keeps its original
+height-based window; other public networks and default regtest are unchanged.
+
+The existing revalidation marker extends beyond #419's height window, bounded
+by parent MTP. A #419 node upgrading after 979920 rewinds to 979919, even
+when its tip is already past expiry, to recheck pre-expiry history and cached
+descendants. Without a marker, revalidation begins at enforcement minus one.
+Pruned nodes missing required history refuse startup before disconnecting
+blocks and must reindex. Nodes that ran different experimental rules sharing
+the marker must also reindex. Assumeutxo background validation must complete
+pre-snapshot coverage.
+
+Mempool admission, reorg filtering, wallet credit, coin selection and GUI
+maturity retain #419 behavior: every coinbase needs the configured long
+depth for policy and wallet availability, including after consensus expiry.
+Policy therefore remains stricter than consensus after expiry. Wallet credit
+retains its one-confirmation margin. RPC category help describes applicable
+maturity; deployment reporting shows the configured long depth, parent-MTP
+expiry and next-block active state. GBT stops advertising the rule at expiry.
+
+Configured regtest accepts `-testcoinbasematuritylong=start:enforce:release[:maturity]`
+and `-testcoinbasematuritylongexpiry=time`. The expiry defaults to the configured
+RDTS expiry, or INT64_MAX if none, and must match `-rdtsexpiry` when both are set.