From 5a7bc03ccda217c32f3704e3b61268e74ca69d94 Mon Sep 17 00:00:00 2001
From: FlyTheElephant1 <259444470+FlyTheElephant1@users.noreply.github.com>
Date: Thu, 10 Sep 2026 19:30:36 -0500
Subject: [PATCH 01/11] test from elephant

---
 ...release-notes-batched-coinbase-maturity.md |  24 ++
 src/chainparams.cpp                           |  11 +
 src/chainparamsbase.cpp                       |   1 +
 src/consensus/consensus.h                     |   6 +
 src/consensus/params.h                        |  17 ++
 src/consensus/tx_verify.cpp                   |  24 +-
 src/consensus/tx_verify.h                     |  11 +-
 src/interfaces/chain.h                        |   5 +
 src/kernel/chainparams.cpp                    |   6 +
 src/kernel/chainparams.h                      |   4 +
 src/node/interfaces.cpp                       |  11 +
 src/qt/transactiondesc.cpp                    |   4 +-
 src/rpc/blockchain.cpp                        |  45 +++-
 src/rpc/mining.cpp                            |   3 +
 src/test/fuzz/coins_view.cpp                  |   2 +-
 src/test/validation_tests.cpp                 |  59 +++++
 src/txmempool.cpp                             |   2 +-
 src/validation.cpp                            |  30 ++-
 src/validation.h                              |   7 +
 src/wallet/wallet.cpp                         |   7 +-
 .../feature_extended_coinbase_maturity.py     | 231 ++++++++++++++++++
 test/functional/test_runner.py                |   1 +
 22 files changed, 486 insertions(+), 25 deletions(-)
 create mode 100644 doc/release-notes-batched-coinbase-maturity.md
 create mode 100644 test/functional/feature_extended_coinbase_maturity.py

diff --git a/doc/release-notes-batched-coinbase-maturity.md b/doc/release-notes-batched-coinbase-maturity.md
new file mode 100644
index 000000000000..296309148655
--- /dev/null
+++ b/doc/release-notes-batched-coinbase-maturity.md
@@ -0,0 +1,24 @@
+### Batched extended coinbase maturity (temporary softfork)
+
+Coinbase outputs created while this deployment is active use a longer
+maturity that is *attached to the creating block*, not to the spend:
+
+- 1/6 of window blocks (`(height - start) % 6 == 0`): 2016 confirmations
+- 2/6 of window blocks (`% 6` in {1,2}): 8064 confirmations
+- 1/2 of window blocks (`% 6` in {3,4,5}): 26280 confirmations
+
+The assignment is by **block height**, so coinbase transaction size does
+not change. There is no extra output and no DATUM/script change.
+
+The window is the same shape as RDTS: first block whose parent MTP
+reaches the start time, through the last block whose parent MTP is still
+below the RDTS expiry. After expiry, **new** coinbases go back to the
+ordinary 100-block maturity. Coinbases created *inside* the window keep
+their 2016/8064/26280 lock until they actually mature — expiry does not
+unlock them early.
+
+Outputs created before activation are never affected.
+
+Mainnet/testnet start time is unset in this patch (flag day later).
+Regtest: `-extendedcoinbasematurity=<mtp>` requires `-rdtsexpiry` and
+must precede it.
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index 54ab526e2b7c..ca3b2da47a14 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -93,6 +93,17 @@ void ReadRegTestArgs(const ArgsManager& args, CChainParams::RegTestOptions& opti
         options.rdts_expiry_time = expiry;
     }
 
+    if (const auto arg{args.GetArg("-extendedcoinbasematurity", "")}; !arg.empty()) {
+        if (!options.rdts_expiry_time) {
+            throw std::runtime_error("-extendedcoinbasematurity requires -rdtsexpiry=<time> (window ends at RDTS expiry).");
+        }
+        int64_t start;
+        if (!ParseInt64(arg, &start) || start >= *options.rdts_expiry_time) {
+            throw std::runtime_error(strprintf("Invalid start (%s) for -extendedcoinbasematurity=<time>: must precede the RDTS expiry (%d).", arg, *options.rdts_expiry_time));
+        }
+        options.extended_coinbase_maturity_start_time = start;
+    }
+
     if (const auto arg{args.GetArg("-blake2b_headline")}; arg) {
         if (!options.activation_heights.contains(Consensus::BuriedDeployment::DEPLOYMENT_BLAKE2B)) {
             throw std::runtime_error("-blake2b_headline requires -testactivationheight=blake2b@<height>");
diff --git a/src/chainparamsbase.cpp b/src/chainparamsbase.cpp
index e2ff25346d0c..8f09e7918ee6 100644
--- a/src/chainparamsbase.cpp
+++ b/src/chainparamsbase.cpp
@@ -18,6 +18,7 @@ void SetupChainParamsBaseOptions(ArgsManager& argsman)
                  "This is intended for regression testing tools and app development. Equivalent to -chain=regtest.", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CHAINPARAMS);
     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("-extendedcoinbasematurity=<time>", "Schedule the batched extended coinbase-maturity softfork: coinbases created from the first block whose parent MTP reaches <time> use the 2016/8064/26280 schedule (1/6, 2/6, 1/2 of blocks). The lock sticks to those coins after RDTS expiry. Requires -rdtsexpiry, which <time> must precede. (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("-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);
diff --git a/src/consensus/consensus.h b/src/consensus/consensus.h
index 69dd2b605950..a0f0b6b826c7 100644
--- a/src/consensus/consensus.h
+++ b/src/consensus/consensus.h
@@ -19,6 +19,12 @@ static const unsigned int REDUCED_DATA_MAX_BLOCK_WEIGHT = 800000;
 static const int64_t MAX_BLOCK_SIGOPS_COST = 80000;
 /** Coinbase transaction outputs can only be spent after this number of new blocks (network rule) */
 static const int COINBASE_MATURITY = 100;
+/** Batched extended coinbase maturity (temporary softfork). Assigned by
+ *  (coinbase_height - window_start) % 6 so 1/6 of window coinbases mature
+ *  at 2016, 2/6 at 8064, and 1/2 at 26280. No extra coinbase outputs. */
+static const int EXTENDED_COINBASE_MATURITY_SHORT = 2016;
+static const int EXTENDED_COINBASE_MATURITY_MID = 8064;
+static const int EXTENDED_COINBASE_MATURITY_LONG = 26280;
 
 static const int WITNESS_SCALE_FACTOR = 4;
 
diff --git a/src/consensus/params.h b/src/consensus/params.h
index 0231e63b20a3..f20a99a1345e 100644
--- a/src/consensus/params.h
+++ b/src/consensus/params.h
@@ -123,6 +123,15 @@ struct Params {
      * behaviour is unchanged on chains that do not set it.
      */
     int64_t RdtsExpiryTime{std::numeric_limits<int64_t>::min()};
+    /**
+     * Batched extended coinbase maturity. Coinbase outputs created in a
+     * block whose parent's median-time-past has reached this start time
+     * and has not yet reached RdtsExpiryTime keep a longer maturity
+     * (see RequiredCoinbaseMaturity) even after RDTS expires. Coinbases
+     * created after expiry use COINBASE_MATURITY again.
+     * Default leaves the deployment unscheduled.
+     */
+    int64_t ExtendedCoinbaseMaturityStartTime{std::numeric_limits<int64_t>::max()};
     /** Don't warn about unknown BIP 9 activations below this height.
      * This prevents us from warning about the CSV and segwit activations. */
     int MinBIP9WarningHeight;
@@ -195,6 +204,14 @@ struct Params {
     {
         return IsBlake2bHeight(height) && mtp_prev < RdtsExpiryTime;
     }
+
+    /** Whether a coinbase created in a block with this parent MTP is
+     *  subject to the batched extended-maturity schedule. The schedule
+     *  sticks to those coins after expiry. */
+    bool ExtendedCoinbaseMaturityCreatedAt(int64_t mtp_prev) const
+    {
+        return mtp_prev >= ExtendedCoinbaseMaturityStartTime && mtp_prev < RdtsExpiryTime;
+    }
 };
 
 } // namespace Consensus
diff --git a/src/consensus/tx_verify.cpp b/src/consensus/tx_verify.cpp
index 84558503c708..9fca8bbb1d4f 100644
--- a/src/consensus/tx_verify.cpp
+++ b/src/consensus/tx_verify.cpp
@@ -172,7 +172,20 @@ bool Consensus::CheckOutputSizes(const CTransaction& tx, TxValidationState& stat
     return true;
 }
 
-bool Consensus::CheckTxInputs(const CTransaction& tx, TxValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee, const CheckTxInputsRules rules)
+int Consensus::RequiredCoinbaseMaturity(int coinbase_height, int ext_start_height, int ext_expiry_height)
+{
+    if (coinbase_height < ext_start_height || coinbase_height >= ext_expiry_height) {
+        return COINBASE_MATURITY;
+    }
+    // 1/6 of window blocks: 2016; 2/6: 8064; 1/2: 26280. Relative to
+    // the first window height so the cadence does not depend on abs height.
+    const int batch = (coinbase_height - ext_start_height) % 6;
+    if (batch == 0) return EXTENDED_COINBASE_MATURITY_SHORT;
+    if (batch == 1 || batch == 2) return EXTENDED_COINBASE_MATURITY_MID;
+    return EXTENDED_COINBASE_MATURITY_LONG;
+}
+
+bool Consensus::CheckTxInputs(const CTransaction& tx, TxValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee, const CheckTxInputsRules rules, int ext_start_height, int ext_expiry_height)
 {
     // are the actual inputs available?
     if (!inputs.HaveInputs(tx)) {
@@ -192,9 +205,12 @@ bool Consensus::CheckTxInputs(const CTransaction& tx, TxValidationState& state,
         assert(!coin.IsSpent());
 
         // If prev is coinbase, check that it's matured
-        if (coin.IsCoinBase() && nSpendHeight - coin.nHeight < COINBASE_MATURITY) {
-            return state.Invalid(TxValidationResult::TX_PREMATURE_SPEND, "bad-txns-premature-spend-of-coinbase",
-                strprintf("tried to spend coinbase at depth %d", nSpendHeight - coin.nHeight));
+        if (coin.IsCoinBase()) {
+            const int maturity = RequiredCoinbaseMaturity(coin.nHeight, ext_start_height, ext_expiry_height);
+            if (nSpendHeight - coin.nHeight < maturity) {
+                return state.Invalid(TxValidationResult::TX_PREMATURE_SPEND, "bad-txns-premature-spend-of-coinbase",
+                    strprintf("tried to spend coinbase at depth %d (maturity %d)", nSpendHeight - coin.nHeight, maturity));
+            }
         }
 
         // Check for negative or overflow input values
diff --git a/src/consensus/tx_verify.h b/src/consensus/tx_verify.h
index 8111a5b77a4f..e5a69bd744d4 100644
--- a/src/consensus/tx_verify.h
+++ b/src/consensus/tx_verify.h
@@ -7,6 +7,7 @@
 
 #include <consensus/amount.h>
 
+#include <limits>
 #include <stdint.h>
 #include <vector>
 
@@ -49,13 +50,21 @@ namespace Consensus {
  */
 bool CheckOutputSizes(const CTransaction& tx, TxValidationState& state);
 
+/**
+ * Confirmations required before a coinbase created at coinbase_height may
+ * be spent. Coins created in [ext_start_height, ext_expiry_height) keep
+ * the batched extended schedule after RDTS expiry. Pass INT_MAX for both
+ * bounds when the deployment is unscheduled on this chain.
+ */
+int RequiredCoinbaseMaturity(int coinbase_height, int ext_start_height, int ext_expiry_height);
+
 /**
  * Check whether all inputs of this transaction are valid (no double spends and amounts)
  * This does not modify the UTXO set. This does not check scripts and sigs.
  * @param[out] txfee Set to the transaction fee if successful.
  * Preconditions: tx.IsCoinBase() is false.
  */
-[[nodiscard]] bool CheckTxInputs(const CTransaction& tx, TxValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee, CheckTxInputsRules rules);
+[[nodiscard]] bool CheckTxInputs(const CTransaction& tx, TxValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee, CheckTxInputsRules rules, int ext_start_height = (std::numeric_limits<int>::max)(), int ext_expiry_height = (std::numeric_limits<int>::max)());
 } // namespace Consensus
 
 /** Auxiliary functions for transaction validation (ideally should not be exposed) */
diff --git a/src/interfaces/chain.h b/src/interfaces/chain.h
index 45dbb98bed15..189ccdc89adf 100644
--- a/src/interfaces/chain.h
+++ b/src/interfaces/chain.h
@@ -144,6 +144,11 @@ class Chain
     //! pruned), and contains transactions.
     virtual bool haveBlockOnDisk(int height) = 0;
 
+    //! Confirmations a coinbase created at coinbase_height still needs, plus
+    //! the usual +1 wallet convention applied by the caller if desired.
+    //! Returns the consensus maturity (100, 2016, 8064, or 26280).
+    virtual int coinbaseMaturity(int coinbase_height) { return 100; }
+
     virtual bool pruneLockExists(const std::string& name) const = 0;
     virtual bool updatePruneLock(const std::string& name, const node::PruneLockInfo& lock_info, bool sync=false) = 0;
     virtual bool deletePruneLock(const std::string& name) = 0;
diff --git a/src/kernel/chainparams.cpp b/src/kernel/chainparams.cpp
index 8ba49ad591e1..d85a913786df 100644
--- a/src/kernel/chainparams.cpp
+++ b/src/kernel/chainparams.cpp
@@ -130,6 +130,8 @@ class CMainParams : public CChainParams {
         // via versionbits; the stall at 961633 prevented it from ever
         // reaching ACTIVE, and that deployment has been removed.)
         consensus.RdtsExpiryTime = 1819756800; // September 1st, 2027 00:00 UTC
+        // Batched extended coinbase maturity: start unset until flag day.
+        // consensus.ExtendedCoinbaseMaturityStartTime = ...;
 
         consensus.nMinimumChainWork = uint256{"00000000000000000000000000000000000000013e00277374c9f9eeadc70200"};
         consensus.defaultAssumeValid = uint256{"0000000000000078ed1e20cac1acf78df6d1060c78059fb6331e17141c881fc8"}; // 964264
@@ -665,6 +667,10 @@ class CRegTestParams : public CChainParams
             consensus.RdtsExpiryTime = *opts.rdts_expiry_time;
         }
 
+        if (opts.extended_coinbase_maturity_start_time) {
+            consensus.ExtendedCoinbaseMaturityStartTime = *opts.extended_coinbase_maturity_start_time;
+        }
+
         for (const auto& [deployment_pos, version_bits_params] : opts.version_bits_parameters) {
             consensus.vDeployments[deployment_pos].nStartTime = version_bits_params.start_time;
             consensus.vDeployments[deployment_pos].nTimeout = version_bits_params.timeout;
diff --git a/src/kernel/chainparams.h b/src/kernel/chainparams.h
index 63ab289be206..27919d63a4b9 100644
--- a/src/kernel/chainparams.h
+++ b/src/kernel/chainparams.h
@@ -170,6 +170,10 @@ class CChainParams
         //! height until the parent block's median-time-past reaches this
         //! value (see -rdtsexpiry). Requires a blake2b activation height.
         std::optional<int64_t> rdts_expiry_time{};
+        //! Start MTP for the batched extended coinbase-maturity rule
+        //! (see -extendedcoinbasematurity). Requires rdts_expiry_time and
+        //! must precede it. Unscheduled when unset.
+        std::optional<int64_t> extended_coinbase_maturity_start_time{};
         std::optional<std::vector<unsigned char>> blake2b_headline{};
     };
 
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index fec8adb20966..d58aa4f0d4a4 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -10,6 +10,8 @@
 #include <chainparamsbase.h>
 #include <common/args.h>
 #include <common/pcp.h>
+#include <consensus/consensus.h>
+#include <consensus/tx_verify.h>
 #include <consensus/merkle.h>
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
@@ -581,6 +583,15 @@ class ChainImpl : public Chain
         const CBlockIndex* block{chainman().ActiveChain()[height]};
         return block && ((block->nStatus & BLOCK_HAVE_DATA) != 0) && block->nTx > 0;
     }
+    int coinbaseMaturity(int coinbase_height) override
+    {
+        LOCK(::cs_main);
+        const CBlockIndex* tip{chainman().ActiveChain().Tip()};
+        if (!tip) return COINBASE_MATURITY;
+        int ext_start, ext_expiry;
+        ExtendedCoinbaseMaturityBounds(chainman().GetConsensus(), *tip, ext_start, ext_expiry);
+        return Consensus::RequiredCoinbaseMaturity(coinbase_height, ext_start, ext_expiry);
+    }
     bool pruneLockExists(const std::string& name) const override
     {
         LOCK(cs_main);
diff --git a/src/qt/transactiondesc.cpp b/src/qt/transactiondesc.cpp
index 5ceb7621d3da..e9ce75929436 100644
--- a/src/qt/transactiondesc.cpp
+++ b/src/qt/transactiondesc.cpp
@@ -329,7 +329,9 @@ QString TransactionDesc::toHTML(interfaces::Node& node, interfaces::Wallet& wall
 
     if (wtx.is_coinbase)
     {
-        quint32 numBlocksToMaturity = COINBASE_MATURITY +  1;
+        quint32 numBlocksToMaturity = status.blocks_to_maturity > 0 && status.is_in_main_chain
+            ? status.blocks_to_maturity + status.depth_in_main_chain
+            : COINBASE_MATURITY + 1;
         strHTML += "<br>" + tr("Generated coins must mature %1 blocks before they can be spent. When you generated this block, it was broadcast to the network to be added to the block chain. If it fails to get into the chain, its state will change to \"not accepted\" and it won't be spendable. This may occasionally happen if another node generates a block within a few seconds of yours.").arg(QString::number(numBlocksToMaturity)) + "<br>";
     }
 
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 8353366862c7..27c34fcafff2 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -1913,10 +1913,11 @@ RPCHelpMan getblockchaininfo()
 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; for \"flagday\" this is the BLAKE2b hardfork height)"},
+    {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; for \"reduced_data\" this is the BLAKE2b hardfork height; for \"extended_coinbase_maturity\" it is the activation height on the queried block's chain, present once that chain's median time past has reached start_time)"},
     {RPCResult::Type::NUM, "height_end", /*optional=*/true, "height of the last block which enforces the rules (only for \"bip9\" type with \"active\" status and temporary deployments)"},
     {RPCResult::Type::BOOL, "active", "true if the rules are enforced for the mempool and the next block (the mempool applies the RDTS rules regardless 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::NUM_TIME, "start_time", /*optional=*/true, "median time past at and after which the rules are enforced (only for the \"extended_coinbase_maturity\" flag-day deployment)"},
+    {RPCResult::Type::NUM_TIME, "expiry_time", /*optional=*/true, "median time past at and after which new coinbases stop using the extended schedule (only for \"flagday\" type; window-created coins keep their lock)"},
     {RPCResult::Type::OBJ, "bip9", /*optional=*/true, "status of bip9 softforks (only for \"bip9\" type)",
     {
         {RPCResult::Type::NUM, "bit", /*optional=*/true, "the bit (0-28) in the block version field used to signal this softfork (only for \"started\" and \"locked_in\" status)"},
@@ -1945,21 +1946,38 @@ const std::vector<RPCResult> RPCHelpForDeployment{
 // median-time-past reaches RdtsExpiryTime. Reported as-of the queried block,
 // with "active" meaning the next block, like the versionbits entries. Omitted
 // entirely when unscheduled (plain regtest), as NEVER_ACTIVE deployments are.
+void FlagDayDescPushBack(UniValue& softforks, const std::string& name, std::optional<int> height, std::optional<int64_t> start_time, int64_t expiry_time, bool active_next)
+{
+    if (expiry_time == std::numeric_limits<int64_t>::min()) return;
+    UniValue rv(UniValue::VOBJ);
+    rv.pushKV("type", "flagday");
+    if (height) rv.pushKV("height", *height);
+    if (start_time) rv.pushKV("start_time", *start_time);
+    rv.pushKV("expiry_time", expiry_time);
+    rv.pushKV("active", active_next);
+    softforks.pushKV(name, std::move(rv));
+}
+
 void RdtsFlagDayDescPushBack(const CBlockIndex* blockindex, UniValue& softforks, const ChainstateManager& chainman)
 {
     const Consensus::Params& params{chainman.GetConsensus()};
-    if (params.Blake2bHeight == std::numeric_limits<int>::max() ||
-        params.RdtsExpiryTime == std::numeric_limits<int64_t>::min()) return;
+    if (params.Blake2bHeight == std::numeric_limits<int>::max()) return;
+    FlagDayDescPushBack(softforks, "reduced_data", params.RdtsActivationHeight(), std::nullopt, params.RdtsExpiryTime,
+                        params.RdtsActiveAt(blockindex->nHeight + 1, blockindex->GetMedianTimePast()));
+}
 
-    UniValue rv(UniValue::VOBJ);
-    rv.pushKV("type", "flagday");
-    rv.pushKV("height", params.RdtsActivationHeight());
-    rv.pushKV("expiry_time", params.RdtsExpiryTime);
-    // "active" describes the NEXT block, as the versionbits entries do, so the
-    // queried block is that block's parent and its median-time-past is exactly
-    // the parent median-time-past RdtsActiveAt expects.
-    rv.pushKV("active", params.RdtsActiveAt(blockindex->nHeight + 1, blockindex->GetMedianTimePast()));
-    softforks.pushKV("reduced_data", std::move(rv));
+void ExtendedCoinbaseMaturityDescPushBack(const CBlockIndex* blockindex, UniValue& softforks, const ChainstateManager& chainman)
+{
+    const Consensus::Params& params{chainman.GetConsensus()};
+    if (params.ExtendedCoinbaseMaturityStartTime == std::numeric_limits<int64_t>::max()) return;
+    const int64_t mtp{blockindex->GetMedianTimePast()};
+    std::optional<int> height;
+    if (mtp >= params.ExtendedCoinbaseMaturityStartTime) {
+        height = FirstHeightWithParentMtpAtLeast(*blockindex, params.ExtendedCoinbaseMaturityStartTime);
+        if (height == std::numeric_limits<int>::max()) height = std::nullopt;
+    }
+    FlagDayDescPushBack(softforks, "extended_coinbase_maturity", height, params.ExtendedCoinbaseMaturityStartTime, params.RdtsExpiryTime,
+                        params.ExtendedCoinbaseMaturityCreatedAt(mtp));
 }
 
 UniValue DeploymentInfo(const CBlockIndex* blockindex, const ChainstateManager& chainman)
@@ -1973,6 +1991,7 @@ UniValue DeploymentInfo(const CBlockIndex* blockindex, const ChainstateManager&
     SoftForkDescPushBack(blockindex, softforks, chainman, Consensus::DEPLOYMENT_TESTDUMMY);
     SoftForkDescPushBack(blockindex, softforks, chainman, Consensus::DEPLOYMENT_TAPROOT);
     RdtsFlagDayDescPushBack(blockindex, softforks, chainman);
+    ExtendedCoinbaseMaturityDescPushBack(blockindex, softforks, chainman);
     return softforks;
 }
 } // anon namespace
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 5c93cf652fee..4eb20eecce97 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -1082,6 +1082,9 @@ static UniValue TemplateToJSON(const Consensus::Params& consensusParams, const C
     if (rdts_active) {
         aRules.push_back("reduced_data");
     }
+    if (pindexPrev != nullptr && consensusParams.ExtendedCoinbaseMaturityCreatedAt(pindexPrev->GetMedianTimePast())) {
+        aRules.push_back("extended_coinbase_maturity");
+    }
 
     result.pushKV("version", block_header.GetCompleteVersion());
     result.pushKV("rules", std::move(aRules));
diff --git a/src/test/fuzz/coins_view.cpp b/src/test/fuzz/coins_view.cpp
index 6cf72784204c..18d0bb79adb6 100644
--- a/src/test/fuzz/coins_view.cpp
+++ b/src/test/fuzz/coins_view.cpp
@@ -256,7 +256,7 @@ FUZZ_TARGET(coins_view, .init = initialize_coins_view)
                     // It is not allowed to call CheckTxInputs if CheckTransaction failed
                     return;
                 }
-                if (Consensus::CheckTxInputs(transaction, state, coins_view_cache, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), tx_fee_out, CheckTxInputsRules::OutputSizeLimit)) {
+                if (Consensus::CheckTxInputs(transaction, state, coins_view_cache, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), tx_fee_out, CheckTxInputsRules::OutputSizeLimit, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()))) {
                     assert(MoneyRange(tx_fee_out));
                 }
             },
diff --git a/src/test/validation_tests.cpp b/src/test/validation_tests.cpp
index 4806533bc0b6..da89dabc851d 100644
--- a/src/test/validation_tests.cpp
+++ b/src/test/validation_tests.cpp
@@ -4,7 +4,9 @@
 
 #include <chainparams.h>
 #include <consensus/amount.h>
+#include <consensus/consensus.h>
 #include <consensus/merkle.h>
+#include <consensus/tx_verify.h>
 #include <core_io.h>
 #include <hash.h>
 #include <net.h>
@@ -13,7 +15,9 @@
 #include <util/chaintype.h>
 #include <validation.h>
 
+#include <limits>
 #include <string>
+#include <vector>
 
 #include <test/util/setup_common.h>
 
@@ -398,4 +402,59 @@ BOOST_AUTO_TEST_CASE(block_malleation)
     }
 }
 
+
+#include <consensus/consensus.h>
+#include <consensus/tx_verify.h>
+#include <limits>
+#include <vector>
+
+static std::vector<CBlockIndex> MakeTimedChain(const std::vector<int64_t>& times)
+{
+    std::vector<CBlockIndex> chain(times.size());
+    for (size_t i = 0; i < times.size(); ++i) {
+        chain[i].nHeight = static_cast<int>(i);
+        chain[i].nTime = times[i];
+        chain[i].pprev = i == 0 ? nullptr : &chain[i - 1];
+        chain[i].BuildSkip();
+    }
+    return chain;
+}
+
+BOOST_AUTO_TEST_CASE(batched_coinbase_maturity_schedule)
+{
+    constexpr int inactive{std::numeric_limits<int>::max()};
+    BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(10, inactive, inactive), COINBASE_MATURITY);
+    const int start = 51;
+    const int expiry = 151;
+    BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(50, start, expiry), COINBASE_MATURITY);
+    BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(51, start, expiry), EXTENDED_COINBASE_MATURITY_SHORT); // %6==0
+    BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(52, start, expiry), EXTENDED_COINBASE_MATURITY_MID);
+    BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(53, start, expiry), EXTENDED_COINBASE_MATURITY_MID);
+    BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(54, start, expiry), EXTENDED_COINBASE_MATURITY_LONG);
+    BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(151, start, expiry), COINBASE_MATURITY);
+    // lock sticks: a window coin evaluated with the same bounds after "now" is past expiry
+    BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(51, start, expiry), EXTENDED_COINBASE_MATURITY_SHORT);
+}
+
+BOOST_AUTO_TEST_CASE(extended_coinbase_maturity_bounds)
+{
+    std::vector<int64_t> times;
+    for (int i = 0; i < 200; ++i) times.push_back(1000 + 10 * i);
+    const auto chain{MakeTimedChain(times)};
+    Consensus::Params params{};
+    constexpr int inactive{std::numeric_limits<int>::max()};
+    int start, expiry;
+    ExtendedCoinbaseMaturityBounds(params, chain.back(), start, expiry);
+    BOOST_CHECK_EQUAL(start, inactive);
+
+    params.ExtendedCoinbaseMaturityStartTime = chain[50].GetMedianTimePast();
+    params.RdtsExpiryTime = chain[150].GetMedianTimePast();
+    ExtendedCoinbaseMaturityBounds(params, chain[100], start, expiry);
+    BOOST_CHECK_EQUAL(start, 51);
+    BOOST_CHECK_EQUAL(expiry, inactive); // tip 100 has not reached expiry mtp
+    ExtendedCoinbaseMaturityBounds(params, chain.back(), start, expiry);
+    BOOST_CHECK_EQUAL(start, 51);
+    BOOST_CHECK_EQUAL(expiry, 151);
+}
+
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 4e1d35782560..c405ca8897f7 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -879,7 +879,7 @@ void CTxMemPool::check(const CCoinsViewCache& active_coins_tip, int64_t spendhei
         assert(!tx.IsCoinBase());
         // Skip output size checks (CheckTxInputsRules::None), as these transactions already passed
         // output size limits at mempool acceptance; this check only verifies UTXO consistency
-        assert(Consensus::CheckTxInputs(tx, dummy_state, mempoolDuplicate, spendheight, txfee, CheckTxInputsRules::None));
+        assert(Consensus::CheckTxInputs(tx, dummy_state, mempoolDuplicate, spendheight, txfee, CheckTxInputsRules::None, std::numeric_limits<int>::max(), std::numeric_limits<int>::max()));
         for (const auto& input: tx.vin) mempoolDuplicate.SpendCoin(input.prevout);
         AddCoins(mempoolDuplicate, tx, std::numeric_limits<int>::max());
     }
diff --git a/src/validation.cpp b/src/validation.cpp
index f19ef0e45901..a99bb46cc5b7 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -438,7 +438,9 @@ void Chainstate::MaybeUpdateMempoolForReorg(
                 const Coin& coin{CoinsTip().AccessCoin(txin.prevout)};
                 assert(!coin.IsSpent());
                 const auto mempool_spend_height{m_chain.Tip()->nHeight + 1};
-                if (coin.IsCoinBase() && mempool_spend_height - coin.nHeight < COINBASE_MATURITY) {
+                int ext_start, ext_expiry;
+                ExtendedCoinbaseMaturityBounds(m_chainman.GetConsensus(), *m_chain.Tip(), ext_start, ext_expiry);
+                if (coin.IsCoinBase() && mempool_spend_height - coin.nHeight < Consensus::RequiredCoinbaseMaturity(coin.nHeight, ext_start, ext_expiry)) {
                     return true;
                 }
             }
@@ -1015,7 +1017,9 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
     // The mempool holds txs for the next block, so pass height+1 to CheckTxInputs
     const auto block_height_current = m_active_chainstate.m_chain.Height();
     const auto block_height_next = block_height_current + 1;
-    if (!Consensus::CheckTxInputs(tx, state, m_view, block_height_next, ws.m_base_fees, CheckTxInputsRules::OutputSizeLimit)) {
+    int ext_start, ext_expiry;
+    ExtendedCoinbaseMaturityBounds(m_active_chainstate.m_chainman.GetConsensus(), *m_active_chainstate.m_chain.Tip(), ext_start, ext_expiry);
+    if (!Consensus::CheckTxInputs(tx, state, m_view, block_height_next, ws.m_base_fees, CheckTxInputsRules::OutputSizeLimit, ext_start, ext_expiry)) {
         return false; // state filled in by CheckTxInputs
     }
 
@@ -3020,7 +3024,9 @@ 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)) {
+            int ext_start, ext_expiry;
+            ExtendedCoinbaseMaturityBounds(params.GetConsensus(), *Assert(pindex->pprev), ext_start, ext_expiry);
+            if (!Consensus::CheckTxInputs(tx, tx_state, view, pindex->nHeight, txfee, chk_input_rules, ext_start, ext_expiry)) {
                 // Any transaction validation failure in ConnectBlock is a block consensus failure
                 state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                               tx_state.GetRejectReason(),
@@ -7356,3 +7362,21 @@ std::pair<int, int> ChainstateManager::GetPruneRange(const Chainstate& chainstat
 
     return {prune_start, prune_end};
 }
+
+
+int FirstHeightWithParentMtpAtLeast(const CBlockIndex& tip, int64_t time)
+{
+    if (!tip.pprev) return std::numeric_limits<int>::max();
+    if (tip.pprev->GetMedianTimePast() < time) return std::numeric_limits<int>::max();
+    const CBlockIndex* p = &tip;
+    while (p->pprev && p->pprev->GetMedianTimePast() >= time) {
+        p = p->pprev;
+    }
+    return p->nHeight;
+}
+
+void ExtendedCoinbaseMaturityBounds(const Consensus::Params& params, const CBlockIndex& tip, int& start_height, int& expiry_height)
+{
+    start_height = FirstHeightWithParentMtpAtLeast(tip, params.ExtendedCoinbaseMaturityStartTime);
+    expiry_height = FirstHeightWithParentMtpAtLeast(tip, params.RdtsExpiryTime);
+}
diff --git a/src/validation.h b/src/validation.h
index e38d63f554d2..ac94a340d068 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -1441,4 +1441,11 @@ bool IsBIP30Repeat(const CBlockIndex& block_index);
 /** Identifies blocks which coinbase output was subsequently overwritten in the UTXO set (see BIP30) */
 bool IsBIP30Unspendable(const CBlockIndex& block_index);
 
+/** First height on this chain whose parent MTP >= time, or INT_MAX if tip has not reached it. */
+int FirstHeightWithParentMtpAtLeast(const CBlockIndex& tip, int64_t time);
+
+/** Window bounds for the batched extended coinbase-maturity rule on this chain.
+ *  Coins with start <= height < expiry keep the extended schedule after expiry. */
+void ExtendedCoinbaseMaturityBounds(const Consensus::Params& params, const CBlockIndex& tip, int& start_height, int& expiry_height);
+
 #endif // BITCOIN_VALIDATION_H
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index c8dbcfd1b790..85655f8c49c4 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -3646,7 +3646,12 @@ int CWallet::GetTxBlocksToMaturity(const CWalletTx& wtx) const
     }
     int chain_depth = GetTxDepthInMainChain(wtx);
     assert(chain_depth >= 0); // coinbase tx should not be conflicted
-    return std::max(0, (COINBASE_MATURITY+1) - chain_depth);
+    int coinbase_height = 0;
+    if (auto* conf = wtx.state<TxStateConfirmed>()) {
+        coinbase_height = conf->confirmed_block_height;
+    }
+    const int maturity = chain().coinbaseMaturity(coinbase_height);
+    return std::max(0, (maturity + 1) - chain_depth);
 }
 
 bool CWallet::IsTxImmatureCoinBase(const CWalletTx& wtx) const
diff --git a/test/functional/feature_extended_coinbase_maturity.py b/test/functional/feature_extended_coinbase_maturity.py
new file mode 100644
index 000000000000..cc954a9d1985
--- /dev/null
+++ b/test/functional/feature_extended_coinbase_maturity.py
@@ -0,0 +1,231 @@
+#!/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 the batched extended coinbase maturity temporary soft fork.
+
+Window-created coinbases use a height-modulo schedule instead of a single
+26280-block lock, and that lock is attached to the creating height:
+
+    (height - activation) % 6 == 0        -> 2016 confirmations  (1/6)
+    (height - activation) % 6 in {1, 2}   -> 8064 confirmations  (2/6)
+    (height - activation) % 6 in {3, 4, 5}-> 26280 confirmations (1/2)
+
+After RDTS expiry, *new* coinbases use COINBASE_MATURITY (100). Coinbases
+created inside the window keep their assigned lock.
+
+Covered:
+- option validation (requires -rdtsexpiry, must precede it)
+- activation height from median-time-past; getdeploymentinfo / getblocktemplate
+- grandfathering: pre-activation coinbase stays at 100
+- short-tranche (mod 6 == 0) rejected at depth 100, accepted at 2016
+- post-expiry new coinbase spendable at 100
+- in-window long/short coinbase still locked after expiry
+- wallet reports the reward as immature while locked
+"""
+
+from test_framework.blocktools import (
+    COINBASE_MATURITY,
+    add_witness_commitment,
+    create_block,
+)
+from test_framework.p2p import P2PInterface
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import (
+    assert_equal,
+    assert_greater_than,
+    assert_raises_rpc_error,
+)
+from test_framework.wallet import MiniWallet
+
+EXTENDED_SHORT = 2016
+BLAKE2B_HEIGHT = 120
+T0 = 1_600_000_000
+START = T0 + 10_000
+EXPIRY = START + 50_000
+REJECT = 'bad-txns-premature-spend-of-coinbase'
+
+
+def maturity_for(height, activation):
+    if height < activation:
+        return COINBASE_MATURITY
+    batch = (height - activation) % 6
+    if batch == 0:
+        return EXTENDED_SHORT
+    if batch in (1, 2):
+        return 8064
+    return 26280
+
+
+class ExtendedCoinbaseMaturityTest(BitcoinTestFramework):
+    def add_options(self, parser):
+        self.add_wallet_options(parser)
+
+    def set_test_params(self):
+        self.num_nodes = 1
+        self.setup_clean_chain = True
+        self.rpc_timeout = 240
+        self.base_args = [
+            f'-testactivationheight=blake2b@{BLAKE2B_HEIGHT}',
+            f'-rdtsexpiry={EXPIRY}',
+            f'-extendedcoinbasematurity={START}',
+        ]
+        self.extra_args = [self.base_args]
+
+    def skip_test_if_missing_module(self):
+        self.skip_if_no_wallet()
+
+    def assert_spend_rejected(self, raw_hex):
+        node = self.nodes[0]
+        assert_raises_rpc_error(-26, REJECT, node.sendrawtransaction, raw_hex)
+
+    def assert_deploymentinfo(self, active, height=None):
+        info = self.nodes[0].getdeploymentinfo()['deployments']['extended_coinbase_maturity']
+        assert_equal(info['type'], 'flagday')
+        assert_equal(info['active'], active)
+        assert_equal(info['start_time'], START)
+        assert_equal(info['expiry_time'], EXPIRY)
+        if height is not None and 'height' in info:
+            assert_equal(info['height'], height)
+
+    def assert_gbt_rule(self, active):
+        rules = self.nodes[0].getblocktemplate({'rules': ['segwit']}).get('rules', [])
+        has = 'extended_coinbase_maturity' in rules
+        assert_equal(has, active)
+
+    def generate_to(self, count):
+        node = self.nodes[0]
+        while node.getblockcount() < count:
+            chunk = min(500, count - node.getblockcount())
+            self.generate(self.wallet, chunk, sync_fun=self.no_op)
+
+    def mtp(self, height):
+        node = self.nodes[0]
+        return node.getblockheader(node.getblockhash(height))['mediantime']
+
+    def coinbase_utxo(self, height):
+        node = self.nodes[0]
+        blockhash = node.getblockhash(height)
+        txid = node.getblock(blockhash)['tx'][0]
+        tx = node.getrawtransaction(txid, True)
+        return {
+            'txid': txid,
+            'vout': 0,
+            'value': tx['vout'][0]['value'],
+            'scriptPubKey': tx['vout'][0]['scriptPubKey']['hex'],
+            'height': height,
+        }
+
+    def run_test(self):
+        node = self.nodes[0]
+        self.wallet = MiniWallet(node)
+
+        self.log.info("Option validation")
+        self.stop_node(0)
+        self.nodes[0].assert_start_raises_init_error(
+            extra_args=[f'-extendedcoinbasematurity={START}'],
+            expected_msg='-extendedcoinbasematurity requires -rdtsexpiry',
+        )
+        self.nodes[0].assert_start_raises_init_error(
+            extra_args=[
+                f'-testactivationheight=blake2b@{BLAKE2B_HEIGHT}',
+                f'-rdtsexpiry={START}',
+                f'-extendedcoinbasematurity={START}',
+            ],
+            expected_msg='must precede the RDTS expiry',
+        )
+        self.start_node(0, extra_args=self.base_args)
+        self.wallet = MiniWallet(node)
+
+        self.log.info("Mine up to the mock-time window")
+        self.mocktime = T0
+        node.setmocktime(self.mocktime)
+        # Connect a peer so generate works with MiniWallet
+        node.add_p2p_connection(P2PInterface())
+
+        # Pre-activation blocks
+        self.generate(self.wallet, 150, sync_fun=self.no_op)
+        pre_height = node.getblockcount()
+        assert_greater_than(START, self.mtp(pre_height))
+        self.assert_deploymentinfo(active=False)
+        self.assert_gbt_rule(active=False)
+
+        pre_utxo = self.coinbase_utxo(pre_height)
+        pre_spend = self.wallet.create_self_transfer(utxo_to_spend=pre_utxo)
+
+        self.log.info("Grandfathered coinbase spendable at 100 after activation")
+        self.mocktime = START
+        node.setmocktime(self.mocktime)
+        # Push MTP across START
+        self.generate(node, 11, sync_fun=self.no_op)
+        activation = None
+        for h in range(1, node.getblockcount() + 1):
+            if self.mtp(h - 1) >= START:
+                activation = h
+                break
+        assert activation is not None
+        self.log.info(f"activation height {activation}")
+        self.assert_deploymentinfo(active=True, height=activation)
+        self.assert_gbt_rule(active=True)
+
+        # bury the pre-activation coinbase under 100
+        need = COINBASE_MATURITY - (node.getblockcount() - pre_height)
+        if need > 0:
+            self.generate(self.wallet, need, sync_fun=self.no_op)
+        node.sendrawtransaction(pre_spend['hex'])
+        self.generate(node, 1, sync_fun=self.no_op)
+
+        self.log.info("Short-tranche window coinbase rejected at 100, accepted at 2016")
+        # Find a window block with (h - activation) % 6 == 0
+        target = activation
+        while (target - activation) % 6 != 0 or target <= activation:
+            target += 1
+        while node.getblockcount() < target:
+            self.generate(self.wallet, 1, sync_fun=self.no_op)
+        short_utxo = self.coinbase_utxo(target)
+        assert_equal(maturity_for(target, activation), EXTENDED_SHORT)
+        short_spend = self.wallet.create_self_transfer(utxo_to_spend=short_utxo)
+
+        # 100 confirmations is not enough
+        while node.getblockcount() < target + COINBASE_MATURITY:
+            self.generate(self.wallet, min(100, target + COINBASE_MATURITY - node.getblockcount()), sync_fun=self.no_op)
+        self.assert_spend_rejected(short_spend['hex'])
+
+        # 2016 confirmations is enough
+        while node.getblockcount() < target + EXTENDED_SHORT:
+            self.generate(self.wallet, min(200, target + EXTENDED_SHORT - node.getblockcount()), sync_fun=self.no_op)
+        node.sendrawtransaction(short_spend['hex'])
+        self.generate(node, 1, sync_fun=self.no_op)
+
+        self.log.info("Expiry: new coinbases are 100; in-window coins stay locked")
+        # Grab an in-window coinbase that is still far from its maturity
+        locked_h = activation + 3  # % 6 == 3 -> 26280
+        if locked_h == target:
+            locked_h = activation + 9
+        while node.getblockcount() < locked_h:
+            self.generate(self.wallet, 1, sync_fun=self.no_op)
+        locked_utxo = self.coinbase_utxo(locked_h)
+        locked_spend = self.wallet.create_self_transfer(utxo_to_spend=locked_utxo)
+
+        self.mocktime = EXPIRY
+        node.setmocktime(self.mocktime)
+        self.generate(node, 11, sync_fun=self.no_op)
+        self.assert_deploymentinfo(active=False, height=activation)
+        self.assert_gbt_rule(active=False)
+
+        # window coinbase still rejected
+        self.assert_spend_rejected(locked_spend['hex'])
+
+        # a brand-new post-expiry coinbase matures at 100
+        post_h = node.getblockcount()
+        post_utxo = self.coinbase_utxo(post_h)
+        post_spend = self.wallet.create_self_transfer(utxo_to_spend=post_utxo)
+        self.generate(self.wallet, COINBASE_MATURITY, sync_fun=self.no_op)
+        node.sendrawtransaction(post_spend['hex'])
+        self.generate(node, 1, sync_fun=self.no_op)
+
+        self.log.info("Passed")
+
+
+if __name__ == '__main__':
+    ExtendedCoinbaseMaturityTest(__file__).main()
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index e912af0f5cfc..667a2ff7532a 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -100,6 +100,7 @@
     'feature_reduced_data_temporary_deployment.py',
     'feature_bip9_max_activation_height.py',
     'feature_rdts.py',
+    'feature_extended_coinbase_maturity.py',
     'feature_rdts_ignore_rejects.py',
     'feature_block.py',
     'mempool_ephemeral_dust.py',

From 969b5649961195333db03f5ba38714329d7a2a61 Mon Sep 17 00:00:00 2001
From: FlyTheElephant1 <259444470+FlyTheElephant1@users.noreply.github.com>
Date: Thu, 10 Sep 2026 20:06:46 -0500
Subject: [PATCH 02/11] Audit fixes: hoist maturity bounds, binary search,
 #402-aligned tests

---
 ...release-notes-batched-coinbase-maturity.md |  41 ++-
 src/interfaces/chain.h                        |   2 +-
 src/test/validation_tests.cpp                 |   4 +-
 src/validation.cpp                            |  28 +-
 .../feature_extended_coinbase_maturity.py     | 307 ++++++++++--------
 test/functional/test_runner.py                |   2 +-
 6 files changed, 233 insertions(+), 151 deletions(-)

diff --git a/doc/release-notes-batched-coinbase-maturity.md b/doc/release-notes-batched-coinbase-maturity.md
index 296309148655..26799e12528d 100644
--- a/doc/release-notes-batched-coinbase-maturity.md
+++ b/doc/release-notes-batched-coinbase-maturity.md
@@ -1,13 +1,13 @@
 ### Batched extended coinbase maturity (temporary softfork)
 
 Coinbase outputs created while this deployment is active use a longer
-maturity that is *attached to the creating block*, not to the spend:
+maturity that is attached to the creating block, not to the spend:
 
 - 1/6 of window blocks (`(height - start) % 6 == 0`): 2016 confirmations
 - 2/6 of window blocks (`% 6` in {1,2}): 8064 confirmations
 - 1/2 of window blocks (`% 6` in {3,4,5}): 26280 confirmations
 
-The assignment is by **block height**, so coinbase transaction size does
+The assignment is by block height, so coinbase transaction size does
 not change. There is no extra output and no DATUM/script change.
 
 The window is the same shape as RDTS: first block whose parent MTP
@@ -17,8 +17,37 @@ ordinary 100-block maturity. Coinbases created *inside* the window keep
 their 2016/8064/26280 lock until they actually mature — expiry does not
 unlock them early.
 
-Outputs created before activation are never affected.
+Only outputs created inside the window are affected. A coinbase output
+created before activation keeps the 100-block rule throughout, so
+activating the deployment cannot lock an output that was already
+spendable. The 100-block rule continues to apply to every coinbase
+output at all times as a floor.
 
-Mainnet/testnet start time is unset in this patch (flag day later).
-Regtest: `-extendedcoinbasematurity=<mtp>` requires `-rdtsexpiry` and
-must precede it.
+The start time is not yet scheduled on mainnet or testnet4 in this
+release (see `src/kernel/chainparams.cpp`); the deployment does nothing
+until it is.
+
+Miners: block rewards mined inside the window cannot be spent until
+their assigned tranche matures (or, for coins created after expiry, 100
+blocks). Pools that pay their miners directly from coinbase outputs pass
+this delay through to those miners. A non-upgraded miner that spends its
+own reward at 100 confirmations produces a block that upgraded nodes
+reject, if that reward was created in the window.
+
+Wallet: rewards subject to the rule are reported as immature (in
+`getbalances` `immature`, `listtransactions` category `immature` and the
+GUI) until they can be spent, and are not selected for spending before
+then, so the wallet never creates a transaction the network would reject.
+
+`getdeploymentinfo` reports the deployment as `extended_coinbase_maturity`,
+a `flagday` entry with `start_time`, `expiry_time` (the RDTS expiry;
+after this, *new* coinbases use 100), `active` (for the next block's
+*creation* rule) and, once the queried chain's median-time-past has
+reached the start time, `height`, the activation height on that chain.
+It is omitted on chains where the deployment is not scheduled.
+`getblocktemplate` lists `extended_coinbase_maturity` in `rules` while
+new coinbases are still being created under the rule; no client-side
+support is required.
+
+On regtest the deployment is scheduled with `-extendedcoinbasematurity=<time>`,
+which requires `-rdtsexpiry` and must precede it.
diff --git a/src/interfaces/chain.h b/src/interfaces/chain.h
index 189ccdc89adf..5b0fdce125de 100644
--- a/src/interfaces/chain.h
+++ b/src/interfaces/chain.h
@@ -147,7 +147,7 @@ class Chain
     //! Confirmations a coinbase created at coinbase_height still needs, plus
     //! the usual +1 wallet convention applied by the caller if desired.
     //! Returns the consensus maturity (100, 2016, 8064, or 26280).
-    virtual int coinbaseMaturity(int coinbase_height) { return 100; }
+    virtual int coinbaseMaturity(int coinbase_height) = 0;
 
     virtual bool pruneLockExists(const std::string& name) const = 0;
     virtual bool updatePruneLock(const std::string& name, const node::PruneLockInfo& lock_info, bool sync=false) = 0;
diff --git a/src/test/validation_tests.cpp b/src/test/validation_tests.cpp
index da89dabc851d..029718655618 100644
--- a/src/test/validation_tests.cpp
+++ b/src/test/validation_tests.cpp
@@ -432,8 +432,10 @@ BOOST_AUTO_TEST_CASE(batched_coinbase_maturity_schedule)
     BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(53, start, expiry), EXTENDED_COINBASE_MATURITY_MID);
     BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(54, start, expiry), EXTENDED_COINBASE_MATURITY_LONG);
     BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(151, start, expiry), COINBASE_MATURITY);
-    // lock sticks: a window coin evaluated with the same bounds after "now" is past expiry
+    // lock sticks: same bounds as a tip that has already crossed expiry
+    // still classify window coins as extended. height 151 is first post-expiry.
     BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(51, start, expiry), EXTENDED_COINBASE_MATURITY_SHORT);
+    BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(54, start, expiry), EXTENDED_COINBASE_MATURITY_LONG);
 }
 
 BOOST_AUTO_TEST_CASE(extended_coinbase_maturity_bounds)
diff --git a/src/validation.cpp b/src/validation.cpp
index a99bb46cc5b7..6387c0e57526 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -433,13 +433,13 @@ void Chainstate::MaybeUpdateMempoolForReorg(
 
         // If the transaction spends any coinbase outputs, it must be mature.
         if (it->GetSpendsCoinbase()) {
+            const auto mempool_spend_height{m_chain.Tip()->nHeight + 1};
+            int ext_start, ext_expiry;
+            ExtendedCoinbaseMaturityBounds(m_chainman.GetConsensus(), *m_chain.Tip(), ext_start, ext_expiry);
             for (const CTxIn& txin : tx.vin) {
                 if (m_mempool->exists(GenTxid::Txid(txin.prevout.hash))) continue;
                 const Coin& coin{CoinsTip().AccessCoin(txin.prevout)};
                 assert(!coin.IsSpent());
-                const auto mempool_spend_height{m_chain.Tip()->nHeight + 1};
-                int ext_start, ext_expiry;
-                ExtendedCoinbaseMaturityBounds(m_chainman.GetConsensus(), *m_chain.Tip(), ext_start, ext_expiry);
                 if (coin.IsCoinBase() && mempool_spend_height - coin.nHeight < Consensus::RequiredCoinbaseMaturity(coin.nHeight, ext_start, ext_expiry)) {
                     return true;
                 }
@@ -2997,6 +2997,9 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
 
     const CheckTxInputsRules chk_input_rules{reduced_data_active ? CheckTxInputsRules::OutputSizeLimit : CheckTxInputsRules::None};
 
+    int ext_start, ext_expiry;
+    ExtendedCoinbaseMaturityBounds(params.GetConsensus(), *Assert(pindex->pprev), ext_start, ext_expiry);
+
     // Check generation tx output sizes if REDUCED_DATA is active
     if (chk_input_rules.test(CheckTxInputsRules::OutputSizeLimit)) {
         TxValidationState tx_state;
@@ -3024,8 +3027,6 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
         {
             CAmount txfee = 0;
             TxValidationState tx_state;
-            int ext_start, ext_expiry;
-            ExtendedCoinbaseMaturityBounds(params.GetConsensus(), *Assert(pindex->pprev), ext_start, ext_expiry);
             if (!Consensus::CheckTxInputs(tx, tx_state, view, pindex->nHeight, txfee, chk_input_rules, ext_start, ext_expiry)) {
                 // Any transaction validation failure in ConnectBlock is a block consensus failure
                 state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
@@ -7368,11 +7369,20 @@ int FirstHeightWithParentMtpAtLeast(const CBlockIndex& tip, int64_t time)
 {
     if (!tip.pprev) return std::numeric_limits<int>::max();
     if (tip.pprev->GetMedianTimePast() < time) return std::numeric_limits<int>::max();
-    const CBlockIndex* p = &tip;
-    while (p->pprev && p->pprev->GetMedianTimePast() >= time) {
-        p = p->pprev;
+    // Binary search: first height whose parent MTP >= time. Same answer as
+    // knots#402 MedianTimePastActivationHeight once the tip has reached `time`.
+    int lo{1};
+    int hi{tip.nHeight};
+    while (lo < hi) {
+        const int mid{lo + (hi - lo) / 2};
+        const CBlockIndex* anc{Assert(tip.GetAncestor(mid))};
+        if (anc->pprev->GetMedianTimePast() >= time) {
+            hi = mid;
+        } else {
+            lo = mid + 1;
+        }
     }
-    return p->nHeight;
+    return lo;
 }
 
 void ExtendedCoinbaseMaturityBounds(const Consensus::Params& params, const CBlockIndex& tip, int& start_height, int& expiry_height)
diff --git a/test/functional/feature_extended_coinbase_maturity.py b/test/functional/feature_extended_coinbase_maturity.py
index cc954a9d1985..4df5d5920bca 100644
--- a/test/functional/feature_extended_coinbase_maturity.py
+++ b/test/functional/feature_extended_coinbase_maturity.py
@@ -4,24 +4,28 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test the batched extended coinbase maturity temporary soft fork.
 
-Window-created coinbases use a height-modulo schedule instead of a single
-26280-block lock, and that lock is attached to the creating height:
-
-    (height - activation) % 6 == 0        -> 2016 confirmations  (1/6)
-    (height - activation) % 6 in {1, 2}   -> 8064 confirmations  (2/6)
-    (height - activation) % 6 in {3, 4, 5}-> 26280 confirmations (1/2)
-
-After RDTS expiry, *new* coinbases use COINBASE_MATURITY (100). Coinbases
-created inside the window keep their assigned lock.
-
-Covered:
+Layout follows knots#402's feature_extended_coinbase_maturity.py so a
+human diff against that PR is mostly the two intended deltas:
+
+  1. Window coinbases use (height - activation) % 6
+       0        -> 2016 confirmations   (1/6 of blocks)
+       1 or 2   -> 8064 confirmations   (2/6)
+       3, 4, 5  -> 26280 confirmations  (1/2)
+     instead of a single 26280-block lock. Coinbase size is unchanged.
+  2. The lock is attached to the creating height. After RDTS expiry,
+     *new* coinbases use COINBASE_MATURITY (100). Window-created
+     coinbases keep their assigned lock. (#402 unlocked them at expiry.)
+
+Covered (same checklist as #402, with (2) replacing "hard expiry unlocks"):
 - option validation (requires -rdtsexpiry, must precede it)
-- activation height from median-time-past; getdeploymentinfo / getblocktemplate
-- grandfathering: pre-activation coinbase stays at 100
-- short-tranche (mod 6 == 0) rejected at depth 100, accepted at 2016
-- post-expiry new coinbase spendable at 100
-- in-window long/short coinbase still locked after expiry
-- wallet reports the reward as immature while locked
+- activation height derived from median-time-past; getdeploymentinfo/getblocktemplate
+- grandfathering: a coinbase from the block before activation keeps the 100-block rule
+- an in-window coinbase is rejected at depth >= 100 by the mempool
+- short-tranche spendable at exactly 2016; the reorg filter evicts it one block earlier
+- after expiry a still-locked window coinbase stays rejected; a post-expiry
+  coinbase is spendable at 100
+- the wallet reports the reward as immature while locked
+- -reindex reproduces the chain and derives the same activation height
 """
 
 from test_framework.blocktools import (
@@ -39,7 +43,13 @@
 from test_framework.wallet import MiniWallet
 
 EXTENDED_SHORT = 2016
+EXTENDED_MID = 8064
+EXTENDED_LONG = 26280
 BLAKE2B_HEIGHT = 120
+# Mock clock: pre-activation blocks are stamped from T0, the window opens once
+# the median-time-past reaches START, and RDTS (with it, this rule's *creation*
+# window) expires at EXPIRY. Block times creep by one second per block, so
+# START and EXPIRY leave room for the blocks mined before each.
 T0 = 1_600_000_000
 START = T0 + 10_000
 EXPIRY = START + 50_000
@@ -47,14 +57,15 @@
 
 
 def maturity_for(height, activation):
+    """Consensus schedule: pre-activation is 100; in-window is batched."""
     if height < activation:
         return COINBASE_MATURITY
     batch = (height - activation) % 6
     if batch == 0:
         return EXTENDED_SHORT
     if batch in (1, 2):
-        return 8064
-    return 26280
+        return EXTENDED_MID
+    return EXTENDED_LONG
 
 
 class ExtendedCoinbaseMaturityTest(BitcoinTestFramework):
@@ -72,32 +83,16 @@ def set_test_params(self):
         ]
         self.extra_args = [self.base_args]
 
-    def skip_test_if_missing_module(self):
-        self.skip_if_no_wallet()
-
-    def assert_spend_rejected(self, raw_hex):
-        node = self.nodes[0]
-        assert_raises_rpc_error(-26, REJECT, node.sendrawtransaction, raw_hex)
-
-    def assert_deploymentinfo(self, active, height=None):
-        info = self.nodes[0].getdeploymentinfo()['deployments']['extended_coinbase_maturity']
-        assert_equal(info['type'], 'flagday')
-        assert_equal(info['active'], active)
-        assert_equal(info['start_time'], START)
-        assert_equal(info['expiry_time'], EXPIRY)
-        if height is not None and 'height' in info:
-            assert_equal(info['height'], height)
-
-    def assert_gbt_rule(self, active):
-        rules = self.nodes[0].getblocktemplate({'rules': ['segwit']}).get('rules', [])
-        has = 'extended_coinbase_maturity' in rules
-        assert_equal(has, active)
-
-    def generate_to(self, count):
+    def mine(self, count):
+        """Mine count blocks to the MiniWallet, keeping the mock clock within
+        the two-hour future window of the creeping block times."""
         node = self.nodes[0]
-        while node.getblockcount() < count:
-            chunk = min(500, count - node.getblockcount())
+        while count > 0:
+            chunk = min(count, 1000)
+            self.mocktime = max(self.mocktime, node.getblockheader(node.getbestblockhash())['time']) + chunk
+            node.setmocktime(self.mocktime)
             self.generate(self.wallet, chunk, sync_fun=self.no_op)
+            count -= chunk
 
     def mtp(self, height):
         node = self.nodes[0]
@@ -105,126 +100,172 @@ def mtp(self, height):
 
     def coinbase_utxo(self, height):
         node = self.nodes[0]
-        blockhash = node.getblockhash(height)
-        txid = node.getblock(blockhash)['tx'][0]
-        tx = node.getrawtransaction(txid, True)
-        return {
-            'txid': txid,
-            'vout': 0,
-            'value': tx['vout'][0]['value'],
-            'scriptPubKey': tx['vout'][0]['scriptPubKey']['hex'],
-            'height': height,
-        }
+        txid = node.getblock(node.getblockhash(height))['tx'][0]
+        return self.wallet.get_utxo(txid=txid)
+
+    def assert_spend_rejected(self, tx_hex):
+        node = self.nodes[0]
+        assert_equal(node.testmempoolaccept([tx_hex])[0]['reject-reason'], REJECT)
+        assert_raises_rpc_error(-26, REJECT, node.sendrawtransaction, tx_hex)
+
+    def submit_block_with(self, tx_hex):
+        """Mine a block carrying tx_hex ourselves and return submitblock's verdict."""
+        node = self.nodes[0]
+        tmpl = node.getblocktemplate({'rules': ['segwit', 'blake2b']})
+        block = create_block(tmpl=tmpl, txlist=[tx_hex])
+        add_witness_commitment(block)
+        block.solve()
+        return node.submitblock(block.serialize().hex())
+
+    def assert_deploymentinfo(self, *, active, height=None):
+        info = self.nodes[0].getdeploymentinfo()['deployments']['extended_coinbase_maturity']
+        assert_equal(info['type'], 'flagday')
+        assert_equal(info['start_time'], START)
+        assert_equal(info['expiry_time'], EXPIRY)
+        assert_equal(info['active'], active)
+        assert_equal(info.get('height'), height)
+
+    def assert_gbt_rule(self, *, active):
+        tmpl = self.nodes[0].getblocktemplate({'rules': ['segwit', 'blake2b']})
+        assert_equal('extended_coinbase_maturity' in tmpl['rules'], active)
 
     def run_test(self):
         node = self.nodes[0]
-        self.wallet = MiniWallet(node)
 
         self.log.info("Option validation")
         self.stop_node(0)
-        self.nodes[0].assert_start_raises_init_error(
-            extra_args=[f'-extendedcoinbasematurity={START}'],
-            expected_msg='-extendedcoinbasematurity requires -rdtsexpiry',
-        )
-        self.nodes[0].assert_start_raises_init_error(
-            extra_args=[
-                f'-testactivationheight=blake2b@{BLAKE2B_HEIGHT}',
-                f'-rdtsexpiry={START}',
-                f'-extendedcoinbasematurity={START}',
-            ],
-            expected_msg='must precede the RDTS expiry',
-        )
-        self.start_node(0, extra_args=self.base_args)
-        self.wallet = MiniWallet(node)
+        node.assert_start_raises_init_error(
+            extra_args=[f'-testactivationheight=blake2b@{BLAKE2B_HEIGHT}', f'-extendedcoinbasematurity={START}'],
+            expected_msg='-extendedcoinbasematurity requires -rdtsexpiry')
+        node.assert_start_raises_init_error(
+            extra_args=[f'-testactivationheight=blake2b@{BLAKE2B_HEIGHT}', f'-rdtsexpiry={EXPIRY}', f'-extendedcoinbasematurity={EXPIRY}'],
+            expected_msg='must precede the RDTS expiry')
+        self.start_node(0)
+        node.add_p2p_connection(P2PInterface())  # getblocktemplate needs a peer
 
-        self.log.info("Mine up to the mock-time window")
+        self.wallet = MiniWallet(node)
         self.mocktime = T0
         node.setmocktime(self.mocktime)
-        # Connect a peer so generate works with MiniWallet
-        node.add_p2p_connection(P2PInterface())
 
-        # Pre-activation blocks
-        self.generate(self.wallet, 150, sync_fun=self.no_op)
-        pre_height = node.getblockcount()
-        assert_greater_than(START, self.mtp(pre_height))
+        self.log.info("Before activation: the 100-block rule applies")
+        self.generate(self.wallet, 200, sync_fun=self.no_op)  # crosses the BLAKE2b fork
+        assert_greater_than(START, self.mtp(200))
         self.assert_deploymentinfo(active=False)
         self.assert_gbt_rule(active=False)
+        spend = self.wallet.create_self_transfer(utxo_to_spend=self.coinbase_utxo(201 - COINBASE_MATURITY))
+        node.sendrawtransaction(spend['hex'])
+        self.generate(self.wallet, 1, sync_fun=self.no_op)
 
-        pre_utxo = self.coinbase_utxo(pre_height)
-        pre_spend = self.wallet.create_self_transfer(utxo_to_spend=pre_utxo)
-
-        self.log.info("Grandfathered coinbase spendable at 100 after activation")
+        self.log.info("Activation: the first block whose parent's median-time-past reaches the start time")
         self.mocktime = START
         node.setmocktime(self.mocktime)
-        # Push MTP across START
-        self.generate(node, 11, sync_fun=self.no_op)
-        activation = None
-        for h in range(1, node.getblockcount() + 1):
-            if self.mtp(h - 1) >= START:
-                activation = h
-                break
-        assert activation is not None
-        self.log.info(f"activation height {activation}")
+        while self.mtp(node.getblockcount()) < START:
+            self.assert_deploymentinfo(active=False)
+            self.generate(self.wallet, 1, sync_fun=self.no_op)
+        activation = node.getblockcount() + 1
+        self.log.info(f"  activation height {activation}")
         self.assert_deploymentinfo(active=True, height=activation)
         self.assert_gbt_rule(active=True)
+        self.generate(self.wallet, 1, sync_fun=self.no_op)  # block `activation`, the first in the window
+        self.assert_deploymentinfo(active=True, height=activation)
+        grandfathered = self.coinbase_utxo(activation - 1)
+        # First window block: (activation - activation) % 6 == 0 -> short tranche
+        locked = self.coinbase_utxo(activation)
+        assert_equal(maturity_for(activation, activation), EXTENDED_SHORT)
+
+        self.log.info("Inside the window: pre-activation coinbases keep the 100-block rule")
+        self.mine(COINBASE_MATURITY)  # tip = activation + 100
+        spend = self.wallet.create_self_transfer(utxo_to_spend=grandfathered)
+        node.sendrawtransaction(spend['hex'])
+        self.generate(node, 1, sync_fun=self.no_op)  # tip = activation + 101
+        assert_equal(node.getrawmempool(), [])
+
+        self.log.info("Inside the window: an in-window coinbase is locked past 100 confirmations")
+        locked_spend = self.wallet.create_self_transfer(utxo_to_spend=locked)
+        self.assert_spend_rejected(locked_spend['hex'])
+        assert_equal(self.submit_block_with(locked_spend['hex']), REJECT)
+        assert_equal(node.getblockcount(), activation + 101)
+
+        if self.is_wallet_compiled():
+            self.log.info("Wallet: an in-window reward stays immature past 100 confirmations")
+            node.createwallet('miner')
+            wallet_rpc = node.get_wallet_rpc('miner')
+            self.mocktime += 1
+            node.setmocktime(self.mocktime)
+            self.generatetoaddress(node, 1, wallet_rpc.getnewaddress(), sync_fun=self.no_op)
+            reward_height = node.getblockcount()
+            self.mine(COINBASE_MATURITY + 10)
+            balances = wallet_rpc.getbalances()['mine']
+            assert_greater_than(balances['immature'], 0)
+            assert_equal(balances['trusted'], 0)
+            assert_equal(wallet_rpc.listunspent(), [])
+            reward = wallet_rpc.listtransactions()[0]
+            assert_equal(reward['category'], 'immature')
+            assert_equal(reward['blockheight'], reward_height)
+
+        self.log.info("-reindex reproduces the chain and the activation height")
+        tip = node.getbestblockhash()
+        self.restart_node(0, extra_args=self.base_args + ['-reindex'])
+        node.setmocktime(self.mocktime)
+        node.add_p2p_connection(P2PInterface())
+        self.wait_until(lambda: node.getbestblockhash() == tip)
+        self.assert_deploymentinfo(active=True, height=activation)
+        self.assert_gbt_rule(active=True)
+        self.assert_spend_rejected(locked_spend['hex'])
 
-        # bury the pre-activation coinbase under 100
-        need = COINBASE_MATURITY - (node.getblockcount() - pre_height)
-        if need > 0:
-            self.generate(self.wallet, need, sync_fun=self.no_op)
-        node.sendrawtransaction(pre_spend['hex'])
-        self.generate(node, 1, sync_fun=self.no_op)
-
-        self.log.info("Short-tranche window coinbase rejected at 100, accepted at 2016")
-        # Find a window block with (h - activation) % 6 == 0
-        target = activation
-        while (target - activation) % 6 != 0 or target <= activation:
-            target += 1
-        while node.getblockcount() < target:
-            self.generate(self.wallet, 1, sync_fun=self.no_op)
-        short_utxo = self.coinbase_utxo(target)
-        assert_equal(maturity_for(target, activation), EXTENDED_SHORT)
-        short_spend = self.wallet.create_self_transfer(utxo_to_spend=short_utxo)
-
-        # 100 confirmations is not enough
-        while node.getblockcount() < target + COINBASE_MATURITY:
-            self.generate(self.wallet, min(100, target + COINBASE_MATURITY - node.getblockcount()), sync_fun=self.no_op)
-        self.assert_spend_rejected(short_spend['hex'])
-
-        # 2016 confirmations is enough
-        while node.getblockcount() < target + EXTENDED_SHORT:
-            self.generate(self.wallet, min(200, target + EXTENDED_SHORT - node.getblockcount()), sync_fun=self.no_op)
-        node.sendrawtransaction(short_spend['hex'])
+        self.log.info(f"Short tranche spendable at exactly {EXTENDED_SHORT} confirmations")
+        self.mine(activation + EXTENDED_SHORT - 2 - node.getblockcount())
+        assert_equal(node.getblockcount(), activation + EXTENDED_SHORT - 2)
+        self.assert_spend_rejected(locked_spend['hex'])
+        self.mine(1)
+        self.assert_deploymentinfo(active=True, height=activation)
+        node.sendrawtransaction(locked_spend['hex'])
+        assert_equal(node.getrawmempool(), [locked_spend['txid']])
         self.generate(node, 1, sync_fun=self.no_op)
-
-        self.log.info("Expiry: new coinbases are 100; in-window coins stay locked")
-        # Grab an in-window coinbase that is still far from its maturity
-        locked_h = activation + 3  # % 6 == 3 -> 26280
-        if locked_h == target:
-            locked_h = activation + 9
-        while node.getblockcount() < locked_h:
-            self.generate(self.wallet, 1, sync_fun=self.no_op)
-        locked_utxo = self.coinbase_utxo(locked_h)
-        locked_spend = self.wallet.create_self_transfer(utxo_to_spend=locked_utxo)
+        mature_block = node.getbestblockhash()
+        assert_equal(node.getblockcount(), activation + EXTENDED_SHORT)
+        assert locked_spend['txid'] in node.getblock(mature_block)['tx']
+
+        self.log.info("A reorg below the maturity boundary evicts the spend from the mempool")
+        node.invalidateblock(mature_block)
+        assert_equal(node.getrawmempool(), [locked_spend['txid']])
+        boundary_block = node.getbestblockhash()
+        node.invalidateblock(boundary_block)
+        assert_equal(node.getrawmempool(), [])
+        node.reconsiderblock(boundary_block)
+        assert_equal(node.getbestblockhash(), mature_block)
+        assert_equal(node.getrawmempool(), [])
+
+        self.log.info("Expiry: window coins stay locked; new coinbases use 100")
+        still_locked_height = activation + 3
+        if node.getblockcount() < still_locked_height:
+            self.mine(still_locked_height - node.getblockcount())
+        still_locked = self.coinbase_utxo(still_locked_height)
+        assert_equal(maturity_for(still_locked_height, activation), EXTENDED_LONG)
+        still_locked_spend = self.wallet.create_self_transfer(utxo_to_spend=still_locked)
+        self.assert_spend_rejected(still_locked_spend['hex'])
 
         self.mocktime = EXPIRY
         node.setmocktime(self.mocktime)
-        self.generate(node, 11, sync_fun=self.no_op)
+        self.generate(node, 5, sync_fun=self.no_op)
+        assert_greater_than(EXPIRY, self.mtp(node.getblockcount()))
+        self.assert_deploymentinfo(active=True, height=activation)
+        self.assert_gbt_rule(active=True)
+        self.assert_spend_rejected(still_locked_spend['hex'])
+        self.generate(node, 1, sync_fun=self.no_op)
+        assert_equal(self.mtp(node.getblockcount()), EXPIRY)
         self.assert_deploymentinfo(active=False, height=activation)
         self.assert_gbt_rule(active=False)
+        # #402 would accept still_locked_spend here. The lock sticks:
+        self.assert_spend_rejected(still_locked_spend['hex'])
 
-        # window coinbase still rejected
-        self.assert_spend_rejected(locked_spend['hex'])
-
-        # a brand-new post-expiry coinbase matures at 100
         post_h = node.getblockcount()
         post_utxo = self.coinbase_utxo(post_h)
         post_spend = self.wallet.create_self_transfer(utxo_to_spend=post_utxo)
-        self.generate(self.wallet, COINBASE_MATURITY, sync_fun=self.no_op)
+        self.mine(COINBASE_MATURITY)
         node.sendrawtransaction(post_spend['hex'])
         self.generate(node, 1, sync_fun=self.no_op)
-
-        self.log.info("Passed")
+        assert post_spend['txid'] in node.getblock(node.getbestblockhash())['tx']
 
 
 if __name__ == '__main__':
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 667a2ff7532a..4f2a91b6d67b 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -98,9 +98,9 @@
     'rpc_combinerawtransaction_unified.py --descriptors',
     'feature_taproot.py',
     'feature_reduced_data_temporary_deployment.py',
+    'feature_extended_coinbase_maturity.py',
     'feature_bip9_max_activation_height.py',
     'feature_rdts.py',
-    'feature_extended_coinbase_maturity.py',
     'feature_rdts_ignore_rejects.py',
     'feature_block.py',
     'mempool_ephemeral_dust.py',

From ad646c90db24745e81c8cb61c2b50e6ffe88445a Mon Sep 17 00:00:00 2001
From: FlyTheElephant1 <259444470+FlyTheElephant1@users.noreply.github.com>
Date: Thu, 10 Sep 2026 21:17:14 -0500
Subject: [PATCH 03/11] fix: align maturity height helper and functional test
 with #402

Use #402's MTP binary search (lo+1) so getdeploymentinfo reports
activation height when the tip MTP first crosses the start time.
Keep window [start, expiry) after RDTS so in-window coinbases stay
locked. Functional test uses exact init-error strings, mines the
post-expiry coinbase to MiniWallet, and covers short-tranche
maturity plus lock-sticks-after-expiry.
---
 src/validation.cpp                                 | 14 ++++++--------
 .../feature_extended_coinbase_maturity.py          |  6 +++---
 2 files changed, 9 insertions(+), 11 deletions(-)
 mode change 100644 => 100755 test/functional/feature_extended_coinbase_maturity.py

diff --git a/src/validation.cpp b/src/validation.cpp
index 6387c0e57526..5a77d39c56d3 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -7367,22 +7367,20 @@ std::pair<int, int> ChainstateManager::GetPruneRange(const Chainstate& chainstat
 
 int FirstHeightWithParentMtpAtLeast(const CBlockIndex& tip, int64_t time)
 {
-    if (!tip.pprev) return std::numeric_limits<int>::max();
-    if (tip.pprev->GetMedianTimePast() < time) return std::numeric_limits<int>::max();
-    // Binary search: first height whose parent MTP >= time. Same answer as
-    // knots#402 MedianTimePastActivationHeight once the tip has reached `time`.
-    int lo{1};
+    if (tip.GetMedianTimePast() < time) {
+        return std::numeric_limits<int>::max();
+    }
+    int lo{0};
     int hi{tip.nHeight};
     while (lo < hi) {
         const int mid{lo + (hi - lo) / 2};
-        const CBlockIndex* anc{Assert(tip.GetAncestor(mid))};
-        if (anc->pprev->GetMedianTimePast() >= time) {
+        if (Assert(tip.GetAncestor(mid))->GetMedianTimePast() >= time) {
             hi = mid;
         } else {
             lo = mid + 1;
         }
     }
-    return lo;
+    return lo + 1;
 }
 
 void ExtendedCoinbaseMaturityBounds(const Consensus::Params& params, const CBlockIndex& tip, int& start_height, int& expiry_height)
diff --git a/test/functional/feature_extended_coinbase_maturity.py b/test/functional/feature_extended_coinbase_maturity.py
old mode 100644
new mode 100755
index 4df5d5920bca..43e7278c8b88
--- a/test/functional/feature_extended_coinbase_maturity.py
+++ b/test/functional/feature_extended_coinbase_maturity.py
@@ -136,10 +136,10 @@ def run_test(self):
         self.stop_node(0)
         node.assert_start_raises_init_error(
             extra_args=[f'-testactivationheight=blake2b@{BLAKE2B_HEIGHT}', f'-extendedcoinbasematurity={START}'],
-            expected_msg='-extendedcoinbasematurity requires -rdtsexpiry')
+            expected_msg='Error: -extendedcoinbasematurity requires -rdtsexpiry=<time> (window ends at RDTS expiry).')
         node.assert_start_raises_init_error(
             extra_args=[f'-testactivationheight=blake2b@{BLAKE2B_HEIGHT}', f'-rdtsexpiry={EXPIRY}', f'-extendedcoinbasematurity={EXPIRY}'],
-            expected_msg='must precede the RDTS expiry')
+            expected_msg=f'Error: Invalid start ({EXPIRY}) for -extendedcoinbasematurity=<time>: must precede the RDTS expiry ({EXPIRY}).')
         self.start_node(0)
         node.add_p2p_connection(P2PInterface())  # getblocktemplate needs a peer
 
@@ -258,7 +258,7 @@ def run_test(self):
         self.assert_gbt_rule(active=False)
         # #402 would accept still_locked_spend here. The lock sticks:
         self.assert_spend_rejected(still_locked_spend['hex'])
-
+        self.generate(self.wallet, 1, sync_fun=self.no_op)
         post_h = node.getblockcount()
         post_utxo = self.coinbase_utxo(post_h)
         post_spend = self.wallet.create_self_transfer(utxo_to_spend=post_utxo)

From 6d6fa126b8c284a2b64e40c89f02ef9981576624 Mon Sep 17 00:00:00 2001
From: FlyTheElephant1 <259444470+FlyTheElephant1@users.noreply.github.com>
Date: Thu, 10 Sep 2026 22:12:51 -0500
Subject: [PATCH 04/11] Use 2016/4032/8064 batched maturity instead of
 2016/8064/26280

---
 doc/release-notes-batched-coinbase-maturity.md        | 4 ++--
 src/chainparamsbase.cpp                               | 2 +-
 src/consensus/consensus.h                             | 4 ++--
 test/functional/feature_extended_coinbase_maturity.py | 8 ++++----
 4 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/doc/release-notes-batched-coinbase-maturity.md b/doc/release-notes-batched-coinbase-maturity.md
index 26799e12528d..eb2b03fb4715 100644
--- a/doc/release-notes-batched-coinbase-maturity.md
+++ b/doc/release-notes-batched-coinbase-maturity.md
@@ -4,8 +4,8 @@ Coinbase outputs created while this deployment is active use a longer
 maturity that is attached to the creating block, not to the spend:
 
 - 1/6 of window blocks (`(height - start) % 6 == 0`): 2016 confirmations
-- 2/6 of window blocks (`% 6` in {1,2}): 8064 confirmations
-- 1/2 of window blocks (`% 6` in {3,4,5}): 26280 confirmations
+- 2/6 of window blocks (`% 6` in {1,2}): 4032 confirmations
+- 1/2 of window blocks (`% 6` in {3,4,5}): 8064 confirmations
 
 The assignment is by block height, so coinbase transaction size does
 not change. There is no extra output and no DATUM/script change.
diff --git a/src/chainparamsbase.cpp b/src/chainparamsbase.cpp
index 8f09e7918ee6..663d9275bcac 100644
--- a/src/chainparamsbase.cpp
+++ b/src/chainparamsbase.cpp
@@ -18,7 +18,7 @@ void SetupChainParamsBaseOptions(ArgsManager& argsman)
                  "This is intended for regression testing tools and app development. Equivalent to -chain=regtest.", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CHAINPARAMS);
     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("-extendedcoinbasematurity=<time>", "Schedule the batched extended coinbase-maturity softfork: coinbases created from the first block whose parent MTP reaches <time> use the 2016/8064/26280 schedule (1/6, 2/6, 1/2 of blocks). The lock sticks to those coins after RDTS expiry. Requires -rdtsexpiry, which <time> must precede. (regtest-only)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
+    argsman.AddArg("-extendedcoinbasematurity=<time>", "Schedule the batched extended coinbase-maturity softfork: coinbases created from the first block whose parent MTP reaches <time> use the 2016/4032/8064 schedule (1/6, 2/6, 1/2 of blocks). The lock sticks to those coins after RDTS expiry. Requires -rdtsexpiry, which <time> must precede. (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("-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);
diff --git a/src/consensus/consensus.h b/src/consensus/consensus.h
index a0f0b6b826c7..85b3efce6814 100644
--- a/src/consensus/consensus.h
+++ b/src/consensus/consensus.h
@@ -23,8 +23,8 @@ static const int COINBASE_MATURITY = 100;
  *  (coinbase_height - window_start) % 6 so 1/6 of window coinbases mature
  *  at 2016, 2/6 at 8064, and 1/2 at 26280. No extra coinbase outputs. */
 static const int EXTENDED_COINBASE_MATURITY_SHORT = 2016;
-static const int EXTENDED_COINBASE_MATURITY_MID = 8064;
-static const int EXTENDED_COINBASE_MATURITY_LONG = 26280;
+static const int EXTENDED_COINBASE_MATURITY_MID = 4032;
+static const int EXTENDED_COINBASE_MATURITY_LONG = 8064;
 
 static const int WITNESS_SCALE_FACTOR = 4;
 
diff --git a/test/functional/feature_extended_coinbase_maturity.py b/test/functional/feature_extended_coinbase_maturity.py
index 43e7278c8b88..cc12688905df 100755
--- a/test/functional/feature_extended_coinbase_maturity.py
+++ b/test/functional/feature_extended_coinbase_maturity.py
@@ -9,8 +9,8 @@
 
   1. Window coinbases use (height - activation) % 6
        0        -> 2016 confirmations   (1/6 of blocks)
-       1 or 2   -> 8064 confirmations   (2/6)
-       3, 4, 5  -> 26280 confirmations  (1/2)
+       1 or 2   -> 4032 confirmations   (2/6)
+       3, 4, 5  -> 8064 confirmations  (1/2)
      instead of a single 26280-block lock. Coinbase size is unchanged.
   2. The lock is attached to the creating height. After RDTS expiry,
      *new* coinbases use COINBASE_MATURITY (100). Window-created
@@ -43,8 +43,8 @@
 from test_framework.wallet import MiniWallet
 
 EXTENDED_SHORT = 2016
-EXTENDED_MID = 8064
-EXTENDED_LONG = 26280
+EXTENDED_MID = 4032
+EXTENDED_LONG = 8064
 BLAKE2B_HEIGHT = 120
 # Mock clock: pre-activation blocks are stamped from T0, the window opens once
 # the median-time-past reaches START, and RDTS (with it, this rule's *creation*

From 061c403b2ab723a9c41e2ddc8b6f68cecaad0b61 Mon Sep 17 00:00:00 2001
From: FlyTheElephant1 <259444470+FlyTheElephant1@users.noreply.github.com>
Date: Thu, 10 Sep 2026 23:13:53 -0500
Subject: [PATCH 05/11] Brought comments in line with new values set in 6d6fa12

---
 src/consensus/consensus.h   | 2 +-
 src/consensus/tx_verify.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/consensus/consensus.h b/src/consensus/consensus.h
index 85b3efce6814..9516e090c3c5 100644
--- a/src/consensus/consensus.h
+++ b/src/consensus/consensus.h
@@ -21,7 +21,7 @@ static const int64_t MAX_BLOCK_SIGOPS_COST = 80000;
 static const int COINBASE_MATURITY = 100;
 /** Batched extended coinbase maturity (temporary softfork). Assigned by
  *  (coinbase_height - window_start) % 6 so 1/6 of window coinbases mature
- *  at 2016, 2/6 at 8064, and 1/2 at 26280. No extra coinbase outputs. */
+ *  at 2016, 2/6 at 4032, and 1/2 at 8064. No extra coinbase outputs. */
 static const int EXTENDED_COINBASE_MATURITY_SHORT = 2016;
 static const int EXTENDED_COINBASE_MATURITY_MID = 4032;
 static const int EXTENDED_COINBASE_MATURITY_LONG = 8064;
diff --git a/src/consensus/tx_verify.cpp b/src/consensus/tx_verify.cpp
index 9fca8bbb1d4f..a5607ee50243 100644
--- a/src/consensus/tx_verify.cpp
+++ b/src/consensus/tx_verify.cpp
@@ -177,7 +177,7 @@ int Consensus::RequiredCoinbaseMaturity(int coinbase_height, int ext_start_heigh
     if (coinbase_height < ext_start_height || coinbase_height >= ext_expiry_height) {
         return COINBASE_MATURITY;
     }
-    // 1/6 of window blocks: 2016; 2/6: 8064; 1/2: 26280. Relative to
+    // 1/6 of window blocks: 2016; 2/6: 4032; 1/2: 8064. Relative to
     // the first window height so the cadence does not depend on abs height.
     const int batch = (coinbase_height - ext_start_height) % 6;
     if (batch == 0) return EXTENDED_COINBASE_MATURITY_SHORT;

From 7e59f2b1dd1234b39235326f99f6d8ecfc002a62 Mon Sep 17 00:00:00 2001
From: FlyTheElephant1 <259444470+FlyTheElephant1@users.noreply.github.com>
Date: Fri, 11 Sep 2026 21:11:57 -0500
Subject: [PATCH 06/11] Assign batched maturity from creating-block hash % 6

---
 ...release-notes-batched-coinbase-maturity.md | 14 +++--
 src/chainparamsbase.cpp                       |  2 +-
 src/consensus/consensus.h                     |  5 +-
 src/consensus/tx_verify.cpp                   | 27 +++++++--
 src/consensus/tx_verify.h                     | 15 +++--
 src/node/interfaces.cpp                       |  6 +-
 src/test/validation_tests.cpp                 | 16 +++---
 src/validation.cpp                            | 10 +++-
 .../feature_extended_coinbase_maturity.py     | 56 ++++++++++++-------
 9 files changed, 99 insertions(+), 52 deletions(-)

diff --git a/doc/release-notes-batched-coinbase-maturity.md b/doc/release-notes-batched-coinbase-maturity.md
index eb2b03fb4715..e3e79b073ecc 100644
--- a/doc/release-notes-batched-coinbase-maturity.md
+++ b/doc/release-notes-batched-coinbase-maturity.md
@@ -3,18 +3,20 @@
 Coinbase outputs created while this deployment is active use a longer
 maturity that is attached to the creating block, not to the spend:
 
-- 1/6 of window blocks (`(height - start) % 6 == 0`): 2016 confirmations
-- 2/6 of window blocks (`% 6` in {1,2}): 4032 confirmations
-- 1/2 of window blocks (`% 6` in {3,4,5}): 8064 confirmations
+- ~1/6 of window blocks (`creating_block_hash % 6 == 0`): 2016 confirmations
+- ~2/6 of window blocks (`% 6` in {1,2}): 4032 confirmations
+- ~1/2 of window blocks (`% 6` in {3,4,5}): 8064 confirmations
 
-The assignment is by block height, so coinbase transaction size does
-not change. There is no extra output and no DATUM/script change.
+The assignment is `GetUint64(0) % 6` of the creating block's hash, so
+the tranche is unknown until proof-of-work is found (miners cannot pick
+a short height in advance). Coinbase transaction size does not change.
+There is no extra output and no DATUM/script change.
 
 The window is the same shape as RDTS: first block whose parent MTP
 reaches the start time, through the last block whose parent MTP is still
 below the RDTS expiry. After expiry, **new** coinbases go back to the
 ordinary 100-block maturity. Coinbases created *inside* the window keep
-their 2016/8064/26280 lock until they actually mature — expiry does not
+their 2016/4032/8064 lock until they actually mature — expiry does not
 unlock them early.
 
 Only outputs created inside the window are affected. A coinbase output
diff --git a/src/chainparamsbase.cpp b/src/chainparamsbase.cpp
index 663d9275bcac..674e02375a13 100644
--- a/src/chainparamsbase.cpp
+++ b/src/chainparamsbase.cpp
@@ -18,7 +18,7 @@ void SetupChainParamsBaseOptions(ArgsManager& argsman)
                  "This is intended for regression testing tools and app development. Equivalent to -chain=regtest.", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CHAINPARAMS);
     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("-extendedcoinbasematurity=<time>", "Schedule the batched extended coinbase-maturity softfork: coinbases created from the first block whose parent MTP reaches <time> use the 2016/4032/8064 schedule (1/6, 2/6, 1/2 of blocks). The lock sticks to those coins after RDTS expiry. Requires -rdtsexpiry, which <time> must precede. (regtest-only)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
+    argsman.AddArg("-extendedcoinbasematurity=<time>", "Schedule the batched extended coinbase-maturity softfork: coinbases created from the first block whose parent MTP reaches <time> use the 2016/4032/8064 schedule from creating-block hash % 6 (~1/6, ~2/6, ~1/2 of blocks). The lock sticks to those coins after RDTS expiry. Requires -rdtsexpiry, which <time> must precede. (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("-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);
diff --git a/src/consensus/consensus.h b/src/consensus/consensus.h
index 9516e090c3c5..54251b4fa100 100644
--- a/src/consensus/consensus.h
+++ b/src/consensus/consensus.h
@@ -20,8 +20,9 @@ static const int64_t MAX_BLOCK_SIGOPS_COST = 80000;
 /** Coinbase transaction outputs can only be spent after this number of new blocks (network rule) */
 static const int COINBASE_MATURITY = 100;
 /** Batched extended coinbase maturity (temporary softfork). Assigned by
- *  (coinbase_height - window_start) % 6 so 1/6 of window coinbases mature
- *  at 2016, 2/6 at 4032, and 1/2 at 8064. No extra coinbase outputs. */
+ *  creating-block hash GetUint64(0) % 6 so ~1/6 of window coinbases mature
+ *  at 2016, ~2/6 at 4032, and ~1/2 at 8064. Unknown until PoW is found.
+ *  No extra coinbase outputs. */
 static const int EXTENDED_COINBASE_MATURITY_SHORT = 2016;
 static const int EXTENDED_COINBASE_MATURITY_MID = 4032;
 static const int EXTENDED_COINBASE_MATURITY_LONG = 8064;
diff --git a/src/consensus/tx_verify.cpp b/src/consensus/tx_verify.cpp
index a5607ee50243..6c4cbcee0c23 100644
--- a/src/consensus/tx_verify.cpp
+++ b/src/consensus/tx_verify.cpp
@@ -12,6 +12,7 @@
 #include <primitives/transaction.h>
 #include <script/interpreter.h>
 #include <util/check.h>
+#include <uint256.h>
 #include <util/moneystr.h>
 
 bool IsFinalTx(const CTransaction &tx, int nBlockHeight, int64_t nBlockTime)
@@ -172,20 +173,28 @@ bool Consensus::CheckOutputSizes(const CTransaction& tx, TxValidationState& stat
     return true;
 }
 
-int Consensus::RequiredCoinbaseMaturity(int coinbase_height, int ext_start_height, int ext_expiry_height)
+int Consensus::CoinbaseHashMod6(const uint256& creating_block_hash)
+{
+    return static_cast<int>(creating_block_hash.GetUint64(0) % 6);
+}
+
+int Consensus::RequiredCoinbaseMaturity(int coinbase_height, int ext_start_height, int ext_expiry_height, int hash_mod6)
 {
     if (coinbase_height < ext_start_height || coinbase_height >= ext_expiry_height) {
         return COINBASE_MATURITY;
     }
-    // 1/6 of window blocks: 2016; 2/6: 4032; 1/2: 8064. Relative to
-    // the first window height so the cadence does not depend on abs height.
-    const int batch = (coinbase_height - ext_start_height) % 6;
+    // ~1/6 of window blocks: 2016; ~2/6: 4032; ~1/2: 8064. Residue is
+    // the creating block's hash (GetUint64(0) % 6), unknown until PoW.
+    const int batch = hash_mod6 % 6;
+    if (batch < 0) {
+        return EXTENDED_COINBASE_MATURITY_LONG;
+    }
     if (batch == 0) return EXTENDED_COINBASE_MATURITY_SHORT;
     if (batch == 1 || batch == 2) return EXTENDED_COINBASE_MATURITY_MID;
     return EXTENDED_COINBASE_MATURITY_LONG;
 }
 
-bool Consensus::CheckTxInputs(const CTransaction& tx, TxValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee, const CheckTxInputsRules rules, int ext_start_height, int ext_expiry_height)
+bool Consensus::CheckTxInputs(const CTransaction& tx, TxValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee, const CheckTxInputsRules rules, int ext_start_height, int ext_expiry_height, const CBlockIndex* hash_tip)
 {
     // are the actual inputs available?
     if (!inputs.HaveInputs(tx)) {
@@ -206,7 +215,13 @@ bool Consensus::CheckTxInputs(const CTransaction& tx, TxValidationState& state,
 
         // If prev is coinbase, check that it's matured
         if (coin.IsCoinBase()) {
-            const int maturity = RequiredCoinbaseMaturity(coin.nHeight, ext_start_height, ext_expiry_height);
+            int hash_mod6 = 5;
+            if (hash_tip) {
+                if (const CBlockIndex* created{hash_tip->GetAncestor(coin.nHeight)}) {
+                    hash_mod6 = CoinbaseHashMod6(created->GetBlockHash());
+                }
+            }
+            const int maturity = RequiredCoinbaseMaturity(coin.nHeight, ext_start_height, ext_expiry_height, hash_mod6);
             if (nSpendHeight - coin.nHeight < maturity) {
                 return state.Invalid(TxValidationResult::TX_PREMATURE_SPEND, "bad-txns-premature-spend-of-coinbase",
                     strprintf("tried to spend coinbase at depth %d (maturity %d)", nSpendHeight - coin.nHeight, maturity));
diff --git a/src/consensus/tx_verify.h b/src/consensus/tx_verify.h
index e5a69bd744d4..d4c03c801ee4 100644
--- a/src/consensus/tx_verify.h
+++ b/src/consensus/tx_verify.h
@@ -15,6 +15,7 @@ class CBlockIndex;
 class CCoinsViewCache;
 class CTransaction;
 class TxValidationState;
+class uint256;
 
 /** Transaction validation functions */
 
@@ -50,21 +51,27 @@ namespace Consensus {
  */
 bool CheckOutputSizes(const CTransaction& tx, TxValidationState& state);
 
+int CoinbaseHashMod6(const uint256& creating_block_hash);
+
 /**
  * Confirmations required before a coinbase created at coinbase_height may
  * be spent. Coins created in [ext_start_height, ext_expiry_height) keep
- * the batched extended schedule after RDTS expiry. Pass INT_MAX for both
- * bounds when the deployment is unscheduled on this chain.
+ * the batched extended schedule after RDTS expiry. hash_mod6 is
+ * CoinbaseHashMod6 of the creating block (0..5). Pass INT_MAX for both
+ * bounds when the deployment is unscheduled. hash_mod6 is ignored outside
+ * the window. Default 5 (long tranche) if the caller has no hash.
  */
-int RequiredCoinbaseMaturity(int coinbase_height, int ext_start_height, int ext_expiry_height);
+int RequiredCoinbaseMaturity(int coinbase_height, int ext_start_height, int ext_expiry_height, int hash_mod6 = 5);
 
 /**
  * Check whether all inputs of this transaction are valid (no double spends and amounts)
  * This does not modify the UTXO set. This does not check scripts and sigs.
+ * @param[in] hash_tip If set, creating-block hashes for coinbase inputs are
+ *            taken from hash_tip->GetAncestor(coin.nHeight).
  * @param[out] txfee Set to the transaction fee if successful.
  * Preconditions: tx.IsCoinBase() is false.
  */
-[[nodiscard]] bool CheckTxInputs(const CTransaction& tx, TxValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee, CheckTxInputsRules rules, int ext_start_height = (std::numeric_limits<int>::max)(), int ext_expiry_height = (std::numeric_limits<int>::max)());
+[[nodiscard]] bool CheckTxInputs(const CTransaction& tx, TxValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee, CheckTxInputsRules rules, int ext_start_height = (std::numeric_limits<int>::max)(), int ext_expiry_height = (std::numeric_limits<int>::max)(), const CBlockIndex* hash_tip = nullptr);
 } // namespace Consensus
 
 /** Auxiliary functions for transaction validation (ideally should not be exposed) */
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index d58aa4f0d4a4..66693230b63e 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -590,7 +590,11 @@ class ChainImpl : public Chain
         if (!tip) return COINBASE_MATURITY;
         int ext_start, ext_expiry;
         ExtendedCoinbaseMaturityBounds(chainman().GetConsensus(), *tip, ext_start, ext_expiry);
-        return Consensus::RequiredCoinbaseMaturity(coinbase_height, ext_start, ext_expiry);
+        int hash_mod6 = 5;
+        if (const CBlockIndex* created{chainman().ActiveChain()[coinbase_height]}) {
+            hash_mod6 = Consensus::CoinbaseHashMod6(created->GetBlockHash());
+        }
+        return Consensus::RequiredCoinbaseMaturity(coinbase_height, ext_start, ext_expiry, hash_mod6);
     }
     bool pruneLockExists(const std::string& name) const override
     {
diff --git a/src/test/validation_tests.cpp b/src/test/validation_tests.cpp
index 029718655618..df134a1ca1d9 100644
--- a/src/test/validation_tests.cpp
+++ b/src/test/validation_tests.cpp
@@ -426,16 +426,16 @@ BOOST_AUTO_TEST_CASE(batched_coinbase_maturity_schedule)
     BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(10, inactive, inactive), COINBASE_MATURITY);
     const int start = 51;
     const int expiry = 151;
-    BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(50, start, expiry), COINBASE_MATURITY);
-    BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(51, start, expiry), EXTENDED_COINBASE_MATURITY_SHORT); // %6==0
-    BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(52, start, expiry), EXTENDED_COINBASE_MATURITY_MID);
-    BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(53, start, expiry), EXTENDED_COINBASE_MATURITY_MID);
-    BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(54, start, expiry), EXTENDED_COINBASE_MATURITY_LONG);
-    BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(151, start, expiry), COINBASE_MATURITY);
+    BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(50, start, expiry, 0), COINBASE_MATURITY);
+    BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(51, start, expiry, 0), EXTENDED_COINBASE_MATURITY_SHORT);
+    BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(52, start, expiry, 1), EXTENDED_COINBASE_MATURITY_MID);
+    BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(53, start, expiry, 2), EXTENDED_COINBASE_MATURITY_MID);
+    BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(54, start, expiry, 3), EXTENDED_COINBASE_MATURITY_LONG);
+    BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(151, start, expiry, 0), COINBASE_MATURITY);
     // lock sticks: same bounds as a tip that has already crossed expiry
     // still classify window coins as extended. height 151 is first post-expiry.
-    BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(51, start, expiry), EXTENDED_COINBASE_MATURITY_SHORT);
-    BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(54, start, expiry), EXTENDED_COINBASE_MATURITY_LONG);
+    BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(51, start, expiry, 0), EXTENDED_COINBASE_MATURITY_SHORT);
+    BOOST_CHECK_EQUAL(Consensus::RequiredCoinbaseMaturity(54, start, expiry, 5), EXTENDED_COINBASE_MATURITY_LONG);
 }
 
 BOOST_AUTO_TEST_CASE(extended_coinbase_maturity_bounds)
diff --git a/src/validation.cpp b/src/validation.cpp
index 5a77d39c56d3..7a969ef5830a 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -440,7 +440,11 @@ void Chainstate::MaybeUpdateMempoolForReorg(
                 if (m_mempool->exists(GenTxid::Txid(txin.prevout.hash))) continue;
                 const Coin& coin{CoinsTip().AccessCoin(txin.prevout)};
                 assert(!coin.IsSpent());
-                if (coin.IsCoinBase() && mempool_spend_height - coin.nHeight < Consensus::RequiredCoinbaseMaturity(coin.nHeight, ext_start, ext_expiry)) {
+                int hash_mod6 = 5;
+                if (const CBlockIndex* created{m_chain.Tip()->GetAncestor(coin.nHeight)}) {
+                    hash_mod6 = Consensus::CoinbaseHashMod6(created->GetBlockHash());
+                }
+                if (coin.IsCoinBase() && mempool_spend_height - coin.nHeight < Consensus::RequiredCoinbaseMaturity(coin.nHeight, ext_start, ext_expiry, hash_mod6)) {
                     return true;
                 }
             }
@@ -1019,7 +1023,7 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
     const auto block_height_next = block_height_current + 1;
     int ext_start, ext_expiry;
     ExtendedCoinbaseMaturityBounds(m_active_chainstate.m_chainman.GetConsensus(), *m_active_chainstate.m_chain.Tip(), ext_start, ext_expiry);
-    if (!Consensus::CheckTxInputs(tx, state, m_view, block_height_next, ws.m_base_fees, CheckTxInputsRules::OutputSizeLimit, ext_start, ext_expiry)) {
+    if (!Consensus::CheckTxInputs(tx, state, m_view, block_height_next, ws.m_base_fees, CheckTxInputsRules::OutputSizeLimit, ext_start, ext_expiry, m_active_chainstate.m_chain.Tip())) {
         return false; // state filled in by CheckTxInputs
     }
 
@@ -3027,7 +3031,7 @@ 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, ext_start, ext_expiry)) {
+            if (!Consensus::CheckTxInputs(tx, tx_state, view, pindex->nHeight, txfee, chk_input_rules, ext_start, ext_expiry, pindex)) {
                 // Any transaction validation failure in ConnectBlock is a block consensus failure
                 state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                               tx_state.GetRejectReason(),
diff --git a/test/functional/feature_extended_coinbase_maturity.py b/test/functional/feature_extended_coinbase_maturity.py
index cc12688905df..e2ef54c1df72 100755
--- a/test/functional/feature_extended_coinbase_maturity.py
+++ b/test/functional/feature_extended_coinbase_maturity.py
@@ -7,11 +7,12 @@
 Layout follows knots#402's feature_extended_coinbase_maturity.py so a
 human diff against that PR is mostly the two intended deltas:
 
-  1. Window coinbases use (height - activation) % 6
-       0        -> 2016 confirmations   (1/6 of blocks)
-       1 or 2   -> 4032 confirmations   (2/6)
-       3, 4, 5  -> 8064 confirmations  (1/2)
+  1. Window coinbases use creating-block hash % 6
+       0        -> 2016 confirmations   (~1/6 of blocks)
+       1 or 2   -> 4032 confirmations   (~2/6)
+       3, 4, 5  -> 8064 confirmations   (~1/2)
      instead of a single 26280-block lock. Coinbase size is unchanged.
+     Tranche is unknown until PoW, so miners cannot pick short heights.
   2. The lock is attached to the creating height. After RDTS expiry,
      *new* coinbases use COINBASE_MATURITY (100). Window-created
      coinbases keep their assigned lock. (#402 unlocked them at expiry.)
@@ -56,11 +57,14 @@
 REJECT = 'bad-txns-premature-spend-of-coinbase'
 
 
-def maturity_for(height, activation):
-    """Consensus schedule: pre-activation is 100; in-window is batched."""
-    if height < activation:
-        return COINBASE_MATURITY
-    batch = (height - activation) % 6
+def hash_mod6(blockhash_hex):
+    """Match Consensus::CoinbaseHashMod6: GetUint64(0) % 6."""
+    raw = bytes.fromhex(blockhash_hex)[::-1]
+    return int.from_bytes(raw[0:8], "little") % 6
+
+
+def maturity_for_hash(blockhash_hex):
+    batch = hash_mod6(blockhash_hex)
     if batch == 0:
         return EXTENDED_SHORT
     if batch in (1, 2):
@@ -103,6 +107,18 @@ def coinbase_utxo(self, height):
         txid = node.getblock(node.getblockhash(height))['tx'][0]
         return self.wallet.get_utxo(txid=txid)
 
+    def find_tranche(self, start_height, want_maturity):
+        """Return (height, utxo) of a window coinbase whose hash maps to want_maturity."""
+        node = self.nodes[0]
+        h = start_height
+        while True:
+            while h > node.getblockcount():
+                self.generate(self.wallet, 1, sync_fun=self.no_op)
+            bh = node.getblockhash(h)
+            if maturity_for_hash(bh) == want_maturity:
+                return h, self.coinbase_utxo(h)
+            h += 1
+
     def assert_spend_rejected(self, tx_hex):
         node = self.nodes[0]
         assert_equal(node.testmempoolaccept([tx_hex])[0]['reject-reason'], REJECT)
@@ -169,9 +185,9 @@ def run_test(self):
         self.generate(self.wallet, 1, sync_fun=self.no_op)  # block `activation`, the first in the window
         self.assert_deploymentinfo(active=True, height=activation)
         grandfathered = self.coinbase_utxo(activation - 1)
-        # First window block: (activation - activation) % 6 == 0 -> short tranche
-        locked = self.coinbase_utxo(activation)
-        assert_equal(maturity_for(activation, activation), EXTENDED_SHORT)
+        short_h, locked = self.find_tranche(activation, EXTENDED_SHORT)
+        self.log.info(f"  short-tranche window height {short_h} hash%6={hash_mod6(node.getblockhash(short_h))}")
+        assert_equal(maturity_for_hash(node.getblockhash(short_h)), EXTENDED_SHORT)
 
         self.log.info("Inside the window: pre-activation coinbases keep the 100-block rule")
         self.mine(COINBASE_MATURITY)  # tip = activation + 100
@@ -184,7 +200,7 @@ def run_test(self):
         locked_spend = self.wallet.create_self_transfer(utxo_to_spend=locked)
         self.assert_spend_rejected(locked_spend['hex'])
         assert_equal(self.submit_block_with(locked_spend['hex']), REJECT)
-        assert_equal(node.getblockcount(), activation + 101)
+        assert_equal(node.getblockcount(), short_h + COINBASE_MATURITY + 1)
 
         if self.is_wallet_compiled():
             self.log.info("Wallet: an in-window reward stays immature past 100 confirmations")
@@ -214,8 +230,8 @@ def run_test(self):
         self.assert_spend_rejected(locked_spend['hex'])
 
         self.log.info(f"Short tranche spendable at exactly {EXTENDED_SHORT} confirmations")
-        self.mine(activation + EXTENDED_SHORT - 2 - node.getblockcount())
-        assert_equal(node.getblockcount(), activation + EXTENDED_SHORT - 2)
+        self.mine(short_h + EXTENDED_SHORT - 2 - node.getblockcount())
+        assert_equal(node.getblockcount(), short_h + EXTENDED_SHORT - 2)
         self.assert_spend_rejected(locked_spend['hex'])
         self.mine(1)
         self.assert_deploymentinfo(active=True, height=activation)
@@ -223,7 +239,7 @@ def run_test(self):
         assert_equal(node.getrawmempool(), [locked_spend['txid']])
         self.generate(node, 1, sync_fun=self.no_op)
         mature_block = node.getbestblockhash()
-        assert_equal(node.getblockcount(), activation + EXTENDED_SHORT)
+        assert_equal(node.getblockcount(), short_h + EXTENDED_SHORT)
         assert locked_spend['txid'] in node.getblock(mature_block)['tx']
 
         self.log.info("A reorg below the maturity boundary evicts the spend from the mempool")
@@ -237,11 +253,9 @@ def run_test(self):
         assert_equal(node.getrawmempool(), [])
 
         self.log.info("Expiry: window coins stay locked; new coinbases use 100")
-        still_locked_height = activation + 3
-        if node.getblockcount() < still_locked_height:
-            self.mine(still_locked_height - node.getblockcount())
-        still_locked = self.coinbase_utxo(still_locked_height)
-        assert_equal(maturity_for(still_locked_height, activation), EXTENDED_LONG)
+        still_locked_height, still_locked = self.find_tranche(activation, EXTENDED_LONG)
+        assert_equal(maturity_for_hash(node.getblockhash(still_locked_height)), EXTENDED_LONG)
+        self.log.info(f"  long-tranche window height {still_locked_height}")
         still_locked_spend = self.wallet.create_self_transfer(utxo_to_spend=still_locked)
         self.assert_spend_rejected(still_locked_spend['hex'])
 

From 1cc6d530e4d711b96b4dccb717d86c5e381dae8b Mon Sep 17 00:00:00 2001
From: FlyTheElephant1 <259444470+FlyTheElephant1@users.noreply.github.com>
Date: Fri, 11 Sep 2026 23:12:39 -0500
Subject: [PATCH 07/11] validation: Assert hash_tip when the maturity window is
 live

Do not default a missing creating-block hash to residue 5 (8064).
txmempool check() and the fuzz harness still pass disabled bounds
and never hit the Assert.
---
 src/consensus/tx_verify.cpp | 9 +++++----
 src/consensus/tx_verify.h   | 8 +++++---
 src/node/interfaces.cpp     | 3 ++-
 src/validation.cpp          | 3 ++-
 4 files changed, 14 insertions(+), 9 deletions(-)

diff --git a/src/consensus/tx_verify.cpp b/src/consensus/tx_verify.cpp
index 6c4cbcee0c23..0d249d7cf196 100644
--- a/src/consensus/tx_verify.cpp
+++ b/src/consensus/tx_verify.cpp
@@ -216,10 +216,11 @@ bool Consensus::CheckTxInputs(const CTransaction& tx, TxValidationState& state,
         // If prev is coinbase, check that it's matured
         if (coin.IsCoinBase()) {
             int hash_mod6 = 5;
-            if (hash_tip) {
-                if (const CBlockIndex* created{hash_tip->GetAncestor(coin.nHeight)}) {
-                    hash_mod6 = CoinbaseHashMod6(created->GetBlockHash());
-                }
+            if (coin.nHeight >= ext_start_height && coin.nHeight < ext_expiry_height) {
+                // No silent "long tranche" fallback: a missing tip would
+                // reject spends that the rest of the network accepts.
+                const CBlockIndex* created{Assert(hash_tip)->GetAncestor(coin.nHeight)};
+                hash_mod6 = CoinbaseHashMod6(Assert(created)->GetBlockHash());
             }
             const int maturity = RequiredCoinbaseMaturity(coin.nHeight, ext_start_height, ext_expiry_height, hash_mod6);
             if (nSpendHeight - coin.nHeight < maturity) {
diff --git a/src/consensus/tx_verify.h b/src/consensus/tx_verify.h
index d4c03c801ee4..a61ee7b40426 100644
--- a/src/consensus/tx_verify.h
+++ b/src/consensus/tx_verify.h
@@ -59,15 +59,17 @@ int CoinbaseHashMod6(const uint256& creating_block_hash);
  * the batched extended schedule after RDTS expiry. hash_mod6 is
  * CoinbaseHashMod6 of the creating block (0..5). Pass INT_MAX for both
  * bounds when the deployment is unscheduled. hash_mod6 is ignored outside
- * the window. Default 5 (long tranche) if the caller has no hash.
+ * the window. Default 5 is only for unit tests that pass the residue
+ * explicitly. CheckTxInputs Asserts a tip when the window is live.
  */
 int RequiredCoinbaseMaturity(int coinbase_height, int ext_start_height, int ext_expiry_height, int hash_mod6 = 5);
 
 /**
  * Check whether all inputs of this transaction are valid (no double spends and amounts)
  * This does not modify the UTXO set. This does not check scripts and sigs.
- * @param[in] hash_tip If set, creating-block hashes for coinbase inputs are
- *            taken from hash_tip->GetAncestor(coin.nHeight).
+ * @param[in] hash_tip Required when a coinbase input was created inside the
+ *            extended-maturity window. Creating-block hash is
+ *            hash_tip->GetAncestor(coin.nHeight)->GetBlockHash().
  * @param[out] txfee Set to the transaction fee if successful.
  * Preconditions: tx.IsCoinBase() is false.
  */
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index 66693230b63e..946f22e5c541 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -591,7 +591,8 @@ class ChainImpl : public Chain
         int ext_start, ext_expiry;
         ExtendedCoinbaseMaturityBounds(chainman().GetConsensus(), *tip, ext_start, ext_expiry);
         int hash_mod6 = 5;
-        if (const CBlockIndex* created{chainman().ActiveChain()[coinbase_height]}) {
+        if (coinbase_height >= ext_start && coinbase_height < ext_expiry) {
+            const CBlockIndex* created{Assert(chainman().ActiveChain()[coinbase_height])};
             hash_mod6 = Consensus::CoinbaseHashMod6(created->GetBlockHash());
         }
         return Consensus::RequiredCoinbaseMaturity(coinbase_height, ext_start, ext_expiry, hash_mod6);
diff --git a/src/validation.cpp b/src/validation.cpp
index 7a969ef5830a..fd633f11de12 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -441,7 +441,8 @@ void Chainstate::MaybeUpdateMempoolForReorg(
                 const Coin& coin{CoinsTip().AccessCoin(txin.prevout)};
                 assert(!coin.IsSpent());
                 int hash_mod6 = 5;
-                if (const CBlockIndex* created{m_chain.Tip()->GetAncestor(coin.nHeight)}) {
+                if (coin.IsCoinBase() && coin.nHeight >= ext_start && coin.nHeight < ext_expiry) {
+                    const CBlockIndex* created{Assert(m_chain.Tip()->GetAncestor(coin.nHeight))};
                     hash_mod6 = Consensus::CoinbaseHashMod6(created->GetBlockHash());
                 }
                 if (coin.IsCoinBase() && mempool_spend_height - coin.nHeight < Consensus::RequiredCoinbaseMaturity(coin.nHeight, ext_start, ext_expiry, hash_mod6)) {

From a0964df20c83d3a9fa28e8fbd701c0ee123f6f70 Mon Sep 17 00:00:00 2001
From: FlyTheElephant1 <259444470+FlyTheElephant1@users.noreply.github.com>
Date: Sat, 12 Sep 2026 00:07:26 -0500
Subject: [PATCH 08/11] Create run-ci.yml

---
 .github/workflows/run-ci.yml | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 .github/workflows/run-ci.yml

diff --git a/.github/workflows/run-ci.yml b/.github/workflows/run-ci.yml
new file mode 100644
index 000000000000..5d862e189bab
--- /dev/null
+++ b/.github/workflows/run-ci.yml
@@ -0,0 +1,14 @@
+name: Trigger Inherited CI
+
+on:
+  push:
+    branches: [ main ]
+  workflow_dispatch: # Allows you to trigger this manually from the Actions UI
+
+jobs:
+  run-bitcoin-ci:
+    # Syntax: OWNER/REPOSITORY/PATH@BRANCH
+    uses: FlyTheElephant1/bitcoin/.github/workflows/ci.yml@29.x-knots
+    
+    # Optional: Automatically passes secrets if the inherited workflow requires any
+    secrets: inherit 

From ba78673cd2e7798144c1e7bc7ae0b737af3fb1da Mon Sep 17 00:00:00 2001
From: FlyTheElephant1 <259444470+FlyTheElephant1@users.noreply.github.com>
Date: Sun, 13 Sep 2026 03:36:35 -0500
Subject: [PATCH 09/11] review: low-word comment, require hash_tip, wallet
 reorg miss

GetUint64(0) is the displayed-hash tail; the high word is unusable
at this difficulty. CheckTxInputs no longer defaults hash_tip, so
coins_view and CTxMemPool::check() pass nullptr next to disabled
bounds. Wallet coinbaseMaturity returns 100 if ActiveChain()[h]
is missing (disconnect race) instead of Asserting.
---
 src/consensus/consensus.h     |  6 +++---
 src/consensus/tx_verify.cpp   |  3 +++
 src/consensus/tx_verify.h     | 11 ++++++-----
 src/node/interfaces.cpp       |  6 +++++-
 src/test/fuzz/coins_view.cpp  |  2 +-
 src/test/validation_tests.cpp |  5 -----
 src/txmempool.cpp             |  2 +-
 7 files changed, 19 insertions(+), 16 deletions(-)

diff --git a/src/consensus/consensus.h b/src/consensus/consensus.h
index 54251b4fa100..f88a97be8ac9 100644
--- a/src/consensus/consensus.h
+++ b/src/consensus/consensus.h
@@ -20,9 +20,9 @@ static const int64_t MAX_BLOCK_SIGOPS_COST = 80000;
 /** Coinbase transaction outputs can only be spent after this number of new blocks (network rule) */
 static const int COINBASE_MATURITY = 100;
 /** Batched extended coinbase maturity (temporary softfork). Assigned by
- *  creating-block hash GetUint64(0) % 6 so ~1/6 of window coinbases mature
- *  at 2016, ~2/6 at 4032, and ~1/2 at 8064. Unknown until PoW is found.
- *  No extra coinbase outputs. */
+ *  creating-block hash GetUint64(0) % 6 (low 64 bits / displayed-hash tail)
+ *  so ~1/6 of window coinbases mature at 2016, ~2/6 at 4032, and ~1/2 at
+ *  8064. The high word is unusable: PoW zeros it. No extra coinbase outputs. */
 static const int EXTENDED_COINBASE_MATURITY_SHORT = 2016;
 static const int EXTENDED_COINBASE_MATURITY_MID = 4032;
 static const int EXTENDED_COINBASE_MATURITY_LONG = 8064;
diff --git a/src/consensus/tx_verify.cpp b/src/consensus/tx_verify.cpp
index 0d249d7cf196..8ddead78b359 100644
--- a/src/consensus/tx_verify.cpp
+++ b/src/consensus/tx_verify.cpp
@@ -175,6 +175,9 @@ bool Consensus::CheckOutputSizes(const CTransaction& tx, TxValidationState& stat
 
 int Consensus::CoinbaseHashMod6(const uint256& creating_block_hash)
 {
+    // Low 64 bits of the uint256 (tail of the displayed hash), not the
+    // PoW-zeroed high word. GetUint64(3) cannot produce residues 4 or 5
+    // at current mainnet difficulty; GetUint64(0) stays uniform.
     return static_cast<int>(creating_block_hash.GetUint64(0) % 6);
 }
 
diff --git a/src/consensus/tx_verify.h b/src/consensus/tx_verify.h
index a61ee7b40426..7b4aefb10cdc 100644
--- a/src/consensus/tx_verify.h
+++ b/src/consensus/tx_verify.h
@@ -60,20 +60,21 @@ int CoinbaseHashMod6(const uint256& creating_block_hash);
  * CoinbaseHashMod6 of the creating block (0..5). Pass INT_MAX for both
  * bounds when the deployment is unscheduled. hash_mod6 is ignored outside
  * the window. Default 5 is only for unit tests that pass the residue
- * explicitly. CheckTxInputs Asserts a tip when the window is live.
+ * explicitly.
  */
 int RequiredCoinbaseMaturity(int coinbase_height, int ext_start_height, int ext_expiry_height, int hash_mod6 = 5);
 
 /**
  * Check whether all inputs of this transaction are valid (no double spends and amounts)
  * This does not modify the UTXO set. This does not check scripts and sigs.
- * @param[in] hash_tip Required when a coinbase input was created inside the
- *            extended-maturity window. Creating-block hash is
- *            hash_tip->GetAncestor(coin.nHeight)->GetBlockHash().
+ * @param[in] hash_tip Must be passed explicitly. Required (non-null) when a
+ *            coinbase input was created inside the extended-maturity window.
+ *            Creating-block hash is hash_tip->GetAncestor(coin.nHeight)->GetBlockHash().
+ *            Callers that pass disabled (INT_MAX) bounds may pass nullptr.
  * @param[out] txfee Set to the transaction fee if successful.
  * Preconditions: tx.IsCoinBase() is false.
  */
-[[nodiscard]] bool CheckTxInputs(const CTransaction& tx, TxValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee, CheckTxInputsRules rules, int ext_start_height = (std::numeric_limits<int>::max)(), int ext_expiry_height = (std::numeric_limits<int>::max)(), const CBlockIndex* hash_tip = nullptr);
+[[nodiscard]] bool CheckTxInputs(const CTransaction& tx, TxValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee, CheckTxInputsRules rules, int ext_start_height, int ext_expiry_height, const CBlockIndex* hash_tip);
 } // namespace Consensus
 
 /** Auxiliary functions for transaction validation (ideally should not be exposed) */
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index 946f22e5c541..99c3eced9b3c 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -592,7 +592,11 @@ class ChainImpl : public Chain
         ExtendedCoinbaseMaturityBounds(chainman().GetConsensus(), *tip, ext_start, ext_expiry);
         int hash_mod6 = 5;
         if (coinbase_height >= ext_start && coinbase_height < ext_expiry) {
-            const CBlockIndex* created{Assert(chainman().ActiveChain()[coinbase_height])};
+            // Height comes from a wallet TxStateConfirmed. ActiveChain()[h]
+            // is the creating block while that coin still exists. A miss is a
+            // disconnect race (entry about to be dropped); do not crash RPC.
+            const CBlockIndex* created{chainman().ActiveChain()[coinbase_height]};
+            if (!created) return COINBASE_MATURITY;
             hash_mod6 = Consensus::CoinbaseHashMod6(created->GetBlockHash());
         }
         return Consensus::RequiredCoinbaseMaturity(coinbase_height, ext_start, ext_expiry, hash_mod6);
diff --git a/src/test/fuzz/coins_view.cpp b/src/test/fuzz/coins_view.cpp
index 18d0bb79adb6..fc19affc0eac 100644
--- a/src/test/fuzz/coins_view.cpp
+++ b/src/test/fuzz/coins_view.cpp
@@ -256,7 +256,7 @@ FUZZ_TARGET(coins_view, .init = initialize_coins_view)
                     // It is not allowed to call CheckTxInputs if CheckTransaction failed
                     return;
                 }
-                if (Consensus::CheckTxInputs(transaction, state, coins_view_cache, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), tx_fee_out, CheckTxInputsRules::OutputSizeLimit, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()))) {
+                if (Consensus::CheckTxInputs(transaction, state, coins_view_cache, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), tx_fee_out, CheckTxInputsRules::OutputSizeLimit, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), nullptr)) {
                     assert(MoneyRange(tx_fee_out));
                 }
             },
diff --git a/src/test/validation_tests.cpp b/src/test/validation_tests.cpp
index df134a1ca1d9..4fb8b4a72ec2 100644
--- a/src/test/validation_tests.cpp
+++ b/src/test/validation_tests.cpp
@@ -403,11 +403,6 @@ BOOST_AUTO_TEST_CASE(block_malleation)
 }
 
 
-#include <consensus/consensus.h>
-#include <consensus/tx_verify.h>
-#include <limits>
-#include <vector>
-
 static std::vector<CBlockIndex> MakeTimedChain(const std::vector<int64_t>& times)
 {
     std::vector<CBlockIndex> chain(times.size());
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index c405ca8897f7..03c44da70302 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -879,7 +879,7 @@ void CTxMemPool::check(const CCoinsViewCache& active_coins_tip, int64_t spendhei
         assert(!tx.IsCoinBase());
         // Skip output size checks (CheckTxInputsRules::None), as these transactions already passed
         // output size limits at mempool acceptance; this check only verifies UTXO consistency
-        assert(Consensus::CheckTxInputs(tx, dummy_state, mempoolDuplicate, spendheight, txfee, CheckTxInputsRules::None, std::numeric_limits<int>::max(), std::numeric_limits<int>::max()));
+        assert(Consensus::CheckTxInputs(tx, dummy_state, mempoolDuplicate, spendheight, txfee, CheckTxInputsRules::None, std::numeric_limits<int>::max(), std::numeric_limits<int>::max(), nullptr));
         for (const auto& input: tx.vin) mempoolDuplicate.SpendCoin(input.prevout);
         AddCoins(mempoolDuplicate, tx, std::numeric_limits<int>::max());
     }

From e639c020722a04bd109cd3e0b9d05bd9149fd00e Mon Sep 17 00:00:00 2001
From: FlyTheElephant1 <259444470+FlyTheElephant1@users.noreply.github.com>
Date: Sun, 13 Sep 2026 18:20:26 -0500
Subject: [PATCH 10/11] fuzz: disable extended-maturity window in coins_view

Pass INT_MAX bounds with nullptr, same as CTxMemPool::check(),
so the harness cannot reach Assert(hash_tip).
---
 src/test/fuzz/coins_view.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/test/fuzz/coins_view.cpp b/src/test/fuzz/coins_view.cpp
index fc19affc0eac..16e627a83bb2 100644
--- a/src/test/fuzz/coins_view.cpp
+++ b/src/test/fuzz/coins_view.cpp
@@ -256,7 +256,7 @@ FUZZ_TARGET(coins_view, .init = initialize_coins_view)
                     // It is not allowed to call CheckTxInputs if CheckTransaction failed
                     return;
                 }
-                if (Consensus::CheckTxInputs(transaction, state, coins_view_cache, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), tx_fee_out, CheckTxInputsRules::OutputSizeLimit, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), nullptr)) {
+                if (Consensus::CheckTxInputs(transaction, state, coins_view_cache, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), tx_fee_out, CheckTxInputsRules::OutputSizeLimit, std::numeric_limits<int>::max(), std::numeric_limits<int>::max(), nullptr)) {
                     assert(MoneyRange(tx_fee_out));
                 }
             },

From 29b0c5bcebccbabbe13958a95e19fa4931b555b1 Mon Sep 17 00:00:00 2001
From: FlyTheElephant1 <259444470+FlyTheElephant1@users.noreply.github.com>
Date: Mon, 14 Sep 2026 02:13:41 -0500
Subject: [PATCH 11/11] Removed polluting CI test runner that should not be
 part of the PR.

---
 .github/workflows/run-ci.yml | 14 --------------
 1 file changed, 14 deletions(-)
 delete mode 100644 .github/workflows/run-ci.yml

diff --git a/.github/workflows/run-ci.yml b/.github/workflows/run-ci.yml
deleted file mode 100644
index 5d862e189bab..000000000000
--- a/.github/workflows/run-ci.yml
+++ /dev/null
@@ -1,14 +0,0 @@
-name: Trigger Inherited CI
-
-on:
-  push:
-    branches: [ main ]
-  workflow_dispatch: # Allows you to trigger this manually from the Actions UI
-
-jobs:
-  run-bitcoin-ci:
-    # Syntax: OWNER/REPOSITORY/PATH@BRANCH
-    uses: FlyTheElephant1/bitcoin/.github/workflows/ci.yml@29.x-knots
-    
-    # Optional: Automatically passes secrets if the inherited workflow requires any
-    secrets: inherit