diff --git a/doc/bips.md b/doc/bips.md
index 07e5024864c6..b225e92ad2df 100644
--- a/doc/bips.md
+++ b/doc/bips.md
@@ -31,6 +31,7 @@ BIPs that are implemented by Bitcoin Core:
 * [`BIP 86`](https://github.com/bitcoin/bips/blob/master/bip-0086.mediawiki): Descriptor wallets by default use the Hierarchical Deterministic Wallet derivation proposed by BIP 86 since **v23.0** ([PR #22364](https://github.com/bitcoin/bitcoin/pull/22364)).
 * [`BIP 90`](https://github.com/bitcoin/bips/blob/master/bip-0090.mediawiki): Trigger mechanism for activation of BIPs 34, 65, and 66 has been simplified to block height checks since **v0.14.0** ([PR #8391](https://github.com/bitcoin/bitcoin/pull/8391)).
 * [`BIP 94`](https://github.com/bitcoin/bips/blob/master/bip-0094.mediawiki): Testnet 4 (`-testnet4`) supported as of **v28.0** ([PR #29775](https://github.com/bitcoin/bitcoin/pull/29775)).
+* [`BIP 110`](https://github.com/bitcoin/bips/blob/master/bip-0110.mediawiki): ReducedData Temporary Softfork (RDTS) consensus rules are implemented as of **FIXME: update version** ([PR #238](https://github.com/bitcoinknots/bitcoin/pull/238)).
 * [`BIP 111`](https://github.com/bitcoin/bips/blob/master/bip-0111.mediawiki): `NODE_BLOOM` service bit added, and enforced for all peer versions as of **v0.13.0** ([PR #6579](https://github.com/bitcoin/bitcoin/pull/6579) and [PR #6641](https://github.com/bitcoin/bitcoin/pull/6641)).
 * [`BIP 112`](https://github.com/bitcoin/bips/blob/master/bip-0112.mediawiki): The CHECKSEQUENCEVERIFY opcode has been implemented since **v0.12.1** ([PR #7524](https://github.com/bitcoin/bitcoin/pull/7524)), and has been *buried* since **v0.19.0** ([PR #16060](https://github.com/bitcoin/bitcoin/pull/16060)).
 * [`BIP 113`](https://github.com/bitcoin/bips/blob/master/bip-0113.mediawiki): Median time past lock-time calculations have been implemented since **v0.12.1** ([PR #6566](https://github.com/bitcoin/bitcoin/pull/6566)), and has been *buried* since **v0.19.0** ([PR #16060](https://github.com/bitcoin/bitcoin/pull/16060)).
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index 32c3bff73482..8286f93cfa70 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -68,8 +68,8 @@ void ReadRegTestArgs(const ArgsManager& args, CChainParams::RegTestOptions& opti
 
     for (const std::string& strDeployment : args.GetArgs("-vbparams")) {
         std::vector<std::string> vDeploymentParams = SplitString(strDeployment, ':');
-        if (vDeploymentParams.size() < 3 || 4 < vDeploymentParams.size()) {
-            throw std::runtime_error("Version bits parameters malformed, expecting deployment:start:end[:min_activation_height]");
+        if (vDeploymentParams.size() < 3 || 7 < vDeploymentParams.size()) {
+            throw std::runtime_error("Version bits parameters malformed, expecting deployment:start:end[:min_activation_height[:max_activation_height[:active_duration[:threshold]]]]");
         }
         CChainParams::VersionBitsParameters vbparams{};
         const auto start_time{ToIntegral<int64_t>(vDeploymentParams[1])};
@@ -91,13 +91,38 @@ void ReadRegTestArgs(const ArgsManager& args, CChainParams::RegTestOptions& opti
         } else {
             vbparams.min_activation_height = 0;
         }
+        if (vDeploymentParams.size() >= 5) {
+            const auto max_activation_height{ToIntegral<int>(vDeploymentParams[4])};
+            if (!max_activation_height) {
+                throw std::runtime_error(strprintf("Invalid max_activation_height (%s)", vDeploymentParams[4]));
+            }
+            vbparams.max_activation_height = *max_activation_height;
+        }
+        if (vDeploymentParams.size() >= 6) {
+            const auto active_duration{ToIntegral<int>(vDeploymentParams[5])};
+            if (!active_duration) {
+                throw std::runtime_error(strprintf("Invalid active_duration (%s)", vDeploymentParams[5]));
+            }
+            vbparams.active_duration = *active_duration;
+        }
+        if (vDeploymentParams.size() >= 7) {
+            const auto threshold{ToIntegral<int>(vDeploymentParams[6])};
+            if (!threshold) {
+                throw std::runtime_error(strprintf("Invalid threshold (%s)", vDeploymentParams[6]));
+            }
+            vbparams.threshold = *threshold;
+        }
+        // Validate that timeout and max_activation_height are mutually exclusive
+        if (vbparams.timeout != Consensus::BIP9Deployment::NO_TIMEOUT && vbparams.max_activation_height < std::numeric_limits<int>::max()) {
+            throw std::runtime_error(strprintf("Cannot specify both timeout (%ld) and max_activation_height (%d) for deployment %s. Use timeout for BIP9 or max_activation_height for mandatory activation deadline, not both.", vbparams.timeout, vbparams.max_activation_height, vDeploymentParams[0]));
+        }
         bool found = false;
         for (int j=0; j < (int)Consensus::MAX_VERSION_BITS_DEPLOYMENTS; ++j) {
             if (vDeploymentParams[0] == VersionBitsDeploymentInfo[j].name) {
                 options.version_bits_parameters[Consensus::DeploymentPos(j)] = vbparams;
                 found = true;
-                LogInfo("Setting version bits activation parameters for %s to start=%ld, timeout=%ld, min_activation_height=%d",
-                        vDeploymentParams[0], vbparams.start_time, vbparams.timeout, vbparams.min_activation_height);
+                LogInfo("Setting version bits activation parameters for %s to start=%ld, timeout=%ld, min_activation_height=%d, max_activation_height=%d, active_duration=%d, threshold=%d",
+                        vDeploymentParams[0], vbparams.start_time, vbparams.timeout, vbparams.min_activation_height, vbparams.max_activation_height, vbparams.active_duration, vbparams.threshold);
                 break;
             }
         }
diff --git a/src/consensus/consensus.h b/src/consensus/consensus.h
index 71b5fe2468d9..e6fb0b8ce7b7 100644
--- a/src/consensus/consensus.h
+++ b/src/consensus/consensus.h
@@ -34,4 +34,7 @@ static constexpr unsigned int LOCKTIME_VERIFY_SEQUENCE = (1 << 0);
  */
 static constexpr int64_t MAX_TIMEWARP = 600;
 
+static constexpr unsigned int MAX_OUTPUT_SCRIPT_SIZE{34};
+static constexpr unsigned int MAX_OUTPUT_DATA_SIZE{83};
+
 #endif // BITCOIN_CONSENSUS_CONSENSUS_H
diff --git a/src/consensus/params.h b/src/consensus/params.h
index 93ee071fdc16..ee40fe0e79f0 100644
--- a/src/consensus/params.h
+++ b/src/consensus/params.h
@@ -34,6 +34,7 @@ constexpr bool ValidDeployment(BuriedDeployment dep) { return dep <= DEPLOYMENT_
 enum DeploymentPos : uint16_t {
     DEPLOYMENT_TESTDUMMY,
     DEPLOYMENT_TAPROOT, // Deployment of Schnorr/Taproot (BIPs 340-342)
+    DEPLOYMENT_REDUCED_DATA, // ReducedData Temporary Softfork (RDTS)
     // NOTE: Also add new deployments to VersionBitsDeploymentInfo in deploymentinfo.cpp
     MAX_VERSION_BITS_DEPLOYMENTS
 };
@@ -54,6 +55,10 @@ struct BIP9Deployment {
      *  boundary.
      */
     int min_activation_height{0};
+    /** Maximum height for activation. If less than INT_MAX, the deployment will activate
+     *  at this height regardless of signaling (similar to BIP8 flag day).
+     *  std::numeric_limits<int>::max() means no maximum (activation only via signaling). */
+    int max_activation_height{std::numeric_limits<int>::max()};
     /** Period of blocks to check signalling in (usually retarget period, ie params.DifficultyAdjustmentInterval()) */
     uint32_t period{2016};
     /**
@@ -62,6 +67,9 @@ struct BIP9Deployment {
      * Examples: 1916 for 95%, 1512 for testchains.
      */
     uint32_t threshold{1916};
+    /** For temporary softforks: number of blocks the deployment remains active after activation.
+     *  std::numeric_limits<int>::max() means permanent (never expires). */
+    int active_duration{std::numeric_limits<int>::max()};
 
     /** Constant for nTimeout very far in the future. */
     static constexpr int64_t NO_TIMEOUT = std::numeric_limits<int64_t>::max();
diff --git a/src/consensus/tx_verify.cpp b/src/consensus/tx_verify.cpp
index 4efed70fd411..c50c14f26e86 100644
--- a/src/consensus/tx_verify.cpp
+++ b/src/consensus/tx_verify.cpp
@@ -161,7 +161,18 @@ int64_t GetTransactionSigOpCost(const CTransaction& tx, const CCoinsViewCache& i
     return nSigOps;
 }
 
-bool Consensus::CheckTxInputs(const CTransaction& tx, TxValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee)
+bool Consensus::CheckOutputSizes(const CTransaction& tx, TxValidationState& state)
+{
+    for (const auto& txout : tx.vout) {
+        if (txout.scriptPubKey.empty()) continue;
+        if (txout.scriptPubKey.size() > ((txout.scriptPubKey[0] == OP_RETURN) ? MAX_OUTPUT_DATA_SIZE : MAX_OUTPUT_SCRIPT_SIZE)) {
+            return state.Invalid(TxValidationResult::TX_PREMATURE_SPEND, "bad-txns-vout-script-toolarge");
+        }
+    }
+    return true;
+}
+
+bool Consensus::CheckTxInputs(const CTransaction& tx, TxValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee, const CheckTxInputsRules rules)
 {
     // are the actual inputs available?
     if (!inputs.HaveInputs(tx)) {
@@ -169,6 +180,11 @@ bool Consensus::CheckTxInputs(const CTransaction& tx, TxValidationState& state,
                          strprintf("%s: inputs missing/spent", __func__));
     }
 
+    // NOTE: CheckTransaction is arguably the more logical place to do this, but it's context-independent, so this is probably the next best place for now
+    if (rules.test(CheckTxInputsRules::OutputSizeLimit) && !CheckOutputSizes(tx, state)) {
+        return false;
+    }
+
     CAmount nValueIn = 0;
     for (unsigned int i = 0; i < tx.vin.size(); ++i) {
         const COutPoint &prevout = tx.vin[i].prevout;
diff --git a/src/consensus/tx_verify.h b/src/consensus/tx_verify.h
index ed44d435c1b9..e7e4323fdb38 100644
--- a/src/consensus/tx_verify.h
+++ b/src/consensus/tx_verify.h
@@ -18,14 +18,45 @@ class TxValidationState;
 
 /** Transaction validation functions */
 
+class CheckTxInputsRules {
+    using underlying_type = unsigned int;
+    underlying_type m_flags;
+    constexpr explicit CheckTxInputsRules(underlying_type flags) noexcept : m_flags(flags) {}
+
+    enum class Rule {
+        None = 0,
+        OutputSizeLimit = 1 << 0,
+    };
+
+public:
+    using enum Rule;
+
+    constexpr CheckTxInputsRules(Rule rule) noexcept : m_flags(static_cast<underlying_type>(rule)) {}
+
+    [[nodiscard]] constexpr bool test(CheckTxInputsRules rules) const noexcept {
+        return (m_flags & rules.m_flags) == rules.m_flags;
+    }
+
+    [[nodiscard]] constexpr CheckTxInputsRules operator|(const CheckTxInputsRules other) const noexcept {
+        return CheckTxInputsRules{m_flags | other.m_flags};
+    }
+};
+
 namespace Consensus {
+/**
+ * Check whether all outputs of this transaction satisfy size limits.
+ * Regular outputs must be <= MAX_OUTPUT_SCRIPT_SIZE (34 bytes).
+ * OP_RETURN outputs must be <= MAX_OUTPUT_DATA_SIZE (83 bytes).
+ */
+bool CheckOutputSizes(const CTransaction& tx, TxValidationState& state);
+
 /**
  * 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);
+[[nodiscard]] bool CheckTxInputs(const CTransaction& tx, TxValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee, CheckTxInputsRules rules);
 } // namespace Consensus
 
 /** Auxiliary functions for transaction validation (ideally should not be exposed) */
diff --git a/src/deploymentinfo.cpp b/src/deploymentinfo.cpp
index e1447d4dde23..f24616383e9d 100644
--- a/src/deploymentinfo.cpp
+++ b/src/deploymentinfo.cpp
@@ -17,6 +17,10 @@ const std::array<VBDeploymentInfo,Consensus::MAX_VERSION_BITS_DEPLOYMENTS> Versi
         .name = "taproot",
         .gbt_optional_rule = true,
     },
+    VBDeploymentInfo{
+        .name = "reduced_data",
+        .gbt_optional_rule = true,
+    },
 };
 
 std::string DeploymentName(Consensus::BuriedDeployment dep)
diff --git a/src/deploymentstatus.h b/src/deploymentstatus.h
index 921c7c187735..ae93cefa75cf 100644
--- a/src/deploymentstatus.h
+++ b/src/deploymentstatus.h
@@ -49,4 +49,5 @@ inline bool DeploymentEnabled(const Consensus::Params& params, Consensus::Deploy
     return params.vDeployments[dep].nStartTime != Consensus::BIP9Deployment::NEVER_ACTIVE;
 }
 
+
 #endif // BITCOIN_DEPLOYMENTSTATUS_H
diff --git a/src/kernel/chainparams.cpp b/src/kernel/chainparams.cpp
index 64809a75911e..fee696e9e198 100644
--- a/src/kernel/chainparams.cpp
+++ b/src/kernel/chainparams.cpp
@@ -16,6 +16,7 @@
 #include <primitives/transaction.h>
 #include <script/interpreter.h>
 #include <script/script.h>
+#include <tinyformat.h>
 #include <uint256.h>
 #include <util/chaintype.h>
 #include <util/log.h>
@@ -29,6 +30,7 @@
 #include <iterator>
 #include <map>
 #include <span>
+#include <stdexcept>
 #include <utility>
 
 using namespace util::hex_literals;
@@ -113,6 +115,14 @@ class CMainParams : public CChainParams {
         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 709632; // Approximately November 12th, 2021
         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].threshold = 1815; // 90%
         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].period = 2016;
+        // ReducedData Temporary Softfork (RDTS)
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].bit = 4;
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].nStartTime = 1764547200; // December 1st, 2025
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].min_activation_height = 0;
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].max_activation_height = 965664; // ~September 1st, 2026
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].active_duration = 52416; // ~1 year
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].threshold = 1109; // 55% of 2016
 
         consensus.nMinimumChainWork = uint256{"0000000000000000000000000000000000000001128750f82f4c366153a3a030"};
         consensus.defaultAssumeValid = uint256{"00000000000000000000ccebd6d74d9194d8dcdc1d177c478e094bfad51ba5ac"}; // 938343
@@ -244,6 +254,13 @@ class CTestNetParams : public CChainParams {
         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 0; // No activation delay
         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].threshold = 1512; // 75%
         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].period = 2016;
+        // ReducedData Temporary Softfork (RDTS)
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].bit = 4;
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].nStartTime = 1764547200; // December 1st, 2025
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].min_activation_height = 0;
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].active_duration = 52416; // ~1 year
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].threshold = 1109; // 55% of 2016
 
         consensus.nMinimumChainWork = uint256{"0000000000000000000000000000000000000000000017dde1c649f3708d14b6"};
         consensus.defaultAssumeValid = uint256{"000000007a61e4230b28ac5cb6b5e5a0130de37ac1faf2f8987d2fa6505b67f4"}; // 4842348
@@ -352,6 +369,13 @@ class CTestNet4Params : public CChainParams {
         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 0; // No activation delay
         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].threshold = 1512; // 75%
         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].period = 2016;
+        // ReducedData Temporary Softfork (RDTS)
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].bit = 4;
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].nStartTime = 1764547200; // December 1st, 2025
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].min_activation_height = 0;
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].active_duration = 52416; // ~1 year
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].threshold = 1109; // 55% of 2016
 
         consensus.nMinimumChainWork = uint256{"0000000000000000000000000000000000000000000009a0fe15d0177d086304"};
         consensus.defaultAssumeValid = uint256{"0000000002368b1e4ee27e2e85676ae6f9f9e69579b29093e9a82c170bf7cf8a"}; // 123613
@@ -503,6 +527,10 @@ class SigNetParams : public CChainParams {
         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 0; // No activation delay
         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].threshold = 1815; // 90%
         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].period = 2016;
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].bit = 4;
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE;
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].min_activation_height = 0;
 
         // message start is defined as the first 4 bytes of the sha256d of the block script
         HashWriter h{};
@@ -592,6 +620,12 @@ class CRegTestParams : public CChainParams
         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 0; // No activation delay
         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].threshold = 108; // 75%
         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].period = 144;
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].bit = 4;
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE;
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].min_activation_height = 0;
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].period = 144;
+        consensus.vDeployments[Consensus::DEPLOYMENT_REDUCED_DATA].threshold = 108; // 75%
 
         consensus.nMinimumChainWork = uint256{};
         consensus.defaultAssumeValid = uint256{};
@@ -629,6 +663,13 @@ class CRegTestParams : public CChainParams
             consensus.vDeployments[deployment_pos].nStartTime = version_bits_params.start_time;
             consensus.vDeployments[deployment_pos].nTimeout = version_bits_params.timeout;
             consensus.vDeployments[deployment_pos].min_activation_height = version_bits_params.min_activation_height;
+            consensus.vDeployments[deployment_pos].max_activation_height = version_bits_params.max_activation_height;
+            consensus.vDeployments[deployment_pos].active_duration = version_bits_params.active_duration;
+            // Validated here rather than in src/chainparams.cpp because period is not yet available at parse time
+            if (version_bits_params.active_duration != std::numeric_limits<int>::max() && version_bits_params.active_duration % consensus.vDeployments[deployment_pos].period != 0) {
+                throw std::runtime_error(strprintf("active_duration (%d) must be a multiple of period (%d)", version_bits_params.active_duration, consensus.vDeployments[deployment_pos].period));
+            }
+            consensus.vDeployments[deployment_pos].threshold = version_bits_params.threshold;
         }
 
         genesis = CreateGenesisBlock(1296688602, 2, 0x207fffff, 1, 50 * COIN);
diff --git a/src/kernel/chainparams.h b/src/kernel/chainparams.h
index f7209bee1b06..173cd14aa5eb 100644
--- a/src/kernel/chainparams.h
+++ b/src/kernel/chainparams.h
@@ -16,6 +16,7 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <limits>
 #include <memory>
 #include <optional>
 #include <string>
@@ -142,6 +143,9 @@ class CChainParams
         int64_t start_time;
         int64_t timeout;
         int min_activation_height;
+        int max_activation_height{std::numeric_limits<int>::max()};
+        int active_duration{std::numeric_limits<int>::max()};
+        int threshold{108};  // regtest default: 75% of 144
     };
 
     /**
diff --git a/src/policy/policy.h b/src/policy/policy.h
index 0bc7b3277083..2a89cd40ec75 100644
--- a/src/policy/policy.h
+++ b/src/policy/policy.h
@@ -128,7 +128,8 @@ static constexpr script_verify_flags STANDARD_SCRIPT_VERIFY_FLAGS{MANDATORY_SCRI
                                                              SCRIPT_VERIFY_CONST_SCRIPTCODE |
                                                              SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_TAPROOT_VERSION |
                                                              SCRIPT_VERIFY_DISCOURAGE_OP_SUCCESS |
-                                                             SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_PUBKEYTYPE};
+                                                             SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_PUBKEYTYPE |
+                                                             REDUCED_DATA_MANDATORY_VERIFY_FLAGS};
 
 /** For convenience, standard but not mandatory verify flags. */
 static constexpr script_verify_flags STANDARD_NOT_MANDATORY_VERIFY_FLAGS{STANDARD_SCRIPT_VERIFY_FLAGS & ~MANDATORY_SCRIPT_VERIFY_FLAGS};
diff --git a/src/psbt.h b/src/psbt.h
index 7fe9967a0c6e..6627104c659f 100644
--- a/src/psbt.h
+++ b/src/psbt.h
@@ -1050,7 +1050,7 @@ struct PSBTOutput
                         s_tree >> depth;
                         s_tree >> leaf_ver;
                         s_tree >> script;
-                        if (depth > TAPROOT_CONTROL_MAX_NODE_COUNT) {
+                        if (depth > TAPROOT_CONTROL_MAX_NODE_COUNT_REDUCED) {
                             throw std::ios_base::failure("Output Taproot tree has as leaf greater than Taproot maximum depth");
                         }
                         if ((leaf_ver & ~TAPROOT_LEAF_MASK) != 0) {
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index c631a93674aa..f885bc43077d 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -1322,6 +1322,9 @@ static void SoftForkDescPushBack(const CBlockIndex* blockindex, UniValue& softfo
     bip9.pushKV("start_time", depparams.nStartTime);
     bip9.pushKV("timeout", depparams.nTimeout);
     bip9.pushKV("min_activation_height", depparams.min_activation_height);
+    if (depparams.max_activation_height < std::numeric_limits<int>::max()) {
+        bip9.pushKV("max_activation_height", depparams.max_activation_height);
+    }
 
     // BIP9 status
     bip9.pushKV("status", info.current_state);
@@ -1354,6 +1357,11 @@ static void SoftForkDescPushBack(const CBlockIndex* blockindex, UniValue& softfo
     if (info.active_since.has_value()) {
         rv.pushKV("height", *info.active_since);
         is_active = (*info.active_since <= blockindex->nHeight + 1);
+        // Add height_end for temporary softforks
+        const auto& deployment = chainman.GetConsensus().vDeployments[id];
+        if (deployment.active_duration < std::numeric_limits<int>::max()) {
+            rv.pushKV("height_end", *info.active_since + deployment.active_duration - 1);
+        }
     }
     rv.pushKV("active", is_active);
     rv.pushKV("bip9", bip9);
@@ -1449,7 +1457,8 @@ RPCHelpMan getblockchaininfo()
 namespace {
 const std::vector<RPCResult> RPCHelpForDeployment{
     {RPCResult::Type::STR, "type", "one of \"buried\", \"bip9\""},
-    {RPCResult::Type::NUM, "height", /*optional=*/true, "height of the first block which the rules are or will be enforced (only for \"buried\" type, or \"bip9\" type with \"active\" status)"},
+    {RPCResult::Type::NUM, "height", /*optional=*/true, "height of the first block which enforces the rules (only for \"buried\" type, or \"bip9\" type with \"active\" status)"},
+    {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"},
     {RPCResult::Type::OBJ, "bip9", /*optional=*/true, "status of bip9 softforks (only for \"bip9\" type)",
     {
@@ -1457,7 +1466,8 @@ const std::vector<RPCResult> RPCHelpForDeployment{
         {RPCResult::Type::NUM_TIME, "start_time", "the minimum median time past of a block at which the bit gains its meaning"},
         {RPCResult::Type::NUM_TIME, "timeout", "the median time past of a block at which the deployment is considered failed if not yet locked in"},
         {RPCResult::Type::NUM, "min_activation_height", "minimum height of blocks for which the rules may be enforced"},
-        {RPCResult::Type::STR, "status", "status of deployment at specified block (one of \"defined\", \"started\", \"locked_in\", \"active\", \"failed\")"},
+        {RPCResult::Type::NUM, "max_activation_height", /*optional=*/true, "height at which the deployment will unconditionally activate (absent for miner-vetoable deployments)"},
+        {RPCResult::Type::STR, "status", "status of deployment at specified block (one of \"defined\", \"started\", \"locked_in\", \"active\", \"failed\", \"expired\")"},
         {RPCResult::Type::NUM, "since", "height of the first block to which the status applies"},
         {RPCResult::Type::STR, "status_next", "status of deployment at the next block"},
         {RPCResult::Type::OBJ, "statistics", /*optional=*/true, "numeric statistics about signalling for a softfork (only for \"started\" and \"locked_in\" status)",
@@ -1482,6 +1492,7 @@ UniValue DeploymentInfo(const CBlockIndex* blockindex, const ChainstateManager&
     SoftForkDescPushBack(blockindex, softforks, chainman, Consensus::DEPLOYMENT_SEGWIT);
     SoftForkDescPushBack(blockindex, softforks, chainman, Consensus::DEPLOYMENT_TESTDUMMY);
     SoftForkDescPushBack(blockindex, softforks, chainman, Consensus::DEPLOYMENT_TAPROOT);
+    SoftForkDescPushBack(blockindex, softforks, chainman, Consensus::DEPLOYMENT_REDUCED_DATA);
     return softforks;
 }
 } // anon namespace
diff --git a/src/rpc/mempool.cpp b/src/rpc/mempool.cpp
index c480b5af47f2..0a780e10a333 100644
--- a/src/rpc/mempool.cpp
+++ b/src/rpc/mempool.cpp
@@ -11,6 +11,7 @@
 #include <common/args.h>
 #include <consensus/validation.h>
 #include <core_io.h>
+#include <core_memusage.h>
 #include <index/txospenderindex.h>
 #include <kernel/mempool_entry.h>
 #include <net_processing.h>
@@ -292,6 +293,7 @@ static RPCHelpMan testmempoolaccept()
                     {RPCResult::Type::BOOL, "allowed", /*optional=*/true, "Whether this tx would be accepted to the mempool and pass client-specified maxfeerate. "
                                                        "If not present, the tx was not fully validated due to a failure in another tx in the list."},
                     {RPCResult::Type::NUM, "vsize", /*optional=*/true, "Virtual transaction size as defined in BIP 141. This is different from actual serialized size for witness transactions as witness data is discounted (only present when 'allowed' is true)"},
+                    {RPCResult::Type::NUM, "usage", "Memory usage of transaction for this node"},
                     {RPCResult::Type::OBJ, "fees", /*optional=*/true, "Transaction fees (only present if 'allowed' is true)",
                     {
                         {RPCResult::Type::STR_AMOUNT, "base", "transaction fee in " + CURRENCY_UNIT},
@@ -357,6 +359,7 @@ static RPCHelpMan testmempoolaccept()
                 UniValue result_inner(UniValue::VOBJ);
                 result_inner.pushKV("txid", tx->GetHash().GetHex());
                 result_inner.pushKV("wtxid", tx->GetWitnessHash().GetHex());
+                result_inner.pushKV("usage", RecursiveDynamicUsage(tx));
                 if (package_result.m_state.GetResult() == PackageValidationResult::PCKG_POLICY) {
                     result_inner.pushKV("package-error", package_result.m_state.ToString());
                 }
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 043e11ff63ad..ac35eadf5613 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -986,7 +986,7 @@ static RPCHelpMan getblocktemplate()
     result.pushKV("version", block.nVersion);
     result.pushKV("rules", std::move(aRules));
     result.pushKV("vbavailable", std::move(vbavailable));
-    result.pushKV("vbrequired", 0);
+    result.pushKV("vbrequired", gbtstatus.vbrequired);
 
     result.pushKV("previousblockhash", block.hashPrevBlock.GetHex());
     result.pushKV("transactions", std::move(transactions));
diff --git a/src/script/descriptor.cpp b/src/script/descriptor.cpp
index 19315dd6a30f..d1989575651b 100644
--- a/src/script/descriptor.cpp
+++ b/src/script/descriptor.cpp
@@ -2481,8 +2481,8 @@ std::vector<std::unique_ptr<DescriptorImpl>> ParseScript(uint32_t& key_exp_index
                 // First process all open braces.
                 while (Const("{", expr)) {
                     branches.push_back(false); // new left branch
-                    if (branches.size() > TAPROOT_CONTROL_MAX_NODE_COUNT) {
-                        error = strprintf("tr() supports at most %i nesting levels", TAPROOT_CONTROL_MAX_NODE_COUNT);
+                    if (branches.size() > TAPROOT_CONTROL_MAX_NODE_COUNT_REDUCED) {
+                        error = strprintf("tr() supports at most %i nesting levels", TAPROOT_CONTROL_MAX_NODE_COUNT_REDUCED);
                         return {};
                     }
                 }
diff --git a/src/script/interpreter.cpp b/src/script/interpreter.cpp
index 443714ceedaf..f490c3a21fec 100644
--- a/src/script/interpreter.cpp
+++ b/src/script/interpreter.cpp
@@ -434,6 +434,8 @@ bool EvalScript(std::vector<std::vector<unsigned char> >& stack, const CScript&
     execdata.m_codeseparator_pos = 0xFFFFFFFFUL;
     execdata.m_codeseparator_pos_init = true;
 
+    const unsigned int max_element_size = (flags & SCRIPT_VERIFY_REDUCED_DATA) ? MAX_SCRIPT_ELEMENT_SIZE_REDUCED : MAX_SCRIPT_ELEMENT_SIZE;
+
     try
     {
         for (; pc < pend; ++opcode_pos) {
@@ -444,7 +446,7 @@ bool EvalScript(std::vector<std::vector<unsigned char> >& stack, const CScript&
             //
             if (!script.GetOp(pc, opcode, vchPushValue))
                 return set_error(serror, SCRIPT_ERR_BAD_OPCODE);
-            if (vchPushValue.size() > MAX_SCRIPT_ELEMENT_SIZE)
+            if (vchPushValue.size() > max_element_size)
                 return set_error(serror, SCRIPT_ERR_PUSH_SIZE);
 
             if (sigversion == SigVersion::BASE || sigversion == SigVersion::WITNESS_V0) {
@@ -617,6 +619,11 @@ bool EvalScript(std::vector<std::vector<unsigned char> >& stack, const CScript&
                             if (vch.size() > 1 || (vch.size() == 1 && vch[0] != 1)) {
                                 return set_error(serror, SCRIPT_ERR_TAPSCRIPT_MINIMALIF);
                             }
+                            // REDUCED_DATA bans OP_IF/OP_NOTIF entirely in tapscript;
+                            // reuses MINIMALIF error code as this is a stricter form of the same restriction
+                            if (flags & SCRIPT_VERIFY_REDUCED_DATA) {
+                                return set_error(serror, SCRIPT_ERR_TAPSCRIPT_MINIMALIF);
+                            }
                         }
                         // Under witness v0 rules it is only a policy rule, enabled through SCRIPT_VERIFY_MINIMALIF.
                         if (sigversion == SigVersion::WITNESS_V0 && (flags & SCRIPT_VERIFY_MINIMALIF)) {
@@ -1856,8 +1863,9 @@ static bool ExecuteWitnessScript(const std::span<const valtype>& stack_span, con
     }
 
     // Disallow stack item size > MAX_SCRIPT_ELEMENT_SIZE in witness stack
+    const unsigned int max_element_size = (flags & SCRIPT_VERIFY_REDUCED_DATA) ? MAX_SCRIPT_ELEMENT_SIZE_REDUCED : MAX_SCRIPT_ELEMENT_SIZE;
     for (const valtype& elem : stack) {
-        if (elem.size() > MAX_SCRIPT_ELEMENT_SIZE) return set_error(serror, SCRIPT_ERR_PUSH_SIZE);
+        if (elem.size() > max_element_size) return set_error(serror, SCRIPT_ERR_PUSH_SIZE);
     }
 
     // Run the script interpreter.
@@ -1951,6 +1959,9 @@ static bool VerifyWitnessProgram(const CScriptWitness& witness, int witversion,
         if (stack.size() >= 2 && !stack.back().empty() && stack.back()[0] == ANNEX_TAG) {
             // Drop annex (this is non-standard; see IsWitnessStandard)
             const valtype& annex = SpanPopBack(stack);
+            if (flags & SCRIPT_VERIFY_REDUCED_DATA) {
+                return set_error(serror, SCRIPT_ERR_PUSH_SIZE);
+            }
             execdata.m_annex_hash = (HashWriter{} << annex).GetSHA256();
             execdata.m_annex_present = true;
         } else {
@@ -1967,7 +1978,8 @@ static bool VerifyWitnessProgram(const CScriptWitness& witness, int witversion,
             // Script path spending (stack size is >1 after removing optional annex)
             const valtype& control = SpanPopBack(stack);
             const valtype& script = SpanPopBack(stack);
-            if (control.size() < TAPROOT_CONTROL_BASE_SIZE || control.size() > TAPROOT_CONTROL_MAX_SIZE || ((control.size() - TAPROOT_CONTROL_BASE_SIZE) % TAPROOT_CONTROL_NODE_SIZE) != 0) {
+            const unsigned int max_control_size = (flags & SCRIPT_VERIFY_REDUCED_DATA) ? TAPROOT_CONTROL_MAX_SIZE_REDUCED : TAPROOT_CONTROL_MAX_SIZE;
+            if (control.size() < TAPROOT_CONTROL_BASE_SIZE || control.size() > max_control_size || ((control.size() - TAPROOT_CONTROL_BASE_SIZE) % TAPROOT_CONTROL_NODE_SIZE) != 0) {
                 return set_error(serror, SCRIPT_ERR_TAPROOT_WRONG_CONTROL_SIZE);
             }
             execdata.m_tapleaf_hash = ComputeTapleafHash(control[0] & TAPROOT_LEAF_MASK, script);
@@ -1987,7 +1999,7 @@ static bool VerifyWitnessProgram(const CScriptWitness& witness, int witversion,
             }
             return set_success(serror);
         }
-    } else if (!is_p2sh && CScript::IsPayToAnchor(witversion, program)) {
+    } else if (stack.empty() && !is_p2sh && CScript::IsPayToAnchor(witversion, program)) {
         return true;
     } else {
         if (flags & SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM) {
@@ -2016,6 +2028,12 @@ bool VerifyScript(const CScript& scriptSig, const CScript& scriptPubKey, const C
     // scriptSig and scriptPubKey must be evaluated sequentially on the same stack
     // rather than being simply concatenated (see CVE-2010-5141)
     std::vector<std::vector<unsigned char> > stack, stackCopy;
+    if (scriptPubKey.IsPayToScriptHash()) {
+        // Disable SCRIPT_VERIFY_REDUCED_DATA for pushing the P2SH redeemScript
+        if (!EvalScript(stack, scriptSig, flags & ~SCRIPT_VERIFY_REDUCED_DATA, checker, SigVersion::BASE, serror))
+            // serror is set
+            return false;
+    } else
     if (!EvalScript(stack, scriptSig, flags, checker, SigVersion::BASE, serror))
         // serror is set
         return false;
@@ -2067,6 +2085,15 @@ bool VerifyScript(const CScript& scriptSig, const CScript& scriptPubKey, const C
         CScript pubKey2(pubKeySerialized.begin(), pubKeySerialized.end());
         popstack(stack);
 
+        if (flags & SCRIPT_VERIFY_REDUCED_DATA) {
+            // We bypassed the reduced data check above to exempt redeemScript
+            // Now enforce it on the rest of the stack items here
+            // This is sufficient because P2SH requires scriptSig to be push-only
+            for (const valtype& elem : stack) {
+                if (elem.size() > MAX_SCRIPT_ELEMENT_SIZE_REDUCED) return set_error(serror, SCRIPT_ERR_PUSH_SIZE);
+            }
+        }
+
         if (!EvalScript(stack, pubKey2, flags, checker, SigVersion::BASE, serror))
             // serror is set
             return false;
@@ -2190,6 +2217,7 @@ const std::map<std::string, script_verify_flag_name>& ScriptFlagNamesToEnum()
         FLAG_NAME(DISCOURAGE_UPGRADABLE_PUBKEYTYPE),
         FLAG_NAME(DISCOURAGE_OP_SUCCESS),
         FLAG_NAME(DISCOURAGE_UPGRADABLE_TAPROOT_VERSION),
+        FLAG_NAME(REDUCED_DATA),
     };
 #undef FLAG_NAME
     return g_names_to_enum;
diff --git a/src/script/interpreter.h b/src/script/interpreter.h
index cbb137e09efb..8b8391aedab2 100644
--- a/src/script/interpreter.h
+++ b/src/script/interpreter.h
@@ -145,6 +145,13 @@ enum class script_verify_flag_name : uint8_t {
     // Making unknown public key versions (in BIP 342 scripts) non-standard
     SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_PUBKEYTYPE,
 
+    // Enforce MAX_SCRIPT_ELEMENT_SIZE_REDUCED instead of MAX_SCRIPT_ELEMENT_SIZE
+    // The P2SH redeemScript push is exempted
+    // Taproot control blocks are limited to TAPROOT_CONTROL_MAX_SIZE_REDUCED
+    // Taproot annex is also invalid
+    // OP_IF is also forbidden inside Tapscript
+    SCRIPT_VERIFY_REDUCED_DATA,
+
     // Constants to point to the highest flag in use. Add new flags above this line.
     //
     SCRIPT_VERIFY_END_MARKER
@@ -158,6 +165,13 @@ static_assert(0 < MAX_SCRIPT_VERIFY_FLAGS_BITS && MAX_SCRIPT_VERIFY_FLAGS_BITS <
 
 static constexpr script_verify_flags::value_type MAX_SCRIPT_VERIFY_FLAGS = ((script_verify_flags::value_type{1} << MAX_SCRIPT_VERIFY_FLAGS_BITS) - 1);
 
+static constexpr script_verify_flags REDUCED_DATA_MANDATORY_VERIFY_FLAGS{
+    SCRIPT_VERIFY_REDUCED_DATA
+    | SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM
+    | SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_TAPROOT_VERSION
+    | SCRIPT_VERIFY_DISCOURAGE_OP_SUCCESS
+};
+
 bool CheckSignatureEncoding(const std::vector<unsigned char> &vchSig, script_verify_flags flags, ScriptError* serror);
 
 struct PrecomputedTransactionData
@@ -244,6 +258,8 @@ static constexpr size_t TAPROOT_CONTROL_BASE_SIZE = 33;
 static constexpr size_t TAPROOT_CONTROL_NODE_SIZE = 32;
 static constexpr size_t TAPROOT_CONTROL_MAX_NODE_COUNT = 128;
 static constexpr size_t TAPROOT_CONTROL_MAX_SIZE = TAPROOT_CONTROL_BASE_SIZE + TAPROOT_CONTROL_NODE_SIZE * TAPROOT_CONTROL_MAX_NODE_COUNT;
+static constexpr size_t TAPROOT_CONTROL_MAX_NODE_COUNT_REDUCED = 7;
+static constexpr size_t TAPROOT_CONTROL_MAX_SIZE_REDUCED = TAPROOT_CONTROL_BASE_SIZE + TAPROOT_CONTROL_NODE_SIZE * TAPROOT_CONTROL_MAX_NODE_COUNT_REDUCED;
 
 extern const HashWriter HASHER_TAPSIGHASH; //!< Hasher with tag "TapSighash" pre-fed to it.
 extern const HashWriter HASHER_TAPLEAF;    //!< Hasher with tag "TapLeaf" pre-fed to it.
diff --git a/src/script/script.h b/src/script/script.h
index b06be9c975d3..1a0d288fac0f 100644
--- a/src/script/script.h
+++ b/src/script/script.h
@@ -26,6 +26,7 @@
 
 // Maximum number of bytes pushable to the stack
 static const unsigned int MAX_SCRIPT_ELEMENT_SIZE = 520;
+static const unsigned int MAX_SCRIPT_ELEMENT_SIZE_REDUCED = 256;
 
 // Maximum number of non-push operations per script
 static const int MAX_OPS_PER_SCRIPT = 201;
diff --git a/src/script/signingprovider.cpp b/src/script/signingprovider.cpp
index 195965444956..c532622bb094 100644
--- a/src/script/signingprovider.cpp
+++ b/src/script/signingprovider.cpp
@@ -415,7 +415,7 @@ void TaprootBuilder::Insert(TaprootBuilder::NodeInfo&& node, int depth)
         // as what Insert() performs on the m_branch variable. Instead of
         // storing a NodeInfo object, just remember whether or not there is one
         // at that depth.
-        if (depth < 0 || (size_t)depth > TAPROOT_CONTROL_MAX_NODE_COUNT) return false;
+        if (depth < 0 || (size_t)depth > TAPROOT_CONTROL_MAX_NODE_COUNT_REDUCED) return false;
         if ((size_t)depth + 1 < branch.size()) return false;
         while (branch.size() > (size_t)depth && branch[depth]) {
             branch.pop_back();
@@ -528,7 +528,7 @@ std::optional<std::vector<std::tuple<int, std::vector<unsigned char>, int>>> Inf
             // Skip script records with nonsensical leaf version.
             if (leaf_ver < 0 || leaf_ver >= 0x100 || leaf_ver & 1) continue;
             // Skip script records with invalid control block sizes.
-            if (control.size() < TAPROOT_CONTROL_BASE_SIZE || control.size() > TAPROOT_CONTROL_MAX_SIZE ||
+            if (control.size() < TAPROOT_CONTROL_BASE_SIZE || control.size() > TAPROOT_CONTROL_MAX_SIZE_REDUCED ||
                 ((control.size() - TAPROOT_CONTROL_BASE_SIZE) % TAPROOT_CONTROL_NODE_SIZE) != 0) continue;
             // Skip script records that don't match the control block.
             if ((control[0] & TAPROOT_LEAF_MASK) != leaf_ver) continue;
diff --git a/src/test/data/tx_valid.json b/src/test/data/tx_valid.json
index ac25f8149b4b..134ef7ccc6dc 100644
--- a/src/test/data/tx_valid.json
+++ b/src/test/data/tx_valid.json
@@ -418,9 +418,9 @@
 ["0000000000000000000000000000000000000000000000000000000000000100", 2, "0x51", 3000]],
 "0100000000010300010000000000000000000000000000000000000000000000000000000000000000000000ffffffff00010000000000000000000000000000000000000000000000000000000000000100000000ffffffff00010000000000000000000000000000000000000000000000000000000000000200000000ffffffff03e8030000000000000151d0070000000000000151b80b00000000000001510002483045022100a3cec69b52cba2d2de623ffffffffff1606184ea55476c0f8189fda231bc9cbb022003181ad597f7c380a7d1c740286b1d022b8b04ded028b833282e055e03b8efef812103596d3451025c19dbbdeb932d6bf8bfb4ad499b95b6f88db8899efac102e5fc710000000000", "DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM"],
 
-["Witness with a push of 520 bytes"],
-[[["0000000000000000000000000000000000000000000000000000000000000100", 0, "0x00 0x20 0x33198a9bfef674ebddb9ffaa52928017b8472791e54c609cb95f278ac6b1e349", 1000]],
-"0100000000010100010000000000000000000000000000000000000000000000000000000000000000000000ffffffff010000000000000000015102fd08020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002755100000000", "NONE"],
+["Witness with a push of 256 bytes (REDUCED_DATA limit)"],
+[[["0000000000000000000000000000000000000000000000000000000000000100", 0, "0x00 0x20 0xa57e25ffadd285772f5627ec6fa613bc8fb49b4db475c371dfd4eb76f25c5073", 1000]],
+"0100000000010100010000000000000000000000000000000000000000000000000000000000000000000000ffffffff010000000000000000015101fd05014d000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000755100000000", "NONE"],
 
 ["Transaction mixing all SigHash, segwit and normal inputs"],
 [[["0000000000000000000000000000000000000000000000000000000000000100", 0, "0x00 0x14 0x4c9c3dfac4207d5d8cb89df5722cb3d712385e3f", 1000],
diff --git a/src/test/descriptor_tests.cpp b/src/test/descriptor_tests.cpp
index a646fc834760..bd7b99fd3967 100644
--- a/src/test/descriptor_tests.cpp
+++ b/src/test/descriptor_tests.cpp
@@ -1090,7 +1090,8 @@ BOOST_AUTO_TEST_CASE(descriptor_test)
     CheckUnparsable("sh(and_v(vc:andor(pk(L4gM1FBdyHNpkzsFh9ipnofLhpZRp2mwobpeULy1a6dBTvw8Ywtd),pk_k(Kx9HCDjGiwFcgVNhTrS5z5NeZdD6veeam61eDxLDCkGWujvL4Gnn),and_v(v:older(1),pk_k(L4o2kDvXXDRH2VS9uBnouScLduWt4dZnM25se7kvEjJeQ285en2A))),after(10)))", "sh(and_v(vc:andor(pk(03cdabb7f2dce7bfbd8a0b9570c6fd1e712e5d64045e9d6b517b3d5072251dc204),pk_k(032707170c71d8f75e4ca4e3fce870b9409dcaf12b051d3bcadff74747fa7619c0),and_v(v:older(1),pk_k(02aa27e5eb2c185e87cd1dbc3e0efc9cb1175235e0259df1713424941c3cb40402))),after(10)))", "Miniscript expressions can only be used in wsh or tr.");
     CheckUnparsable("tr(and_v(vc:andor(pk(L4gM1FBdyHNpkzsFh9ipnofLhpZRp2mwobpeULy1a6dBTvw8Ywtd),pk_k(Kx9HCDjGiwFcgVNhTrS5z5NeZdD6veeam61eDxLDCkGWujvL4Gnn),and_v(v:older(1),pk_k(L4o2kDvXXDRH2VS9uBnouScLduWt4dZnM25se7kvEjJeQ285en2A))),after(10)))", "tr(and_v(vc:andor(pk(03cdabb7f2dce7bfbd8a0b9570c6fd1e712e5d64045e9d6b517b3d5072251dc204),pk_k(032707170c71d8f75e4ca4e3fce870b9409dcaf12b051d3bcadff74747fa7619c0),and_v(v:older(1),pk_k(02aa27e5eb2c185e87cd1dbc3e0efc9cb1175235e0259df1713424941c3cb40402))),after(10)))", "tr(): key 'and_v(vc:andor(pk(03cdabb7f2dce7bfbd8a0b9570c6fd1e712e5d64045e9d6b517b3d5072251dc204),pk_k(032707170c71d8f75e4ca4e3fce870b9409dcaf12b051d3bcadff74747fa7619c0),and_v(v:older(1),pk_k(02aa27e5eb2c185e87cd1dbc3e0efc9cb1175235e0259df1713424941c3cb40402))),after(10))' is not valid");
     CheckUnparsable("raw(and_v(vc:andor(pk(L4gM1FBdyHNpkzsFh9ipnofLhpZRp2mwobpeULy1a6dBTvw8Ywtd),pk_k(Kx9HCDjGiwFcgVNhTrS5z5NeZdD6veeam61eDxLDCkGWujvL4Gnn),and_v(v:older(1),pk_k(L4o2kDvXXDRH2VS9uBnouScLduWt4dZnM25se7kvEjJeQ285en2A))),after(10)))", "sh(and_v(vc:andor(pk(03cdabb7f2dce7bfbd8a0b9570c6fd1e712e5d64045e9d6b517b3d5072251dc204),pk_k(032707170c71d8f75e4ca4e3fce870b9409dcaf12b051d3bcadff74747fa7619c0),and_v(v:older(1),pk_k(02aa27e5eb2c185e87cd1dbc3e0efc9cb1175235e0259df1713424941c3cb40402))),after(10)))", "Miniscript expressions can only be used in wsh or tr.");
-    CheckUnparsable("", "tr(034D2224bbbbbbbbbbcbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb40,{{{{{{{{{{{{{{{{{{{{{{multi(1,xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc/967808'/9,xprvA1RpRA33e1JQ7ifknakTFNpgXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc/968/2/5/8/5/2/5/58/58/2/5/5/5/58/588/2/6/8/5/2/8/2/5/8/2/58/2/5/8/5/2/8/5/8/3/4/5/58/55/2/5/58/58/2/5/5/5/8/5/2/8/5/85/2/8/2/5/8/5/2/5/58/58/2/5/58/58/588/2/58/2/8/5/8/5/4/5/585/2/5/58/58/2/5/5/58/588/2/58/2/5/8/5/2/8/2/5/8/5/5/58/588/2/6/8/5/2/8/2/5/8/5/2/5/58/58/2/5/58/58/2/0/8/5/2/8/5/8/5/4/5/58/588/2/6/8/5/2/8/2/5/8/5/2/5/58/58/2/5/58/58/588/2/58/2/5/8/5/8/24/5/58/52/5/8/5/2/8/24/5/58/588/246/8/5/2/8/2/5/8/5/2/5/58/58/2/5/5/5/58/588/2/6/8/5/2/8/2/5/8/2/58/2/5/8/5/2/8/5/8/5/4/5/58/55/58/2/5/8/55/2/5/8/58/555/58/2/5/8/4//2/5/58/5w/2/5/8/5/2/4/5/58/5558'/2/5/58/58/2/5/5/58/588/2/58/2/5/8/5/2/8/2/5/8/5/5/8/58/2/5/58/58/2/5/8/9/588/2/58/2/5/8/5/2/8/5/8/5/4/5/58/588/2/6/8/5/2/8/2/5/8/5/2/5/58/58/2/5/5/58/588/2/58/2/5/8/5/2/82/5/8/5/5/58/52/6/8/5/2/8/{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{}{{{{{{{{{DDD2/5/8/5/2/5/58/58/2/5/58/58/588/2/58/2/8/5/8/5/4/5/58/588/2/6/8/5/2/8/2/5/8588/246/8/5/2DLDDDDDDDbbD3DDDD/8/2/5/8/5/2/5/58/58/2/5/5/5/58/588/2/6/8/5/2/8/2/5/8/2/58/2/5/8/5/2/8/5/8/3/4/5/58/55/2/5/58/58/2/5/5/5/8/5/2/8/5/85/2/8/2/5/8D)/5/2/5/58/58/2/5/58/58/58/588/2/58/2/5/8/5/25/58/58/2/5/58/58/2/5/8/9/588/2/58/2/6780,xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFW/8/5/2/5/58678008')", "'multi(1,xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc/967808'/9,xprvA1RpRA33e1JQ7ifknakTFNpgXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc/968/2/5/8/5/2/5/58/58/2/5/5/5/58/588/2/6/8/5/2/8/2/5/8/2/58/2/5/8/5/2/8/5/8/3/4/5/58/55/2/5/58/58/2/5/5/5/8/5/2/8/5/85/2/8/2/5/8/5/2/5/58/58/2/5/58/58/588/2/58/2/8/5/8/5/4/5/585/2/5/58/58/2/5/5/58/588/2/58/2/5/8/5/2/8/2/5/8/5/5/58/588/2/6/8/5/2/8/2/5/8/5/2/5/58/58/2/5/58/58/2/0/8/5/2/8/5/8/5/4/5/58/588/2/6/8/5/2/8/2/5/8/5/2/5/58/58/2/5/58/58/588/2/58/2/5/8/5/8/24/5/58/52/5/8/5/2/8/24/5/58/588/246/8/5/2/8/2/5/8/5/2/5/58/58/2/5/5/5/58/588/2/6/8/5/2/8/2/5/8/2/58/2/5/8/5/2/8/5/8/5/4/5/58/55/58/2/5/8/55/2/5/8/58/555/58/2/5/8/4//2/5/58/5w/2/5/8/5/2/4/5/58/5558'/2/5/58/58/2/5/5/58/588/2/58/2/5/8/5/2/8/2/5/8/5/5/8/58/2/5/58/58/2/5/8/9/588/2/58/2/5/8/5/2/8/5/8/5/4/5/58/588/2/6/8/5/2/8/2/5/8/5/2/5/58/58/2/5/5/58/588/2/58/2/5/8/5/2/82/5/8/5/5/58/52/6/8/5/2/8/{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{}{{{{{{{{{DDD2/5/8/5/2/5/58/58/2/5/58/58/588/2/58/2/8/5/8/5/4/5/58/588/2/6/8/5/2/8/2/5/8588/246/8/5/2DLDDDDDDDbbD3DDDD/8/2/5/8/5/2/5/58/58/2/5/5/5/58/588/2/6/8/5/2/8/2/5/8/2/58/2/5/8/5/2/8/5/8/3/4/5/58/55/2/5/58/58/2/5/5/5/8/5/2/8/5/85/2/8/2/5/8D)/5/2/5/58/58/2/5/58/58/58/588/2/58/2/5/8/5/25/58/58/2/5/58/58/2/5/8/9/588/2/58/2/6780,xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFW/8/5/2/5/58678008'' is not a valid descriptor function");
+    // REDUCED_DATA limits Taproot nesting to 7 levels, so this test now hits that limit before the multi() error
+    CheckUnparsable("", "tr(034D2224bbbbbbbbbbcbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb40,{{{{{{{{{{{{{{{{{{{{{{multi(1,xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc/967808'/9,xprvA1RpRA33e1JQ7ifknakTFNpgXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc/968/2/5/8/5/2/5/58/58/2/5/5/5/58/588/2/6/8/5/2/8/2/5/8/2/58/2/5/8/5/2/8/5/8/3/4/5/58/55/2/5/58/58/2/5/5/5/8/5/2/8/5/85/2/8/2/5/8/5/2/5/58/58/2/5/58/58/588/2/58/2/8/5/8/5/4/5/585/2/5/58/58/2/5/5/58/588/2/58/2/5/8/5/2/8/2/5/8/5/5/58/588/2/6/8/5/2/8/2/5/8/5/2/5/58/58/2/5/58/58/2/0/8/5/2/8/5/8/5/4/5/58/588/2/6/8/5/2/8/2/5/8/5/2/5/58/58/2/5/58/58/588/2/58/2/5/8/5/8/24/5/58/52/5/8/5/2/8/24/5/58/588/246/8/5/2/8/2/5/8/5/2/5/58/58/2/5/5/5/58/588/2/6/8/5/2/8/2/5/8/2/58/2/5/8/5/2/8/5/8/5/4/5/58/55/58/2/5/8/55/2/5/8/58/555/58/2/5/8/4//2/5/58/5w/2/5/8/5/2/4/5/58/5558'/2/5/58/58/2/5/5/58/588/2/58/2/5/8/5/2/8/2/5/8/5/5/8/58/2/5/58/58/2/5/8/9/588/2/58/2/5/8/5/2/8/5/8/5/4/5/58/588/2/6/8/5/2/8/2/5/8/5/2/5/58/58/2/5/5/58/588/2/58/2/5/8/5/2/82/5/8/5/5/58/52/6/8/5/2/8/{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{}{{{{{{{{{DDD2/5/8/5/2/5/58/58/2/5/58/58/588/2/58/2/8/5/8/5/4/5/58/588/2/6/8/5/2/8/2/5/8588/246/8/5/2DLDDDDDDDbbD3DDDD/8/2/5/8/5/2/5/58/58/2/5/5/5/58/588/2/6/8/5/2/8/2/5/8/2/58/2/5/8/5/2/8/5/8/3/4/5/58/55/2/5/58/58/2/5/5/5/8/5/2/8/5/85/2/8/2/5/8D)/5/2/5/58/58/2/5/58/58/58/588/2/58/2/5/8/5/25/58/58/2/5/58/58/2/5/8/9/588/2/58/2/6780,xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFW/8/5/2/5/58678008')", "tr() supports at most 7 nesting levels");
     // No uncompressed keys allowed
     CheckUnparsable("", "wsh(and_v(vc:andor(pk(03cdabb7f2dce7bfbd8a0b9570c6fd1e712e5d64045e9d6b517b3d5072251dc204),pk_k(032707170c71d8f75e4ca4e3fce870b9409dcaf12b051d3bcadff74747fa7619c0),and_v(v:older(1),pk_k(049228de6902abb4f541791f6d7f925b10e2078ccb1298856e5ea5cc5fd667f930eac37a00cc07f9a91ef3c2d17bf7a17db04552ff90ac312a5b8b4caca6c97aa4))),after(10)))", "Uncompressed keys are not allowed");
     // No hybrid keys allowed
@@ -1131,7 +1132,8 @@ BOOST_AUTO_TEST_CASE(descriptor_test)
     Check("wsh(and_v(v:hash256(ae253ca2a54debcac7ecf414f6734f48c56421a08bb59182ff9f39a6fffdb588),pk(xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc)))", "wsh(and_v(v:hash256(ae253ca2a54debcac7ecf414f6734f48c56421a08bb59182ff9f39a6fffdb588),pk(xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL)))", "wsh(and_v(v:hash256(ae253ca2a54debcac7ecf414f6734f48c56421a08bb59182ff9f39a6fffdb588),pk(xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL)))", SIGNABLE_FAILS, {{"0020cf62bf97baf977aec69cbc290c372899f913337a9093e8f066ab59b8657a365c"}}, OutputType::BECH32, /*op_desc_id=*/uint256{"8412ba3ac20ba3a30f81442d10d32e0468fa52814960d04e959bf84a9b813b88"}, {{}}, /*spender_nlocktime=*/0, /*spender_nsequence=*/CTxIn::SEQUENCE_FINAL, {});
     Check("wsh(and_v(v:hash256(ae253ca2a54debcac7ecf414f6734f48c56421a08bb59182ff9f39a6fffdb588),pk(xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc)))", "wsh(and_v(v:hash256(ae253ca2a54debcac7ecf414f6734f48c56421a08bb59182ff9f39a6fffdb588),pk(xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL)))", "wsh(and_v(v:hash256(ae253ca2a54debcac7ecf414f6734f48c56421a08bb59182ff9f39a6fffdb588),pk(xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL)))", SIGNABLE, {{"0020cf62bf97baf977aec69cbc290c372899f913337a9093e8f066ab59b8657a365c"}}, OutputType::BECH32, /*op_desc_id=*/uint256{"8412ba3ac20ba3a30f81442d10d32e0468fa52814960d04e959bf84a9b813b88"}, {{}}, /*spender_nlocktime=*/0, /*spender_nsequence=*/CTxIn::SEQUENCE_FINAL, {{"ae253ca2a54debcac7ecf414f6734f48c56421a08bb59182ff9f39a6fffdb588"_hex_v_u8, "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"_hex_v_u8}});
     // Can have a Miniscript expression under tr() if it's alone.
-    Check("tr(a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd,thresh(2,pk(L1NKM8dVA1h52mwDrmk1YreTWkAZZTu2vmKLpmLEbFRqGQYjHeEV),s:pk(Kz3iCBy3HNGP5CZWDsAMmnCMFNwqdDohudVN9fvkrN7tAkzKNtM7),adv:older(42)))", "tr(a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd,thresh(2,pk(30a6069f344fb784a2b4c99540a91ee727c91e3a25ef6aae867d9c65b5f23529),s:pk(9918d400c1b8c3c478340a40117ced4054b6b58f48cdb3c89b836bdfee1f5766),adv:older(42)))", "tr(a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd,thresh(2,pk(30a6069f344fb784a2b4c99540a91ee727c91e3a25ef6aae867d9c65b5f23529),s:pk(9918d400c1b8c3c478340a40117ced4054b6b58f48cdb3c89b836bdfee1f5766),adv:older(42)))", MISSING_PRIVKEYS | XONLY_KEYS | SIGNABLE, {{"512033982eebe204dc66508e4b19cfc31b5ffc6e1bfcbf6e5597dfc2521a52270795"}}, OutputType::BECH32M);
+    // Note: thresh() uses OP_IF which is forbidden with REDUCED_DATA, so using and_v() instead
+    Check("tr(a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd,and_v(v:pk(L1NKM8dVA1h52mwDrmk1YreTWkAZZTu2vmKLpmLEbFRqGQYjHeEV),pk(Kz3iCBy3HNGP5CZWDsAMmnCMFNwqdDohudVN9fvkrN7tAkzKNtM7)))", "tr(a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd,and_v(v:pk(30a6069f344fb784a2b4c99540a91ee727c91e3a25ef6aae867d9c65b5f23529),pk(9918d400c1b8c3c478340a40117ced4054b6b58f48cdb3c89b836bdfee1f5766)))", "tr(a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd,and_v(v:pk(30a6069f344fb784a2b4c99540a91ee727c91e3a25ef6aae867d9c65b5f23529),pk(9918d400c1b8c3c478340a40117ced4054b6b58f48cdb3c89b836bdfee1f5766)))", MISSING_PRIVKEYS | XONLY_KEYS | SIGNABLE, {{"51202aca0fdcbfbc513549e2c9490e60ba54e3c345ff01d667c4f846c802c0e7b8f4"}}, OutputType::BECH32M);
     // Can have a pkh() expression alone as tr() script path (because pkh() is valid Miniscript).
     Check("tr(a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd,pkh(L1NKM8dVA1h52mwDrmk1YreTWkAZZTu2vmKLpmLEbFRqGQYjHeEV))", "tr(a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd,pkh(30a6069f344fb784a2b4c99540a91ee727c91e3a25ef6aae867d9c65b5f23529))", "tr(a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd,pkh(30a6069f344fb784a2b4c99540a91ee727c91e3a25ef6aae867d9c65b5f23529))", MISSING_PRIVKEYS | XONLY_KEYS | SIGNABLE, {{"51201e9875f690f5847404e4c5951e2f029887df0525691ee11a682afd37b608aad4"}}, OutputType::BECH32M);
     // Can have a Miniscript expression under tr() if it's part of a tree.
diff --git a/src/test/fuzz/coins_view.cpp b/src/test/fuzz/coins_view.cpp
index a47dc3706c87..307cec97921c 100644
--- a/src/test/fuzz/coins_view.cpp
+++ b/src/test/fuzz/coins_view.cpp
@@ -283,7 +283,7 @@ void TestCoinsView(FuzzedDataProvider& fuzzed_data_provider, CCoinsViewCache& co
                     // 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)) {
+                if (Consensus::CheckTxInputs(transaction, state, coins_view_cache, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), tx_fee_out, CheckTxInputsRules::OutputSizeLimit)) {
                     assert(MoneyRange(tx_fee_out));
                 }
             },
diff --git a/src/test/fuzz/miniscript.cpp b/src/test/fuzz/miniscript.cpp
index a7934f7e50fd..7ecae192235d 100644
--- a/src/test/fuzz/miniscript.cpp
+++ b/src/test/fuzz/miniscript.cpp
@@ -1128,13 +1128,25 @@ void TestNode(const MsCtx script_ctx, const std::optional<Node>& node, FuzzedDat
         SatisfactionToWitness(script_ctx, witness_nonmal, script, builder);
         ScriptError serror;
         bool res = VerifyScript(DUMMY_SCRIPTSIG, script_pubkey, &witness_nonmal, STANDARD_SCRIPT_VERIFY_FLAGS, CHECKER_CTX, &serror);
-        // Non-malleable satisfactions are guaranteed to be valid if ValidSatisfactions().
-        if (node->ValidSatisfactions()) assert(res);
+        // Non-malleable satisfactions are guaranteed to be valid if ValidSatisfactions(), unless REDUCED_DATA rules are violated.
+        if (node->ValidSatisfactions()) {
+            assert(res ||
+                   serror == ScriptError::SCRIPT_ERR_PUSH_SIZE ||
+                   serror == ScriptError::SCRIPT_ERR_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM ||
+                   serror == ScriptError::SCRIPT_ERR_DISCOURAGE_UPGRADABLE_TAPROOT_VERSION ||
+                   serror == ScriptError::SCRIPT_ERR_DISCOURAGE_OP_SUCCESS ||
+                   serror == ScriptError::SCRIPT_ERR_TAPSCRIPT_MINIMALIF);
+        }
         // More detailed: non-malleable satisfactions must be valid, or could fail with ops count error (if CheckOpsLimit failed),
-        // or with a stack size error (if CheckStackSize check failed).
+        // or with a stack size error (if CheckStackSize check failed), or with REDUCED_DATA-related errors.
         assert(res ||
                (!node->CheckOpsLimit() && serror == ScriptError::SCRIPT_ERR_OP_COUNT) ||
-               (!node->CheckStackSize() && serror == ScriptError::SCRIPT_ERR_STACK_SIZE));
+               (!node->CheckStackSize() && serror == ScriptError::SCRIPT_ERR_STACK_SIZE) ||
+               serror == ScriptError::SCRIPT_ERR_PUSH_SIZE ||
+               serror == ScriptError::SCRIPT_ERR_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM ||
+               serror == ScriptError::SCRIPT_ERR_DISCOURAGE_UPGRADABLE_TAPROOT_VERSION ||
+               serror == ScriptError::SCRIPT_ERR_DISCOURAGE_OP_SUCCESS ||
+               serror == ScriptError::SCRIPT_ERR_TAPSCRIPT_MINIMALIF);
     }
 
     if (mal_success && (!nonmal_success || witness_mal.stack != witness_nonmal.stack)) {
@@ -1144,8 +1156,15 @@ void TestNode(const MsCtx script_ctx, const std::optional<Node>& node, FuzzedDat
         ScriptError serror;
         bool res = VerifyScript(DUMMY_SCRIPTSIG, script_pubkey, &witness_mal, STANDARD_SCRIPT_VERIFY_FLAGS, CHECKER_CTX, &serror);
         // Malleable satisfactions are not guaranteed to be valid under any conditions, but they can only
-        // fail due to stack or ops limits.
-        assert(res || serror == ScriptError::SCRIPT_ERR_OP_COUNT || serror == ScriptError::SCRIPT_ERR_STACK_SIZE);
+        // fail due to stack or ops limits, or REDUCED_DATA-related errors.
+        assert(res ||
+               serror == ScriptError::SCRIPT_ERR_OP_COUNT ||
+               serror == ScriptError::SCRIPT_ERR_STACK_SIZE ||
+               serror == ScriptError::SCRIPT_ERR_PUSH_SIZE ||
+               serror == ScriptError::SCRIPT_ERR_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM ||
+               serror == ScriptError::SCRIPT_ERR_DISCOURAGE_UPGRADABLE_TAPROOT_VERSION ||
+               serror == ScriptError::SCRIPT_ERR_DISCOURAGE_OP_SUCCESS ||
+               serror == ScriptError::SCRIPT_ERR_TAPSCRIPT_MINIMALIF);
     }
 
     if (node->IsSane()) {
diff --git a/src/test/fuzz/versionbits.cpp b/src/test/fuzz/versionbits.cpp
index a2085e6a4098..73b459373eee 100644
--- a/src/test/fuzz/versionbits.cpp
+++ b/src/test/fuzz/versionbits.cpp
@@ -33,6 +33,7 @@ class TestConditionChecker : public VersionBitsConditionChecker
         assert(dep.threshold <= dep.period);
         assert(0 <= dep.bit && dep.bit < 32 && dep.bit < VERSIONBITS_NUM_BITS);
         assert(0 <= dep.min_activation_height);
+        assert(dep.active_duration > 0);
     }
 
     ThresholdState GetStateFor(const CBlockIndex* pindexPrev) const { return AbstractThresholdConditionChecker::GetStateFor(pindexPrev, m_cache); }
@@ -148,6 +149,7 @@ FUZZ_TARGET(versionbits, .init = initialize)
             if (fuzzed_data_provider.ConsumeBool()) dep.nTimeout += interval / 2;
         }
         dep.min_activation_height = fuzzed_data_provider.ConsumeIntegralInRange<int>(0, period * max_periods);
+        dep.active_duration = fuzzed_data_provider.ConsumeBool() ? std::numeric_limits<int>::max() : (fuzzed_data_provider.ConsumeIntegralInRange<int>(1, max_periods) * period);
         return dep;
     }()};
     TestConditionChecker checker(dep);
@@ -314,13 +316,22 @@ FUZZ_TARGET(versionbits, .init = initialize)
             assert(exp_state == ThresholdState::FAILED);
         }
         break;
+    case ThresholdState::EXPIRED:
+        assert(!always_active_test);
+        assert(dep.active_duration < std::numeric_limits<int>::max());
+        assert(dep.min_activation_height <= current_block->nHeight + 1);
+        assert(exp_state == ThresholdState::EXPIRED || exp_state == ThresholdState::ACTIVE);
+        if (exp_state == ThresholdState::ACTIVE) {
+            assert(since == exp_since + dep.active_duration);  // EXPIRED starts exactly active_duration blocks after ACTIVE started
+        }
+        break;
     default:
         assert(false);
     }
 
     if (blocks.size() >= period * max_periods) {
         // we chose the timeout (and block times) so that by the time we have this many blocks it's all over
-        assert(state == ThresholdState::ACTIVE || state == ThresholdState::FAILED);
+        assert(state == ThresholdState::ACTIVE || state == ThresholdState::FAILED || state == ThresholdState::EXPIRED);
     }
 
     if (always_active_test) {
diff --git a/src/test/miniscript_tests.cpp b/src/test/miniscript_tests.cpp
index 9a3e9ea0789b..56a0a6f70d75 100644
--- a/src/test/miniscript_tests.cpp
+++ b/src/test/miniscript_tests.cpp
@@ -388,13 +388,25 @@ void TestSatisfy(const KeyConverter& converter, const Node& node)
                 // Test non-malleable satisfaction.
                 ScriptError serror;
                 bool res = VerifyScript(CScript(), script_pubkey, &witness_nonmal, STANDARD_SCRIPT_VERIFY_FLAGS, checker, &serror);
-                // Non-malleable satisfactions are guaranteed to be valid if ValidSatisfactions().
-                if (node.ValidSatisfactions()) BOOST_CHECK(res);
+                // Non-malleable satisfactions are guaranteed to be valid if ValidSatisfactions(), unless REDUCED_DATA rules are violated.
+                if (node.ValidSatisfactions()) {
+                    BOOST_CHECK(res ||
+                                serror == ScriptError::SCRIPT_ERR_PUSH_SIZE ||
+                                serror == ScriptError::SCRIPT_ERR_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM ||
+                                serror == ScriptError::SCRIPT_ERR_DISCOURAGE_UPGRADABLE_TAPROOT_VERSION ||
+                                serror == ScriptError::SCRIPT_ERR_DISCOURAGE_OP_SUCCESS ||
+                                serror == ScriptError::SCRIPT_ERR_TAPSCRIPT_MINIMALIF);
+                }
                 // More detailed: non-malleable satisfactions must be valid, or could fail with ops count error (if CheckOpsLimit failed),
-                // or with a stack size error (if CheckStackSize check fails).
+                // or with a stack size error (if CheckStackSize check fails), or with REDUCED_DATA-related errors.
                 BOOST_CHECK(res ||
                             (!node.CheckOpsLimit() && serror == ScriptError::SCRIPT_ERR_OP_COUNT) ||
-                            (!node.CheckStackSize() && serror == ScriptError::SCRIPT_ERR_STACK_SIZE));
+                            (!node.CheckStackSize() && serror == ScriptError::SCRIPT_ERR_STACK_SIZE) ||
+                            (serror == ScriptError::SCRIPT_ERR_PUSH_SIZE) ||
+                            (serror == ScriptError::SCRIPT_ERR_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM) ||
+                            (serror == ScriptError::SCRIPT_ERR_DISCOURAGE_UPGRADABLE_TAPROOT_VERSION) ||
+                            (serror == ScriptError::SCRIPT_ERR_DISCOURAGE_OP_SUCCESS) ||
+                            (serror == ScriptError::SCRIPT_ERR_TAPSCRIPT_MINIMALIF));
             }
 
             if (mal_success && (!nonmal_success || witness_mal.stack != witness_nonmal.stack)) {
@@ -402,8 +414,15 @@ void TestSatisfy(const KeyConverter& converter, const Node& node)
                 ScriptError serror;
                 bool res = VerifyScript(CScript(), script_pubkey, &witness_mal, STANDARD_SCRIPT_VERIFY_FLAGS, checker, &serror);
                 // Malleable satisfactions are not guaranteed to be valid under any conditions, but they can only
-                // fail due to stack or ops limits.
-                BOOST_CHECK(res || serror == ScriptError::SCRIPT_ERR_OP_COUNT || serror == ScriptError::SCRIPT_ERR_STACK_SIZE);
+                // fail due to stack or ops limits, or REDUCED_DATA-related errors.
+                BOOST_CHECK(res ||
+                            serror == ScriptError::SCRIPT_ERR_OP_COUNT ||
+                            serror == ScriptError::SCRIPT_ERR_STACK_SIZE ||
+                            serror == ScriptError::SCRIPT_ERR_PUSH_SIZE ||
+                            serror == ScriptError::SCRIPT_ERR_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM ||
+                            serror == ScriptError::SCRIPT_ERR_DISCOURAGE_UPGRADABLE_TAPROOT_VERSION ||
+                            serror == ScriptError::SCRIPT_ERR_DISCOURAGE_OP_SUCCESS ||
+                            serror == ScriptError::SCRIPT_ERR_TAPSCRIPT_MINIMALIF);
             }
 
             if (node.IsSane()) {
diff --git a/src/test/script_standard_tests.cpp b/src/test/script_standard_tests.cpp
index a1e0c46a0fe0..acbb1b6bbf31 100644
--- a/src/test/script_standard_tests.cpp
+++ b/src/test/script_standard_tests.cpp
@@ -427,9 +427,10 @@ BOOST_AUTO_TEST_CASE(script_standard_taproot_builder)
     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,2,0}), false);
     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,2,1}), true);
     BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,2,2}), false);
-    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,2,2,3,4,5,6,7,8,9,10,11,12,14,14,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,31,31,31,31,31,31,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,128}), true);
-    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({128,128,127,126,125,124,123,122,121,120,119,118,117,116,115,114,113,112,111,110,109,108,107,106,105,104,103,102,101,100,99,98,97,96,95,94,93,92,91,90,89,88,87,86,85,84,83,82,81,80,79,78,77,76,75,74,73,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1}), true);
-    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({129,129,128,127,126,125,124,123,122,121,120,119,118,117,116,115,114,113,112,111,110,109,108,107,106,105,104,103,102,101,100,99,98,97,96,95,94,93,92,91,90,89,88,87,86,85,84,83,82,81,80,79,78,77,76,75,74,73,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1}), false);
+    // REDUCED_DATA limits Taproot tree depth to 7 instead of 128
+    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({2,2,2,3,4,5,6,7,7}), true);
+    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({7,7,6,5,4,3,2,1}), true);
+    BOOST_CHECK_EQUAL(TaprootBuilder::ValidDepths({8,8,7,6,5,4,3,2,1}), false);
 
     XOnlyPubKey key_inner{"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"_hex_u8};
     XOnlyPubKey key_1{"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5"_hex_u8};
diff --git a/src/test/transaction_tests.cpp b/src/test/transaction_tests.cpp
index 916f565c04df..eab088f3e80a 100644
--- a/src/test/transaction_tests.cpp
+++ b/src/test/transaction_tests.cpp
@@ -1130,7 +1130,7 @@ BOOST_AUTO_TEST_CASE(checktxinputs_invalid_transactions_test)
 
         TxValidationState state;
         CAmount txfee{0};
-        BOOST_CHECK(!Consensus::CheckTxInputs(CTransaction{mtx}, state, inputs, spend_height, txfee));
+        BOOST_CHECK(!Consensus::CheckTxInputs(CTransaction{mtx}, state, inputs, spend_height, txfee, CheckTxInputsRules::None));
         BOOST_CHECK(state.IsInvalid());
         BOOST_CHECK_EQUAL(state.GetResult(), expected_result);
         BOOST_CHECK_EQUAL(state.GetRejectReason(), expected_reason);
diff --git a/src/test/txvalidationcache_tests.cpp b/src/test/txvalidationcache_tests.cpp
index 9ea39c9150a7..f1807ad5a792 100644
--- a/src/test/txvalidationcache_tests.cpp
+++ b/src/test/txvalidationcache_tests.cpp
@@ -2,9 +2,11 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <addresstype.h>
 #include <consensus/validation.h>
 #include <key.h>
 #include <random.h>
+#include <script/interpreter.h>
 #include <script/sigcache.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
@@ -24,7 +26,9 @@ bool CheckInputScripts(const CTransaction& tx, TxValidationState& state,
                        const CCoinsViewCache& inputs, script_verify_flags flags, bool cacheSigStore,
                        bool cacheFullScriptStore, PrecomputedTransactionData& txdata,
                        ValidationCache& validation_cache,
-                       std::vector<CScriptCheck>* pvChecks) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+                       std::vector<CScriptCheck>* pvChecks,
+                       const std::vector<script_verify_flags>& flags_per_input = {}
+) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
 BOOST_AUTO_TEST_SUITE(txvalidationcache_tests)
 
@@ -34,7 +38,8 @@ BOOST_FIXTURE_TEST_CASE(tx_mempool_block_doublespend, Dersig100Setup)
     // validated going into the memory pool does not allow
     // double-spends in blocks to pass validation when they should not.
 
-    CScript scriptPubKey = CScript() <<  ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
+    CScript p2pk_scriptPubKey = CScript() <<  ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
+    CScript scriptPubKey = GetScriptForDestination(PKHash(coinbaseKey.GetPubKey()));
 
     const auto ToMemPool = [this](const CMutableTransaction& tx) {
         LOCK(cs_main);
@@ -58,7 +63,7 @@ BOOST_FIXTURE_TEST_CASE(tx_mempool_block_doublespend, Dersig100Setup)
 
         // Sign:
         std::vector<unsigned char> vchSig;
-        uint256 hash = SignatureHash(scriptPubKey, spends[i], 0, SIGHASH_ALL, 0, SigVersion::BASE);
+        uint256 hash = SignatureHash(p2pk_scriptPubKey, spends[i], 0, SIGHASH_ALL, 0, SigVersion::BASE);
         BOOST_CHECK(coinbaseKey.Sign(hash, vchSig));
         vchSig.push_back((unsigned char)SIGHASH_ALL);
         spends[i].vin[0].scriptSig << vchSig;
@@ -385,4 +390,76 @@ BOOST_FIXTURE_TEST_CASE(checkinputs_test, Dersig100Setup)
     }
 }
 
+BOOST_FIXTURE_TEST_CASE(checkinputs_flags_per_input_cache_safety, Dersig100Setup)
+{
+    // Reproducer for cache poisoning via per-input flag relaxation.
+    //
+    // A 300-byte witness push passes only when SCRIPT_VERIFY_REDUCED_DATA is
+    // relaxed (as it would be for pre-activation UTXOs). The cache key is
+    // computed from the strict global flags, so if the result is cached after
+    // passing with relaxed per-input flags, a subsequent strict-flags lookup
+    // will incorrectly return a cache hit.
+
+    const auto& coinbase_script{m_coinbase_txns[0]->vout[0].scriptPubKey};
+    const script_verify_flags strict_flags{SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_REDUCED_DATA};
+    const script_verify_flags relaxed_flags{SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS};
+
+    // P2WSH witness script: OP_DROP OP_TRUE (accepts any single witness element)
+    const CScript witness_script = CScript() << OP_DROP << OP_TRUE;
+    const std::vector<unsigned char> big_witness_elem(300, 0x42);
+    const CScript p2wsh_script = GetScriptForDestination(WitnessV0ScriptHash(witness_script));
+
+    // Mine a funding tx that pays to the P2WSH output.
+    const auto mine_funding_tx{[&]
+    {
+        CMutableTransaction tx;
+        tx.vin = {CTxIn{m_coinbase_txns[0]->GetHash(), 0}};
+        tx.vout = {CTxOut{11 * CENT, p2wsh_script}};
+
+        std::vector<unsigned char> vchSig;
+        const uint256 hash = SignatureHash(coinbase_script, tx, 0, SIGHASH_ALL, 0, SigVersion::BASE);
+        BOOST_CHECK(coinbaseKey.Sign(hash, vchSig));
+        vchSig.push_back(SIGHASH_ALL);
+        tx.vin[0].scriptSig << vchSig;
+
+        const CBlock block = CreateAndProcessBlock({tx}, coinbase_script);
+        LOCK(cs_main);
+        BOOST_CHECK(m_node.chainman->ActiveChain().Tip()->GetBlockHash() == block.GetHash());
+        return CTransaction{tx};
+    }};
+    const CTransaction funding_tx{mine_funding_tx()};
+
+    // Build spending tx with a 300-byte witness element (violates REDUCED_DATA).
+    CMutableTransaction spend_tx;
+    spend_tx.vin = {CTxIn{funding_tx.GetHash(), 0}};
+    spend_tx.vout = {CTxOut{10 * CENT, GetScriptForDestination(PKHash(coinbaseKey.GetPubKey()))}};
+    spend_tx.vin[0].scriptWitness.stack = {big_witness_elem, {witness_script.begin(), witness_script.end()}};
+    const CTransaction spend{spend_tx};
+    BOOST_CHECK_EQUAL(spend.vin[0].scriptWitness.stack[0].size(), 300U);
+
+    LOCK(cs_main);
+    auto& coins_tip = m_node.chainman->ActiveChainstate().CoinsTip();
+
+    // Use a fresh validation cache to isolate this test.
+    ValidationCache validation_cache{/*script_execution_cache_bytes=*/1 << 20, /*signature_cache_bytes=*/1 << 20};
+
+    const auto run_check{[&](const std::vector<script_verify_flags>& flags_per_input) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
+        TxValidationState state;
+        PrecomputedTransactionData txdata;
+        return CheckInputScripts(spend, state, &coins_tip, strict_flags,
+                                 /*cacheSigStore=*/true, /*cacheFullScriptStore=*/true,
+                                 txdata, validation_cache, /*pvChecks=*/nullptr, flags_per_input);
+    }};
+
+    // Step 1: strict validation (REDUCED_DATA enforced) must fail.
+    BOOST_CHECK(!run_check({}));
+
+    // Step 2: relaxed per-input flags (no REDUCED_DATA) must pass.
+    BOOST_CHECK(run_check({relaxed_flags}));
+
+    // Step 3: strict validation must STILL fail.
+    // If the cache was poisoned in step 2, this incorrectly passes.
+    BOOST_CHECK(!run_check({}));
+}
+
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/versionbits_tests.cpp b/src/test/versionbits_tests.cpp
index ad7920531175..a8ccf7e21306 100644
--- a/src/test/versionbits_tests.cpp
+++ b/src/test/versionbits_tests.cpp
@@ -481,4 +481,657 @@ BOOST_FIXTURE_TEST_CASE(versionbits_computeblockversion, BlockVersionTest)
     }
 }
 
+/**
+ * Test condition checker with max_activation_height for mandatory activation deadline.
+ * When max_activation_height is set, the deployment forces LOCKED_IN one period before
+ * max_activation_height, even if threshold signaling was not met.
+ */
+class TestMaxActivationHeightConditionChecker : public AbstractThresholdConditionChecker
+{
+private:
+    mutable ThresholdConditionCache cache;
+    int m_max_activation_height;
+
+public:
+    explicit TestMaxActivationHeightConditionChecker(int max_height) : m_max_activation_height(max_height) {}
+
+    int64_t BeginTime() const override { return 0; }
+    int64_t EndTime() const override { return Consensus::BIP9Deployment::NO_TIMEOUT; }
+    int Period() const override { return 144; }
+    int Threshold() const override { return 108; }
+    int MaxActivationHeight() const override { return m_max_activation_height; }
+    bool Condition(const CBlockIndex* pindex) const override { return (pindex->nVersion & 0x100); }
+
+    ThresholdState GetStateFor(const CBlockIndex* pindexPrev) const { return AbstractThresholdConditionChecker::GetStateFor(pindexPrev, cache); }
+    int GetStateSinceHeightFor(const CBlockIndex* pindexPrev) const { return AbstractThresholdConditionChecker::GetStateSinceHeightFor(pindexPrev, cache); }
+    void ClearCache() { cache.clear(); }
+};
+
+BOOST_AUTO_TEST_CASE(versionbits_max_activation_height)
+{
+    // Test that max_activation_height forces LOCKED_IN one period before max_activation_height
+    // even without sufficient signaling.
+    //
+    // Timeline with period=144, max_activation_height=432:
+    // - Period 0 (0-143): DEFINED
+    // - Period 1 (144-287): STARTED (no signaling -> normally would stay STARTED)
+    // - Period 2 (288-431): LOCKED_IN (forced because 288 >= 432 - 144)
+    // - Period 3 (432+): ACTIVE
+
+    std::vector<CBlockIndex*> blocks;
+    auto cleanup = [&blocks]() {
+        for (auto* b : blocks) delete b;
+        blocks.clear();
+    };
+
+    // max_activation_height = 432 (period 3 start)
+    TestMaxActivationHeightConditionChecker checker(432);
+
+    // Helper to create blocks
+    auto mine_block = [&blocks](int32_t nVersion) -> CBlockIndex* {
+        CBlockIndex* pindex = new CBlockIndex();
+        pindex->nHeight = blocks.size();
+        pindex->pprev = blocks.empty() ? nullptr : blocks.back();
+        pindex->nTime = 1415926536 + 600 * pindex->nHeight;
+        pindex->nVersion = nVersion;
+        pindex->BuildSkip();
+        blocks.push_back(pindex);
+        return pindex;
+    };
+
+    // Mine through period 0 (DEFINED) - 144 blocks (0-143)
+    for (int i = 0; i < 144; i++) {
+        mine_block(0); // No signaling
+    }
+    BOOST_CHECK_EQUAL(blocks.back()->nHeight, 143);
+    // At tip 143, next block (144) would be STARTED
+    BOOST_CHECK(checker.GetStateFor(blocks.back()) == ThresholdState::STARTED);
+    BOOST_CHECK_EQUAL(checker.GetStateSinceHeightFor(blocks.back()), 144);
+
+    // Mine through period 1 (STARTED) without signaling - blocks 144-287
+    for (int i = 0; i < 144; i++) {
+        mine_block(0); // No signaling
+    }
+    BOOST_CHECK_EQUAL(blocks.back()->nHeight, 287);
+    // At tip 287, next block (288) would be LOCKED_IN due to max_activation_height
+    // 288 >= 432 - 144, so forced LOCKED_IN
+    BOOST_CHECK(checker.GetStateFor(blocks.back()) == ThresholdState::LOCKED_IN);
+    BOOST_CHECK_EQUAL(checker.GetStateSinceHeightFor(blocks.back()), 288);
+
+    // Mine through period 2 (LOCKED_IN) - blocks 288-431
+    for (int i = 0; i < 144; i++) {
+        mine_block(0);
+    }
+    BOOST_CHECK_EQUAL(blocks.back()->nHeight, 431);
+    // At tip 431, next block (432) would be ACTIVE
+    BOOST_CHECK(checker.GetStateFor(blocks.back()) == ThresholdState::ACTIVE);
+    BOOST_CHECK_EQUAL(checker.GetStateSinceHeightFor(blocks.back()), 432);
+
+    // Mine into period 3 (ACTIVE) - blocks 432+
+    for (int i = 0; i < 10; i++) {
+        mine_block(0);
+    }
+    BOOST_CHECK_EQUAL(blocks.back()->nHeight, 441);
+    BOOST_CHECK(checker.GetStateFor(blocks.back()) == ThresholdState::ACTIVE);
+    BOOST_CHECK_EQUAL(checker.GetStateSinceHeightFor(blocks.back()), 432);
+
+    cleanup();
+
+    // Test 2: Verify that signaling still works to activate earlier than max_activation_height
+    TestMaxActivationHeightConditionChecker checker2(1000); // max_activation_height far in future
+
+    // Period 0: DEFINED
+    for (int i = 0; i < 144; i++) {
+        mine_block(0);
+    }
+    BOOST_CHECK(checker2.GetStateFor(blocks.back()) == ThresholdState::STARTED);
+
+    // Period 1: Signal 108+ blocks (threshold)
+    for (int i = 0; i < 108; i++) {
+        mine_block(0x100); // Signal
+    }
+    for (int i = 0; i < 36; i++) {
+        mine_block(0); // No signal
+    }
+    BOOST_CHECK_EQUAL(blocks.back()->nHeight, 287);
+    // Should be LOCKED_IN via signaling, not via max_activation_height
+    BOOST_CHECK(checker2.GetStateFor(blocks.back()) == ThresholdState::LOCKED_IN);
+    BOOST_CHECK_EQUAL(checker2.GetStateSinceHeightFor(blocks.back()), 288);
+
+    // Period 2: LOCKED_IN -> ACTIVE
+    for (int i = 0; i < 144; i++) {
+        mine_block(0);
+    }
+    BOOST_CHECK(checker2.GetStateFor(blocks.back()) == ThresholdState::ACTIVE);
+    BOOST_CHECK_EQUAL(checker2.GetStateSinceHeightFor(blocks.back()), 432);
+
+    cleanup();
+}
+
+BOOST_AUTO_TEST_CASE(versionbits_max_activation_height_boundary)
+{
+    // Test edge case: verify exact boundary where LOCKED_IN is forced
+    // With period=144 and max_activation_height=432:
+    // - At height 287, next block is 288, which is >= 432-144=288, so LOCKED_IN
+    // - At height 286, next block is 287, which is < 288, so would stay STARTED
+
+    std::vector<CBlockIndex*> blocks;
+    auto cleanup = [&blocks]() {
+        for (auto* b : blocks) delete b;
+        blocks.clear();
+    };
+
+    TestMaxActivationHeightConditionChecker checker(432);
+
+    auto mine_block = [&blocks](int32_t nVersion) -> CBlockIndex* {
+        CBlockIndex* pindex = new CBlockIndex();
+        pindex->nHeight = blocks.size();
+        pindex->pprev = blocks.empty() ? nullptr : blocks.back();
+        pindex->nTime = 1415926536 + 600 * pindex->nHeight;
+        pindex->nVersion = nVersion;
+        pindex->BuildSkip();
+        blocks.push_back(pindex);
+        return pindex;
+    };
+
+    // Mine to height 143 (end of period 0)
+    for (int i = 0; i < 144; i++) {
+        mine_block(0);
+    }
+    BOOST_CHECK_EQUAL(blocks.back()->nHeight, 143);
+    // State for block 144 is STARTED
+    BOOST_CHECK(checker.GetStateFor(blocks.back()) == ThresholdState::STARTED);
+
+    // Mine period 1 without signaling (blocks 144-287)
+    // But stop at block 286 first to check boundary
+    for (int i = 0; i < 143; i++) {
+        mine_block(0);
+    }
+    BOOST_CHECK_EQUAL(blocks.back()->nHeight, 286);
+    // At tip 286, next block 287 is still in STARTED period
+    // State is still STARTED
+    BOOST_CHECK(checker.GetStateFor(blocks.back()) == ThresholdState::STARTED);
+
+    // Mine block 287 (last block of period 1)
+    mine_block(0);
+    BOOST_CHECK_EQUAL(blocks.back()->nHeight, 287);
+    // At tip 287, state for next block (288) is computed
+    // 288 >= 432 - 144 = 288, so LOCKED_IN
+    BOOST_CHECK(checker.GetStateFor(blocks.back()) == ThresholdState::LOCKED_IN);
+    BOOST_CHECK_EQUAL(checker.GetStateSinceHeightFor(blocks.back()), 288);
+
+    cleanup();
+}
+
+BOOST_FIXTURE_TEST_CASE(versionbits_active_duration, BasicTestingSetup)
+{
+    // Test active_duration parameter via -vbparams
+    // Format: deployment:start:timeout:min_activation_height:max_activation_height:active_duration
+    //
+    // This tests that the parameter is parsed correctly. The actual expiry logic
+    // is tested in DeploymentActiveAt/DeploymentActiveAfter which use active_duration.
+
+    {
+        ArgsManager args;
+        // start=0, timeout=never, min_height=0, max_height=INT_MAX (disabled), active_duration=144
+        args.ForceSetArg("-vbparams", "testdummy:0:999999999999:0:2147483647:144");
+        const auto chainParams = CreateChainParams(args, ChainType::REGTEST);
+        const auto& deployment = chainParams->GetConsensus().vDeployments[Consensus::DEPLOYMENT_TESTDUMMY];
+
+        BOOST_CHECK_EQUAL(deployment.nStartTime, 0);
+        BOOST_CHECK_EQUAL(deployment.nTimeout, 999999999999);
+        BOOST_CHECK_EQUAL(deployment.min_activation_height, 0);
+        BOOST_CHECK_EQUAL(deployment.max_activation_height, std::numeric_limits<int>::max());
+        BOOST_CHECK_EQUAL(deployment.active_duration, 144);
+    }
+
+    {
+        ArgsManager args;
+        // Test with max_activation_height set
+        // start=0, timeout=NO_TIMEOUT, min_height=288, max_height=432, active_duration=1008 (144*7)
+        // NO_TIMEOUT = INT64_MAX = 9223372036854775807
+        args.ForceSetArg("-vbparams", "testdummy:0:9223372036854775807:288:432:1008");
+        const auto chainParams = CreateChainParams(args, ChainType::REGTEST);
+        const auto& deployment = chainParams->GetConsensus().vDeployments[Consensus::DEPLOYMENT_TESTDUMMY];
+
+        BOOST_CHECK_EQUAL(deployment.min_activation_height, 288);
+        BOOST_CHECK_EQUAL(deployment.max_activation_height, 432);
+        BOOST_CHECK_EQUAL(deployment.active_duration, 1008);
+    }
+
+    {
+        ArgsManager args;
+        // Test permanent deployment (active_duration = INT_MAX)
+        args.ForceSetArg("-vbparams", "testdummy:0:999999999999:0:2147483647:2147483647");
+        const auto chainParams = CreateChainParams(args, ChainType::REGTEST);
+        const auto& deployment = chainParams->GetConsensus().vDeployments[Consensus::DEPLOYMENT_TESTDUMMY];
+
+        BOOST_CHECK_EQUAL(deployment.active_duration, std::numeric_limits<int>::max());
+    }
+}
+
+BOOST_FIXTURE_TEST_CASE(versionbits_max_activation_height_parsing, BasicTestingSetup)
+{
+    // Test max_activation_height parameter via -vbparams
+
+    {
+        ArgsManager args;
+        // Test with max_activation_height=432 (mandatory activation deadline)
+        // NO_TIMEOUT = INT64_MAX = 9223372036854775807
+        args.ForceSetArg("-vbparams", "testdummy:0:9223372036854775807:0:432:2147483647");
+        const auto chainParams = CreateChainParams(args, ChainType::REGTEST);
+        const auto& deployment = chainParams->GetConsensus().vDeployments[Consensus::DEPLOYMENT_TESTDUMMY];
+
+        BOOST_CHECK_EQUAL(deployment.max_activation_height, 432);
+        // active_duration should be permanent when not specified differently
+        BOOST_CHECK_EQUAL(deployment.active_duration, std::numeric_limits<int>::max());
+    }
+
+    {
+        ArgsManager args;
+        // Test combined: max_activation_height + active_duration (RDTS)
+        // NO_TIMEOUT = INT64_MAX = 9223372036854775807
+        args.ForceSetArg("-vbparams", "testdummy:0:9223372036854775807:288:576:144");
+        const auto chainParams = CreateChainParams(args, ChainType::REGTEST);
+        const auto& deployment = chainParams->GetConsensus().vDeployments[Consensus::DEPLOYMENT_TESTDUMMY];
+
+        BOOST_CHECK_EQUAL(deployment.min_activation_height, 288);
+        BOOST_CHECK_EQUAL(deployment.max_activation_height, 576);
+        BOOST_CHECK_EQUAL(deployment.active_duration, 144);
+    }
+}
+
+/**
+ * Helper to create a BIP9Deployment for temporary deployment tests.
+ * Uses bit 8 and version mask 0x100 for signaling (same as Deployments::normal).
+ */
+static Consensus::BIP9Deployment MakeTemporaryDeployment(int active_duration, int max_activation_height = std::numeric_limits<int>::max())
+{
+    return Consensus::BIP9Deployment{
+        .bit = 8,
+        .nStartTime = 0,
+        .nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT,
+        .min_activation_height = 0,
+        .max_activation_height = max_activation_height,
+        .period = 144,
+        .threshold = 108,
+        .active_duration = active_duration,
+    };
+}
+
+BOOST_AUTO_TEST_CASE(versionbits_expired_state)
+{
+    // Test that a temporary deployment transitions from ACTIVE to EXPIRED
+    // after active_duration blocks past activation.
+    //
+    // Timeline with period=144, active_duration=288:
+    // - Period 0 (0-143): DEFINED
+    // - Period 1 (144-287): STARTED, signal enough to lock in
+    // - Period 2 (288-431): LOCKED_IN
+    // - Period 3 (432-575): ACTIVE (activation_height=432)
+    // - Period 4 (576-719): ACTIVE (blocks in this period are ACTIVE)
+    // - At pindexPrev=719: EXPIRED for block 720+ (720 >= 432 + 288)
+
+    std::vector<CBlockIndex*> blocks;
+    auto cleanup = [&blocks]() {
+        for (auto* b : blocks) delete b;
+        blocks.clear();
+    };
+
+    const auto dep = MakeTemporaryDeployment(288);
+    TestConditionChecker checker(dep);
+
+    auto mine_block = [&blocks](int32_t nVersion) -> CBlockIndex* {
+        CBlockIndex* pindex = new CBlockIndex();
+        pindex->nHeight = blocks.size();
+        pindex->pprev = blocks.empty() ? nullptr : blocks.back();
+        pindex->nTime = 1415926536 + 600 * pindex->nHeight;
+        pindex->nVersion = nVersion;
+        pindex->BuildSkip();
+        blocks.push_back(pindex);
+        return pindex;
+    };
+
+    // Period 0: DEFINED (blocks 0-143)
+    for (int i = 0; i < 144; i++) {
+        mine_block(0);
+    }
+    BOOST_CHECK(checker.StateFor(blocks.back()) == ThresholdState::STARTED);
+
+    // Period 1: STARTED, signal all blocks to lock in (blocks 144-287)
+    for (int i = 0; i < 144; i++) {
+        mine_block(VERSIONBITS_TOP_BITS | 0x100); // Signal
+    }
+    BOOST_CHECK(checker.StateFor(blocks.back()) == ThresholdState::LOCKED_IN);
+    BOOST_CHECK_EQUAL(checker.StateSinceHeightFor(blocks.back()), 288);
+
+    // Period 2: LOCKED_IN (blocks 288-431)
+    for (int i = 0; i < 144; i++) {
+        mine_block(0);
+    }
+    BOOST_CHECK(checker.StateFor(blocks.back()) == ThresholdState::ACTIVE);
+    BOOST_CHECK_EQUAL(checker.StateSinceHeightFor(blocks.back()), 432);
+
+    // Period 3: ACTIVE (blocks 432-575), activation_height = 432
+    for (int i = 0; i < 144; i++) {
+        mine_block(0);
+    }
+    BOOST_CHECK(checker.StateFor(blocks.back()) == ThresholdState::ACTIVE);
+    BOOST_CHECK_EQUAL(checker.StateSinceHeightFor(blocks.back()), 432);
+
+    // Period 4 (blocks 576-719): blocks in this period are ACTIVE,
+    // but at pindexPrev=719 the state for block 720+ is EXPIRED (720 >= 432 + 288)
+    for (int i = 0; i < 144; i++) {
+        mine_block(0);
+    }
+    BOOST_CHECK(checker.StateFor(blocks.back()) == ThresholdState::EXPIRED);
+    BOOST_CHECK_EQUAL(checker.StateSinceHeightFor(blocks.back()), 720);
+
+    // Verify EXPIRED is terminal
+    for (int i = 0; i < 144; i++) {
+        mine_block(VERSIONBITS_TOP_BITS | 0x100); // Signal shouldn't matter
+    }
+    BOOST_CHECK(checker.StateFor(blocks.back()) == ThresholdState::EXPIRED);
+    BOOST_CHECK_EQUAL(checker.StateSinceHeightFor(blocks.back()), 720);
+
+    cleanup();
+}
+
+BOOST_AUTO_TEST_CASE(versionbits_expired_unaligned_duration_rejected)
+{
+    // Test that active_duration that is NOT a multiple of the period is rejected.
+    ArgsManager args;
+    args.ForceSetArg("-vbparams", "testdummy:0:9223372036854775807:0:432:200");
+    BOOST_CHECK_THROW(CreateChainParams(args, ChainType::REGTEST), std::runtime_error);
+}
+
+BOOST_AUTO_TEST_CASE(versionbits_expired_minimum_duration)
+{
+    // Test active_duration = 1 period (144). Minimum useful duration.
+    // Activation at 432, so 432+144=576. At pindexPrev=575, state for 576+:
+    // 576 >= 576 -> EXPIRED. Only one period of ACTIVE.
+
+    std::vector<CBlockIndex*> blocks;
+    auto cleanup = [&blocks]() {
+        for (auto* b : blocks) delete b;
+        blocks.clear();
+    };
+
+    const auto dep = MakeTemporaryDeployment(144);
+    TestConditionChecker checker(dep);
+
+    auto mine_block = [&blocks](int32_t nVersion) -> CBlockIndex* {
+        CBlockIndex* pindex = new CBlockIndex();
+        pindex->nHeight = blocks.size();
+        pindex->pprev = blocks.empty() ? nullptr : blocks.back();
+        pindex->nTime = 1415926536 + 600 * pindex->nHeight;
+        pindex->nVersion = nVersion;
+        pindex->BuildSkip();
+        blocks.push_back(pindex);
+        return pindex;
+    };
+
+    // Period 0: DEFINED (0-143)
+    for (int i = 0; i < 144; i++) mine_block(0);
+    BOOST_CHECK(checker.StateFor(blocks.back()) == ThresholdState::STARTED);
+
+    // Period 1: Signal (144-287)
+    for (int i = 0; i < 144; i++) mine_block(VERSIONBITS_TOP_BITS | 0x100);
+    BOOST_CHECK(checker.StateFor(blocks.back()) == ThresholdState::LOCKED_IN);
+
+    // Period 2: LOCKED_IN (288-431)
+    for (int i = 0; i < 144; i++) mine_block(0);
+    BOOST_CHECK(checker.StateFor(blocks.back()) == ThresholdState::ACTIVE);
+    BOOST_CHECK_EQUAL(checker.StateSinceHeightFor(blocks.back()), 432);
+
+    // Period 3 (432-575): ACTIVE for this period, but state for 576+:
+    // 576 >= 432 + 144 = 576 -> EXPIRED immediately at next boundary
+    for (int i = 0; i < 144; i++) mine_block(0);
+    BOOST_CHECK(checker.StateFor(blocks.back()) == ThresholdState::EXPIRED);
+    BOOST_CHECK_EQUAL(checker.StateSinceHeightFor(blocks.back()), 576);
+
+    cleanup();
+}
+
+BOOST_AUTO_TEST_CASE(versionbits_expired_cold_cache)
+{
+    // Test that clearing the cache and re-querying correctly recovers
+    // the EXPIRED state. This exercises the activation_height recovery
+    // path in GetStateFor where it calls GetStateSinceHeightFor to find
+    // when ACTIVE started.
+
+    std::vector<CBlockIndex*> blocks;
+    auto cleanup = [&blocks]() {
+        for (auto* b : blocks) delete b;
+        blocks.clear();
+    };
+
+    const auto dep = MakeTemporaryDeployment(288);
+    TestConditionChecker checker(dep);
+
+    auto mine_block = [&blocks](int32_t nVersion) -> CBlockIndex* {
+        CBlockIndex* pindex = new CBlockIndex();
+        pindex->nHeight = blocks.size();
+        pindex->pprev = blocks.empty() ? nullptr : blocks.back();
+        pindex->nTime = 1415926536 + 600 * pindex->nHeight;
+        pindex->nVersion = nVersion;
+        pindex->BuildSkip();
+        blocks.push_back(pindex);
+        return pindex;
+    };
+
+    // Build chain through to EXPIRED (same as basic test)
+    // Period 0: DEFINED (0-143)
+    for (int i = 0; i < 144; i++) mine_block(0);
+    // Period 1: Signal (144-287)
+    for (int i = 0; i < 144; i++) mine_block(VERSIONBITS_TOP_BITS | 0x100);
+    // Period 2: LOCKED_IN (288-431)
+    for (int i = 0; i < 144; i++) mine_block(0);
+    // Period 3: ACTIVE (432-575)
+    for (int i = 0; i < 144; i++) mine_block(0);
+    // Period 4: (576-719) -> EXPIRED at 720
+    for (int i = 0; i < 144; i++) mine_block(0);
+
+    // Verify EXPIRED with warm cache
+    BOOST_CHECK(checker.StateFor(blocks.back()) == ThresholdState::EXPIRED);
+    BOOST_CHECK_EQUAL(checker.StateSinceHeightFor(blocks.back()), 720);
+
+    // Clear cache completely — simulates node restart
+    checker.clear();
+
+    // Re-query: must walk from genesis, recover activation_height, compute EXPIRED
+    BOOST_CHECK(checker.StateFor(blocks.back()) == ThresholdState::EXPIRED);
+    BOOST_CHECK_EQUAL(checker.StateSinceHeightFor(blocks.back()), 720);
+
+    // Also verify intermediate states are correct after cache rebuild
+    checker.clear();
+    // Query at end of period 3 (pindexPrev=575) — should be ACTIVE
+    BOOST_CHECK(checker.StateFor(blocks[575]) == ThresholdState::ACTIVE);
+    BOOST_CHECK_EQUAL(checker.StateSinceHeightFor(blocks[575]), 432);
+
+    // Now query at end of period 4 with partially-populated cache
+    // (period 3 is cached as ACTIVE from the query above)
+    BOOST_CHECK(checker.StateFor(blocks.back()) == ThresholdState::EXPIRED);
+    BOOST_CHECK_EQUAL(checker.StateSinceHeightFor(blocks.back()), 720);
+
+    cleanup();
+}
+
+BOOST_AUTO_TEST_CASE(versionbits_expired_with_max_activation_height)
+{
+    // Test interaction: deployment with BOTH max_activation_height AND active_duration.
+    // max_activation_height forces LOCKED_IN, then active_duration causes EXPIRED.
+    //
+    // period=144, max_activation_height=432, active_duration=288
+    // - Period 0 (0-143): DEFINED
+    // - Period 1 (144-287): STARTED (no signaling, but forced LOCKED_IN at boundary
+    //   because 288 >= 432 - 144)
+    // - Period 2 (288-431): LOCKED_IN
+    // - Period 3 (432-575): ACTIVE (activation_height=432)
+    // - Period 4 (576-719): ACTIVE
+    // - At pindexPrev=719: EXPIRED (720 >= 432 + 288)
+
+    std::vector<CBlockIndex*> blocks;
+    auto cleanup = [&blocks]() {
+        for (auto* b : blocks) delete b;
+        blocks.clear();
+    };
+
+    const auto dep = MakeTemporaryDeployment(288, /*max_activation_height=*/432);
+    TestConditionChecker checker(dep);
+
+    auto mine_block = [&blocks](int32_t nVersion) -> CBlockIndex* {
+        CBlockIndex* pindex = new CBlockIndex();
+        pindex->nHeight = blocks.size();
+        pindex->pprev = blocks.empty() ? nullptr : blocks.back();
+        pindex->nTime = 1415926536 + 600 * pindex->nHeight;
+        pindex->nVersion = nVersion;
+        pindex->BuildSkip();
+        blocks.push_back(pindex);
+        return pindex;
+    };
+
+    // Period 0: DEFINED (0-143), no signaling
+    for (int i = 0; i < 144; i++) mine_block(0);
+    BOOST_CHECK(checker.StateFor(blocks.back()) == ThresholdState::STARTED);
+
+    // Period 1: STARTED (144-287), no signaling — forced LOCKED_IN by max_activation_height
+    for (int i = 0; i < 144; i++) mine_block(0);
+    BOOST_CHECK(checker.StateFor(blocks.back()) == ThresholdState::LOCKED_IN);
+    BOOST_CHECK_EQUAL(checker.StateSinceHeightFor(blocks.back()), 288);
+
+    // Period 2: LOCKED_IN (288-431)
+    for (int i = 0; i < 144; i++) mine_block(0);
+    BOOST_CHECK(checker.StateFor(blocks.back()) == ThresholdState::ACTIVE);
+    BOOST_CHECK_EQUAL(checker.StateSinceHeightFor(blocks.back()), 432);
+
+    // Period 3: ACTIVE (432-575)
+    for (int i = 0; i < 144; i++) mine_block(0);
+    BOOST_CHECK(checker.StateFor(blocks.back()) == ThresholdState::ACTIVE);
+
+    // Period 4: (576-719) -> EXPIRED at 720
+    for (int i = 0; i < 144; i++) mine_block(0);
+    BOOST_CHECK(checker.StateFor(blocks.back()) == ThresholdState::EXPIRED);
+    BOOST_CHECK_EQUAL(checker.StateSinceHeightFor(blocks.back()), 720);
+
+    cleanup();
+}
+
+BOOST_AUTO_TEST_CASE(versionbits_expired_zero_duration)
+{
+    // Test active_duration = 0. This means the deployment expires immediately
+    // after activation — zero blocks of enforcement.
+    // Activation at 432, so 432 + 0 = 432. At pindexPrev=431 (end of LOCKED_IN),
+    // state for 432+: LOCKED_IN transitions to ACTIVE, sets activation_height=432.
+    // But that's computed for this period boundary. The ACTIVE->EXPIRED check
+    // happens on the NEXT iteration of the walk-forward.
+    // At pindexPrev=575 (end of period 3): 576 >= 432 + 0 = 432 -> EXPIRED.
+    // So active_duration=0 gives exactly one period of ACTIVE, same as
+    // active_duration=144 with period=144 (since transitions are per-period).
+
+    std::vector<CBlockIndex*> blocks;
+    auto cleanup = [&blocks]() {
+        for (auto* b : blocks) delete b;
+        blocks.clear();
+    };
+
+    const auto dep = MakeTemporaryDeployment(0);
+    TestConditionChecker checker(dep);
+
+    auto mine_block = [&blocks](int32_t nVersion) -> CBlockIndex* {
+        CBlockIndex* pindex = new CBlockIndex();
+        pindex->nHeight = blocks.size();
+        pindex->pprev = blocks.empty() ? nullptr : blocks.back();
+        pindex->nTime = 1415926536 + 600 * pindex->nHeight;
+        pindex->nVersion = nVersion;
+        pindex->BuildSkip();
+        blocks.push_back(pindex);
+        return pindex;
+    };
+
+    // Period 0: DEFINED (0-143)
+    for (int i = 0; i < 144; i++) mine_block(0);
+    // Period 1: Signal (144-287)
+    for (int i = 0; i < 144; i++) mine_block(VERSIONBITS_TOP_BITS | 0x100);
+    BOOST_CHECK(checker.StateFor(blocks.back()) == ThresholdState::LOCKED_IN);
+
+    // Period 2: LOCKED_IN (288-431) -> ACTIVE at 432
+    for (int i = 0; i < 144; i++) mine_block(0);
+    BOOST_CHECK(checker.StateFor(blocks.back()) == ThresholdState::ACTIVE);
+    BOOST_CHECK_EQUAL(checker.StateSinceHeightFor(blocks.back()), 432);
+
+    // Period 3 (432-575): ACTIVE, but 576 >= 432+0 -> EXPIRED at next boundary
+    for (int i = 0; i < 144; i++) mine_block(0);
+    BOOST_CHECK(checker.StateFor(blocks.back()) == ThresholdState::EXPIRED);
+    BOOST_CHECK_EQUAL(checker.StateSinceHeightFor(blocks.back()), 576);
+
+    cleanup();
+}
+
+BOOST_AUTO_TEST_CASE(versionbits_no_signaling_after_expired)
+{
+    // Test that ComputeBlockVersion does NOT set the deployment bit after EXPIRED.
+    // Uses regtest with testdummy deployment configured with active_duration.
+    //
+    // ComputeBlockVersion only signals for STARTED and LOCKED_IN states.
+    // After EXPIRED, the bit should not be set.
+
+    ArgsManager args;
+    // testdummy: start=0, timeout=never, min_height=0, max_height=INT_MAX, active_duration=144
+    args.ForceSetArg("-vbparams", "testdummy:0:9223372036854775807:0:2147483647:144");
+    const auto chainParams = CreateChainParams(args, ChainType::REGTEST);
+    const auto& params = chainParams->GetConsensus();
+
+    VersionBitsCache vbcache;
+    const auto dep = Consensus::DEPLOYMENT_TESTDUMMY;
+    TestConditionChecker checker(params.vDeployments[dep]);
+    const uint32_t bitmask = uint32_t{1} << params.vDeployments[dep].bit;
+    const int period = params.vDeployments[dep].period;
+
+    std::vector<CBlockIndex*> blocks;
+    auto cleanup = [&blocks]() {
+        for (auto* b : blocks) delete b;
+        blocks.clear();
+    };
+
+    auto mine_block = [&blocks](int32_t nVersion) -> CBlockIndex* {
+        CBlockIndex* pindex = new CBlockIndex();
+        pindex->nHeight = blocks.size();
+        pindex->pprev = blocks.empty() ? nullptr : blocks.back();
+        pindex->nTime = 1415926536 + 600 * pindex->nHeight;
+        pindex->nVersion = nVersion;
+        pindex->BuildSkip();
+        blocks.push_back(pindex);
+        return pindex;
+    };
+
+    // Period 0: DEFINED (0-143) — bit should not be set
+    for (int i = 0; i < period; i++) mine_block(VERSIONBITS_TOP_BITS);
+    BOOST_CHECK_EQUAL(vbcache.ComputeBlockVersion(blocks.back(), params) & bitmask, bitmask); // STARTED, bit set
+
+    // Period 1: STARTED — signal to lock in (144-287), bit should be set
+    for (int i = 0; i < period; i++) mine_block(VERSIONBITS_TOP_BITS | bitmask);
+    BOOST_CHECK(checker.StateFor(blocks.back()) == ThresholdState::LOCKED_IN);
+    BOOST_CHECK_EQUAL(vbcache.ComputeBlockVersion(blocks.back(), params) & bitmask, bitmask); // LOCKED_IN, bit set
+
+    // Period 2: LOCKED_IN (288-431), bit should be set
+    for (int i = 0; i < period; i++) mine_block(VERSIONBITS_TOP_BITS | bitmask);
+    BOOST_CHECK(checker.StateFor(blocks.back()) == ThresholdState::ACTIVE);
+    // ACTIVE: bit should NOT be set
+    BOOST_CHECK_EQUAL(vbcache.ComputeBlockVersion(blocks.back(), params) & bitmask, 0u);
+
+    // Period 3: ACTIVE (432-575)
+    for (int i = 0; i < period; i++) mine_block(VERSIONBITS_TOP_BITS);
+    BOOST_CHECK(checker.StateFor(blocks.back()) == ThresholdState::EXPIRED);
+    // EXPIRED: bit should NOT be set
+    BOOST_CHECK_EQUAL(vbcache.ComputeBlockVersion(blocks.back(), params) & bitmask, 0u);
+
+    // Period 4: EXPIRED (576+) — verify bit stays off
+    for (int i = 0; i < period; i++) mine_block(VERSIONBITS_TOP_BITS);
+    BOOST_CHECK(checker.StateFor(blocks.back()) == ThresholdState::EXPIRED);
+    BOOST_CHECK_EQUAL(vbcache.ComputeBlockVersion(blocks.back(), params) & bitmask, 0u);
+
+    cleanup();
+}
+
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index bfff18168327..0afbc1bada14 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -534,7 +534,9 @@ void CTxMemPool::check(const CCoinsViewCache& active_coins_tip, int64_t spendhei
         TxValidationState dummy_state; // Not used. CheckTxInputs() should always pass
         CAmount txfee = 0;
         assert(!tx.IsCoinBase());
-        assert(Consensus::CheckTxInputs(tx, dummy_state, mempoolDuplicate, spendheight, txfee));
+        // 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));
         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 5c02ec2341cd..dc027070e3de 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -18,6 +18,7 @@
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
 #include <cuckoocache.h>
+#include <deploymentinfo.h>
 #include <flatfile.h>
 #include <hash.h>
 #include <kernel/chainparams.h>
@@ -141,7 +142,8 @@ bool CheckInputScripts(const CTransaction& tx, TxValidationState& state,
                        const CCoinsViewCache& inputs, script_verify_flags flags, bool cacheSigStore,
                        bool cacheFullScriptStore, PrecomputedTransactionData& txdata,
                        ValidationCache& validation_cache,
-                       std::vector<CScriptCheck>* pvChecks = nullptr)
+                       std::vector<CScriptCheck>* pvChecks = nullptr,
+                       const std::vector<script_verify_flags>& flags_per_input = {})
                        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
 bool CheckFinalTxAtTip(const CBlockIndex& active_chain_tip, const CTransaction& tx)
@@ -889,7 +891,7 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
     }
 
     // The mempool holds txs for the next block, so pass height+1 to CheckTxInputs
-    if (!Consensus::CheckTxInputs(tx, state, m_view, m_active_chainstate.m_chain.Height() + 1, ws.m_base_fees)) {
+    if (!Consensus::CheckTxInputs(tx, state, m_view, m_active_chainstate.m_chain.Height() + 1, ws.m_base_fees, CheckTxInputsRules::OutputSizeLimit)) {
         return false; // state filled in by CheckTxInputs
     }
 
@@ -2042,6 +2044,10 @@ ValidationCache::ValidationCache(const size_t script_execution_cache_bytes, cons
  * This involves ECDSA signature checks so can be computationally intensive. This function should
  * only be called after the cheap sanity checks in CheckTxInputs passed.
  *
+ * WARNING: flags_per_input deviations from flags must be handled with care. It should only be more
+ * relaxed than flags, never stricter (or a cached result could be wrong). Do not provide
+ * flags_per_input if every input uses the same flags, or the result will not be cached.
+ *
  * If pvChecks is not nullptr, script checks are pushed onto it instead of being performed inline. Any
  * script checks which are not necessary (eg due to script execution cache hits) are, obviously,
  * not pushed onto pvChecks/run.
@@ -2059,7 +2065,8 @@ bool CheckInputScripts(const CTransaction& tx, TxValidationState& state,
                        const CCoinsViewCache& inputs, script_verify_flags flags, bool cacheSigStore,
                        bool cacheFullScriptStore, PrecomputedTransactionData& txdata,
                        ValidationCache& validation_cache,
-                       std::vector<CScriptCheck>* pvChecks)
+                       std::vector<CScriptCheck>* pvChecks,
+                       const std::vector<script_verify_flags>& flags_per_input)
 {
     if (tx.IsCoinBase()) return true;
 
@@ -2093,8 +2100,10 @@ bool CheckInputScripts(const CTransaction& tx, TxValidationState& state,
         txdata.Init(tx, std::move(spent_outputs));
     }
     assert(txdata.m_spent_outputs.size() == tx.vin.size());
+    assert(flags_per_input.empty() || flags_per_input.size() == tx.vin.size());
 
     for (unsigned int i = 0; i < tx.vin.size(); i++) {
+        if (!flags_per_input.empty()) flags = flags_per_input[i];
 
         // We very carefully only pass in things to CScriptCheck which
         // are clearly committed to by tx' witness hash. This provides
@@ -2121,7 +2130,7 @@ bool CheckInputScripts(const CTransaction& tx, TxValidationState& state,
         }
     }
 
-    if (cacheFullScriptStore && !pvChecks) {
+    if (cacheFullScriptStore && (!pvChecks) && flags_per_input.empty()) {
         // We executed all of the provided scripts, and were told to
         // cache the result. Do so now.
         validation_cache.m_script_execution_cache.insert(hashCacheEntry);
@@ -2282,9 +2291,14 @@ script_verify_flags GetBlockScriptFlags(const CBlockIndex& block_index, const Ch
         flags |= SCRIPT_VERIFY_NULLDUMMY;
     }
 
+    if (DeploymentActiveAt(block_index, chainman, Consensus::DEPLOYMENT_REDUCED_DATA)) {
+        flags |= REDUCED_DATA_MANDATORY_VERIFY_FLAGS;
+    }
+
     return flags;
 }
 
+static bool ContextualCheckBlockHeaderVolatile(const CBlockHeader& block, BlockValidationState& state, const ChainstateManager& chainman, const CBlockIndex* pindexPrev) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
 /** Apply the effects of this block (with given index) on the UTXO set represented by coins.
  *  Validity checks that depend on the UTXO set are also done; ConnectBlock()
@@ -2329,6 +2343,11 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
     uint256 hashPrevBlock = pindex->pprev == nullptr ? uint256() : pindex->pprev->GetBlockHash();
     assert(hashPrevBlock == view.GetBestBlock());
 
+    if (!ContextualCheckBlockHeaderVolatile(block, state, m_chainman, pindex->pprev)) {
+        LogError("%s: Consensus::ContextualCheckBlockHeaderVolatile: %s\n", __func__, state.ToString());
+        return false;
+    }
+
     m_chainman.num_blocks_total++;
 
     // Special case for the genesis block, skipping connection of its transactions
@@ -2513,11 +2532,31 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
 
     std::vector<PrecomputedTransactionData> txsdata(block.vtx.size());
 
+    // For BIP9 deployments, get the activation height dynamically
+    const auto reduced_data_start_height = [&]() -> int {
+        if (!DeploymentActiveAt(*pindex, m_chainman, Consensus::DEPLOYMENT_REDUCED_DATA)) return std::numeric_limits<int>::max();
+        auto info = m_chainman.m_versionbitscache.Info(*pindex, params.GetConsensus(), Consensus::DEPLOYMENT_REDUCED_DATA);
+        return info.active_since.value_or(std::numeric_limits<int>::max());
+    }();
+
+    const CheckTxInputsRules chk_input_rules{DeploymentActiveAt(*pindex, m_chainman, Consensus::DEPLOYMENT_REDUCED_DATA) ? CheckTxInputsRules::OutputSizeLimit : CheckTxInputsRules::None};
+
+    // Check generation tx output sizes if REDUCED_DATA is active
+    if (chk_input_rules.test(CheckTxInputsRules::OutputSizeLimit)) {
+        TxValidationState tx_state;
+        if (!Consensus::CheckOutputSizes(*block.vtx[0], tx_state)) {
+            return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
+                                 tx_state.GetRejectReason(),
+                                 tx_state.GetDebugMessage() + " in generation tx " + block.vtx[0]->GetHash().ToString());
+        }
+    }
+
     std::vector<int> prevheights;
     CAmount nFees = 0;
     int nInputs = 0;
     int64_t nSigOpsCost = 0;
     blockundo.vtxundo.reserve(block.vtx.size() - 1);
+    std::vector<script_verify_flags> flags_per_input;
     for (unsigned int i = 0; i < block.vtx.size(); i++)
     {
         if (!state.IsValid()) break;
@@ -2529,7 +2568,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)) {
+            if (!Consensus::CheckTxInputs(tx, tx_state, view, pindex->nHeight, txfee, chk_input_rules)) {
                 // Any transaction validation failure in ConnectBlock is a block consensus failure
                 state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                               tx_state.GetRejectReason(),
@@ -2547,8 +2586,13 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
             // BIP68 lock checks (as opposed to nLockTime checks) must
             // be in ConnectBlock because they require the UTXO set
             prevheights.resize(tx.vin.size());
+            flags_per_input.clear();
             for (size_t j = 0; j < tx.vin.size(); j++) {
                 prevheights[j] = view.AccessCoin(tx.vin[j].prevout).nHeight;
+                if (prevheights[j] < reduced_data_start_height) {
+                    flags_per_input.resize(tx.vin.size(), flags);
+                    flags_per_input[j] = flags & ~REDUCED_DATA_MANDATORY_VERIFY_FLAGS;
+                }
             }
 
             if (!SequenceLocks(tx, nLockTimeFlags, prevheights, *pindex)) {
@@ -2577,10 +2621,10 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
             // they need to be added to control which runs them asynchronously. Otherwise, CheckInputScripts runs the checks before returning.
             if (control) {
                 std::vector<CScriptCheck> vChecks;
-                tx_ok = CheckInputScripts(tx, tx_state, view, flags, fCacheResults, fCacheResults, txsdata[i], m_chainman.m_validation_cache, &vChecks);
+                tx_ok = CheckInputScripts(tx, tx_state, view, flags, fCacheResults, fCacheResults, txsdata[i], m_chainman.m_validation_cache, &vChecks, flags_per_input);
                 if (tx_ok) control->Add(std::move(vChecks));
             } else {
-                tx_ok = CheckInputScripts(tx, tx_state, view, flags, fCacheResults, fCacheResults, txsdata[i], m_chainman.m_validation_cache);
+                tx_ok = CheckInputScripts(tx, tx_state, view, flags, fCacheResults, fCacheResults, txsdata[i], m_chainman.m_validation_cache, nullptr, flags_per_input);
             }
             if (!tx_ok) {
                 // Any transaction validation failure in ConnectBlock is a block consensus failure
@@ -4149,6 +4193,37 @@ static bool ContextualCheckBlockHeader(const CBlockHeader& block, BlockValidatio
                                  strprintf("rejected nVersion=0x%08x block", block.nVersion));
     }
 
+    if (!ContextualCheckBlockHeaderVolatile(block, state, chainman, pindexPrev)) return false;
+
+    return true;
+}
+
+/** Context-dependent validity checks, but rechecked in ConnectBlock().
+ *  Note that -reindex-chainstate skips the validation that happens here!
+ */
+static bool ContextualCheckBlockHeaderVolatile(const CBlockHeader& block, BlockValidationState& state, const ChainstateManager& chainman, const CBlockIndex* pindexPrev) EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
+{
+    const Consensus::Params& consensusParams = chainman.GetConsensus();
+
+    // Mandatory signaling for deployments approaching max_activation_height
+    for (int i = 0; i < (int)Consensus::MAX_VERSION_BITS_DEPLOYMENTS; i++) {
+        const Consensus::DeploymentPos pos = static_cast<Consensus::DeploymentPos>(i);
+
+        if (chainman.m_versionbitscache.MustSignal(pindexPrev, consensusParams, pos)) {
+            const auto& deployment = consensusParams.vDeployments[pos];
+            const bool fVersionBits = (block.nVersion & VERSIONBITS_TOP_MASK) == VERSIONBITS_TOP_BITS;
+            const bool fDeploymentBit = (block.nVersion & (uint32_t{1} << deployment.bit)) != 0;
+
+            if (!(fVersionBits && fDeploymentBit)) {
+                const std::string deployment_name = VersionBitsDeploymentInfo[i].name;
+                return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
+                                   "bad-version-" + deployment_name,
+                                   strprintf("Block must signal for %s approaching max_activation_height=%d",
+                                           deployment_name, deployment.max_activation_height));
+            }
+        }
+    }
+
     return true;
 }
 
diff --git a/src/versionbits.cpp b/src/versionbits.cpp
index e282d21d2e5f..aa7f7caa780a 100644
--- a/src/versionbits.cpp
+++ b/src/versionbits.cpp
@@ -19,15 +19,19 @@ std::string StateName(ThresholdState state)
     case LOCKED_IN: return "locked_in";
     case ACTIVE: return "active";
     case FAILED: return "failed";
+    case EXPIRED: return "expired";
     }
     return "invalid";
 }
 
+// NOLINTBEGIN(misc-no-recursion)
 ThresholdState AbstractThresholdConditionChecker::GetStateFor(const CBlockIndex* pindexPrev, ThresholdConditionCache& cache) const
 {
     int nPeriod = Period();
     int nThreshold = Threshold();
     int min_activation_height = MinActivationHeight();
+    int max_activation_height = MaxActivationHeight();
+    int active_duration = ActiveDuration();
     int64_t nTimeStart = BeginTime();
     int64_t nTimeTimeout = EndTime();
 
@@ -67,6 +71,23 @@ ThresholdState AbstractThresholdConditionChecker::GetStateFor(const CBlockIndex*
     assert(cache.contains(pindexPrev));
     ThresholdState state = cache[pindexPrev];
 
+    // Everything is already cached. Return immediately.
+    if (vToCompute.empty()) {
+        return state;
+    }
+
+    // For temporary deployments, we need to know when ACTIVE started to determine the
+    // ACTIVE -> EXPIRED transition. We get this by calling GetStateSinceHeightFor, which
+    // internally calls GetStateFor on earlier periods. Those calls could recurse back here
+    // and call GetStateSinceHeightFor again, but the early return above prevents this:
+    // the walk-back above guarantees all periods before pindexPrev are already cached,
+    // and GetStateSinceHeightFor only walks backwards, so its GetStateFor calls always hit
+    // the cache, have empty vToCompute, and return immediately via the early return.
+    int activation_height = 0;
+    if (state == ThresholdState::ACTIVE && active_duration < std::numeric_limits<int>::max()) {
+        activation_height = GetStateSinceHeightFor(pindexPrev, cache);
+    }
+
     // Now walk forward and compute the state of descendants of pindexPrev
     while (!vToCompute.empty()) {
         ThresholdState stateNext = state;
@@ -91,8 +112,15 @@ ThresholdState AbstractThresholdConditionChecker::GetStateFor(const CBlockIndex*
                     pindexCount = pindexCount->pprev;
                 }
                 if (count >= nThreshold) {
+                    // Normal BIP9 activation via signaling
+                    stateNext = ThresholdState::LOCKED_IN;
+                } else if (max_activation_height < std::numeric_limits<int>::max() && pindexPrev->nHeight + 1 >= max_activation_height - nPeriod) {
+                    // Force LOCKED_IN one period before max_activation_height
+                    // This ensures activation happens AT max_activation_height (not one period later)
+                    // Overrides timeout to guarantee activation
                     stateNext = ThresholdState::LOCKED_IN;
                 } else if (pindexPrev->GetMedianTimePast() >= nTimeTimeout) {
+                    // Timeout without activation
                     stateNext = ThresholdState::FAILED;
                 }
                 break;
@@ -101,11 +129,21 @@ ThresholdState AbstractThresholdConditionChecker::GetStateFor(const CBlockIndex*
                 // Progresses into ACTIVE provided activation height will have been reached.
                 if (pindexPrev->nHeight + 1 >= min_activation_height) {
                     stateNext = ThresholdState::ACTIVE;
+                    if (active_duration < std::numeric_limits<int>::max()) {
+                        activation_height = pindexPrev->nHeight + 1;
+                    }
                 }
                 break;
             }
-            case ThresholdState::FAILED:
             case ThresholdState::ACTIVE: {
+                if (active_duration < std::numeric_limits<int>::max() &&
+                    pindexPrev->nHeight + 1 >= activation_height + active_duration) {
+                    stateNext = ThresholdState::EXPIRED;
+                }
+                break;
+            }
+            case ThresholdState::FAILED:
+            case ThresholdState::EXPIRED: {
                 // Nothing happens, these are terminal states.
                 break;
             }
@@ -115,6 +153,7 @@ ThresholdState AbstractThresholdConditionChecker::GetStateFor(const CBlockIndex*
 
     return state;
 }
+// NOLINTEND(misc-no-recursion)
 
 BIP9Stats AbstractThresholdConditionChecker::GetStateStatisticsFor(const CBlockIndex* pindex, std::vector<bool>* signalling_blocks) const
 {
@@ -154,6 +193,13 @@ BIP9Stats AbstractThresholdConditionChecker::GetStateStatisticsFor(const CBlockI
     return stats;
 }
 
+// WARNING: This function is called from GetStateFor and calls GetStateFor in turn.
+// The recursion is safe because this function calls GetStateFor first (which populates
+// the cache), then only walks BACKWARDS through periods that are now cached. GetStateFor
+// returns immediately for cached entries (via the early return when vToCompute is empty).
+// If the backwards walk is ever changed to query uncached periods, infinite recursion
+// will result.
+// NOLINTBEGIN(misc-no-recursion)
 int AbstractThresholdConditionChecker::GetStateSinceHeightFor(const CBlockIndex* pindexPrev, ThresholdConditionCache& cache) const
 {
     int64_t start_time = BeginTime();
@@ -188,6 +234,7 @@ int AbstractThresholdConditionChecker::GetStateSinceHeightFor(const CBlockIndex*
     // Adjust the result because right now we point to the parent block.
     return pindexPrev->nHeight + 1;
 }
+// NOLINTEND(misc-no-recursion)
 
 BIP9Info VersionBitsCache::Info(const CBlockIndex& block_index, const Consensus::Params& params, Consensus::DeploymentPos id)
 {
@@ -240,10 +287,21 @@ BIP9GBTStatus VersionBitsCache::GBTStatus(const CBlockIndex& block_index, const
         switch (state) {
         case DEFINED:
         case FAILED:
+        case EXPIRED:
             // Not exposed to GBT
             break;
         case STARTED:
             result.signalling.try_emplace(vbdepinfo.name, gbtinfo);
+            {
+                const auto& dep = params.vDeployments[pos];
+                if (dep.max_activation_height < std::numeric_limits<int>::max()) {
+                    const int nHeight = block_index.nHeight + 1;
+                    if (nHeight >= dep.max_activation_height - (2 * (int)dep.period)
+                        && nHeight < dep.max_activation_height - (int)dep.period) {
+                        result.vbrequired |= checker.Mask();
+                    }
+                }
+            }
             break;
         case LOCKED_IN:
             result.locked_in.try_emplace(vbdepinfo.name, gbtinfo);
@@ -262,6 +320,18 @@ bool VersionBitsCache::IsActiveAfter(const CBlockIndex* pindexPrev, const Consen
     return ThresholdState::ACTIVE == VersionBitsConditionChecker(params, pos).GetStateFor(pindexPrev, m_caches[pos]);
 }
 
+bool VersionBitsCache::MustSignal(const CBlockIndex* pindexPrev, const Consensus::Params& params, Consensus::DeploymentPos pos)
+{
+    LOCK(m_mutex);
+    const auto& dep = params.vDeployments[pos];
+    if (dep.max_activation_height >= std::numeric_limits<int>::max()) return false;
+    VersionBitsConditionChecker checker(params, pos);
+    if (STARTED != checker.GetStateFor(pindexPrev, m_caches[pos])) return false;
+    const int nHeight = pindexPrev == nullptr ? 0 : pindexPrev->nHeight + 1;
+    return nHeight >= dep.max_activation_height - (2 * (int)dep.period)
+        && nHeight < dep.max_activation_height - (int)dep.period;
+}
+
 static int32_t ComputeBlockVersion(const CBlockIndex* pindexPrev, const Consensus::Params& params, std::array<ThresholdConditionCache, Consensus::MAX_VERSION_BITS_DEPLOYMENTS>& caches)
 {
     int32_t nVersion = VERSIONBITS_TOP_BITS;
diff --git a/src/versionbits.h b/src/versionbits.h
index 59b0cbeee716..ea505822d1d4 100644
--- a/src/versionbits.h
+++ b/src/versionbits.h
@@ -69,6 +69,7 @@ struct BIP9GBTStatus {
         bool gbt_optional_rule;
     };
     std::map<std::string, const Info, std::less<>> signalling, locked_in, active;
+    uint32_t vbrequired{0};
 };
 
 /** BIP 9 allows multiple softforks to be deployed in parallel. We cache
@@ -85,9 +86,12 @@ class VersionBitsCache
 
     BIP9GBTStatus GBTStatus(const CBlockIndex& block_index, const Consensus::Params& params) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
 
-    /** Get the BIP9 state for a given deployment for the block after pindexPrev. */
+    /** Check if a deployment is active for the block after pindexPrev. */
     bool IsActiveAfter(const CBlockIndex* pindexPrev, const Consensus::Params& params, Consensus::DeploymentPos pos) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
 
+    /** Check if mandatory signaling is required for a deployment at the block after pindexPrev. */
+    bool MustSignal(const CBlockIndex* pindexPrev, const Consensus::Params& params, Consensus::DeploymentPos pos) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
+
     /** Determine what nVersion a new block should use */
     int32_t ComputeBlockVersion(const CBlockIndex* pindexPrev, const Consensus::Params& params) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
 
diff --git a/src/versionbits_impl.h b/src/versionbits_impl.h
index bd59bf73d885..c3dfaabcdd23 100644
--- a/src/versionbits_impl.h
+++ b/src/versionbits_impl.h
@@ -9,6 +9,8 @@
 #include <sync.h>
 #include <versionbits.h>
 
+#include <limits>
+
 /** BIP 9 defines a finite-state-machine to deploy a softfork in multiple stages.
  *  State transitions happen during retarget period if conditions are met
  *  In case of reorg, transitions can go backward. Without transition, state is
@@ -18,8 +20,9 @@ enum class ThresholdState : uint8_t {
     DEFINED,   // First state that each softfork starts out as. The genesis block is by definition in this state for each deployment.
     STARTED,   // For blocks past the starttime.
     LOCKED_IN, // For at least one retarget period after the first retarget period with STARTED blocks of which at least threshold have the associated bit set in nVersion, until min_activation_height is reached.
-    ACTIVE,    // For all blocks after the LOCKED_IN retarget period (final state)
+    ACTIVE,    // For all blocks after the LOCKED_IN retarget period (final state for permanent deployments)
     FAILED,    // For all blocks once the first retarget period after the timeout time is hit, if LOCKED_IN wasn't already reached (final state)
+    EXPIRED,   // For temporary deployments: all blocks after active_duration periods past activation (final state)
 };
 
 /** Get a string with the state name */
@@ -34,6 +37,8 @@ class AbstractThresholdConditionChecker {
     virtual int64_t BeginTime() const =0;
     virtual int64_t EndTime() const =0;
     virtual int MinActivationHeight() const { return 0; }
+    virtual int MaxActivationHeight() const { return std::numeric_limits<int>::max(); }
+    virtual int ActiveDuration() const { return std::numeric_limits<int>::max(); }
     virtual int Period() const =0;
     virtual int Threshold() const =0;
 
@@ -62,6 +67,8 @@ class VersionBitsConditionChecker : public AbstractThresholdConditionChecker {
     int64_t BeginTime() const override { return dep.nStartTime; }
     int64_t EndTime() const override { return dep.nTimeout; }
     int MinActivationHeight() const override { return dep.min_activation_height; }
+    int MaxActivationHeight() const override { return dep.max_activation_height; }
+    int ActiveDuration() const override { return dep.active_duration; }
     int Period() const override { return dep.period; }
     int Threshold() const override { return dep.threshold; }
 
diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
index 54f453623e93..e646128b114c 100644
--- a/src/wallet/test/wallet_tests.cpp
+++ b/src/wallet/test/wallet_tests.cpp
@@ -95,7 +95,7 @@ BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions, TestChain100Setup)
     // Cap last block file size, and mine new block in a new block file.
     CBlockIndex* oldTip = WITH_LOCK(Assert(m_node.chainman)->GetMutex(), return m_node.chainman->ActiveChain().Tip());
     WITH_LOCK(::cs_main, m_node.chainman->m_blockman.GetBlockFileInfo(oldTip->GetBlockPos().nFile)->nSize = MAX_BLOCKFILE_SIZE);
-    CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
+    CreateAndProcessBlock({}, GetScriptForDestination(PKHash(coinbaseKey.GetPubKey())));
     CBlockIndex* newTip = WITH_LOCK(Assert(m_node.chainman)->GetMutex(), return m_node.chainman->ActiveChain().Tip());
 
     // Verify ScanForWalletTransactions fails to read an unknown start block.
@@ -354,7 +354,7 @@ class ListCoinsTestingSetup : public TestChain100Setup
 public:
     ListCoinsTestingSetup()
     {
-        CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
+        CreateAndProcessBlock({}, GetScriptForDestination(PKHash(coinbaseKey.GetPubKey())));
         wallet = CreateSyncedWallet(*m_node.chain, WITH_LOCK(Assert(m_node.chainman)->GetMutex(), return m_node.chainman->ActiveChain()), coinbaseKey);
     }
 
@@ -378,7 +378,7 @@ class ListCoinsTestingSetup : public TestChain100Setup
             LOCK(wallet->cs_wallet);
             blocktx = CMutableTransaction(*wallet->mapWallet.at(tx->GetHash()).tx);
         }
-        CreateAndProcessBlock({CMutableTransaction(blocktx)}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
+        CreateAndProcessBlock({CMutableTransaction(blocktx)}, GetScriptForDestination(PKHash(coinbaseKey.GetPubKey())));
 
         LOCK(wallet->cs_wallet);
         LOCK(Assert(m_node.chainman)->GetMutex());
@@ -616,10 +616,10 @@ BOOST_FIXTURE_TEST_CASE(CreateWallet, TestChain100Setup)
         promise.get_future().wait();
     });
     std::string error;
-    m_coinbase_txns.push_back(CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]);
-    auto block_tx = TestSimpleSpend(*m_coinbase_txns[0], 0, coinbaseKey, GetScriptForRawPubKey(key.GetPubKey()));
-    m_coinbase_txns.push_back(CreateAndProcessBlock({block_tx}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]);
-    auto mempool_tx = TestSimpleSpend(*m_coinbase_txns[1], 0, coinbaseKey, GetScriptForRawPubKey(key.GetPubKey()));
+    m_coinbase_txns.push_back(CreateAndProcessBlock({}, GetScriptForDestination(PKHash(coinbaseKey.GetPubKey()))).vtx[0]);
+    auto block_tx = TestSimpleSpend(*m_coinbase_txns[0], 0, coinbaseKey, GetScriptForDestination(PKHash(key.GetPubKey())));
+    m_coinbase_txns.push_back(CreateAndProcessBlock({block_tx}, GetScriptForDestination(PKHash(coinbaseKey.GetPubKey()))).vtx[0]);
+    auto mempool_tx = TestSimpleSpend(*m_coinbase_txns[1], 0, coinbaseKey, GetScriptForDestination(PKHash(key.GetPubKey())));
     BOOST_CHECK(m_node.chain->broadcastTransaction(MakeTransactionRef(mempool_tx), DEFAULT_TRANSACTION_MAXFEE, node::TxBroadcast::MEMPOOL_NO_BROADCAST, error));
 
 
@@ -658,10 +658,10 @@ BOOST_FIXTURE_TEST_CASE(CreateWallet, TestChain100Setup)
     addtx_count = 0;
     auto handler = HandleLoadWallet(context, [&](std::unique_ptr<interfaces::Wallet> wallet) {
             BOOST_CHECK(rescan_completed);
-            m_coinbase_txns.push_back(CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]);
-            block_tx = TestSimpleSpend(*m_coinbase_txns[2], 0, coinbaseKey, GetScriptForRawPubKey(key.GetPubKey()));
-            m_coinbase_txns.push_back(CreateAndProcessBlock({block_tx}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]);
-            mempool_tx = TestSimpleSpend(*m_coinbase_txns[3], 0, coinbaseKey, GetScriptForRawPubKey(key.GetPubKey()));
+            m_coinbase_txns.push_back(CreateAndProcessBlock({}, GetScriptForDestination(PKHash(coinbaseKey.GetPubKey()))).vtx[0]);
+            block_tx = TestSimpleSpend(*m_coinbase_txns[2], 0, coinbaseKey, GetScriptForDestination(PKHash(key.GetPubKey())));
+            m_coinbase_txns.push_back(CreateAndProcessBlock({block_tx}, GetScriptForDestination(PKHash(coinbaseKey.GetPubKey()))).vtx[0]);
+            mempool_tx = TestSimpleSpend(*m_coinbase_txns[3], 0, coinbaseKey, GetScriptForDestination(PKHash(key.GetPubKey())));
             BOOST_CHECK(m_node.chain->broadcastTransaction(MakeTransactionRef(mempool_tx), DEFAULT_TRANSACTION_MAXFEE, node::TxBroadcast::MEMPOOL_NO_BROADCAST, error));
             m_node.validation_signals->SyncWithValidationInterfaceQueue();
         });
@@ -699,9 +699,9 @@ BOOST_FIXTURE_TEST_CASE(RemoveTxs, TestChain100Setup)
     AddKey(*wallet, key);
 
     std::string error;
-    m_coinbase_txns.push_back(CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]);
-    auto block_tx = TestSimpleSpend(*m_coinbase_txns[0], 0, coinbaseKey, GetScriptForRawPubKey(key.GetPubKey()));
-    CreateAndProcessBlock({block_tx}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
+    m_coinbase_txns.push_back(CreateAndProcessBlock({}, GetScriptForDestination(PKHash(coinbaseKey.GetPubKey()))).vtx[0]);
+    auto block_tx = TestSimpleSpend(*m_coinbase_txns[0], 0, coinbaseKey, GetScriptForDestination(PKHash(key.GetPubKey())));
+    CreateAndProcessBlock({block_tx}, GetScriptForDestination(PKHash(coinbaseKey.GetPubKey())));
 
     m_node.validation_signals->SyncWithValidationInterfaceQueue();
 
diff --git a/test/functional/data/invalid_txs.py b/test/functional/data/invalid_txs.py
index 3903bf9de4d0..084f48214918 100644
--- a/test/functional/data/invalid_txs.py
+++ b/test/functional/data/invalid_txs.py
@@ -238,10 +238,14 @@ class TooManySigopsPerBlock(BadTxTemplate):
     block_reject_reason = "bad-blk-sigops, out-of-bounds SigOpCount"
 
     def get_tx(self):
+        # Put OP_CHECKSIGs in scriptSig (input) instead of scriptPubKey (output)
+        # to avoid violating MAX_OUTPUT_SCRIPT_SIZE=34 consensus limit.
+        # Sigops are counted from both input and output scripts.
         lotsa_checksigs = CScript([OP_CHECKSIG] * (MAX_BLOCK_SIGOPS))
         return create_tx_with_script(
             self.spend_tx, 0,
-            output_script=lotsa_checksigs,
+            script_sig=lotsa_checksigs,
+            output_script=basic_p2sh,  # 23-byte P2SH, well under 34-byte limit
             amount=1)
 
 
@@ -250,10 +254,12 @@ class TooManySigopsPerTransaction(BadTxTemplate):
     valid_in_block = True
 
     def get_tx(self):
+        # Put sigops in scriptSig to avoid violating MAX_OUTPUT_SCRIPT_SIZE=34 limit
         lotsa_checksigs = CScript([OP_CHECKSIG] * (MAX_STANDARD_TX_SIGOPS + 1))
         return create_tx_with_script(
             self.spend_tx, 0,
-            output_script=lotsa_checksigs,
+            script_sig=lotsa_checksigs,
+            output_script=basic_p2sh,
             amount=1)
 
 
diff --git a/test/functional/feature_bip9_max_activation_height.py b/test/functional/feature_bip9_max_activation_height.py
new file mode 100755
index 000000000000..759d3adbee6d
--- /dev/null
+++ b/test/functional/feature_bip9_max_activation_height.py
@@ -0,0 +1,553 @@
+#!/usr/bin/env python3
+# Copyright (c) 2025 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Test max_activation_height for mandatory BIP9 activation.
+
+This test verifies that BIP9 deployments with max_activation_height properly
+activate at the specified height regardless of miner signaling, similar to BIP8.
+
+The test verifies four critical scenarios:
+1. Mandatory activation at max_height without signaling
+2. Normal deployment without max_height (requires signaling)
+3. Early activation via signaling before reaching max_height
+4. Max_height overrides timeout
+
+Expected behavior:
+- When max_activation_height is set and reached while in STARTED state,
+  the deployment transitions to LOCKED_IN (then ACTIVE) regardless of signaling
+- Max_activation_height overrides timeout
+- Once ACTIVE, the deployment remains ACTIVE permanently (terminal state)
+- Without max_activation_height, activation requires sufficient signaling
+"""
+
+from test_framework.blocktools import (
+    create_block,
+    create_coinbase,
+    add_witness_commitment,
+)
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import assert_equal
+
+TESTDUMMY_BIT = 28
+TESTDUMMY_MASK = 1 << TESTDUMMY_BIT
+VERSIONBITS_TOP_BITS = 0x20000000
+
+
+class MaxActivationHeightTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 6  # 6 nodes for tests 1-6 (test 0 validation is done separately)
+        self.setup_clean_chain = True
+        # NO_TIMEOUT = std::numeric_limits<int64_t>::max() = 9223372036854775807
+        NO_TIMEOUT = '9223372036854775807'
+        # INT_MAX = std::numeric_limits<int>::max() = 2147483647
+        INT_MAX = '2147483647'
+        self.extra_args = [
+            [f'-vbparams=testdummy:0:{NO_TIMEOUT}:0:576'],      # Test 1: max_height=576 (shows full flow)
+            ['-vbparams=testdummy:0:999999999999'],              # Test 2: no max_height (uses timeout)
+            [f'-vbparams=testdummy:0:{NO_TIMEOUT}:0:576'],      # Test 3: max_height=576 (early activation)
+            [f'-vbparams=testdummy:0:{NO_TIMEOUT}:0:432'],      # Test 4: verify permanent ACTIVE
+            [f'-vbparams=testdummy:0:{NO_TIMEOUT}:0:432:144'],  # Test 5: max_height + active_duration
+            [f'-vbparams=testdummy:0:999999999999:0:{INT_MAX}:{INT_MAX}:72'],  # Test 6: custom 50% threshold (72/144)
+        ]
+
+    def setup_network(self):
+        """Keep nodes isolated - don't connect them to each other"""
+        self.add_nodes(self.num_nodes)
+        for i in range(self.num_nodes):
+            self.start_node(i, extra_args=self.extra_args[i])
+        # Nodes remain disconnected for independent blockchain testing
+
+    def mine_blocks(self, node, count, signal=False):
+        """Mine count blocks, optionally signaling for testdummy."""
+        for i in range(count):
+            tip = node.getbestblockhash()
+            height = node.getblockcount() + 1
+            tip_header = node.getblockheader(tip)
+            block_time = tip_header['time'] + 1
+            block = create_block(int(tip, 16), create_coinbase(height), ntime=block_time)
+            if signal:
+                block.nVersion = VERSIONBITS_TOP_BITS | (1 << TESTDUMMY_BIT)
+            add_witness_commitment(block)
+            block.solve()
+            node.submitblock(block.serialize().hex())
+
+            # Log every 20 blocks and at key heights for debugging
+            if height % 20 == 0 or height == 143 or height == 144:
+                mtp = node.getblockheader(node.getbestblockhash())['mediantime']
+                self.log.info(f"  Block {height}: time={block_time}, MTP={mtp}")
+
+    def get_status(self, node):
+        """Get testdummy deployment status."""
+        info = node.getdeploymentinfo()
+        td = info['deployments']['testdummy']
+        if 'bip9' in td:
+            return td['bip9']['status'], td['bip9'].get('since', 0)
+        return td.get('status', 'unknown'), 0
+
+    def run_test(self):
+        # Test 0: Verify validation rejects both timeout and max_activation_height
+        self.log.info("=== TEST 0: Validation test - reject both timeout and max_activation_height ===")
+        self.log.info("Attempting to start bitcoind with both timeout and max_activation_height...")
+
+        # Run bitcoind directly with invalid config to test validation
+        import subprocess
+
+        # Get the bitcoind binary path from the test framework
+        bitcoind_path = self.binary_paths.bitcoind
+
+        # Create a temporary datadir for this test
+        import tempfile
+        with tempfile.TemporaryDirectory() as tmpdir:
+            try:
+                # Run bitcoind with invalid vbparams (both timeout and max_activation_height)
+                result = subprocess.run(
+                    [bitcoind_path, f'-datadir={tmpdir}', '-regtest',
+                     '-vbparams=testdummy:0:1:0:432'],  # timeout=1, max_activation_height=432
+                    capture_output=True,
+                    text=True,
+                    timeout=5
+                )
+
+                # If we get here with exit code 0, the validation failed
+                if result.returncode == 0:
+                    raise AssertionError("bitcoind should have failed to start with both timeout and max_activation_height")
+
+                # Check that the error message contains the expected validation error
+                error_output = result.stderr
+                self.log.info(f"bitcoind correctly failed with error: {error_output[:200]}")
+
+                assert "Cannot specify both timeout" in error_output and "max_activation_height" in error_output, \
+                    f"Expected validation error about both parameters, got: {error_output}"
+
+                self.log.info("SUCCESS: Validation correctly rejected invalid configuration")
+
+            except subprocess.TimeoutExpired:
+                raise AssertionError("bitcoind timed out (should have failed immediately with validation error)")
+
+        self.log.info("\n=== Test: max_activation_height=576 (full flow with non-mandatory period) ===")
+        node = self.nodes[0]
+
+        # Check deployment info to verify max_activation_height is set
+        info = node.getdeploymentinfo()
+        self.log.info(f"Deployment info: {info['deployments']['testdummy']}")
+
+        # Period 0 (0-143): DEFINED
+        self.log.info("\n--- Period 0 (blocks 0-143): DEFINED ---")
+        self.mine_blocks(node, 143, signal=False)
+        assert_equal(node.getblockcount(), 143)
+        status, since = self.get_status(node)
+        self.log.info(f"Block 143: Status={status}")
+        assert_equal(status, 'defined')
+
+        # Block 144: Transition to STARTED
+        self.log.info("\n--- Block 144: Transition to STARTED ---")
+        self.mine_blocks(node, 1, signal=False)
+        status, since = self.get_status(node)
+        self.log.info(f"Block 144: Status={status}, Since={since}")
+        assert_equal(status, 'started')
+        assert_equal(since, 144)
+
+        # GBT: vbrequired should NOT have TESTDUMMY bit (before enforcement window [288, 432))
+        gbt = node.getblocktemplate({"rules": ["segwit"]})
+        assert_equal(gbt['vbrequired'] & TESTDUMMY_MASK, 0)
+
+        # Period 1 (144-287): STARTED
+        self.log.info("\n--- Period 1 (blocks 145-287): STARTED ---")
+        self.mine_blocks(node, 143, signal=False)
+        assert_equal(node.getblockcount(), 287)
+        status, since = self.get_status(node)
+        self.log.info(f"Block 287: Status={status}")
+        assert_equal(status, 'started')
+
+        # GBT: vbrequired SHOULD have TESTDUMMY bit (next block 288 is in enforcement window [288, 432))
+        gbt = node.getblocktemplate({"rules": ["segwit"]})
+        assert_equal(gbt['vbrequired'] & TESTDUMMY_MASK, TESTDUMMY_MASK)
+
+        # Period 2 (288-431): STARTED - forced lock-in will occur at end of this period
+        self.log.info("\n--- Period 2 (blocks 288-431): STARTED ---")
+        self.log.info("Forced lock-in will occur at block 432 (max_activation_height - nPeriod)")
+
+        # Try to mine block 288 without signaling - should be REJECTED
+        self.log.info("\nNEGATIVE TEST: Attempting to mine block 288 without signaling...")
+        tip = node.getbestblockhash()
+        height = node.getblockcount() + 1
+        tip_header = node.getblockheader(tip)
+        block_time = tip_header['time'] + 1
+        block = create_block(int(tip, 16), create_coinbase(height), ntime=block_time)
+        block.nVersion = VERSIONBITS_TOP_BITS  # No signaling bit
+        add_witness_commitment(block)
+        block.solve()
+        result = node.submitblock(block.serialize().hex())
+        self.log.info(f"Submitblock result (should be rejected): {result}")
+        # Block should be rejected - check we're still at block 287
+        assert_equal(node.getblockcount(), 287)
+        self.log.info("SUCCESS: Block without signaling was correctly REJECTED during enforcement window")
+
+        # Now mine Period 2 with proper signaling (blocks 288-430)
+        self.log.info("\nMining blocks 288-430 with proper signaling...")
+        self.mine_blocks(node, 143, signal=True)
+        assert_equal(node.getblockcount(), 430)
+
+        # GBT: vbrequired SHOULD have TESTDUMMY bit (next block 431 is in enforcement window [288, 432))
+        gbt = node.getblocktemplate({"rules": ["segwit"]})
+        assert_equal(gbt['vbrequired'] & TESTDUMMY_MASK, TESTDUMMY_MASK)
+
+        # Try to mine block 431 without signaling - should be REJECTED (last block of enforcement window)
+        self.log.info("\nNEGATIVE TEST: Attempting to mine block 431 without signaling (upper boundary)...")
+        tip = node.getbestblockhash()
+        height = node.getblockcount() + 1
+        tip_header = node.getblockheader(tip)
+        block_time = tip_header['time'] + 1
+        block = create_block(int(tip, 16), create_coinbase(height), ntime=block_time)
+        block.nVersion = VERSIONBITS_TOP_BITS  # No signaling bit
+        add_witness_commitment(block)
+        block.solve()
+        result = node.submitblock(block.serialize().hex())
+        self.log.info(f"Submitblock result (should be rejected): {result}")
+        assert_equal(node.getblockcount(), 430)
+        self.log.info("SUCCESS: Block without signaling was correctly REJECTED at upper boundary of enforcement window")
+
+        # Mine block 431 with proper signaling
+        self.mine_blocks(node, 1, signal=True)
+        assert_equal(node.getblockcount(), 431)
+        status, since = self.get_status(node)
+        self.log.info(f"Block 431: Status={status}")
+        assert_equal(status, 'started')
+
+        # GBT: vbrequired should NOT have TESTDUMMY bit (next block 432 is outside enforcement window)
+        gbt = node.getblocktemplate({"rules": ["segwit"]})
+        assert_equal(gbt['vbrequired'] & TESTDUMMY_MASK, 0)
+
+        # status_next should be locked_in (forced lock-in at next period boundary)
+        info = node.getdeploymentinfo()
+        assert_equal(info['deployments']['testdummy']['bip9']['status_next'], 'locked_in')
+
+        # Period 3 (432-575): LOCKED_IN (forced by max_activation_height)
+        self.log.info("\n--- Period 3 (blocks 432-575): LOCKED_IN ---")
+        self.mine_blocks(node, 1, signal=False)  # Mine block 432
+        assert_equal(node.getblockcount(), 432)
+        status, since = self.get_status(node)
+        self.log.info(f"Block 432: Status={status}, Since={since}")
+        assert_equal(status, 'locked_in')
+        assert_equal(since, 432)
+
+        # Mine through period 3 to activate at block 576
+        self.log.info("Mining blocks 433-575...")
+        self.mine_blocks(node, 143, signal=False)
+        assert_equal(node.getblockcount(), 575)
+        status, since = self.get_status(node)
+        assert_equal(status, 'locked_in')
+
+        # status_next should be active (activation at next period boundary)
+        info = node.getdeploymentinfo()
+        assert_equal(info['deployments']['testdummy']['bip9']['status_next'], 'active')
+
+        # Period 4 (576+): ACTIVE
+        self.log.info("\n--- Period 4 (block 576+): ACTIVE ---")
+        self.mine_blocks(node, 1, signal=False)
+        assert_equal(node.getblockcount(), 576)
+        status, since = self.get_status(node)
+        self.log.info(f"Block 576: Status={status}, Since={since}")
+        assert_equal(status, 'active')
+        assert_equal(since, 576)
+
+        # RPC field assertions: max_activation_height present, height set, no height_end (permanent)
+        info = node.getdeploymentinfo()
+        td = info['deployments']['testdummy']
+        assert_equal(td['bip9']['max_activation_height'], 576)
+        assert_equal(td['height'], 576)
+        assert 'height_end' not in td
+
+        self.log.info("\n=== TEST 1 COMPLETE ===")
+        self.log.info("Summary: max_activation_height=576 test passed")
+        self.log.info("- Deployment activated at height 576 via forced lock-in at 432")
+        self.log.info("- Mandatory signaling enforced during blocks 288-431 (BIP148-style)")
+        self.log.info("- Non-signaling blocks rejected during enforcement window")
+        self.log.info("- Non-signaling blocks accepted outside enforcement window")
+
+        # Test 2: Deployment without max_height requires signaling
+        self.log.info("\n\n=== TEST 2: Deployment without max_height requires signaling ===")
+        node = self.nodes[1]
+
+        # Period 0 (0-143): DEFINED
+        self.log.info("\n--- Period 0 (blocks 0-143): DEFINED ---")
+        self.mine_blocks(node, 143, signal=False)
+        assert_equal(node.getblockcount(), 143)
+        status, since = self.get_status(node)
+        self.log.info(f"Block 143: Status={status}")
+        assert_equal(status, 'defined')
+
+        # Mine period 1 (blocks 144-287) without signaling - should transition to STARTED
+        self.log.info("Mining period 1 (blocks 144-287) without signaling...")
+        self.mine_blocks(node, 144, signal=False)
+        assert_equal(node.getblockcount(), 287)
+        status, since = self.get_status(node)
+        self.log.info(f"Block 287: Status={status}")
+        assert_equal(status, 'started')
+
+        # Mine period 2 (blocks 288-431) without signaling - should remain STARTED
+        self.log.info("Mining period 2 (blocks 288-431) without signaling...")
+        self.mine_blocks(node, 144, signal=False)
+        status, since = self.get_status(node)
+        self.log.info(f"Block 431: Status={status}")
+        assert_equal(status, 'started')  # Should NOT lock in without signaling
+
+        # Mine period 3 (blocks 432-575) without signaling - should remain STARTED
+        self.log.info("Mining period 3 (blocks 432-575) without signaling...")
+        self.mine_blocks(node, 144, signal=False)
+        status, since = self.get_status(node)
+        self.log.info(f"Block 575: Status={status}")
+        assert_equal(status, 'started')  # Still STARTED without signaling
+
+        # RPC field assertions: max_activation_height should be absent (no max_height)
+        info = node.getdeploymentinfo()
+        assert 'max_activation_height' not in info['deployments']['testdummy']['bip9']
+
+        self.log.info("\n=== TEST 2 COMPLETE ===")
+        self.log.info("SUCCESS: Deployment did NOT activate without signaling (no max_height)")
+
+        # Test 3: Early activation via signaling before max_height
+        self.log.info("\n\n=== TEST 3: Early activation via signaling before max_height ===")
+        node = self.nodes[2]
+
+        # Period 0 (0-143): DEFINED
+        self.log.info("\n--- Period 0 (blocks 0-143): DEFINED ---")
+        self.mine_blocks(node, 143, signal=False)
+        assert_equal(node.getblockcount(), 143)
+        status, since = self.get_status(node)
+        self.log.info(f"Block 143: Status={status}")
+        assert_equal(status, 'defined')
+
+        # Mine period 1 (blocks 144-287) with 100% signaling
+        self.log.info("Mining period 1 (blocks 144-287) with 100% signaling...")
+        self.mine_blocks(node, 144, signal=True)
+        assert_equal(node.getblockcount(), 287)
+        status, since = self.get_status(node)
+        self.log.info(f"Block 287: Status={status}")
+        assert_equal(status, 'started')
+
+        # Mine period 2 (blocks 288-431) with signaling - should lock in
+        self.log.info("Mining period 2 (blocks 288-431) with signaling - should lock in...")
+        self.mine_blocks(node, 144, signal=True)
+        assert_equal(node.getblockcount(), 431)
+        status, since = self.get_status(node)
+        self.log.info(f"Block 431: Status={status}, Since={since}")
+        assert_equal(status, 'locked_in')
+        assert_equal(since, 288)  # Locked in at start of period 2 via signaling threshold
+
+        # Mine block 432 - should activate via signaling (well before max_height 576)
+        self.log.info("Mining block 432 - should activate via signaling (before max_height 576)...")
+        self.mine_blocks(node, 1, signal=True)
+        assert_equal(node.getblockcount(), 432)
+        status, since = self.get_status(node)
+        self.log.info(f"Block 432: Status={status}, Since={since}")
+        assert_equal(status, 'active')
+        assert_equal(since, 432)
+
+        self.log.info("\n=== TEST 3 COMPLETE ===")
+        self.log.info("SUCCESS: Deployment activated early via signaling (at 432, before max_height 576)")
+
+        # Test 4: Verify ACTIVE state is permanent
+        self.log.info("\n\n=== TEST 4: Verify ACTIVE state is permanent ===")
+        node = self.nodes[3]
+
+        # Activate via max_height (max_height=432)
+        # Mine to block 143 (period 0) without signaling
+        self.log.info("Mining period 0 (blocks 0-143) without signaling...")
+        self.mine_blocks(node, 143, signal=False)
+        assert_equal(node.getblockcount(), 143)
+
+        # Mine through enforcement window (blocks 144-287) WITH signaling
+        # Enforcement window for max_height=432 is [144, 288)
+        self.log.info("Mining blocks 144-287 with signaling (enforcement window)...")
+        self.mine_blocks(node, 144, signal=True)
+        assert_equal(node.getblockcount(), 287)
+        status, since = self.get_status(node)
+        assert_equal(status, 'started')
+
+        # Mine period 2 (blocks 288-431) - will force lock-in at 288 (432 - 144)
+        self.log.info("Mining period 2 (blocks 288-431) - forced lock-in at end...")
+        self.mine_blocks(node, 144, signal=False)
+        assert_equal(node.getblockcount(), 431)
+        status, since = self.get_status(node)
+        assert_equal(status, 'locked_in')
+
+        # Mine block 432 - should activate
+        self.log.info("Mining block 432 - should activate via max_height...")
+        self.mine_blocks(node, 1, signal=False)
+        assert_equal(node.getblockcount(), 432)
+        status, since = self.get_status(node)
+        self.log.info(f"Block 432: Status={status}, Since={since}")
+        assert_equal(status, 'active')
+        assert_equal(since, 432)
+
+        # Mine 300 more blocks to verify permanence
+        self.log.info("Mining 300 more blocks to verify ACTIVE state persists...")
+        self.mine_blocks(node, 300, signal=False)
+        assert_equal(node.getblockcount(), 732)
+        status, since = self.get_status(node)
+        self.log.info(f"Block 732: Status={status}, Since={since}")
+        assert_equal(status, 'active')
+        assert_equal(since, 432)
+
+        self.log.info("\n=== TEST 4 COMPLETE ===")
+        self.log.info("SUCCESS: Deployment remains ACTIVE permanently")
+
+        # Test 5: Combined temporary deployment with max_height
+        self.log.info("\n\n=== TEST 5: Temporary deployment with max_height ===")
+        node = self.nodes[4]
+
+        # This node has max_activation_height=432 AND active_duration=144
+        # Should activate at 432 via max_height, then expire at 432+144=576
+        # Mine to block 143 (period 0) without signaling
+        self.log.info("Mining period 0 (blocks 0-143) without signaling...")
+        self.mine_blocks(node, 143, signal=False)
+        assert_equal(node.getblockcount(), 143)
+
+        # Mine through enforcement window (blocks 144-287) WITH signaling
+        # Enforcement window for max_height=432 is [144, 288)
+        self.log.info("Mining blocks 144-287 with signaling (enforcement window)...")
+        self.mine_blocks(node, 144, signal=True)
+        assert_equal(node.getblockcount(), 287)
+        status, since = self.get_status(node)
+        self.log.info(f"Block 287: Status={status}")
+        assert_equal(status, 'started')
+
+        # Mine period 2 (blocks 288-431) - will force lock-in at 288 (432 - 144)
+        self.log.info("Mining period 2 (blocks 288-431) - forced lock-in at end...")
+        self.mine_blocks(node, 144, signal=False)
+        assert_equal(node.getblockcount(), 431)
+        status, since = self.get_status(node)
+        self.log.info(f"Block 431: Status={status}")
+        assert_equal(status, 'locked_in')
+
+        # Mine block 432 - should activate via max_height
+        self.log.info("Mining block 432 - should activate via max_height...")
+        self.mine_blocks(node, 1, signal=False)
+        assert_equal(node.getblockcount(), 432)
+        status, since = self.get_status(node)
+        self.log.info(f"Block 432: Status={status}, Since={since}")
+        assert_equal(status, 'active')
+        assert_equal(since, 432)
+
+        # RPC field assertions: max_activation_height, height, and height_end for temporary deployment
+        info = node.getdeploymentinfo()
+        td = info['deployments']['testdummy']
+        assert_equal(td['bip9']['max_activation_height'], 432)
+        assert_equal(td['height'], 432)
+        assert_equal(td['height_end'], 575)  # 432 + 144 - 1
+
+        # Mine through active period to block 575 (432+144-1)
+        self.log.info("Mining through active period to block 575 (432+144-1)...")
+        self.mine_blocks(node, 143, signal=False)
+        assert_equal(node.getblockcount(), 575)
+        status, since = self.get_status(node)
+        self.log.info(f"Block 575: Status={status}")
+        assert_equal(status, 'active')
+
+        # status_next should be expired (expiry at next period boundary)
+        info = node.getdeploymentinfo()
+        assert_equal(info['deployments']['testdummy']['bip9']['status_next'], 'expired')
+
+        # Mine block 576 (432+144) - deployment has expired
+        # RPC status uses State(blockindex->pprev), so expired appears at tip 576
+        self.log.info("Mining block 576 (432+144) - deployment should be expired...")
+        self.mine_blocks(node, 1, signal=False)
+        assert_equal(node.getblockcount(), 576)
+        status, since = self.get_status(node)
+        self.log.info(f"Block 576: Status={status}, Since={since}")
+        assert_equal(status, 'expired')
+        assert_equal(since, 576)
+
+        # status_next should also be expired (terminal state)
+        info = node.getdeploymentinfo()
+        assert_equal(info['deployments']['testdummy']['bip9']['status_next'], 'expired')
+
+        # Mine block 577 - verify EXPIRED is terminal
+        self.log.info("Mining block 577 - verify EXPIRED is terminal...")
+        self.mine_blocks(node, 1, signal=False)
+        assert_equal(node.getblockcount(), 577)
+        status, since = self.get_status(node)
+        self.log.info(f"Block 577: Status={status}")
+        assert_equal(status, 'expired')
+
+        self.log.info("\n=== TEST 5 COMPLETE ===")
+        self.log.info("SUCCESS: Temporary deployment with max_height activated and expired correctly")
+
+        # Test 6: Custom per-deployment threshold
+        self.log.info("\n\n=== TEST 6: Custom per-deployment threshold (50% = 72/144 blocks) ===")
+        node = self.nodes[5]
+
+        # This node has threshold=72 (50% of 144 blocks)
+        # Default regtest threshold is 108 (75%), but this deployment should activate at 72
+
+        # Period 0 (0-143): DEFINED
+        self.log.info("Mining period 0 (blocks 0-143) without signaling...")
+        self.mine_blocks(node, 143, signal=False)
+        assert_equal(node.getblockcount(), 143)
+        status, _ = self.get_status(node)
+        assert_equal(status, 'defined')
+
+        # Block 144: Transition to STARTED
+        self.log.info("Mining block 144 to transition to STARTED...")
+        self.mine_blocks(node, 1, signal=False)
+        assert_equal(node.getblockcount(), 144)
+        status, since = self.get_status(node)
+        self.log.info(f"Block 144: Status={status}, Since={since}")
+        assert_equal(status, 'started')
+        assert_equal(since, 144)
+
+        # Period 1 (144-287): NEGATIVE TEST - Mine only 71 signaling blocks (one below threshold)
+        self.log.info("NEGATIVE TEST: Mining period 1 with only 71 signaling blocks (below threshold of 72)...")
+        self.mine_blocks(node, 71, signal=True)   # 71 signaling blocks
+        self.mine_blocks(node, 72, signal=False)  # 72 non-signaling blocks (+ 1 from block 144 = 73 total)
+        assert_equal(node.getblockcount(), 287)
+
+        # Block 288: Should remain STARTED (71 < 72 threshold)
+        self.mine_blocks(node, 1, signal=False)
+        assert_equal(node.getblockcount(), 288)
+        status, since = self.get_status(node)
+        self.log.info(f"Block 288: Status={status} (should remain started, 71 < threshold 72)")
+        assert_equal(status, 'started')
+        assert_equal(since, 144)
+
+        # Period 2 (288-431): POSITIVE TEST - Mine exactly 72 signaling blocks (meets threshold)
+        self.log.info("Mining period 2 with exactly 72 signaling blocks (meets threshold of 72)...")
+        self.mine_blocks(node, 72, signal=True)   # 72 signaling blocks
+        self.mine_blocks(node, 71, signal=False)  # 71 non-signaling blocks (+ 1 from block 288 = 72 total)
+        assert_equal(node.getblockcount(), 431)
+
+        # Block 432: Should transition to LOCKED_IN (threshold met in previous period)
+        self.log.info("Mining block 432 to check lock-in...")
+        self.mine_blocks(node, 1, signal=False)
+        assert_equal(node.getblockcount(), 432)
+        status, since = self.get_status(node)
+        self.log.info(f"Block 432: Status={status}, Since={since}")
+        assert_equal(status, 'locked_in')
+        assert_equal(since, 432)
+
+        # Mine through locked_in period to activate
+        self.log.info("Mining through locked_in period (433-575)...")
+        self.mine_blocks(node, 143, signal=False)
+        assert_equal(node.getblockcount(), 575)
+        status, since = self.get_status(node)
+        assert_equal(status, 'locked_in')
+
+        # Block 576: Should transition to ACTIVE
+        self.log.info("Mining block 576 to activate...")
+        self.mine_blocks(node, 1, signal=False)
+        assert_equal(node.getblockcount(), 576)
+        status, since = self.get_status(node)
+        self.log.info(f"Block 576: Status={status}, Since={since}")
+        assert_equal(status, 'active')
+        assert_equal(since, 576)
+
+        self.log.info("\n=== TEST 6 COMPLETE ===")
+        self.log.info("SUCCESS: Deployment activated with custom 50% threshold (72/144 blocks)")
+        self.log.info("- 71/144 signaling correctly failed to lock in (negative test)")
+        self.log.info("- 72/144 signaling correctly locked in (positive test)")
+
+
+if __name__ == '__main__':
+    MaxActivationHeightTest(__file__).main()
diff --git a/test/functional/feature_block.py b/test/functional/feature_block.py
index 6803bb3345fd..c620b80ad787 100755
--- a/test/functional/feature_block.py
+++ b/test/functional/feature_block.py
@@ -40,6 +40,7 @@
     OP_ELSE,
     OP_ENDIF,
     OP_DROP,
+    OP_DUP,
     OP_FALSE,
     OP_IF,
     OP_INVALIDOPCODE,
@@ -48,7 +49,7 @@
     sign_input_legacy,
 )
 from test_framework.script_util import (
-    key_to_p2pk_script,
+    key_to_p2pkh_script,
     script_to_p2sh_script,
 )
 from test_framework.test_framework import BitcoinTestFramework
@@ -1167,7 +1168,7 @@ def run_test(self):
         #    The resurrected transactions must pass the node's mempool policy, so create
         #    and spend standard outputs (P2PK using the coinbase pubkey to keep it simple).
         self.log.info("Test transaction resurrection during a re-org")
-        standard_output_script = key_to_p2pk_script(self.coinbase_pubkey)
+        standard_output_script = key_to_p2pkh_script(self.coinbase_pubkey)
         self.move_tip(76)
         self.next_block(77)
         tx77 = self.create_and_sign_transaction(out[24], 10 * COIN, standard_output_script)
@@ -1347,6 +1348,9 @@ def sign_tx(self, tx, spend_tx):
         if (scriptPubKey[0] == OP_TRUE):  # an anyone-can-spend
             tx.vin[0].scriptSig = CScript()
             return
+        # For P2PKH, pre-set the pubkey so sign_input_legacy prepends the signature
+        if scriptPubKey[0] == OP_DUP:  # P2PKH starts with OP_DUP
+            tx.vin[0].scriptSig = CScript([self.coinbase_pubkey])
         sign_input_legacy(tx, 0, spend_tx.vout[0].scriptPubKey, self.coinbase_key)
 
     def create_and_sign_transaction(self, spend_tx, value, output_script=None):
diff --git a/test/functional/feature_cltv.py b/test/functional/feature_cltv.py
index 0cc2f458735f..9133ba7fa6c2 100755
--- a/test/functional/feature_cltv.py
+++ b/test/functional/feature_cltv.py
@@ -166,16 +166,16 @@ def run_test(self):
             # rejected from the mempool for exactly that reason.
             spendtx_txid = spendtx.txid_hex
             spendtx_wtxid = spendtx.wtxid_hex
-            assert_equal(
-                [{
-                    'txid': spendtx_txid,
-                    'wtxid': spendtx_wtxid,
-                    'allowed': False,
-                    'reject-reason': tx_rej + expected_cltv_reject_reason,
-                    'reject-details': tx_rej + expected_cltv_reject_reason + f", input 0 of {spendtx_txid} (wtxid {spendtx_wtxid}), spending {coin_txid}:{coin_vout}"
-                }],
-                self.nodes[0].testmempoolaccept(rawtxs=[spendtx.serialize().hex()], maxfeerate=0),
-            )
+            expected = {
+                'txid': spendtx_txid,
+                'wtxid': spendtx_wtxid,
+                'allowed': False,
+                'reject-reason': tx_rej + expected_cltv_reject_reason,
+                'reject-details': tx_rej + expected_cltv_reject_reason + f", input 0 of {spendtx_txid} (wtxid {spendtx_wtxid}), spending {coin_txid}:{coin_vout}",
+            }
+            result = self.nodes[0].testmempoolaccept(rawtxs=[spendtx.serialize().hex()], maxfeerate=0)[0]
+            result.pop('usage', None)
+            assert_equal(result, expected)
 
             # Now we verify that a block with this transaction is also invalid.
             block.vtx[1] = spendtx
diff --git a/test/functional/feature_dersig.py b/test/functional/feature_dersig.py
index 01529647cc79..138be9b59e43 100755
--- a/test/functional/feature_dersig.py
+++ b/test/functional/feature_dersig.py
@@ -116,17 +116,18 @@ def run_test(self):
         # rejected from the mempool for exactly that reason.
         spendtx_txid = spendtx.txid_hex
         spendtx_wtxid = spendtx.wtxid_hex
-        assert_equal(
-            [{
+        expected = {
                 'txid': spendtx_txid,
                 'wtxid': spendtx_wtxid,
                 'allowed': False,
                 'reject-reason': 'mempool-script-verify-flag-failed (Non-canonical DER signature)',
                 'reject-details': 'mempool-script-verify-flag-failed (Non-canonical DER signature), ' +
-                                  f"input 0 of {spendtx_txid} (wtxid {spendtx_wtxid}), spending {coin_txid}:0"
-            }],
-            self.nodes[0].testmempoolaccept(rawtxs=[spendtx.serialize().hex()], maxfeerate=0),
-        )
+                                  f"input 0 of {spendtx_txid} (wtxid {spendtx_wtxid}), spending {coin_txid}:0",
+        }
+        result = self.nodes[0].testmempoolaccept(rawtxs=[spendtx.serialize().hex()], maxfeerate=0)[0]
+        # skip for now
+        result.pop('usage')
+        assert_equal(result, expected)
 
         # Now we verify that a block with this transaction is also invalid.
         block.vtx.append(spendtx)
diff --git a/test/functional/feature_rdts.py b/test/functional/feature_rdts.py
new file mode 100755
index 000000000000..858cd8316c3d
--- /dev/null
+++ b/test/functional/feature_rdts.py
@@ -0,0 +1,1033 @@
+#!/usr/bin/env python3
+# Copyright (c) 2025 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Test ReducedData Temporary Softfork (RDTS) consensus rules.
+
+This test verifies all 7 consensus rules enforced by DEPLOYMENT_REDUCED_DATA:
+
+1. Output scriptPubKeys exceeding 34 bytes are invalid (except OP_RETURN up to 83 bytes)
+2. OP_PUSHDATA* with payloads larger than 256 bytes are invalid (except BIP16 redeemScript)
+3. Spending undefined witness versions (not v0/v1) is invalid
+4. Witness stacks with a Taproot annex are invalid
+5. Taproot control blocks larger than 257 bytes are invalid (max 7 merkle nodes = 128 leaves)
+6. Tapscripts including OP_SUCCESS* opcodes are invalid
+7. Tapscripts executing OP_IF or OP_NOTIF instructions are invalid
+"""
+
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.wallet import MiniWallet
+from test_framework.messages import (
+    COutPoint,
+    CTransaction,
+    CTxIn,
+    CTxInWitness,
+    CTxOut,
+)
+from test_framework.script import (
+    ANNEX_TAG,
+    CScript,
+    CScriptOp,
+    OP_0,
+    OP_1,
+    OP_2,
+    OP_11,
+    OP_15,
+    OP_CHECKSIG,
+    OP_CHECKMULTISIG,
+    OP_DROP,
+    OP_IF,
+    OP_NOTIF,
+    OP_ENDIF,
+    OP_RETURN,
+    OP_TRUE,
+    SegwitV0SignatureHash,
+    SIGHASH_ALL,
+    SIGHASH_DEFAULT,
+    hash160,
+    taproot_construct,
+    TaprootSignatureHash,
+)
+from test_framework.blocktools import (
+    create_block,
+    create_coinbase,
+    add_witness_commitment,
+)
+from test_framework.script_util import (
+    PAY_TO_ANCHOR,
+    script_to_p2wsh_script,
+    script_to_p2sh_script,
+)
+from test_framework.util import (
+    assert_equal,
+)
+from test_framework.key import (
+    ECKey,
+    compute_xonly_pubkey,
+    generate_privkey,
+    sign_schnorr,
+    tweak_add_privkey,
+)
+
+
+# Constants from BIP444
+MAX_OUTPUT_SCRIPT_SIZE = 34
+MAX_OUTPUT_DATA_SIZE = 83
+MAX_SCRIPT_ELEMENT_SIZE_REDUCED = 256
+TAPROOT_CONTROL_BASE_SIZE = 33
+TAPROOT_CONTROL_NODE_SIZE = 32
+TAPROOT_CONTROL_MAX_NODE_COUNT_REDUCED = 7
+TAPROOT_CONTROL_MAX_SIZE_REDUCED = TAPROOT_CONTROL_BASE_SIZE + TAPROOT_CONTROL_NODE_SIZE * TAPROOT_CONTROL_MAX_NODE_COUNT_REDUCED
+# ANNEX_TAG is imported from test_framework.script
+
+
+class ReducedDataTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 1
+        self.setup_clean_chain = True
+        # Make DEPLOYMENT_REDUCED_DATA always active (from block 0)
+        # Using start_time=-1 (ALWAYS_ACTIVE) bypasses BIP9 state machine
+        self.extra_args = [[
+            '-vbparams=reduced_data:-1:999999999999:0',
+            '-acceptnonstdtxn=1',
+        ]]
+
+    def init_test(self):
+        """Initialize test by mining blocks and creating UTXOs."""
+        node = self.nodes[0]
+
+        # MiniWallet provides a simple wallet for test transactions
+        self.wallet = MiniWallet(node)
+
+        # Mine 120 blocks to mature coinbase outputs and create spending UTXOs
+        # (101 for maturity + extras since each test consumes a UTXO)
+        self.generate(self.wallet, 120)
+
+        self.log.info("Test initialization complete")
+
+    def create_test_transaction(self, scriptPubKey, value=None):
+        """Helper to create a transaction with custom scriptPubKey (not broadcast)."""
+        # Start with a valid transaction from the wallet
+        tx_dict = self.wallet.create_self_transfer()
+        tx = tx_dict['tx']
+
+        # Use default output value if not specified (handles fee calculation)
+        if value is None:
+            value = tx.vout[0].nValue
+
+        # Replace output with our custom scriptPubKey
+        tx.vout[0] = CTxOut(value, scriptPubKey)
+        tx.txid_hex
+
+        return tx
+
+    def test_output_script_size_limit(self):
+        """Test spec 1: Output scriptPubKeys exceeding 34 bytes are invalid."""
+        self.log.info("Testing output scriptPubKey size limits...")
+
+        node = self.nodes[0]
+
+        # Test 1.1: 34-byte P2WSH output (exactly at limit - should pass)
+        witness_program_32 = b'\x00' * 32
+        script_p2wsh = CScript([OP_0, witness_program_32])  # OP_0 (1 byte) + 32-byte push = 34 bytes
+        assert_equal(len(script_p2wsh), 34)
+
+        tx_valid = self.create_test_transaction(script_p2wsh)
+        result = node.testmempoolaccept([tx_valid.serialize().hex()])[0]
+        if not result['allowed']:
+            self.log.info(f"  DEBUG: P2WSH rejection reason: {result}")
+        assert_equal(result['allowed'], True)
+        self.log.info("  ✓ 34-byte P2WSH output accepted")
+
+        # Test 1.2: 35-byte P2PK output (exceeds limit - should fail)
+        pubkey_33 = b'\x02' + b'\x00' * 32  # Compressed pubkey
+        script_p2pk = CScript([pubkey_33, OP_CHECKSIG])  # 33-byte push + OP_CHECKSIG = 35 bytes
+        assert_equal(len(script_p2pk), 35)
+
+        tx_invalid = self.create_test_transaction(script_p2pk)
+        result = node.testmempoolaccept([tx_invalid.serialize().hex()])[0]
+        assert_equal(result['allowed'], False)
+        assert 'bad-txns-vout-script-toolarge' in result['reject-reason']
+        self.log.info("  ✓ 35-byte P2PK output rejected")
+
+        # Test 1.3: 37-byte bare multisig (exceeds limit - should fail)
+        script_bare_multisig = CScript([OP_1, pubkey_33, OP_1, OP_CHECKMULTISIG])
+        assert len(script_bare_multisig) >= 37
+
+        tx_invalid = self.create_test_transaction(script_bare_multisig)
+        result = node.testmempoolaccept([tx_invalid.serialize().hex()])[0]
+        assert_equal(result['allowed'], False)
+        assert 'bad-txns-vout-script-toolarge' in result['reject-reason']
+        self.log.info("  ✓ 37-byte bare multisig output rejected")
+
+        # Test 1.4: OP_RETURN with 83 bytes (at the OP_RETURN exception limit)
+        # Note: CScript adds PUSHDATA overhead for data >75 bytes
+        # 80 bytes data: OP_RETURN (1) + direct push (1) + data (80) = 82 bytes total
+        # 81+ bytes data: OP_RETURN (1) + OP_PUSHDATA1 (1) + len (1) + data = 84+ bytes
+        data_80 = b'\x00' * 80
+        script_opreturn_82 = CScript([OP_RETURN, data_80])
+        self.log.info(f"  DEBUG: OP_RETURN script with 80 data bytes has length: {len(script_opreturn_82)}")
+
+        tx_valid = self.create_test_transaction(script_opreturn_82, value=0)
+        result = node.testmempoolaccept([tx_valid.serialize().hex()])[0]
+        # OP_RETURN with value=0 may be rejected by standardness policy
+        self.log.info(f"  ✓ OP_RETURN with {len(script_opreturn_82)} bytes: {result.get('allowed', False)}")
+
+        # Test 1.5: OP_RETURN with 85 bytes (exceeds 83-byte exception)
+        data_82 = b'\x00' * 82
+        script_opreturn_85 = CScript([OP_RETURN, data_82])
+        self.log.info(f"  DEBUG: OP_RETURN script with 82 data bytes has length: {len(script_opreturn_85)}")
+
+        tx_invalid = self.create_test_transaction(script_opreturn_85, value=0)
+        result = node.testmempoolaccept([tx_invalid.serialize().hex()])[0]
+        assert_equal(result['allowed'], False)
+        if result['allowed'] == False:
+            self.log.info(f"  ✓ OP_RETURN with {len(script_opreturn_85)} bytes rejected")
+
+    def test_pushdata_size_limit(self):
+        """Test spec 2: OP_PUSHDATA* with payloads > 256 bytes are invalid."""
+        self.log.info("Testing OP_PUSHDATA size limits...")
+
+        node = self.nodes[0]
+
+        # Standard P2WPKH hash for outputs (avoids tx-size-small policy rejection)
+        dummy_pubkey_hash = hash160(b'\x00' * 33)
+
+        # Test 2.1: Witness script with 256-byte PUSHDATA (exactly at limit - should pass)
+        data_256 = b'\x00' * 256
+        witness_script_256 = CScript([data_256, OP_DROP, OP_TRUE])  # Script: <256 bytes> DROP TRUE
+        script_pubkey_256 = script_to_p2wsh_script(witness_script_256)
+
+        # First create an output with this witness script
+        funding_tx_256 = self.create_test_transaction(script_pubkey_256)
+        txid_256 = node.sendrawtransaction(funding_tx_256.serialize().hex())
+        self.generate(node, 1)
+        output_value_256 = funding_tx_256.vout[0].nValue
+
+        # Now spend it - this reveals the witness script with the 256-byte PUSHDATA
+        spending_tx_256 = CTransaction()
+        spending_tx_256.vin = [CTxIn(COutPoint(int(txid_256, 16), 0))]
+        spending_tx_256.vout = [CTxOut(output_value_256 - 10000, CScript([OP_0, dummy_pubkey_hash]))]
+        spending_tx_256.wit.vtxinwit = [CTxInWitness()]
+        spending_tx_256.wit.vtxinwit[0].scriptWitness.stack = [witness_script_256]
+        spending_tx_256.txid_hex
+
+        # 256 bytes is at the limit, should be accepted
+        result = node.testmempoolaccept([spending_tx_256.serialize().hex()])[0]
+        if not result['allowed']:
+            self.log.info(f"  DEBUG: 256-byte PUSHDATA rejection: {result}")
+        assert_equal(result['allowed'], True)
+        self.log.info("  ✓ PUSHDATA with 256 bytes accepted in witness script")
+
+        # Test 2.2: Witness script with 257-byte PUSHDATA (exceeds limit - should fail)
+        data_257 = b'\x00' * 257
+        witness_script_257 = CScript([data_257, OP_DROP, OP_TRUE])
+        script_pubkey_257 = script_to_p2wsh_script(witness_script_257)
+
+        # Create and fund the output
+        funding_tx_257 = self.create_test_transaction(script_pubkey_257)
+        txid_257 = node.sendrawtransaction(funding_tx_257.serialize().hex())
+        self.generate(node, 1)
+        output_value_257 = funding_tx_257.vout[0].nValue
+
+        # Try to spend it - should be rejected due to 257-byte PUSHDATA
+        spending_tx_257 = CTransaction()
+        spending_tx_257.vin = [CTxIn(COutPoint(int(txid_257, 16), 0))]
+        spending_tx_257.vout = [CTxOut(output_value_257 - 10000, CScript([OP_0, dummy_pubkey_hash]))]
+        spending_tx_257.wit.vtxinwit = [CTxInWitness()]
+        spending_tx_257.wit.vtxinwit[0].scriptWitness.stack = [witness_script_257]
+        spending_tx_257.txid_hex
+
+        result = node.testmempoolaccept([spending_tx_257.serialize().hex()])[0]
+        assert_equal(result['allowed'], False)
+        assert 'non-mandatory-script-verify-flag' in result['reject-reason'] or 'Push value size limit exceeded' in result['reject-reason']
+        self.log.info("  ✓ PUSHDATA with 257 bytes rejected in witness script")
+
+        # Test 2.3: P2SH redeemScript with 300-byte PUSHDATA (tests BIP16 exception boundary)
+        # Important: BIP16 allows pushing the redeemScript itself even if >256 bytes,
+        # BUT any PUSHDATAs executed WITHIN that redeemScript are still limited to 256 bytes
+        large_redeem_script = CScript([b'\x00' * 300, OP_DROP, OP_TRUE])  # Contains 300-byte PUSHDATA
+        p2sh_script_pubkey = script_to_p2sh_script(large_redeem_script)
+
+        # Create the P2SH output
+        funding_tx_p2sh = self.create_test_transaction(p2sh_script_pubkey)
+        txid_p2sh = node.sendrawtransaction(funding_tx_p2sh.serialize().hex())
+        self.generate(node, 1)
+        output_value_p2sh = funding_tx_p2sh.vout[0].nValue
+
+        # Spend it by revealing the redeemScript in scriptSig
+        spending_tx_p2sh = CTransaction()
+        spending_tx_p2sh.vin = [CTxIn(COutPoint(int(txid_p2sh, 16), 0), CScript([large_redeem_script]))]
+        spending_tx_p2sh.vout = [CTxOut(output_value_p2sh - 10000, CScript([OP_0, dummy_pubkey_hash]))]
+        spending_tx_p2sh.txid_hex
+
+        # Should fail because the 300-byte PUSHDATA inside the redeemScript exceeds the limit
+        result = node.testmempoolaccept([spending_tx_p2sh.serialize().hex()])[0]
+        assert_equal(result['allowed'], False)
+        assert 'non-mandatory-script-verify-flag' in result['reject-reason'] or 'Push value size limit exceeded' in result['reject-reason']
+        self.log.info("  ✓ P2SH redeemScript with >256 byte PUSHDATA correctly rejected")
+        self.log.info("    (BIP16 exception only applies to pushing the redeemScript blob, not PUSHDATAs within it)")
+
+    def test_undefined_witness_versions(self):
+        """Test spec 3: Spending undefined witness versions is invalid.
+
+        Bitcoin currently defines witness v0 (P2WPKH/P2WSH) and v1 (Taproot).
+        Versions v2-v16 are reserved for future upgrades and are currently undefined.
+        After DEPLOYMENT_REDUCED_DATA, spending these undefined versions is invalid.
+        """
+        self.log.info("Testing undefined witness version rejection...")
+
+        node = self.nodes[0]
+
+        # Test witness v2 as representative (same logic applies to v3-v16)
+        version_op = OP_2  # Witness version 2
+        version = version_op - 0x50  # Convert OP_2 to numeric 2
+
+        # Create output to witness v2: <version> <32-byte program>
+        witness_program = b'\x00' * 32
+        script_v2 = CScript([CScriptOp(version_op), witness_program])
+
+        # Step 1: Create an output to witness v2 (this is allowed)
+        funding_tx = self.create_test_transaction(script_v2)
+        txid = node.sendrawtransaction(funding_tx.serialize().hex())
+        self.generate(node, 1)
+        self.log.info(f"  Created witness v2 output in tx {txid[:16]}...")
+
+        # Step 2: Try to spend the witness v2 output (should be rejected)
+        spending_tx = CTransaction()
+        spending_tx.vin = [CTxIn(COutPoint(int(txid, 16), 0))]
+        dummy_pubkey_hash = hash160(b'\x00' * 33)
+        spending_tx.vout = [CTxOut(funding_tx.vout[0].nValue - 10000, CScript([OP_0, dummy_pubkey_hash]))]
+
+        # For undefined witness versions, pre-softfork behavior was "anyone-can-spend"
+        # with an empty witness stack. Post-REDUCED_DATA, this is now invalid.
+        spending_tx.wit.vtxinwit = [CTxInWitness()]
+        spending_tx.wit.vtxinwit[0].scriptWitness.stack = []  # Empty witness
+        spending_tx.txid_hex
+
+        # Should be rejected - undefined witness versions can't be spent after activation
+        result = node.testmempoolaccept([spending_tx.serialize().hex()])[0]
+        assert_equal(result['allowed'], False)
+        # Rejection happens during script verification
+        assert any(x in result['reject-reason'] for x in ['mempool-script-verify-flag', 'witness-program', 'bad-witness', 'discouraged'])
+        self.log.info(f"  ✓ Witness v{version} spending correctly rejected ({result['reject-reason']})")
+
+        # All undefined versions (v2-v16) are validated identically
+        self.log.info("  ✓ Witness versions v2-v16 are all similarly rejected")
+
+    def test_taproot_annex_rejection(self):
+        """Test spec 4: Witness stacks with a Taproot annex are invalid."""
+        self.log.info("Testing Taproot annex rejection...")
+        node = self.nodes[0]
+
+        # Generate a Taproot key pair for testing
+        privkey = generate_privkey()
+        internal_pubkey, _ = compute_xonly_pubkey(privkey)
+
+        # Create a simple Taproot output (key-path only, no script tree)
+        taproot_info = taproot_construct(internal_pubkey)
+        taproot_spk = taproot_info.scriptPubKey
+
+        # Test 4.1: Taproot key-path spend WITHOUT annex (valid baseline)
+        self.log.info("  Test 4.1: Taproot key-path spend without annex (should be valid)")
+
+        # Create funding transaction with Taproot output
+        funding_tx = self.create_test_transaction(taproot_spk)
+        funding_txid = funding_tx.txid_hex
+
+        # Mine the funding transaction in a block
+        block_height = node.getblockcount() + 1
+        block = create_block(int(node.getbestblockhash(), 16), create_coinbase(block_height), int(node.getblockheader(node.getbestblockhash())['time']) + 1)
+        block.vtx.append(funding_tx)
+        add_witness_commitment(block)
+        block.solve()
+        node.submitblock(block.serialize().hex())
+
+        # Create spending transaction (key-path, no annex)
+        spending_tx = CTransaction()
+        spending_tx.vin = [CTxIn(COutPoint(int(funding_txid, 16), 0), nSequence=0)]
+        # Use the actual output value from funding_tx minus a small fee
+        output_value = funding_tx.vout[0].nValue - 1000  # 1000 sats fee
+        spending_tx.vout = [CTxOut(output_value, CScript([OP_1, bytes(20)]))]  # P2WPKH output
+
+        # Sign with Schnorr signature for Taproot key-path spend
+        sighash = TaprootSignatureHash(spending_tx, [funding_tx.vout[0]], SIGHASH_DEFAULT, 0)
+        tweaked_privkey = tweak_add_privkey(privkey, taproot_info.tweak)
+        sig = sign_schnorr(tweaked_privkey, sighash)
+
+        # Witness for key-path: just the signature
+        spending_tx.wit.vtxinwit.append(CTxInWitness())
+        spending_tx.wit.vtxinwit[0].scriptWitness.stack = [sig]
+
+        # This should be accepted (no annex)
+        result = node.testmempoolaccept([spending_tx.serialize().hex()])[0]
+        if not result['allowed']:
+            self.log.info(f"  DEBUG: Taproot spend rejection: {result}")
+        assert_equal(result['allowed'], True)
+        self.log.info("  ✓ Taproot key-path spend without annex: ACCEPTED")
+
+        # Test 4.2: Taproot key-path spend WITH annex (invalid after DEPLOYMENT_REDUCED_DATA)
+        self.log.info("  Test 4.2: Taproot key-path spend with annex (should be rejected)")
+
+        # Create another funding transaction
+        funding_tx2 = self.create_test_transaction(taproot_spk)
+        funding_txid2 = funding_tx2.txid_hex
+
+        # Mine the funding transaction in a block
+        block_height2 = node.getblockcount() + 1
+        block2 = create_block(int(node.getbestblockhash(), 16), create_coinbase(block_height2), int(node.getblockheader(node.getbestblockhash())['time']) + 1)
+        block2.vtx.append(funding_tx2)
+        add_witness_commitment(block2)
+        block2.solve()
+        node.submitblock(block2.serialize().hex())
+
+        # Create spending transaction with annex
+        spending_tx2 = CTransaction()
+        spending_tx2.vin = [CTxIn(COutPoint(int(funding_txid2, 16), 0), nSequence=0)]
+        output_value2 = funding_tx2.vout[0].nValue - 1000
+        spending_tx2.vout = [CTxOut(output_value2, CScript([OP_1, bytes(20)]))]
+
+        # Sign the transaction (annex affects sighash)
+        annex = bytes([ANNEX_TAG]) + b'\x00' * 10  # Annex must start with 0x50
+        sighash2 = TaprootSignatureHash(spending_tx2, [funding_tx2.vout[0]], SIGHASH_DEFAULT, 0, annex=annex)
+        sig2 = sign_schnorr(tweaked_privkey, sighash2)
+
+        # Witness for key-path with annex: [signature, annex]
+        spending_tx2.wit.vtxinwit.append(CTxInWitness())
+        spending_tx2.wit.vtxinwit[0].scriptWitness.stack = [sig2, annex]
+
+        # This should be rejected (annex present)
+        result2 = node.testmempoolaccept([spending_tx2.serialize().hex()])[0]
+        if result2['allowed']:
+            self.log.info(f"  DEBUG: Taproot spend with annex was unexpectedly accepted: {result2}")
+        assert_equal(result2['allowed'], False)
+        self.log.info(f"  ✓ Taproot spend with annex: REJECTED ({result2['reject-reason']})")
+
+    def test_taproot_control_block_size(self):
+        """Test spec 5: Taproot control blocks > 257 bytes are invalid."""
+        self.log.info("Testing Taproot control block size limits...")
+        node = self.nodes[0]
+
+        # Control block size = 33 + 32 * num_nodes
+        # Max allowed: 7 nodes = 33 + 32*7 = 257 bytes (depth 7, 128 leaves)
+        # Invalid: 8 nodes = 33 + 32*8 = 289 bytes (depth 8, 256 leaves)
+
+        max_valid_size = TAPROOT_CONTROL_MAX_SIZE_REDUCED
+        assert_equal(max_valid_size, 257)
+        self.log.info(f"  Max valid control block size: {max_valid_size} bytes (7 nodes)")
+
+        # Helper function to build a balanced binary tree of given depth
+        def build_tree(depth, leaf_prefix="leaf"):
+            """Build a balanced binary tree for Taproot script tree."""
+            if depth == 0:
+                # At leaf level, return a simple script
+                return (f"{leaf_prefix}", CScript([OP_TRUE]))
+            else:
+                # Recursively build left and right subtrees
+                left = build_tree(depth - 1, f"{leaf_prefix}_L")
+                right = build_tree(depth - 1, f"{leaf_prefix}_R")
+                return [left, right]
+
+        # Generate a Taproot key pair
+        privkey = generate_privkey()
+        internal_pubkey, _ = compute_xonly_pubkey(privkey)
+
+        # Test 5.1: Control block with 7 merkle nodes (valid, 257 bytes)
+        self.log.info("  Test 5.1: Control block with 7 nodes / depth 7 (should be valid)")
+
+        # Build a balanced tree of depth 7 (128 leaves)
+        tree_valid = build_tree(7)
+        taproot_info_valid = taproot_construct(internal_pubkey, [tree_valid])
+        taproot_spk_valid = taproot_info_valid.scriptPubKey
+
+        # Create and mine funding transaction
+        funding_tx_valid = self.create_test_transaction(taproot_spk_valid)
+        funding_txid_valid = funding_tx_valid.txid_hex
+
+        block_height = node.getblockcount() + 1
+        block = create_block(int(node.getbestblockhash(), 16), create_coinbase(block_height), int(node.getblockheader(node.getbestblockhash())['time']) + 1)
+        block.vtx.append(funding_tx_valid)
+        add_witness_commitment(block)
+        block.solve()
+        node.submitblock(block.serialize().hex())
+
+        # Spend using the deepest leaf (which will have the longest control block)
+        # The deepest leaf should be at path L_L_L_L_L_L_L (all left)
+        deepest_leaf_name = "leaf" + "_L" * 7
+        leaf_info_valid = taproot_info_valid.leaves[deepest_leaf_name]
+        control_block_valid = bytes([leaf_info_valid.version + taproot_info_valid.negflag]) + internal_pubkey + leaf_info_valid.merklebranch
+
+        # Verify control block size
+        assert_equal(len(control_block_valid), 257)
+        self.log.info(f"    Control block size: {len(control_block_valid)} bytes ✓")
+
+        # Create spending transaction
+        spending_tx_valid = CTransaction()
+        spending_tx_valid.vin = [CTxIn(COutPoint(int(funding_txid_valid, 16), 0), nSequence=0)]
+        output_value = funding_tx_valid.vout[0].nValue - 1000
+        spending_tx_valid.vout = [CTxOut(output_value, CScript([OP_1, bytes(20)]))]
+
+        spending_tx_valid.wit.vtxinwit.append(CTxInWitness())
+        spending_tx_valid.wit.vtxinwit[0].scriptWitness.stack = [leaf_info_valid.script, control_block_valid]
+
+        result_valid = node.testmempoolaccept([spending_tx_valid.serialize().hex()])[0]
+        if not result_valid['allowed']:
+            self.log.info(f"    DEBUG: Depth 7 rejection: {result_valid}")
+        assert_equal(result_valid['allowed'], True)
+        self.log.info("  ✓ Control block with 7 nodes (257 bytes): ACCEPTED")
+
+        # Test 5.2: Control block with 8 merkle nodes (invalid, 289 bytes)
+        self.log.info("  Test 5.2: Control block with 8 nodes / depth 8 (should be rejected)")
+
+        # Build a balanced tree of depth 8 (256 leaves)
+        tree_invalid = build_tree(8)
+        taproot_info_invalid = taproot_construct(internal_pubkey, [tree_invalid])
+        taproot_spk_invalid = taproot_info_invalid.scriptPubKey
+
+        # Create and mine funding transaction
+        funding_tx_invalid = self.create_test_transaction(taproot_spk_invalid)
+        funding_txid_invalid = funding_tx_invalid.txid_hex
+
+        block_height = node.getblockcount() + 1
+        block = create_block(int(node.getbestblockhash(), 16), create_coinbase(block_height), int(node.getblockheader(node.getbestblockhash())['time']) + 1)
+        block.vtx.append(funding_tx_invalid)
+        add_witness_commitment(block)
+        block.solve()
+        node.submitblock(block.serialize().hex())
+
+        # Spend using the deepest leaf
+        deepest_leaf_name_invalid = "leaf" + "_L" * 8
+        leaf_info_invalid = taproot_info_invalid.leaves[deepest_leaf_name_invalid]
+        control_block_invalid = bytes([leaf_info_invalid.version + taproot_info_invalid.negflag]) + internal_pubkey + leaf_info_invalid.merklebranch
+
+        # Verify control block size
+        assert_equal(len(control_block_invalid), 289)
+        self.log.info(f"    Control block size: {len(control_block_invalid)} bytes (exceeds 257)")
+
+        # Create spending transaction
+        spending_tx_invalid = CTransaction()
+        spending_tx_invalid.vin = [CTxIn(COutPoint(int(funding_txid_invalid, 16), 0), nSequence=0)]
+        output_value = funding_tx_invalid.vout[0].nValue - 1000
+        spending_tx_invalid.vout = [CTxOut(output_value, CScript([OP_1, bytes(20)]))]
+
+        spending_tx_invalid.wit.vtxinwit.append(CTxInWitness())
+        spending_tx_invalid.wit.vtxinwit[0].scriptWitness.stack = [leaf_info_invalid.script, control_block_invalid]
+
+        result_invalid = node.testmempoolaccept([spending_tx_invalid.serialize().hex()])[0]
+        if result_invalid['allowed']:
+            self.log.info(f"    DEBUG: Depth 8 was unexpectedly accepted: {result_invalid}")
+        assert_equal(result_invalid['allowed'], False)
+        self.log.info(f"  ✓ Control block with 8 nodes (289 bytes): REJECTED ({result_invalid['reject-reason']})")
+
+    def test_op_success_rejection(self):
+        """Test spec 6: Tapscripts including OP_SUCCESS* opcodes are invalid."""
+        self.log.info("Testing OP_SUCCESS opcode rejection...")
+        node = self.nodes[0]
+
+        # Generate a Taproot key pair
+        privkey = generate_privkey()
+        internal_pubkey, _ = compute_xonly_pubkey(privkey)
+
+        # Test 6.1: Tapscript without OP_SUCCESS (valid baseline)
+        self.log.info("  Test 6.1: Tapscript without OP_SUCCESS (should be valid)")
+
+        # Create a simple Tapscript: OP_TRUE (always valid)
+        tapscript_valid = CScript([OP_TRUE])
+        taproot_info_valid = taproot_construct(internal_pubkey, [("valid", tapscript_valid)])
+        taproot_spk_valid = taproot_info_valid.scriptPubKey
+
+        # Create and mine funding transaction
+        funding_tx_valid = self.create_test_transaction(taproot_spk_valid)
+        funding_txid_valid = funding_tx_valid.txid_hex
+
+        block_height = node.getblockcount() + 1
+        block = create_block(int(node.getbestblockhash(), 16), create_coinbase(block_height), int(node.getblockheader(node.getbestblockhash())['time']) + 1)
+        block.vtx.append(funding_tx_valid)
+        add_witness_commitment(block)
+        block.solve()
+        node.submitblock(block.serialize().hex())
+
+        # Create spending transaction (script-path)
+        spending_tx_valid = CTransaction()
+        spending_tx_valid.vin = [CTxIn(COutPoint(int(funding_txid_valid, 16), 0), nSequence=0)]
+        output_value = funding_tx_valid.vout[0].nValue - 1000
+        spending_tx_valid.vout = [CTxOut(output_value, CScript([OP_1, bytes(20)]))]
+
+        # Build witness for script-path spend
+        leaf_info = taproot_info_valid.leaves["valid"]
+        control_block = bytes([leaf_info.version + taproot_info_valid.negflag]) + internal_pubkey + leaf_info.merklebranch
+        spending_tx_valid.wit.vtxinwit.append(CTxInWitness())
+        spending_tx_valid.wit.vtxinwit[0].scriptWitness.stack = [tapscript_valid, control_block]
+
+        result_valid = node.testmempoolaccept([spending_tx_valid.serialize().hex()])[0]
+        if not result_valid['allowed']:
+            self.log.info(f"  DEBUG: Valid Tapscript rejection: {result_valid}")
+        assert_equal(result_valid['allowed'], True)
+        self.log.info("  ✓ Tapscript without OP_SUCCESS: ACCEPTED")
+
+        # Test 6.2: Tapscript with OP_SUCCESS (invalid)
+        self.log.info("  Test 6.2: Tapscript with OP_SUCCESS (should be rejected)")
+
+        # Create a Tapscript with OP_SUCCESS: opcodes 0x50, 0x62, etc.
+        # IMPORTANT: Use CScriptOp to create the actual opcode, not PUSHDATA
+        # Testing 0x50 (which is also ANNEX_TAG but different context)
+        for op_success in [0x50, 0x62, 0x89]:
+            tapscript_invalid = CScript([CScriptOp(op_success)])
+            taproot_info_invalid = taproot_construct(internal_pubkey, [("invalid", tapscript_invalid)])
+            taproot_spk_invalid = taproot_info_invalid.scriptPubKey
+
+            # Create and mine funding transaction
+            funding_tx_invalid = self.create_test_transaction(taproot_spk_invalid)
+            funding_txid_invalid = funding_tx_invalid.txid_hex
+
+            block_height = node.getblockcount() + 1
+            block = create_block(int(node.getbestblockhash(), 16), create_coinbase(block_height), int(node.getblockheader(node.getbestblockhash())['time']) + 1)
+            block.vtx.append(funding_tx_invalid)
+            add_witness_commitment(block)
+            block.solve()
+            node.submitblock(block.serialize().hex())
+
+            # Create spending transaction
+            spending_tx_invalid = CTransaction()
+            spending_tx_invalid.vin = [CTxIn(COutPoint(int(funding_txid_invalid, 16), 0), nSequence=0)]
+            output_value = funding_tx_invalid.vout[0].nValue - 1000
+            spending_tx_invalid.vout = [CTxOut(output_value, CScript([OP_1, bytes(20)]))]
+
+            # Build witness for script-path spend
+            leaf_info_invalid = taproot_info_invalid.leaves["invalid"]
+            control_block_invalid = bytes([leaf_info_invalid.version + taproot_info_invalid.negflag]) + internal_pubkey + leaf_info_invalid.merklebranch
+            spending_tx_invalid.wit.vtxinwit.append(CTxInWitness())
+            spending_tx_invalid.wit.vtxinwit[0].scriptWitness.stack = [tapscript_invalid, control_block_invalid]
+
+            result_invalid = node.testmempoolaccept([spending_tx_invalid.serialize().hex()])[0]
+            if result_invalid['allowed']:
+                self.log.info(f"  DEBUG: OP_SUCCESS 0x{op_success:02x} was unexpectedly accepted")
+            assert_equal(result_invalid['allowed'], False)
+            self.log.info(f"  ✓ Tapscript with OP_SUCCESS (0x{op_success:02x}): REJECTED ({result_invalid['reject-reason']})")
+
+    def test_op_if_notif_rejection(self):
+        """Test spec 7: Tapscripts executing OP_IF or OP_NOTIF are invalid."""
+        self.log.info("Testing OP_IF/OP_NOTIF rejection in Tapscript...")
+        node = self.nodes[0]
+
+        # Generate a Taproot key pair
+        privkey = generate_privkey()
+        internal_pubkey, _ = compute_xonly_pubkey(privkey)
+
+        # Test 7.1: Tapscript with OP_IF (invalid in Tapscript under DEPLOYMENT_REDUCED_DATA)
+        self.log.info("  Test 7.1: Tapscript with OP_IF (should be rejected)")
+
+        # Create a Tapscript with OP_IF: OP_1 OP_IF OP_1 OP_ENDIF
+        tapscript_if = CScript([OP_1, OP_IF, OP_1, OP_ENDIF])
+        taproot_info_if = taproot_construct(internal_pubkey, [("with_if", tapscript_if)])
+        taproot_spk_if = taproot_info_if.scriptPubKey
+
+        # Create and mine funding transaction
+        funding_tx_if = self.create_test_transaction(taproot_spk_if)
+        funding_txid_if = funding_tx_if.txid_hex
+
+        block_height = node.getblockcount() + 1
+        block = create_block(int(node.getbestblockhash(), 16), create_coinbase(block_height), int(node.getblockheader(node.getbestblockhash())['time']) + 1)
+        block.vtx.append(funding_tx_if)
+        add_witness_commitment(block)
+        block.solve()
+        node.submitblock(block.serialize().hex())
+
+        # Create spending transaction
+        spending_tx_if = CTransaction()
+        spending_tx_if.vin = [CTxIn(COutPoint(int(funding_txid_if, 16), 0), nSequence=0)]
+        output_value = funding_tx_if.vout[0].nValue - 1000
+        spending_tx_if.vout = [CTxOut(output_value, CScript([OP_1, bytes(20)]))]
+
+        # Build witness for script-path spend
+        leaf_info_if = taproot_info_if.leaves["with_if"]
+        control_block_if = bytes([leaf_info_if.version + taproot_info_if.negflag]) + internal_pubkey + leaf_info_if.merklebranch
+        spending_tx_if.wit.vtxinwit.append(CTxInWitness())
+        spending_tx_if.wit.vtxinwit[0].scriptWitness.stack = [tapscript_if, control_block_if]
+
+        result_if = node.testmempoolaccept([spending_tx_if.serialize().hex()])[0]
+        if result_if['allowed']:
+            self.log.info(f"  DEBUG: OP_IF was unexpectedly accepted: {result_if}")
+        assert_equal(result_if['allowed'], False)
+        self.log.info(f"  ✓ Tapscript with OP_IF: REJECTED ({result_if['reject-reason']})")
+
+        # Test 7.2: Tapscript with OP_NOTIF (invalid in Tapscript under DEPLOYMENT_REDUCED_DATA)
+        self.log.info("  Test 7.2: Tapscript with OP_NOTIF (should be rejected)")
+
+        # Create a Tapscript with OP_NOTIF: OP_0 OP_NOTIF OP_1 OP_ENDIF
+        tapscript_notif = CScript([OP_0, OP_NOTIF, OP_1, OP_ENDIF])
+        taproot_info_notif = taproot_construct(internal_pubkey, [("with_notif", tapscript_notif)])
+        taproot_spk_notif = taproot_info_notif.scriptPubKey
+
+        # Create and mine funding transaction
+        funding_tx_notif = self.create_test_transaction(taproot_spk_notif)
+        funding_txid_notif = funding_tx_notif.txid_hex
+
+        block_height = node.getblockcount() + 1
+        block = create_block(int(node.getbestblockhash(), 16), create_coinbase(block_height), int(node.getblockheader(node.getbestblockhash())['time']) + 1)
+        block.vtx.append(funding_tx_notif)
+        add_witness_commitment(block)
+        block.solve()
+        node.submitblock(block.serialize().hex())
+
+        # Create spending transaction
+        spending_tx_notif = CTransaction()
+        spending_tx_notif.vin = [CTxIn(COutPoint(int(funding_txid_notif, 16), 0), nSequence=0)]
+        output_value = funding_tx_notif.vout[0].nValue - 1000
+        spending_tx_notif.vout = [CTxOut(output_value, CScript([OP_1, bytes(20)]))]
+
+        # Build witness for script-path spend
+        leaf_info_notif = taproot_info_notif.leaves["with_notif"]
+        control_block_notif = bytes([leaf_info_notif.version + taproot_info_notif.negflag]) + internal_pubkey + leaf_info_notif.merklebranch
+        spending_tx_notif.wit.vtxinwit.append(CTxInWitness())
+        spending_tx_notif.wit.vtxinwit[0].scriptWitness.stack = [tapscript_notif, control_block_notif]
+
+        result_notif = node.testmempoolaccept([spending_tx_notif.serialize().hex()])[0]
+        if result_notif['allowed']:
+            self.log.info(f"  DEBUG: OP_NOTIF was unexpectedly accepted: {result_notif}")
+        assert_equal(result_notif['allowed'], False)
+        self.log.info(f"  ✓ Tapscript with OP_NOTIF: REJECTED ({result_notif['reject-reason']})")
+
+    def test_mandatory_flags_cannot_be_bypassed(self):
+        """Test that REDUCED_DATA consensus-mandatory flags cannot be bypassed via ignore_rejects.
+
+        This test verifies that even though PolicyScriptChecks can be bypassed via ignore_rejects,
+        the subsequent ConsensusScriptChecks enforces consensus rules and prevents invalid transactions
+        from entering the mempool.
+        """
+        self.log.info("Testing that REDUCED_DATA rules are enforced despite ignore_rejects...")
+        node = self.nodes[0]
+
+        # Test case: Create a witness script with a 257-byte PUSHDATA (violates REDUCED_DATA)
+        self.log.info("  Test: 257-byte PUSHDATA in witness script")
+
+        # Create a P2WSH output with a witness script containing 257-byte data push
+        witness_script_257 = CScript([b'\x00' * 257, OP_DROP, OP_TRUE])
+        script_pubkey_257 = script_to_p2wsh_script(witness_script_257)
+
+        # Create and fund the output
+        funding_tx_257 = self.create_test_transaction(script_pubkey_257)
+        txid_257 = node.sendrawtransaction(funding_tx_257.serialize().hex())
+        self.generate(node, 1)
+        output_value_257 = funding_tx_257.vout[0].nValue
+
+        # Create spending transaction that reveals the 257-byte PUSHDATA
+        spending_tx_257 = CTransaction()
+        spending_tx_257.vin = [CTxIn(COutPoint(int(txid_257, 16), 0))]
+        # Add padding to output to ensure tx meets minimum size requirements (82 bytes non-witness)
+        spending_tx_257.vout = [CTxOut(output_value_257 - 1000, CScript([OP_TRUE, OP_DROP] + [OP_TRUE] * 30))]
+        spending_tx_257.wit.vtxinwit.append(CTxInWitness())
+        spending_tx_257.wit.vtxinwit[0].scriptWitness.stack = [witness_script_257]
+        spending_tx_257.txid_hex
+
+        # Test 1: Normal testmempoolaccept should reject
+        self.log.info("    Test 1a: Normal testmempoolaccept (should reject)")
+        result_normal = node.testmempoolaccept([spending_tx_257.serialize().hex()])[0]
+        assert_equal(result_normal['allowed'], False)
+        assert 'mempool-script-verify-flag' in result_normal['reject-reason']
+        self.log.info(f"    ✓ Normal testmempoolaccept correctly rejected: {result_normal['reject-reason']}")
+
+        # Test 2: Try to bypass with ignore_rejects=["non-mandatory-script-verify-flag"]
+        # Expected: Transaction is STILL REJECTED because ConsensusScriptChecks enforces consensus rules
+        self.log.info("    Test 1b: testmempoolaccept with ignore_rejects")
+        self.log.info("      This bypasses PolicyScriptChecks but NOT ConsensusScriptChecks")
+        result_bypass = node.testmempoolaccept(
+            rawtxs=[spending_tx_257.serialize().hex()],
+            ignore_rejects=["mempool-script-verify-flag-failed"]
+        )[0]
+
+        # The transaction should still be rejected because ConsensusScriptChecks
+        # uses GetBlockScriptFlags() which includes REDUCED_DATA consensus rules
+        self.log.info(f"    Result: allowed={result_bypass['allowed']}")
+        assert_equal(result_bypass['allowed'], False)
+        self.log.info(f"    ✓ Transaction correctly rejected: {result_bypass['reject-reason']}")
+        self.log.info("    ✓ ConsensusScriptChecks prevents bypass of REDUCED_DATA consensus rules")
+
+    def test_p2wsh_multisig_witness_script_exemption(self):
+        """Test that a large P2WSH witness script (>256 bytes) is exempted from the element size limit.
+
+        Inspired by mainnet tx a0032427454536006263d237819df5e72fe539a38cb26264ea45a1019fb53bee,
+        which is a 9-input transaction where each input spends an 11-of-15 P2WSH multisig.
+
+        The witness script for 11-of-15 multisig is ~513 bytes, which exceeds the 256-byte
+        MAX_SCRIPT_ELEMENT_SIZE_REDUCED limit. However, for P2WSH spends, the witness script
+        is popped from the stack BEFORE the element size check runs in ExecuteWitnessScript,
+        so it is implicitly exempted.
+        """
+        self.log.info("Testing 11-of-15 P2WSH multisig witness script exemption...")
+
+        node = self.nodes[0]
+
+        # Generate 15 key pairs
+        privkeys = [generate_privkey() for _ in range(15)]
+        pubkeys = []
+        for priv in privkeys:
+            k = ECKey()
+            k.set(priv, compressed=True)
+            pubkeys.append(k.get_pubkey().get_bytes())
+
+        # Build 11-of-15 multisig witness script:
+        # OP_11 <pub1> <pub2> ... <pub15> OP_15 OP_CHECKMULTISIG
+        witness_script = CScript([OP_11] + pubkeys + [OP_15, OP_CHECKMULTISIG])
+        self.log.info(f"  Witness script size: {len(witness_script)} bytes")
+        assert len(witness_script) > MAX_SCRIPT_ELEMENT_SIZE_REDUCED, \
+            f"Witness script should exceed 256 bytes, got {len(witness_script)}"
+
+        # Create P2WSH output
+        script_pubkey = script_to_p2wsh_script(witness_script)
+
+        # Fund the P2WSH output
+        funding_tx = self.create_test_transaction(script_pubkey)
+        txid = node.sendrawtransaction(funding_tx.serialize().hex())
+        self.generate(node, 1)
+
+        # Create spending transaction
+        spending_tx = CTransaction()
+        spending_tx.vin = [CTxIn(COutPoint(int(txid, 16), 0))]
+        output_value = funding_tx.vout[0].nValue - 10000
+        spending_tx.vout = [CTxOut(output_value, CScript([OP_0, hash160(b'\x01' * 33)]))]
+
+        # Sign with 11 of the 15 keys
+        spending_tx.wit.vtxinwit = [CTxInWitness()]
+        sighash = SegwitV0SignatureHash(
+            witness_script, spending_tx, 0, SIGHASH_ALL, funding_tx.vout[0].nValue
+        )
+
+        sigs = []
+        for i in range(11):
+            k = ECKey()
+            k.set(privkeys[i], compressed=True)
+            sig = k.sign_ecdsa(sighash) + b'\x01'  # SIGHASH_ALL
+            sigs.append(sig)
+
+        # Witness stack: [OP_0_dummy, sig1, ..., sig11, witness_script]
+        spending_tx.wit.vtxinwit[0].scriptWitness.stack = [b''] + sigs + [witness_script]
+        spending_tx.txid_hex
+
+        # Should be ACCEPTED: witness script is popped before size check
+        result = node.testmempoolaccept([spending_tx.serialize().hex()])[0]
+        assert_equal(result['allowed'], True)
+        self.log.info("  PASS: 11-of-15 P2WSH multisig accepted under reduced_data")
+
+    def test_tapscript_script_exemption(self):
+        """Test that a large tapleaf script (>256 bytes) is exempted from the element size limit.
+
+        Similar to P2WSH, for tapscript spends the tapleaf script is popped from the
+        witness stack BEFORE the element size check runs in ExecuteWitnessScript,
+        so it is implicitly exempted.
+        """
+        self.log.info("Testing tapleaf script size exemption...")
+
+        node = self.nodes[0]
+
+        # Build a tapscript >256 bytes using repeated <data> OP_DROP, ending with OP_TRUE
+        # Each data push is ≤256 bytes (valid), but the total script exceeds 256 bytes.
+        large_tapscript = CScript([b'\x00' * 200, OP_DROP, b'\x00' * 200, OP_DROP, OP_TRUE])
+        assert len(large_tapscript) > MAX_SCRIPT_ELEMENT_SIZE_REDUCED, \
+            f"Tapscript should exceed 256 bytes, got {len(large_tapscript)}"
+        self.log.info(f"  Tapleaf script size: {len(large_tapscript)} bytes")
+
+        # Construct taproot output with this script as a leaf
+        privkey = generate_privkey()
+        internal_pubkey, _ = compute_xonly_pubkey(privkey)
+        taproot_info = taproot_construct(internal_pubkey, [("large_script", large_tapscript)])
+        taproot_spk = taproot_info.scriptPubKey
+
+        # Fund the taproot output
+        funding_tx = self.create_test_transaction(taproot_spk)
+        funding_txid = funding_tx.txid_hex
+
+        block_height = node.getblockcount() + 1
+        block = create_block(int(node.getbestblockhash(), 16), create_coinbase(block_height), int(node.getblockheader(node.getbestblockhash())['time']) + 1)
+        block.vtx.append(funding_tx)
+        add_witness_commitment(block)
+        block.solve()
+        node.submitblock(block.serialize().hex())
+
+        # Spend via script path
+        leaf_info = taproot_info.leaves["large_script"]
+        control_block = bytes([leaf_info.version + taproot_info.negflag]) + internal_pubkey + leaf_info.merklebranch
+
+        spending_tx = CTransaction()
+        spending_tx.vin = [CTxIn(COutPoint(int(funding_txid, 16), 0), nSequence=0)]
+        output_value = funding_tx.vout[0].nValue - 1000
+        spending_tx.vout = [CTxOut(output_value, CScript([OP_1, bytes(20)]))]
+
+        # Witness stack: [<empty stack for script execution>, script, control_block]
+        # The script just does <data> DROP <data> DROP TRUE, so no stack inputs needed
+        spending_tx.wit.vtxinwit.append(CTxInWitness())
+        spending_tx.wit.vtxinwit[0].scriptWitness.stack = [large_tapscript, control_block]
+
+        spending_tx.txid_hex
+
+        # Should be ACCEPTED: tapleaf script is popped before size check
+        result = node.testmempoolaccept([spending_tx.serialize().hex()])[0]
+        assert_equal(result['allowed'], True)
+        self.log.info("  PASS: >256-byte tapleaf script accepted under reduced_data")
+
+    def test_generation_output_size_limit(self):
+        """Test that generation tx outputs are also subject to output size limits."""
+        self.log.info("Testing generation tx output scriptPubKey size limits...")
+
+        node = self.nodes[0]
+
+        def create_block_with_generation_output(script_pubkey):
+            """Helper to create a block with a custom generation tx output script."""
+            tip = node.getbestblockhash()
+            height = node.getblockcount() + 1
+            tip_header = node.getblockheader(tip)
+            block_time = tip_header['time'] + 1
+            coinbase = create_coinbase(height, script_pubkey=script_pubkey)
+            block = create_block(int(tip, 16), coinbase, ntime=block_time)
+            add_witness_commitment(block)
+            block.solve()
+            return block
+
+        # Test 1: 34-byte P2WSH generation tx output (exactly at limit - should pass)
+        self.log.info("  Test: 34-byte P2WSH generation tx output (at limit)")
+        witness_program_32 = b'\x00' * 32
+        script_p2wsh = CScript([OP_0, witness_program_32])
+        assert_equal(len(script_p2wsh), 34)
+
+        block_valid = create_block_with_generation_output(script_p2wsh)
+        result = node.submitblock(block_valid.serialize().hex())
+        assert_equal(result, None)
+        self.log.info("  ✓ 34-byte P2WSH generation tx output accepted")
+
+        # Test 2: 35-byte P2PK generation tx output (exceeds limit - should fail)
+        self.log.info("  Test: 35-byte P2PK generation tx output (exceeds limit)")
+        pubkey_33 = b'\x02' + b'\x00' * 32  # Compressed pubkey format
+        script_p2pk = CScript([pubkey_33, OP_CHECKSIG])
+        assert_equal(len(script_p2pk), 35)
+
+        block_invalid = create_block_with_generation_output(script_p2pk)
+        result = node.submitblock(block_invalid.serialize().hex())
+        assert_equal(result, 'bad-txns-vout-script-toolarge')
+        self.log.info("  ✓ 35-byte P2PK generation tx output rejected")
+
+        # Test 3: Generation tx with OP_RETURN at 83 bytes (at OP_RETURN limit - should pass)
+        self.log.info("  Test: Generation tx with 83-byte OP_RETURN extra output (at limit)")
+        # 80 bytes data = OP_RETURN (1) + push opcode (1) + data (80) = 82 bytes
+        # We need 83 bytes, so use 81 bytes of data with PUSHDATA1
+        # OP_RETURN (1) + OP_PUSHDATA1 (1) + len (1) + data (80) = 83 bytes
+        data_80 = b'\x00' * 80
+        script_opreturn_83 = CScript([OP_RETURN, data_80])
+        # Verify we're at exactly 83 bytes (with CScript's encoding)
+        self.log.info(f"    OP_RETURN script length: {len(script_opreturn_83)} bytes")
+
+        # Create block with valid main output and OP_RETURN extra output
+        tip = node.getbestblockhash()
+        height = node.getblockcount() + 1
+        tip_header = node.getblockheader(tip)
+        block_time = tip_header['time'] + 1
+        coinbase = create_coinbase(height, extra_output_script=script_opreturn_83)
+        block_opreturn_valid = create_block(int(tip, 16), coinbase, ntime=block_time)
+        add_witness_commitment(block_opreturn_valid)
+        block_opreturn_valid.solve()
+
+        result = node.submitblock(block_opreturn_valid.serialize().hex())
+        if result is None:
+            self.log.info("  ✓ Generation tx with 83-byte OP_RETURN output accepted")
+        else:
+            self.log.info(f"  Note: Generation tx OP_RETURN result: {result}")
+
+        # Test 4: Generation tx with OP_RETURN at 84 bytes (exceeds limit - should fail)
+        self.log.info("  Test: Generation tx with 84-byte OP_RETURN extra output (exceeds limit)")
+        # 81 bytes data = OP_RETURN (1) + OP_PUSHDATA1 (1) + len (1) + data (81) = 84 bytes
+        data_81 = b'\x00' * 81
+        script_opreturn_84 = CScript([OP_RETURN, data_81])
+        self.log.info(f"    OP_RETURN script length: {len(script_opreturn_84)} bytes")
+
+        tip = node.getbestblockhash()
+        height = node.getblockcount() + 1
+        tip_header = node.getblockheader(tip)
+        block_time = tip_header['time'] + 1
+        coinbase = create_coinbase(height, extra_output_script=script_opreturn_84)
+        block_opreturn_invalid = create_block(int(tip, 16), coinbase, ntime=block_time)
+        add_witness_commitment(block_opreturn_invalid)
+        block_opreturn_invalid.solve()
+
+        result = node.submitblock(block_opreturn_invalid.serialize().hex())
+        assert_equal(result, 'bad-txns-vout-script-toolarge')
+        self.log.info("  ✓ Generation tx with 84-byte OP_RETURN output rejected")
+
+    def test_p2a_witness_rejected(self):
+        """Test that P2A (PayToAnchor) spends with non-empty witness are rejected."""
+        self.log.info("Testing P2A non-empty witness rejection...")
+        node = self.nodes[0]
+
+        # Create a P2A output (4 bytes, within the 34-byte limit)
+        p2a_funding = self.create_test_transaction(PAY_TO_ANCHOR)
+        p2a_funding.txid_hex
+        p2a_value = p2a_funding.vout[0].nValue
+
+        block_height = node.getblockcount() + 1
+        block = create_block(int(node.getbestblockhash(), 16), create_coinbase(block_height), int(node.getblockheader(node.getbestblockhash())['time']) + 1)
+        block.vtx.append(p2a_funding)
+        add_witness_commitment(block)
+        block.solve()
+        assert_equal(node.submitblock(block.serialize().hex()), None)
+        self.log.info("  P2A output created")
+
+        # Test 1: Spend with 100 KB of arbitrary witness data (must be rejected)
+        self.log.info("  Test: P2A spend with large arbitrary witness (should be rejected)")
+        arbitrary_data = b'\xab' * 100_000
+
+        p2a_spend = CTransaction()
+        p2a_spend.vin = [CTxIn(COutPoint(p2a_funding.txid_int, 0))]
+        p2a_spend.vout = [CTxOut(p2a_value - 1000, CScript([OP_0, hash160(b'\x01' * 33)]))]
+        p2a_spend.wit.vtxinwit = [CTxInWitness()]
+        p2a_spend.wit.vtxinwit[0].scriptWitness.stack = [arbitrary_data]
+        p2a_spend.txid_hex
+
+        block_height = node.getblockcount() + 1
+        block_bad = create_block(int(node.getbestblockhash(), 16), create_coinbase(block_height), int(node.getblockheader(node.getbestblockhash())['time']) + 1)
+        block_bad.vtx.append(p2a_spend)
+        add_witness_commitment(block_bad)
+        block_bad.solve()
+
+        result = node.submitblock(block_bad.serialize().hex())
+        assert result is not None
+        assert_equal(node.getblockcount(), block_height - 1)
+        self.log.info(f"  ✓ P2A spend with 100 KB witness rejected ({result})")
+
+        # Test 2: Spend with empty witness (must still be accepted)
+        self.log.info("  Test: P2A spend with empty witness (should be accepted)")
+        p2a_spend_empty = CTransaction()
+        p2a_spend_empty.vin = [CTxIn(COutPoint(p2a_funding.txid_int, 0))]
+        p2a_spend_empty.vout = [CTxOut(p2a_value - 1000, CScript([OP_0, hash160(b'\x01' * 33)]))]
+        p2a_spend_empty.wit.vtxinwit = [CTxInWitness()]
+        p2a_spend_empty.wit.vtxinwit[0].scriptWitness.stack = []
+        p2a_spend_empty.txid_hex
+
+        block_height = node.getblockcount() + 1
+        block_good = create_block(int(node.getbestblockhash(), 16), create_coinbase(block_height), int(node.getblockheader(node.getbestblockhash())['time']) + 1)
+        block_good.vtx.append(p2a_spend_empty)
+        add_witness_commitment(block_good)
+        block_good.solve()
+
+        assert_equal(node.submitblock(block_good.serialize().hex()), None)
+        assert_equal(node.getblockcount(), block_height)
+        self.log.info("  ✓ P2A spend with empty witness accepted")
+
+    def run_test(self):
+        self.init_test()
+
+        # Run all spec tests
+        self.test_output_script_size_limit()
+        self.test_generation_output_size_limit()
+        self.test_pushdata_size_limit()
+        self.test_undefined_witness_versions()
+        self.test_taproot_annex_rejection()
+        self.test_taproot_control_block_size()
+        self.test_op_success_rejection()
+        self.test_op_if_notif_rejection()
+        self.test_p2a_witness_rejected()
+        self.test_p2wsh_multisig_witness_script_exemption()
+        self.test_tapscript_script_exemption()
+
+        self.log.info("All ReducedData tests completed")
+
+
+if __name__ == '__main__':
+    ReducedDataTest(__file__).main()
diff --git a/test/functional/feature_reduced_data_temporary_deployment.py b/test/functional/feature_reduced_data_temporary_deployment.py
new file mode 100755
index 000000000000..8069d4a5f6b1
--- /dev/null
+++ b/test/functional/feature_reduced_data_temporary_deployment.py
@@ -0,0 +1,294 @@
+#!/usr/bin/env python3
+# Copyright (c) 2025 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Test temporary BIP9 deployment with active_duration parameter.
+
+This test verifies that a BIP9 deployment with active_duration properly expires
+after the specified number of blocks. We use REDUCED_DATA as the test deployment
+with active_duration=144 blocks.
+
+The test uses two nodes:
+- Node 0: BIP-110 enforcing (active_duration=144)
+- Node 1: Non-BIP-110 (never active, simulates Bitcoin Core)
+
+The test verifies:
+1. BIP9 state transitions: DEFINED -> STARTED -> LOCKED_IN -> ACTIVE
+2. Consensus rules ARE enforced during the active period (blocks 432-575)
+3. Chain split: BIP-110 node rejects invalid blocks, non-BIP-110 accepts
+4. Reorg: Longer valid chain wins when nodes reconnect
+5. Consensus rules STOP being enforced after expiry (block 576+)
+6. Post-expiry convergence: Both nodes accept the same blocks
+
+Expected timeline:
+- Period 0 (blocks 0-143): DEFINED
+- Period 1 (blocks 144-287): STARTED (signaling happens here)
+- Period 2 (blocks 288-431): LOCKED_IN
+- Period 3 (blocks 432-575): ACTIVE (144 blocks, rules enforced on node0 only)
+- Block 576+: EXPIRED (rules no longer enforced, nodes converge)
+"""
+
+from test_framework.blocktools import (
+    create_block,
+    create_coinbase,
+    add_witness_commitment,
+)
+from test_framework.messages import (
+    CTxOut,
+)
+from test_framework.script import (
+    CScript,
+    OP_RETURN,
+)
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import assert_equal
+from test_framework.wallet import MiniWallet
+
+REDUCED_DATA_BIT = 4
+VERSIONBITS_TOP_BITS = 0x20000000
+
+
+class TemporaryDeploymentTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 2
+        self.setup_clean_chain = True
+        # Node 0: BIP-110 with active_duration=144 blocks
+        # Node 1: BIP-110 never active (simulates Bitcoin Core)
+        # NEVER_ACTIVE = -2 for start_time prevents deployment from ever leaving DEFINED state
+        self.extra_args = [
+            ['-vbparams=reduced_data:0:999999999999:0:2147483647:144', '-acceptnonstdtxn=1'],
+            ['-vbparams=reduced_data:-2:-1', '-acceptnonstdtxn=1'],
+        ]
+
+    def setup_network(self):
+        self.setup_nodes()
+        self.connect_nodes(0, 1)
+
+    def create_block_for_node(self, node, txs=None, signal=False, time_offset=0):
+        """Create a block for a specific node."""
+        if txs is None:
+            txs = []
+        tip = node.getbestblockhash()
+        height = node.getblockcount() + 1
+        tip_header = node.getblockheader(tip)
+        block_time = tip_header['time'] + 1 + time_offset
+        block = create_block(int(tip, 16), create_coinbase(height), ntime=block_time, txlist=txs)
+        if signal:
+            block.nVersion = VERSIONBITS_TOP_BITS | (1 << REDUCED_DATA_BIT)
+        add_witness_commitment(block)
+        block.solve()
+        return block
+
+    def mine_blocks_on_node(self, node, count, signal=False):
+        """Mine count blocks on a specific node."""
+        for _ in range(count):
+            block = self.create_block_for_node(node, signal=signal)
+            node.submitblock(block.serialize().hex())
+
+    def create_tx_with_large_output(self, wallet):
+        """Create a transaction with 84-byte OP_RETURN (violates BIP-110's 83-byte limit)."""
+        tx_dict = wallet.create_self_transfer()
+        tx = tx_dict['tx']
+        # 81 bytes data = 84-byte script (OP_RETURN + OP_PUSHDATA1 + len + data)
+        tx.vout.append(CTxOut(0, CScript([OP_RETURN, b'x' * 81])))
+        return tx
+
+    def get_deployment_status(self, node):
+        """Get reduced_data deployment status."""
+        info = node.getdeploymentinfo()
+        rd = info['deployments']['reduced_data']
+        if 'bip9' in rd:
+            return rd['bip9']['status'], rd['bip9'].get('since', 'N/A')
+        return rd.get('status'), rd.get('since', 'N/A')
+
+    def run_test(self):
+        node_bip110 = self.nodes[0]
+        node_core = self.nodes[1]
+
+        wallet = MiniWallet(node_bip110)
+
+        # =====================================================================
+        # Phase 1: Build common chain through BIP9 state transitions
+        # =====================================================================
+        self.log.info("Phase 1: Building common chain through BIP9 states")
+
+        self.log.info("Mining initial blocks for spendable coins...")
+        self.generate(wallet, 101)
+        self.sync_all()
+
+        status, _ = self.get_deployment_status(node_bip110)
+        assert_equal(status, 'defined')
+
+        # Mine to end of period 0
+        self.log.info("Mining through period 0 (DEFINED)...")
+        self.generate(node_bip110, 42)
+        self.sync_all()
+        assert_equal(node_bip110.getblockcount(), 143)
+
+        # Period 1: Signal for activation
+        self.log.info("Mining period 1 with signaling (STARTED)...")
+        self.mine_blocks_on_node(node_bip110, 144, signal=True)
+        self.sync_all()
+        assert_equal(node_bip110.getblockcount(), 287)
+        status, _ = self.get_deployment_status(node_bip110)
+        assert_equal(status, 'started')
+
+        # Period 2: Lock in
+        self.log.info("Mining period 2 (LOCKED_IN)...")
+        self.mine_blocks_on_node(node_bip110, 144, signal=True)
+        self.sync_all()
+        assert_equal(node_bip110.getblockcount(), 431)
+        status, since = self.get_deployment_status(node_bip110)
+        assert_equal(status, 'locked_in')
+        assert_equal(since, 288)
+
+        # =====================================================================
+        # Phase 2: Test activation and chain split
+        # =====================================================================
+        self.log.info("Phase 2: Testing activation and chain split behavior")
+
+        # Mine block 432 (activation)
+        self.mine_blocks_on_node(node_bip110, 1)
+        self.sync_all()
+        assert_equal(node_bip110.getblockcount(), 432)
+        status, since = self.get_deployment_status(node_bip110)
+        self.log.info(f"Block 432 - Status: {status}, Since: {since}")
+        assert_equal(status, 'active')
+        assert_equal(since, 432)
+
+        # Disconnect nodes BEFORE creating invalid block to prevent P2P relay
+        # (Bitcoin Core relays blocks via compact blocks before full validation completes)
+        self.log.info("Disconnecting nodes for chain split test...")
+        self.disconnect_nodes(0, 1)
+
+        # Create the invalid block (84-byte OP_RETURN violates BIP-110's 83-byte limit)
+        self.log.info("Test: BIP-110 node rejects block with 84-byte OP_RETURN output")
+        tx_invalid = self.create_tx_with_large_output(wallet)
+        block_invalid = self.create_block_for_node(node_bip110, [tx_invalid])
+
+        # Submit to BIP-110 node - should be rejected
+        result_bip110 = node_bip110.submitblock(block_invalid.serialize().hex())
+        assert_equal(result_bip110, 'bad-txns-vout-script-toolarge')
+        assert_equal(node_bip110.getblockcount(), 432)
+
+        # Submit to non-BIP-110 node - should be accepted
+        self.log.info("Test: Non-BIP-110 node accepts the same block")
+        result_core = node_core.submitblock(block_invalid.serialize().hex())
+        assert_equal(result_core, None)
+        assert_equal(node_core.getblockcount(), 433)
+
+        # Chain split confirmed
+        self.log.info(f"Chain split: BIP-110={node_bip110.getblockcount()}, Core={node_core.getblockcount()}")
+
+        # =====================================================================
+        # Phase 3: Test reorg behavior
+        # =====================================================================
+        self.log.info("Phase 3: Testing reorg behavior")
+
+        # Non-BIP-110 extends its chain
+        self.log.info("Non-BIP-110 node extends chain with 3 more blocks...")
+        for i in range(3):
+            block = self.create_block_for_node(node_core, time_offset=i)
+            node_core.submitblock(block.serialize().hex())
+        assert_equal(node_core.getblockcount(), 436)
+
+        # BIP-110 node builds longer valid chain
+        self.log.info("BIP-110 node builds longer valid chain (5 blocks)...")
+        for i in range(5):
+            block = self.create_block_for_node(node_bip110, time_offset=i+10)
+            node_bip110.submitblock(block.serialize().hex())
+        assert_equal(node_bip110.getblockcount(), 437)
+
+        # Reconnect - non-BIP-110 should reorg to BIP-110's chain
+        self.log.info("Reconnecting nodes - expecting reorg...")
+        self.connect_nodes(0, 1)
+        self.sync_blocks()
+
+        assert_equal(node_core.getbestblockhash(), node_bip110.getbestblockhash())
+        assert_equal(node_core.getblockcount(), 437)
+        self.log.info(f"Reorg complete: both nodes at height {node_core.getblockcount()}")
+
+        # =====================================================================
+        # Phase 4: Test rules enforced until expiry
+        # =====================================================================
+        self.log.info("Phase 4: Testing rules enforced until expiry")
+
+        # Mine to block 574 (one before last active block)
+        # active_duration=144, activation at 432, so last active block is 432+144-1=575
+        blocks_to_574 = 574 - node_bip110.getblockcount()
+        self.log.info(f"Mining {blocks_to_574} blocks to reach block 574...")
+        self.generate(node_bip110, blocks_to_574)
+        self.sync_all()
+        assert_equal(node_bip110.getblockcount(), 574)
+
+        # Disconnect nodes to prevent compact block relay of invalid block
+        self.disconnect_nodes(0, 1)
+
+        # Verify rules still enforced at block 575 (last active block)
+        self.log.info("Test: Rules still enforced at block 575 (last active block)")
+        tx_invalid = self.create_tx_with_large_output(wallet)
+        block_invalid = self.create_block_for_node(node_bip110, [tx_invalid])
+        result = node_bip110.submitblock(block_invalid.serialize().hex())
+        assert_equal(result, 'bad-txns-vout-script-toolarge')
+
+        # Mine valid block 575 (last active block)
+        block_valid = self.create_block_for_node(node_bip110)
+        node_bip110.submitblock(block_valid.serialize().hex())
+        assert_equal(node_bip110.getblockcount(), 575)
+
+        # Reconnect and sync
+        self.connect_nodes(0, 1)
+        self.sync_all()
+
+        # =====================================================================
+        # Phase 5: Test expiry - rules no longer enforced
+        # =====================================================================
+        self.log.info("Phase 5: Testing expiry - rules no longer enforced")
+
+        # At block 576, deployment has expired (first expired block = 432 + 144)
+        self.log.info("Test: BIP-110 node accepts 'invalid' block at height 576 (expired)")
+        tx_invalid = self.create_tx_with_large_output(wallet)
+        block_after_expiry = self.create_block_for_node(node_bip110, [tx_invalid])
+        result = node_bip110.submitblock(block_after_expiry.serialize().hex())
+        assert_equal(result, None)
+        self.sync_all()
+        assert_equal(node_bip110.getblockcount(), 576)
+
+        # Verify state machine reports EXPIRED
+        status, since = self.get_deployment_status(node_bip110)
+        self.log.info(f"Block 576: Status={status}, Since={since}")
+        assert_equal(status, 'expired')
+        assert_equal(since, 576)
+
+        # =====================================================================
+        # Phase 6: Test post-expiry convergence
+        # =====================================================================
+        self.log.info("Phase 6: Testing post-expiry convergence")
+
+        # Both nodes should accept the same "invalid" blocks now
+        self.log.info("Test: Both nodes accept 'invalid' blocks after expiry")
+        for i in range(5):
+            tx = self.create_tx_with_large_output(wallet)
+            block = self.create_block_for_node(node_bip110, [tx], time_offset=i)
+            result_bip110 = node_bip110.submitblock(block.serialize().hex())
+            assert_equal(result_bip110, None)
+            self.sync_all()
+            assert_equal(node_core.getbestblockhash(), node_bip110.getbestblockhash())
+
+        final_height = node_bip110.getblockcount()
+        self.log.info(f"Final height: {final_height}, both nodes synced")
+
+        # =====================================================================
+        # Summary
+        # =====================================================================
+        self.log.info("All tests passed:")
+        self.log.info("  - BIP9 state transitions (DEFINED -> STARTED -> LOCKED_IN -> ACTIVE -> EXPIRED)")
+        self.log.info("  - Chain split at activation (BIP-110 rejects, Core accepts)")
+        self.log.info("  - Reorg to longer valid chain on reconnect")
+        self.log.info("  - Rules enforced during active period (432-575)")
+        self.log.info("  - Rules not enforced after expiry (576+)")
+        self.log.info("  - Post-expiry convergence (both nodes accept same blocks)")
+
+
+if __name__ == '__main__':
+    TemporaryDeploymentTest(__file__).main()
diff --git a/test/functional/feature_reduced_data_utxo_height.py b/test/functional/feature_reduced_data_utxo_height.py
new file mode 100755
index 000000000000..bba383d5f5d7
--- /dev/null
+++ b/test/functional/feature_reduced_data_utxo_height.py
@@ -0,0 +1,518 @@
+#!/usr/bin/env python3
+# Copyright (c) 2025 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 REDUCED_DATA soft fork UTXO height checking.
+
+This test verifies that the REDUCED_DATA deployment correctly exempts UTXOs
+created before ReducedDataHeightBegin from reduced_data script validation rules,
+as implemented in validation.cpp.
+
+Test scenarios:
+1. Old UTXO (created before activation) spent during active period with violation - should be ACCEPTED (EXEMPT)
+2. New UTXO (created during active period) spent with violation - should be REJECTED
+3. Mixed inputs (old + new UTXOs) in same transaction
+4. Boundary test: UTXO created at exactly ReducedDataHeightBegin
+"""
+
+from io import BytesIO
+
+from test_framework.blocktools import (
+    COINBASE_MATURITY,
+    create_block,
+    create_coinbase,
+    add_witness_commitment,
+)
+from test_framework.messages import (
+    COutPoint,
+    CTransaction,
+    CTxIn,
+    CTxInWitness,
+    CTxOut,
+)
+from test_framework.p2p import P2PDataStore
+from test_framework.script import (
+    CScript,
+    OP_TRUE,
+    OP_DROP,
+)
+from test_framework.script_util import (
+    script_to_p2wsh_script,
+)
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import (
+    assert_equal,
+)
+from test_framework.wallet import MiniWallet
+
+
+# BIP9 constants for regtest
+BIP9_PERIOD = 144  # blocks per period in regtest
+BIP9_THRESHOLD = 108  # 75% of 144
+VERSIONBITS_TOP_BITS = 0x20000000
+REDUCED_DATA_BIT = 4
+
+# REDUCED_DATA enforces MAX_SCRIPT_ELEMENT_SIZE_REDUCED (256) instead of MAX_SCRIPT_ELEMENT_SIZE (520)
+MAX_ELEMENT_SIZE_STANDARD = 520
+MAX_ELEMENT_SIZE_REDUCED = 256
+VIOLATION_SIZE = 300  # Violates reduced (256) but OK for standard (520)
+
+
+class ReducedDataUTXOHeightTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 1
+        self.setup_clean_chain = True
+        # Activate REDUCED_DATA using BIP9 with min_activation_height=288
+        # Due to BIP9 design, period 0 is always DEFINED, so signaling happens in period 1
+        # This activates at height 432 (start of period 3)
+        # Format: deployment:start:timeout:min_activation_height:max_activation_height:active_duration
+        # start_time=0, timeout=999999999999 (never), min_activation_height=288, max=2147483647 (INT_MAX, disabled), active_duration=2147483647 (permanent)
+        self.extra_args = [[
+            '-vbparams=reduced_data:0:999999999999:288:2147483647:2147483647',
+        ]]
+
+    def create_p2wsh_funding_and_spending_tx(self, wallet, node, witness_element_size):
+        """Create a P2WSH output, then a transaction spending it with custom witness size.
+
+        Returns:
+            tuple: (funding_tx, spending_tx) where funding_tx creates P2WSH output,
+                   spending_tx spends it with witness element of specified size
+        """
+        # Create a simple witness script: <data> OP_DROP OP_TRUE
+        # This allows us to put arbitrary data in the witness
+        witness_script = CScript([OP_DROP, OP_TRUE])
+        script_pubkey = script_to_p2wsh_script(witness_script)
+
+        # Use MiniWallet to create funding transaction to P2WSH output
+        funding_txid = wallet.send_to(from_node=node, scriptPubKey=script_pubkey, amount=100000)['txid']
+        funding_tx_hex = node.getrawtransaction(funding_txid)
+        funding_tx = CTransaction()
+        funding_tx.deserialize(BytesIO(bytes.fromhex(funding_tx_hex)))
+        funding_tx.txid_hex  # Calculate sha256 hash after deserializing
+
+        # Find the P2WSH output
+        p2wsh_vout = None
+        for i, vout in enumerate(funding_tx.vout):
+            if vout.scriptPubKey == script_pubkey:
+                p2wsh_vout = i
+                break
+        assert p2wsh_vout is not None, "P2WSH output not found"
+
+        # Spending transaction: spend P2WSH output with custom witness
+        spending_tx = CTransaction()
+        spending_tx.vin = [CTxIn(COutPoint(funding_tx.txid_int, p2wsh_vout))]
+        spending_tx.vout = [CTxOut(funding_tx.vout[p2wsh_vout].nValue - 1000, CScript([OP_TRUE]))]
+
+        # Create witness with element of specified size
+        spending_tx.wit.vtxinwit.append(CTxInWitness())
+        spending_tx.wit.vtxinwit[0].scriptWitness.stack = [
+            b'\x42' * witness_element_size,  # Data element of specified size
+            witness_script  # Witness script
+        ]
+        spending_tx.txid_hex
+
+        return funding_tx, spending_tx
+
+    def create_test_block(self, txs, signal=False):
+        """Create a block with the given transactions."""
+        # Always get fresh tip and height to ensure blocks chain correctly
+        tip = self.nodes[0].getbestblockhash()
+        height = self.nodes[0].getblockcount() + 1
+        tip_header = self.nodes[0].getblockheader(tip)
+        block_time = tip_header['time'] + 1
+        block = create_block(int(tip, 16), create_coinbase(height), ntime=block_time, txlist=txs)
+        if signal:
+            block.nVersion = VERSIONBITS_TOP_BITS | (1 << REDUCED_DATA_BIT)
+        add_witness_commitment(block)
+        block.solve()
+        return block
+
+    def mine_blocks(self, count, signal=False):
+        """Mine blocks with optional BIP9 signaling for REDUCED_DATA."""
+        for _ in range(count):
+            block = self.create_test_block([], signal=signal)
+            result = self.nodes[0].submitblock(block.serialize().hex())
+            if result is not None:
+                raise AssertionError(f"submitblock failed: {result}")
+            # Verify block was accepted
+            assert self.nodes[0].getbestblockhash() == block.hash_hex
+
+    def run_test(self):
+        node = self.nodes[0]
+        self.peer = node.add_p2p_connection(P2PDataStore())
+
+        # Use MiniWallet for easy UTXO management
+        wallet = MiniWallet(node)
+
+        self.log.info("Mining blocks to activate REDUCED_DATA via BIP9...")
+
+        # BIP9 state timeline with start_time=0:
+        # - Period 0 (blocks 0-143): DEFINED (cannot signal yet)
+        # - Period 1 (blocks 144-287): STARTED (signal here with 108/144 threshold)
+        # - Period 2 (blocks 288-431): LOCKED_IN (if threshold met in period 1)
+        # - Period 3 (blocks 432-575): ACTIVE
+
+        # Mine through period 0 (DEFINED state)
+        self.log.info("Mining through period 0 (DEFINED)...")
+        self.generate(wallet, 144)
+        self.log.info(f"DEBUG: After period 0, height = {node.getblockcount()}")
+
+        # Mine 108 signaling blocks in period 1 (STARTED state)
+        self.log.info("Mining 108 signaling blocks in period 1 (blocks 144-251)...")
+        self.mine_blocks(108, signal=True)
+        self.log.info(f"DEBUG: After 108 signaling blocks, height = {node.getblockcount()}")
+
+        # Mine to end of period 1 (block 287)
+        self.log.info("Mining to end of period 1 (block 287)...")
+        self.mine_blocks(287 - 144 - 108, signal=False)
+        self.log.info(f"DEBUG: After period 1, height = {node.getblockcount()}")
+
+        # Check that we're LOCKED_IN at start of period 2
+        self.generate(wallet, 1)  # Mine block 288
+        self.log.info(f"DEBUG: After mining block 288, height = {node.getblockcount()}")
+        deployment_info = node.getdeploymentinfo()
+        rd_info = deployment_info['deployments']['reduced_data']
+        if 'bip9' in rd_info:
+            status = rd_info['bip9']['status']
+            self.log.info(f"At height {node.getblockcount()}, REDUCED_DATA status: {status}")
+            assert status == 'locked_in', f"Expected LOCKED_IN at block 288, got {status}"
+        else:
+            raise AssertionError("REDUCED_DATA deployment not found")
+
+        # Mine to block 432 (start of period 3) where activation occurs
+        self.log.info("Mining to block 432 for activation...")
+        self.generate(wallet, 432 - 288)
+
+        current_height = node.getblockcount()
+
+        # Check activation status
+        deployment_info = node.getdeploymentinfo()
+        rd_info = deployment_info['deployments']['reduced_data']
+        if 'bip9' in rd_info:
+            status = rd_info['bip9']['status']
+            self.log.info(f"At height {current_height}, REDUCED_DATA status: {status}")
+            if status == 'active':
+                ACTIVATION_HEIGHT = rd_info['bip9']['since']
+            else:
+                raise AssertionError(f"REDUCED_DATA not active at height {current_height}, status: {status}")
+        else:
+            raise AssertionError("REDUCED_DATA deployment not found")
+
+        self.log.info(f"✓ REDUCED_DATA activated at height {ACTIVATION_HEIGHT}")
+        assert ACTIVATION_HEIGHT == 432, f"Expected activation at 432, got {ACTIVATION_HEIGHT}"
+
+        # Initialize wallet with some coins
+        self.generate(wallet, COINBASE_MATURITY + 10)
+        current_height = node.getblockcount()
+
+        # Now rewind to before activation to create test UTXOs
+        # Rewind to 20 blocks before activation
+        target_height = ACTIVATION_HEIGHT - 20
+        blocks_to_invalidate = current_height - target_height
+        self.log.info(f"Rewinding {blocks_to_invalidate} blocks to height {target_height}...")
+        for _ in range(blocks_to_invalidate):
+            node.invalidateblock(node.getbestblockhash())
+
+        assert_equal(node.getblockcount(), target_height)
+
+        # ======================================================================
+        # Test 1: Create OLD UTXO before activation
+        # ======================================================================
+        self.log.info("Test 1: Creating P2WSH UTXO before activation height...")
+
+        # Create P2WSH funding transaction for old UTXO
+        old_funding_tx, old_spending_tx = self.create_p2wsh_funding_and_spending_tx(
+            wallet, node, VIOLATION_SIZE
+        )
+
+        # Confirm the funding transaction in a block
+        block = self.create_test_block([old_funding_tx], signal=False)
+        node.submitblock(block.serialize().hex())
+        old_utxo_height = node.getblockcount()
+
+        self.log.info(f"Created old P2WSH UTXO at height {old_utxo_height} (< {ACTIVATION_HEIGHT})")
+
+        # ======================================================================
+        # Test 2: Mine to activation height
+        # ======================================================================
+        self.log.info("Test 2: Mining to activation height...")
+
+        current_height = node.getblockcount()
+        blocks_to_activation = ACTIVATION_HEIGHT - current_height
+        if blocks_to_activation > 0:
+            self.mine_blocks(blocks_to_activation, signal=False)
+
+        current_height = node.getblockcount()
+        assert_equal(current_height, ACTIVATION_HEIGHT)
+        self.log.info(f"At activation height: {current_height}")
+
+        # Verify REDUCED_DATA is active
+        deployment_info = node.getdeploymentinfo()
+        rd_info = deployment_info['deployments']['reduced_data']
+        if 'bip9' in rd_info:
+            status = rd_info['bip9']['status']
+        else:
+            status = 'active' if rd_info.get('active') else 'unknown'
+        assert status == 'active', f"Expected 'active' at height {current_height}, got '{status}'"
+
+        # ======================================================================
+        # Test 3: Create NEW UTXO at/after activation
+        # ======================================================================
+        self.log.info("Test 3: Creating P2WSH UTXO at activation height...")
+
+        # Create P2WSH funding transaction for new UTXO
+        new_funding_tx, new_spending_tx = self.create_p2wsh_funding_and_spending_tx(
+            wallet, node, VIOLATION_SIZE
+        )
+
+        # Confirm the funding transaction in a block
+        block = self.create_test_block([new_funding_tx], signal=False)
+        node.submitblock(block.serialize().hex())
+        new_utxo_height = node.getblockcount()
+
+        self.log.info(f"Created new P2WSH UTXO at height {new_utxo_height} (>= {ACTIVATION_HEIGHT})")
+
+        # Mine a few more blocks
+        self.mine_blocks(5, signal=False)
+        current_height = node.getblockcount()
+        self.log.info(f"Current height: {current_height}")
+
+        # ======================================================================
+        # Test 4: Spend OLD UTXO with oversized witness - should be ACCEPTED
+        # ======================================================================
+        self.log.info(f"Test 4: Spending old UTXO (height {old_utxo_height}) with {VIOLATION_SIZE}-byte witness element...")
+        self.log.info(f"        This violates REDUCED_DATA ({MAX_ELEMENT_SIZE_REDUCED} limit) but old UTXOs should be EXEMPT")
+
+        # Try to mine block with old_spending_tx (has 300-byte witness element)
+        block = self.create_test_block([old_spending_tx], signal=False)
+        result = node.submitblock(block.serialize().hex())
+        assert result is None, f"Expected success, got: {result}"
+
+        self.log.info(f"✓ SUCCESS: Old UTXO with {VIOLATION_SIZE}-byte witness element was ACCEPTED (correctly exempt)")
+
+        # ======================================================================
+        # Test 5: Spend NEW UTXO with oversized witness - should be REJECTED
+        # ======================================================================
+        self.log.info(f"Test 5: Spending new UTXO (height {new_utxo_height}) with {VIOLATION_SIZE}-byte witness element...")
+        self.log.info(f"        This violates REDUCED_DATA ({MAX_ELEMENT_SIZE_REDUCED} limit) and should be REJECTED")
+
+        # Try to mine block with new_spending_tx (has 300-byte witness element)
+        block = self.create_test_block([new_spending_tx], signal=False)
+        result = node.submitblock(block.serialize().hex())
+        assert result is not None and 'script-verify-flag-failed' in result, f"Expected rejection, got: {result}"
+
+        self.log.info(f"✓ SUCCESS: New UTXO with {VIOLATION_SIZE}-byte witness element was REJECTED (correctly enforced)")
+
+        # ======================================================================
+        # Test 6: Boundary test - UTXO at exactly ReducedDataHeightBegin
+        # ======================================================================
+        self.log.info(f"Test 6: Boundary test - verifying UTXO at activation height {ACTIVATION_HEIGHT}...")
+
+        # The new_funding_tx was confirmed at height ACTIVATION_HEIGHT+1, but let's create one AT height ACTIVATION_HEIGHT
+        # First, invalidate back to height ACTIVATION_HEIGHT-1
+        current_tip = node.getbestblockhash()
+        blocks_to_invalidate = node.getblockcount() - (ACTIVATION_HEIGHT - 1)
+        for _ in range(blocks_to_invalidate):
+            node.invalidateblock(node.getbestblockhash())
+
+        assert_equal(node.getblockcount(), ACTIVATION_HEIGHT - 1)
+        self.log.info(f"        Rewound to height {node.getblockcount()}")
+
+        # Create UTXO exactly at activation height
+        boundary_funding_tx, boundary_spending_tx = self.create_p2wsh_funding_and_spending_tx(
+            wallet, node, VIOLATION_SIZE
+        )
+        block = self.create_test_block([boundary_funding_tx], signal=False)
+        result = node.submitblock(block.serialize().hex())
+        assert result is None, f"Expected success, got: {result}"
+        boundary_height = node.getblockcount()
+        assert_equal(boundary_height, ACTIVATION_HEIGHT)
+
+        self.log.info(f"        Created boundary UTXO at height {boundary_height} (exactly at activation)")
+
+        # Mine a few blocks past activation
+        self.mine_blocks(5, signal=False)
+
+        # Try to spend boundary UTXO - should be REJECTED (height ACTIVATION_HEIGHT >= ACTIVATION_HEIGHT)
+        self.log.info(f"        Spending boundary UTXO with {VIOLATION_SIZE}-byte witness (should be REJECTED)")
+        block = self.create_test_block([boundary_spending_tx], signal=False)
+        result = node.submitblock(block.serialize().hex())
+        assert result is not None and 'script-verify-flag-failed' in result, f"Expected rejection, got: {result}"
+
+        self.log.info(f"✓ SUCCESS: UTXO at exactly activation height {ACTIVATION_HEIGHT} is SUBJECT to rules (not exempt)")
+
+        # Restore chain to where we were
+        node.reconsiderblock(current_tip)
+
+        # ======================================================================
+        # Test 7: Mixed inputs - one old (exempt) + one new (subject to rules)
+        # ======================================================================
+        self.log.info("Test 7: Creating transaction with mixed inputs (old + new UTXOs)...")
+
+        # We need fresh old and new UTXOs. Rewind to before activation again
+        current_tip2 = node.getbestblockhash()
+        blocks_to_invalidate = node.getblockcount() - (ACTIVATION_HEIGHT - 20)
+        for _ in range(blocks_to_invalidate):
+            node.invalidateblock(node.getbestblockhash())
+
+        # Create OLD UTXO at height before activation
+        old_mixed_funding, old_mixed_spending = self.create_p2wsh_funding_and_spending_tx(
+            wallet, node, VIOLATION_SIZE
+        )
+        block = self.create_test_block([old_mixed_funding], signal=False)
+        node.submitblock(block.serialize().hex())
+        old_mixed_height = node.getblockcount()
+        self.log.info(f"        Created old UTXO at height {old_mixed_height}")
+
+        # Mine to after activation
+        blocks_to_mine = ACTIVATION_HEIGHT - node.getblockcount() + 5
+        self.mine_blocks(blocks_to_mine, signal=False)
+
+        # Create NEW UTXO at height after activation
+        new_mixed_funding, new_mixed_spending = self.create_p2wsh_funding_and_spending_tx(
+            wallet, node, VIOLATION_SIZE
+        )
+        block = self.create_test_block([new_mixed_funding], signal=False)
+        node.submitblock(block.serialize().hex())
+        new_mixed_height = node.getblockcount()
+        self.log.info(f"        Created new UTXO at height {new_mixed_height}")
+
+        # Find P2WSH outputs in funding transactions
+        witness_script = CScript([OP_DROP, OP_TRUE])
+        script_pubkey = script_to_p2wsh_script(witness_script)
+
+        old_p2wsh_vout = None
+        for i, vout in enumerate(old_mixed_funding.vout):
+            if vout.scriptPubKey == script_pubkey:
+                old_p2wsh_vout = i
+                break
+
+        new_p2wsh_vout = None
+        for i, vout in enumerate(new_mixed_funding.vout):
+            if vout.scriptPubKey == script_pubkey:
+                new_p2wsh_vout = i
+                break
+
+        # Create transaction with BOTH inputs
+        mixed_tx = CTransaction()
+        mixed_tx.vin = [
+            CTxIn(COutPoint(old_mixed_funding.txid_int, old_p2wsh_vout)),  # Old UTXO (exempt)
+            CTxIn(COutPoint(new_mixed_funding.txid_int, new_p2wsh_vout)),  # New UTXO (subject to rules)
+        ]
+        total_value = (old_mixed_funding.vout[old_p2wsh_vout].nValue +
+                      new_mixed_funding.vout[new_p2wsh_vout].nValue - 2000)
+        mixed_tx.vout = [CTxOut(total_value, CScript([OP_TRUE]))]
+
+        # Add witness for both inputs - both with 300-byte elements
+        mixed_tx.wit.vtxinwit = []
+
+        # Input 0: old UTXO (would pass alone)
+        wit0 = CTxInWitness()
+        wit0.scriptWitness.stack = [b'\x42' * VIOLATION_SIZE, witness_script]
+        mixed_tx.wit.vtxinwit.append(wit0)
+
+        # Input 1: new UTXO (would fail)
+        wit1 = CTxInWitness()
+        wit1.scriptWitness.stack = [b'\x42' * VIOLATION_SIZE, witness_script]
+        mixed_tx.wit.vtxinwit.append(wit1)
+
+        mixed_tx.txid_hex
+
+        self.log.info(f"        Mixed tx: old UTXO (height {old_mixed_height}, exempt) + new UTXO (height {new_mixed_height}, subject)")
+        self.log.info(f"        Both inputs have {VIOLATION_SIZE}-byte witness elements")
+
+        # Try to mine block - should REJECT because new input violates
+        self.mine_blocks(2, signal=False)
+        block = self.create_test_block([mixed_tx], signal=False)
+        result = node.submitblock(block.serialize().hex())
+        assert result is not None and 'script-verify-flag-failed' in result, f"Expected rejection, got: {result}"
+
+        self.log.info("✓ SUCCESS: Mixed transaction REJECTED (new input violated rules, even though old input was exempt)")
+
+        # Restore chain
+        node.reconsiderblock(current_tip2)
+
+        # ======================================================================
+        # Test 8: cache state must not survive activation-boundary reorg
+        # ======================================================================
+        self.log.info("Test 8: script-execution cache must not survive boundary-context flip")
+
+        def rewind_to(height):
+            # Height-based loop: invalidating one tip can switch to an alternate branch at same height.
+            while node.getblockcount() > height:
+                node.invalidateblock(node.getbestblockhash())
+            assert_equal(node.getblockcount(), height)
+
+        branch_point = ACTIVATION_HEIGHT - 2  # 430
+        rewind_to(branch_point)
+
+        # spend_tx has a 300-byte witness element: valid only with pre-activation exemption.
+        funding_tx, spend_tx = self.create_p2wsh_funding_and_spending_tx(wallet, node, VIOLATION_SIZE)
+
+        # Branch A: funding at 431 (exempt).
+        block = self.create_test_block([funding_tx], signal=False)
+        assert_equal(node.submitblock(block.serialize().hex()), None)
+        assert_equal(node.getblockcount(), ACTIVATION_HEIGHT - 1)
+
+        self.restart_node(0, extra_args=['-vbparams=reduced_data:0:999999999999:288:2147483647:2147483647', '-par=1'])  # Use single-threaded validation to maximize chance of hitting cache-related issues.
+
+        # Validate-only block at height 432. This calls TestBlockValidity(fJustCheck=true),
+        # which populates the tx-wide script-execution cache under STRICT flags, even though
+        # the spend is only valid here due to the per-input "pre-activation UTXO" exemption.
+        self.generateblock(node, output=wallet.get_address(), transactions=[spend_tx.serialize().hex()], submit=False, sync_fun=self.no_op)
+
+        assert_equal(node.getblockcount(), ACTIVATION_HEIGHT - 1)
+
+        # Reorg to branch point; cache state is intentionally retained across reorg.
+        rewind_to(branch_point)
+
+        # Branch B: funding at 432 (non-exempt).
+        # Make this empty block unique to avoid duplicate-invalid when rebuilding branch B.
+        block = self.create_test_block([], signal=False)
+        block.nTime += 1
+        block.solve()
+        assert_equal(node.submitblock(block.serialize().hex()), None)  # 431
+        block = self.create_test_block([funding_tx], signal=False)
+        assert_equal(node.submitblock(block.serialize().hex()), None)  # 432
+
+        # Same spend is now non-exempt and must be rejected.
+        attack_block = self.create_test_block([spend_tx], signal=False)  # 433
+        result = node.submitblock(attack_block.serialize().hex())
+        assert result is not None and 'Push value size limit exceeded' in result, \
+            f"Expected rejection after boundary-crossing reorg, got: {result}"
+
+        self.log.info("✓ SUCCESS: Cache poisoning via activation-boundary reorg correctly prevented")
+
+        # ======================================================================
+        # Summary
+        # ======================================================================
+        self.log.info(f"""
+        ============================================================
+        TEST SUMMARY - UTXO Height-Based REDUCED_DATA Enforcement
+        ============================================================
+
+        ✓ Test 1-3: Setup old and new UTXOs at correct heights
+        ✓ Test 4: Old UTXO (height < {ACTIVATION_HEIGHT}) is EXEMPT - 300-byte witness ACCEPTED
+        ✓ Test 5: New UTXO (height >= {ACTIVATION_HEIGHT}) is SUBJECT - 300-byte witness REJECTED
+        ✓ Test 6: Boundary condition - UTXO at exactly height {ACTIVATION_HEIGHT} is SUBJECT
+        ✓ Test 7: Mixed inputs - transaction rejected if ANY input violates
+        ✓ Test 8: Cache poisoning via activation-boundary reorg prevented
+
+        Key validations:
+        • REDUCED_DATA activated via BIP9 signaling at height {ACTIVATION_HEIGHT}
+        • UTXOs created before activation height are EXEMPT from rules
+        • UTXOs created at/after activation height are SUBJECT to rules
+        • Per-input validation flags work correctly (validation.cpp)
+        • Boundary at activation height uses >= operator (not >)
+
+        This confirms the implementation of UTXO height exemption:
+        "Exempt inputs spending UTXOs prior to ReducedDataHeightBegin from
+        reduced_data script validation rules"
+
+        All 8 tests passed!
+        ============================================================
+        """)
+
+
+if __name__ == '__main__':
+    ReducedDataUTXOHeightTest(__file__).main()
diff --git a/test/functional/feature_taproot.py b/test/functional/feature_taproot.py
index 8891e0f9994b..3deb9446f3cc 100755
--- a/test/functional/feature_taproot.py
+++ b/test/functional/feature_taproot.py
@@ -81,6 +81,7 @@
     SIGHASH_ANYONECANPAY,
     SegwitV0SignatureMsg,
     TaggedHash,
+    TAPROOT_CONTROL_MAX_NODE_COUNT_REDUCED,
     TaprootSignatureMsg,
     is_op_success,
     taproot_construct,
@@ -778,10 +779,12 @@ def spenders_taproot_active():
         tap = taproot_construct(pubs[0], scripts)
         add_spender(spenders, "sighash/pk_codesep", tap=tap, leaf="pk_codesep", key=secs[1], **common, **SINGLE_SIG, **SIGHASH_BITFLIP, **ERR_SCHNORR_SIG)
         add_spender(spenders, "sighash/codesep_pk", tap=tap, leaf="codesep_pk", key=secs[1], codeseppos=0, **common, **SINGLE_SIG, **SIGHASH_BITFLIP, **ERR_SCHNORR_SIG)
-        add_spender(spenders, "sighash/branched_codesep/left", tap=tap, leaf="branched_codesep", key=secs[0], codeseppos=3, **common, inputs=[getter("sign"), b'\x01'], **SIGHASH_BITFLIP, **ERR_SCHNORR_SIG)
-        add_spender(spenders, "sighash/branched_codesep/right", tap=tap, leaf="branched_codesep", key=secs[1], codeseppos=6, **common, inputs=[getter("sign"), b''], **SIGHASH_BITFLIP, **ERR_SCHNORR_SIG)
         add_spender(spenders, "sighash/codesep_pk_wrongpos1", tap=tap, leaf="codesep_pk", key=secs[1], codeseppos=0, **common, **SINGLE_SIG, failure={"codeseppos": 1}, **ERR_SCHNORR_SIG)
         add_spender(spenders, "sighash/codesep_pk_wrongpos2", tap=tap, leaf="codesep_pk", key=secs[1], codeseppos=0, **common, **SINGLE_SIG, failure={"codeseppos": 0xfffffffe}, **ERR_SCHNORR_SIG)
+        common['standard'] = False
+        add_spender(spenders, "sighash/branched_codesep/left", tap=tap, leaf="branched_codesep", key=secs[0], codeseppos=3, **common, inputs=[getter("sign"), b'\x01'], **SIGHASH_BITFLIP, **ERR_SCHNORR_SIG)
+        add_spender(spenders, "sighash/branched_codesep/right", tap=tap, leaf="branched_codesep", key=secs[1], codeseppos=6, **common, inputs=[getter("sign"), b''], **SIGHASH_BITFLIP, **ERR_SCHNORR_SIG)
+        common['standard'] = no_annex
 
     # Reusing the scripts above, test that various features affect the sighash.
     add_spender(spenders, "sighash/annex", tap=tap, leaf="pk_codesep", key=secs[1], hashtype=hashtype, standard=False, **SINGLE_SIG, annex=bytes([ANNEX_TAG]), failure={"sighash": override(default_sighash, annex=None)}, **ERR_SCHNORR_SIG)
@@ -895,6 +898,8 @@ def mutate(spk):
         scripts = [scripts, random.choice(PARTNER_MERKLE_FN)]
     tap = taproot_construct(pubs[0], scripts)
     # Test that spends with a depth of 128 work, but 129 doesn't (even with a tree with weird Merkle branches in it).
+    assert 'standard' not in SINGLE_SIG
+    SINGLE_SIG['standard'] = False
     add_spender(spenders, "spendpath/merklelimit", tap=tap, leaf="128deep", **SINGLE_SIG, key=secs[0], failure={"leaf": "129deep"}, **ERR_TAPROOT_WRONG_CONTROL_SIZE)
     # Test that flipping the negation bit invalidates spends.
     add_spender(spenders, "spendpath/negflag", tap=tap, leaf="128deep", **SINGLE_SIG, key=secs[0], failure={"negflag": lambda ctx: 1 - default_negflag(ctx)}, **ERR_WITNESS_PROGRAM_MISMATCH)
@@ -908,6 +913,7 @@ def mutate(spk):
     add_spender(spenders, "spendpath/padlongcontrol", tap=tap, leaf="128deep", **SINGLE_SIG, key=secs[0], failure={"controlblock": lambda ctx: default_controlblock(ctx) + random.randbytes(random.randrange(1, 32))}, **ERR_TAPROOT_WRONG_CONTROL_SIZE)
     # Test that truncating the control block invalidates it.
     add_spender(spenders, "spendpath/trunclongcontrol", tap=tap, leaf="128deep", **SINGLE_SIG, key=secs[0], failure={"controlblock": lambda ctx: default_merklebranch(ctx)[0:random.randrange(1, 32)]}, **ERR_TAPROOT_WRONG_CONTROL_SIZE)
+    del SINGLE_SIG['standard']
 
     scripts = [("s", CScript([pubs[0], OP_CHECKSIG]))]
     tap = taproot_construct(pubs[1], scripts)
@@ -1026,7 +1032,7 @@ def big_spend_inputs(ctx):
         ("t36", CScript([])),
     ]
     # Add many dummies to test huge trees
-    for j in range(100000):
+    for j in range(min(100000, 2**TAPROOT_CONTROL_MAX_NODE_COUNT_REDUCED - len(scripts))):
         scripts.append((None, CScript([OP_RETURN, random.randrange(100000)])))
     random.shuffle(scripts)
     tap = taproot_construct(pubs[0], scripts)
@@ -1043,10 +1049,13 @@ def big_spend_inputs(ctx):
     add_spender(spenders, "tapscript/disabled_checkmultisig", leaf="t1", **common, **SINGLE_SIG, failure={"leaf": "t3"}, **ERR_TAPSCRIPT_CHECKMULTISIG)
     add_spender(spenders, "tapscript/disabled_checkmultisigverify", leaf="t2", **common, **SINGLE_SIG, failure={"leaf": "t4"}, **ERR_TAPSCRIPT_CHECKMULTISIG)
     # Test that OP_IF and OP_NOTIF do not accept non-0x01 as truth value (the MINIMALIF rule is consensus in Tapscript)
+    assert 'standard' not in common
+    common['standard'] = False
     add_spender(spenders, "tapscript/minimalif", leaf="t5", **common, inputs=[getter("sign"), b'\x01'], failure={"inputs": [getter("sign"), b'\x02']}, **ERR_TAPSCRIPT_MINIMALIF)
     add_spender(spenders, "tapscript/minimalnotif", leaf="t6", **common, inputs=[getter("sign"), b'\x01'], failure={"inputs": [getter("sign"), b'\x03']}, **ERR_TAPSCRIPT_MINIMALIF)
     add_spender(spenders, "tapscript/minimalif", leaf="t5", **common, inputs=[getter("sign"), b'\x01'], failure={"inputs": [getter("sign"), b'\x0001']}, **ERR_TAPSCRIPT_MINIMALIF)
     add_spender(spenders, "tapscript/minimalnotif", leaf="t6", **common, inputs=[getter("sign"), b'\x01'], failure={"inputs": [getter("sign"), b'\x0100']}, **ERR_TAPSCRIPT_MINIMALIF)
+    del common['standard']
     # Test that 1-byte public keys (which are unknown) are acceptable but nonstandard with unrelated signatures, but 0-byte public keys are not valid.
     add_spender(spenders, "tapscript/unkpk/checksig", leaf="t16", standard=False, **common, **SINGLE_SIG, failure={"leaf": "t7"}, **ERR_TAPSCRIPT_EMPTY_PUBKEY)
     add_spender(spenders, "tapscript/unkpk/checksigadd", leaf="t17", standard=False, **common, **SINGLE_SIG, failure={"leaf": "t10"}, **ERR_TAPSCRIPT_EMPTY_PUBKEY)
@@ -1076,7 +1085,7 @@ def big_spend_inputs(ctx):
     # Test that an input stack size of 1000 elements is permitted, but 1001 isn't.
     add_spender(spenders, "tapscript/1000inputs", leaf="t23", **common, inputs=[getter("sign")] + [b'' for _ in range(999)], failure={"leaf": "t24", "inputs": [getter("sign")] + [b'' for _ in range(1000)]}, **ERR_STACK_SIZE)
     # Test that pushing a MAX_SCRIPT_ELEMENT_SIZE byte stack element is valid, but one longer is not.
-    add_spender(spenders, "tapscript/pushmaxlimit", leaf="t25", **common, **SINGLE_SIG, failure={"leaf": "t26"}, **ERR_PUSH_SIZE)
+    add_spender(spenders, "tapscript/pushmaxlimit", standard=False, leaf="t25", **common, **SINGLE_SIG, failure={"leaf": "t26"}, **ERR_PUSH_SIZE)
     # Test that 999-of-999 multisig works (but 1000-of-1000 triggers stack size limits)
     add_spender(spenders, "tapscript/bigmulti", leaf="t33", **common, inputs=big_spend_inputs, num=999, failure={"leaf": "t34", "num": 1000}, **ERR_STACK_SIZE)
     # Test that the CLEANSTACK rule is consensus critical in tapscript
@@ -1135,11 +1144,13 @@ def predict_sigops_ratio(n, dummy_size):
                     dummylen = 0
                     while not predict_sigops_ratio(n, dummylen):
                         dummylen += 1
-                    scripts = [("s", fn(n, pubkey)[0])]
+                    script = fn(n, pubkey)[0]
+                    scripts = [("s", script)]
                     for _ in range(merkledepth):
                         scripts = [scripts, random.choice(PARTNER_MERKLE_FN)]
                     tap = taproot_construct(pubs[0], scripts)
-                    standard = annex is None and dummylen <= 80 and len(pubkey) == 32
+                    has_conditional = any(op in (OP_IF, OP_NOTIF) for op, _, _ in script.raw_iter())
+                    standard = annex is None and dummylen <= 80 and len(pubkey) == 32 and not has_conditional and merkledepth <= TAPROOT_CONTROL_MAX_NODE_COUNT_REDUCED
                     add_spender(spenders, "tapscript/sigopsratio_%i" % fn_num, tap=tap, leaf="s", annex=annex, hashtype=hashtype, key=secs[1], inputs=[getter("sign"), random.randbytes(dummylen)], standard=standard, failure={"inputs": [getter("sign"), random.randbytes(dummylen - 1)]}, **ERR_TAPSCRIPT_VALIDATION_WEIGHT)
 
     # Future leaf versions
diff --git a/test/functional/mempool_accept.py b/test/functional/mempool_accept.py
index 5893b1cc7526..d8f187f65921 100755
--- a/test/functional/mempool_accept.py
+++ b/test/functional/mempool_accept.py
@@ -9,7 +9,6 @@
 import math
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.blocktools import MAX_STANDARD_TX_WEIGHT
 from test_framework.mempool_util import (
     DEFAULT_MIN_RELAY_TX_FEE,
     DEFAULT_INCREMENTAL_RELAY_FEE,
@@ -70,6 +69,7 @@ def check_mempool_result(self, result_expected, *args, **kwargs):
         for r in result_test:
             # Skip these checks for now
             r.pop('wtxid')
+            r.pop('usage')
             if "fees" in r:
                 r["fees"].pop("effective-feerate")
                 r["fees"].pop("effective-includes")
@@ -347,16 +347,14 @@ def run_test(self):
             rawtxs=[tx.serialize().hex()],
         )
 
-        # Multiple OP_RETURN and more than 83 bytes, even if over MAX_SCRIPT_ELEMENT_SIZE
-        # are standard since v30
+        # Multiple OP_RETURN and more than 83 bytes are rejected by OutputSizeLimit
         tx = tx_from_hex(raw_tx_reference)
         tx.vout.append(CTxOut(0, CScript([OP_RETURN, b'\xff'])))
         tx.vout.append(CTxOut(0, CScript([OP_RETURN, b'\xff' * 50000])))
 
         self.check_mempool_result(
-            result_expected=[{'txid': tx.txid_hex, 'allowed': True, 'vsize': tx.get_vsize(), 'fees': {'base': Decimal('0.05')}}],
+            result_expected=[{'txid': tx.txid_hex, 'allowed': False, 'reject-reason': 'bad-txns-vout-script-toolarge'}],
             rawtxs=[tx.serialize().hex()],
-            maxfeerate=0
         )
 
         self.log.info("A transaction with several OP_RETURN outputs.")
@@ -370,20 +368,11 @@ def run_test(self):
             rawtxs=[tx.serialize().hex()],
         )
 
-        self.log.info("A transaction with an OP_RETURN output that bumps into the max standardness tx size.")
+        self.log.info("A transaction with an OP_RETURN output that exceeds OutputSizeLimit.")
         tx = tx_from_hex(raw_tx_reference)
-        tx.vout[0].scriptPubKey = CScript([OP_RETURN])
-        data_len = int(MAX_STANDARD_TX_WEIGHT / 4) - tx.get_vsize() - 5 - 4  # -5 for PUSHDATA4 and -4 for script size
-        tx.vout[0].scriptPubKey = CScript([OP_RETURN, b"\xff" * (data_len)])
-        assert_equal(tx.get_vsize(), int(MAX_STANDARD_TX_WEIGHT / 4))
+        tx.vout[0].scriptPubKey = CScript([OP_RETURN, b"\xff" * 81])  # 84 bytes > 83 limit
         self.check_mempool_result(
-            result_expected=[{"txid": tx.txid_hex, "allowed": True, "vsize": tx.get_vsize(), "fees": {"base": Decimal("0.1") - Decimal("0.05")}}],
-            rawtxs=[tx.serialize().hex()],
-        )
-        tx.vout[0].scriptPubKey = CScript([OP_RETURN, b"\xff" * (data_len + 1)])
-        assert_greater_than(tx.get_vsize(), int(MAX_STANDARD_TX_WEIGHT / 4))
-        self.check_mempool_result(
-            result_expected=[{"txid": tx.txid_hex, "allowed": False, "reject-reason": "tx-size"}],
+            result_expected=[{"txid": tx.txid_hex, "allowed": False, "reject-reason": "bad-txns-vout-script-toolarge"}],
             rawtxs=[tx.serialize().hex()],
         )
 
diff --git a/test/functional/mempool_accept_wtxid.py b/test/functional/mempool_accept_wtxid.py
index a9edea6d6467..6ac77487d191 100755
--- a/test/functional/mempool_accept_wtxid.py
+++ b/test/functional/mempool_accept_wtxid.py
@@ -56,20 +56,28 @@ def run_test(self):
         assert_equal(node.getmempoolinfo()["unbroadcastcount"], 0)
 
         # testmempoolaccept reports the "already in mempool" error
-        assert_equal(node.testmempoolaccept([child_one.serialize().hex()]), [{
+        expected = {
             "txid": child_one.txid_hex,
             "wtxid": child_one.wtxid_hex,
             "allowed": False,
             "reject-reason": "txn-already-in-mempool",
-            "reject-details": "txn-already-in-mempool"
-        }])
-        assert_equal(node.testmempoolaccept([child_two.serialize().hex()])[0], {
+            "reject-details": "txn-already-in-mempool",
+        }
+        result = node.testmempoolaccept([child_one.serialize().hex()])[0]
+        result.pop('usage')
+        assert_equal(result, expected)
+
+        expected = {
             "txid": child_two.txid_hex,
             "wtxid": child_two.wtxid_hex,
             "allowed": False,
             "reject-reason": "txn-same-nonwitness-data-in-mempool",
-            "reject-details": "txn-same-nonwitness-data-in-mempool"
-        })
+            "reject-details": "txn-same-nonwitness-data-in-mempool",
+        }
+        result = node.testmempoolaccept([child_two.serialize().hex()])[0]
+        # skip for now
+        result.pop('usage')
+        assert_equal(result, expected)
 
         # sendrawtransaction will not throw but quits early when the exact same transaction is already in mempool
         node.sendrawtransaction(child_one.serialize().hex())
diff --git a/test/functional/mempool_datacarrier.py b/test/functional/mempool_datacarrier.py
index 8e17d4a3ccdf..93464dfabdc2 100755
--- a/test/functional/mempool_datacarrier.py
+++ b/test/functional/mempool_datacarrier.py
@@ -34,7 +34,7 @@ def set_test_params(self):
             ["-datacarrier=1", "-datacarriersize=2"],
         ]
 
-    def test_null_data_transaction(self, node: TestNode, data, success: bool) -> None:
+    def test_null_data_transaction(self, node: TestNode, data, success: bool, expected_error: str = "scriptpubkey") -> None:
         tx = self.wallet.create_self_transfer(fee_rate=0)["tx"]
         data = [] if data is None else [data]
         tx.vout.append(CTxOut(nValue=0, scriptPubKey=CScript([OP_RETURN] + data)))
@@ -46,7 +46,7 @@ def test_null_data_transaction(self, node: TestNode, data, success: bool) -> Non
             self.wallet.sendrawtransaction(from_node=node, tx_hex=tx_hex)
             assert tx.txid_hex in node.getrawmempool(True), f'{tx_hex} not in mempool'
         else:
-            assert_raises_rpc_error(-26, "datacarrier", self.wallet.sendrawtransaction, from_node=node, tx_hex=tx_hex)
+            assert_raises_rpc_error(-26, expected_error, self.wallet.sendrawtransaction, from_node=node, tx_hex=tx_hex)
 
     def run_test(self):
         self.wallet = MiniWallet(self.nodes[0])
@@ -59,46 +59,45 @@ def run_test(self):
         assert_equal(self.nodes[2].getmempoolinfo()["maxdatacarriersize"], CUSTOM_DATACARRIER_ARG)
         assert_equal(self.nodes[3].getmempoolinfo()["maxdatacarriersize"], 2)
 
-        # By default, any size is allowed.
-
-        # If it is custom set to 83, the historical value,
-        # only 80 bytes are used for data (+1 for OP_RETURN, +2 for the pushdata opcodes).
-        custom_size_data = randbytes(CUSTOM_DATACARRIER_ARG - 3)
-        too_long_data = randbytes(CUSTOM_DATACARRIER_ARG - 2)
-        extremely_long_data = randbytes(MAX_OP_RETURN_RELAY - 200)
+        # OutputSizeLimit caps all OP_RETURN outputs to 83 bytes regardless of -datacarriersize.
+        # 80 bytes data + 1 OP_RETURN + 2 pushdata opcodes = 83 bytes script (the maximum).
+        custom_size_data = randbytes(CUSTOM_DATACARRIER_ARG - 3)  # 80 bytes data = 83 bytes script
+        too_long_data = randbytes(CUSTOM_DATACARRIER_ARG - 2)  # 81 bytes data = 84 bytes script (exceeds limit)
         one_byte = randbytes(1)
         zero_bytes = randbytes(0)
 
-        self.log.info("Testing a null data transaction succeeds for default arg regardless of size.")
-        self.test_null_data_transaction(node=self.nodes[0], data=too_long_data, success=True)
-        self.test_null_data_transaction(node=self.nodes[0], data=extremely_long_data, success=True)
+        self.log.info("Testing a null data transaction at the maximum size (83 byte script).")
+        self.test_null_data_transaction(node=self.nodes[0], data=custom_size_data, success=True)
+
+        self.log.info("Testing a null data transaction exceeding OutputSizeLimit (84 byte script).")
+        self.test_null_data_transaction(node=self.nodes[0], data=too_long_data, success=False, expected_error="bad-txns-vout-script-toolarge")
 
         self.log.info("Testing a null data transaction with -datacarrier=false.")
-        self.test_null_data_transaction(node=self.nodes[1], data=custom_size_data, success=False)
+        self.test_null_data_transaction(node=self.nodes[1], data=custom_size_data, success=False, expected_error="datacarrier")
 
         self.log.info("Testing a null data transaction with a size larger than accepted by -datacarriersize.")
-        self.test_null_data_transaction(node=self.nodes[2], data=too_long_data, success=False)
+        self.test_null_data_transaction(node=self.nodes[2], data=too_long_data, success=False, expected_error="datacarrier")
 
         self.log.info("Testing a null data transaction with a size equal to -datacarriersize.")
         self.test_null_data_transaction(node=self.nodes[2], data=custom_size_data, success=True)
 
         self.log.info("Testing a null data transaction with no data.")
         self.test_null_data_transaction(node=self.nodes[0], data=None, success=True)
-        self.test_null_data_transaction(node=self.nodes[1], data=None, success=False)
+        self.test_null_data_transaction(node=self.nodes[1], data=None, success=False, expected_error="datacarrier")
         self.test_null_data_transaction(node=self.nodes[2], data=None, success=True)
         self.test_null_data_transaction(node=self.nodes[3], data=None, success=True)
 
         self.log.info("Testing a null data transaction with zero bytes of data.")
         self.test_null_data_transaction(node=self.nodes[0], data=zero_bytes, success=True)
-        self.test_null_data_transaction(node=self.nodes[1], data=zero_bytes, success=False)
+        self.test_null_data_transaction(node=self.nodes[1], data=zero_bytes, success=False, expected_error="datacarrier")
         self.test_null_data_transaction(node=self.nodes[2], data=zero_bytes, success=True)
         self.test_null_data_transaction(node=self.nodes[3], data=zero_bytes, success=True)
 
         self.log.info("Testing a null data transaction with one byte of data.")
         self.test_null_data_transaction(node=self.nodes[0], data=one_byte, success=True)
-        self.test_null_data_transaction(node=self.nodes[1], data=one_byte, success=False)
+        self.test_null_data_transaction(node=self.nodes[1], data=one_byte, success=False, expected_error="datacarrier")
         self.test_null_data_transaction(node=self.nodes[2], data=one_byte, success=True)
-        self.test_null_data_transaction(node=self.nodes[3], data=one_byte, success=False)
+        self.test_null_data_transaction(node=self.nodes[3], data=one_byte, success=False, expected_error="datacarrier")
 
 if __name__ == '__main__':
     DataCarrierTest(__file__).main()
diff --git a/test/functional/mempool_dust.py b/test/functional/mempool_dust.py
index 957cfccccf61..9d024ff809ad 100755
--- a/test/functional/mempool_dust.py
+++ b/test/functional/mempool_dust.py
@@ -99,18 +99,92 @@ def test_dustrelay(self):
 
         assert_equal(self.nodes[0].getrawmempool(), [])
 
+    def test_output_size_limit(self):
+        """Test that outputs exceeding MAX_OUTPUT_SCRIPT_SIZE (34 bytes) are rejected"""
+        self.log.info("Test MAX_OUTPUT_SCRIPT_SIZE limit (34 bytes)")
+
+        node = self.nodes[0]
+        _, pubkey = generate_keypair(compressed=True)
+
+        # Test Case 1: Scripts at or under 34 bytes should be accepted
+        self.log.info("-> Testing scripts at or under 34-byte limit (should pass)")
+
+        passing_scripts = [
+            (key_to_p2pkh_script(pubkey), "P2PKH", 25),
+            (key_to_p2wpkh_script(pubkey), "P2WPKH", 22),
+            (script_to_p2wsh_script(CScript([OP_TRUE])), "P2WSH", 34),
+            (script_to_p2sh_script(CScript([OP_TRUE])), "P2SH", 23),
+            (output_key_to_p2tr_script(pubkey[1:]), "P2TR", 34),
+        ]
+
+        for script, name, expected_size in passing_scripts:
+            assert_equal(len(script), expected_size)
+            tx = self.wallet.create_self_transfer()["tx"]
+            tx.vout.append(CTxOut(nValue=1000, scriptPubKey=script))
+            res = node.testmempoolaccept([tx.serialize().hex()])[0]
+            assert_equal(res['allowed'], True)
+            self.log.info(f"   ✓ {name} ({expected_size} bytes) accepted")
+
+        # Test Case 2: P2PK with compressed pubkey (35 bytes) should be rejected
+        self.log.info("-> Testing P2PK compressed (35 bytes) - should be rejected")
+        p2pk_script = key_to_p2pk_script(pubkey)
+        assert_equal(len(p2pk_script), 35)
+
+        tx = self.wallet.create_self_transfer()["tx"]
+        tx.vout.append(CTxOut(nValue=1000, scriptPubKey=p2pk_script))
+        res = node.testmempoolaccept([tx.serialize().hex()])[0]
+        assert_equal(res['allowed'], False)
+        assert 'output-script-size' in res['reject-reason'].lower() or \
+               'bad-txns' in res['reject-reason'].lower(), \
+               f"Expected output-script-size error, got: {res['reject-reason']}"
+        self.log.info(f"   ✓ P2PK compressed (35 bytes) correctly rejected: {res['reject-reason']}")
+
+        # Test Case 3: 1-of-1 bare multisig (37 bytes) should be rejected
+        self.log.info("-> Testing 1-of-1 bare multisig (37 bytes) - should be rejected")
+        multisig_script = keys_to_multisig_script([pubkey], k=1)
+        assert_equal(len(multisig_script), 37)
+
+        tx = self.wallet.create_self_transfer()["tx"]
+        tx.vout.append(CTxOut(nValue=1000, scriptPubKey=multisig_script))
+        res = node.testmempoolaccept([tx.serialize().hex()])[0]
+        assert_equal(res['allowed'], False)
+        assert 'output-script-size' in res['reject-reason'].lower() or \
+               'bad-txns' in res['reject-reason'].lower(), \
+               f"Expected output-script-size error, got: {res['reject-reason']}"
+        self.log.info(f"   ✓ 1-of-1 bare multisig (37 bytes) correctly rejected: {res['reject-reason']}")
+
+        # Test Case 4: Boundary testing (exactly 34 vs 35 bytes)
+        self.log.info("-> Testing boundary conditions")
+
+        # Exactly 34 bytes should pass (create a witness program v0 with 32-byte data)
+        script_34 = CScript([0, bytes(32)])  # OP_0 + 32 bytes = 34 bytes
+        assert_equal(len(script_34), 34)
+        tx = self.wallet.create_self_transfer()["tx"]
+        tx.vout.append(CTxOut(nValue=1000, scriptPubKey=script_34))
+        res = node.testmempoolaccept([tx.serialize().hex()])[0]
+        assert_equal(res['allowed'], True)
+        self.log.info("   ✓ Exactly 34 bytes accepted (boundary)")
+
+        # 35 bytes should fail (create a witness program v0 with 33-byte data - invalid but tests size)
+        script_35 = CScript([0, bytes(33)])  # OP_0 + 33 bytes = 35 bytes
+        assert_equal(len(script_35), 35)
+        tx = self.wallet.create_self_transfer()["tx"]
+        tx.vout.append(CTxOut(nValue=1000, scriptPubKey=script_35))
+        res = node.testmempoolaccept([tx.serialize().hex()])[0]
+        assert_equal(res['allowed'], False)
+        self.log.info(f"   ✓ 35 bytes rejected (boundary): {res['reject-reason']}")
+
     def run_test(self):
         self.wallet = MiniWallet(self.nodes[0])
 
         self.test_dustrelay()
+        self.test_output_size_limit()
 
         # prepare output scripts of each standard type
         _, uncompressed_pubkey = generate_keypair(compressed=False)
         _, pubkey = generate_keypair(compressed=True)
 
         output_scripts = (
-            (key_to_p2pk_script(uncompressed_pubkey),          "P2PK (uncompressed)"),
-            (key_to_p2pk_script(pubkey),                       "P2PK (compressed)"),
             (key_to_p2pkh_script(pubkey),                      "P2PKH"),
             (script_to_p2sh_script(CScript([OP_TRUE])),        "P2SH"),
             (key_to_p2wpkh_script(pubkey),                     "P2WPKH"),
@@ -118,9 +192,7 @@ def run_test(self):
             (output_key_to_p2tr_script(pubkey[1:]),            "P2TR"),
             # witness programs for segwitv2+ can be between 2 and 40 bytes
             (program_to_witness_script(2,  b'\x66' * 2),       "P2?? (future witness version 2)"),
-            (program_to_witness_script(16, b'\x77' * 40),      "P2?? (future witness version 16)"),
-            # largest possible output script considered standard
-            (keys_to_multisig_script([uncompressed_pubkey]*3), "bare multisig (m-of-3)"),
+            (program_to_witness_script(16, b'\x77' * 32),      "P2?? (future witness version 16)"),
             (CScript([OP_RETURN, b'superimportanthash']),      "null data (OP_RETURN)"),
         )
 
diff --git a/test/functional/mempool_limit.py b/test/functional/mempool_limit.py
index 597d02f9e0cb..78a90bb684ac 100755
--- a/test/functional/mempool_limit.py
+++ b/test/functional/mempool_limit.py
@@ -68,7 +68,7 @@ def test_mid_package_eviction_success(self):
         num_big_parents = 3
         # Need to be large enough to trigger eviction
         # (note that the mempool usage of a tx is about three times its vsize)
-        assert_greater_than(parent_vsize * num_big_parents * 3, current_info["maxmempool"] - current_info["bytes"])
+        assert_greater_than(parent_vsize * num_big_parents * 3, current_info["maxmempool"] - current_info["usage"])
 
         big_parent_txids = []
         big_parent_wtxids = []
@@ -106,7 +106,7 @@ def test_mid_package_eviction_success(self):
             assert_equal(len(package_res["tx-results"][wtxid]["fees"]["effective-includes"]), 1)
 
         # Maximum size must never be exceeded.
-        assert_greater_than(node.getmempoolinfo()["maxmempool"], node.getmempoolinfo()["bytes"])
+        assert_greater_than(node.getmempoolinfo()["maxmempool"], node.getmempoolinfo()["usage"])
 
         # Package found in mempool still
         resulting_mempool_txids = node.getrawmempool()
@@ -182,7 +182,7 @@ def test_mid_package_replacement(self):
         assert len([tx_res for _, tx_res in res["tx-results"].items() if "error" in tx_res and tx_res["error"] == "bad-txns-inputs-missingorspent"])
 
         # Maximum size must never be exceeded.
-        assert_greater_than(node.getmempoolinfo()["maxmempool"], node.getmempoolinfo()["bytes"])
+        assert_greater_than(node.getmempoolinfo()["maxmempool"], node.getmempoolinfo()["usage"])
 
         resulting_mempool_txids = node.getrawmempool()
         # The replacement should be successful.
@@ -259,7 +259,7 @@ def run_test(self):
         # Needs to be large enough to trigger eviction
         # (note that the mempool usage of a tx is about three times its vsize)
         target_vsize_each = 50000
-        assert_greater_than(target_vsize_each * 2 * 3, node.getmempoolinfo()["maxmempool"] - node.getmempoolinfo()["bytes"])
+        assert_greater_than(target_vsize_each * 2 * 3, node.getmempoolinfo()["maxmempool"] - node.getmempoolinfo()["usage"])
         # Should be a true CPFP: parent's feerate is just below mempool min feerate
         parent_feerate = mempoolmin_feerate - Decimal("0.0000001")  # 0.01 sats/vbyte below min feerate
         # Parent + child is above mempool minimum feerate
diff --git a/test/functional/mempool_sigoplimit.py b/test/functional/mempool_sigoplimit.py
index 932e045a8162..e47d60961dde 100755
--- a/test/functional/mempool_sigoplimit.py
+++ b/test/functional/mempool_sigoplimit.py
@@ -4,7 +4,6 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test sigop limit mempool policy (`-bytespersigop` parameter)"""
 from copy import deepcopy
-from decimal import Decimal
 from math import ceil
 
 from test_framework.messages import (
@@ -13,11 +12,13 @@
     CTxIn,
     CTxInWitness,
     CTxOut,
+    MAX_OUTPUT_DATA_SIZE,
     WITNESS_SCALE_FACTOR,
     tx_from_hex,
 )
 from test_framework.script import (
     CScript,
+    OP_1,
     OP_2DUP,
     OP_CHECKMULTISIG,
     OP_CHECKSIG,
@@ -30,7 +31,6 @@
     OP_TRUE,
 )
 from test_framework.script_util import (
-    keys_to_multisig_script,
     script_to_p2wsh_script,
     script_to_p2sh_script,
     MAX_STD_LEGACY_SIGOPS,
@@ -40,7 +40,6 @@
 from test_framework.util import (
     assert_equal,
     assert_greater_than,
-    assert_greater_than_or_equal,
     assert_raises_rpc_error,
 )
 from test_framework.wallet import MiniWallet
@@ -85,16 +84,84 @@ def test_sigops_limit(self, bytes_per_sigop, num_sigops):
             [OP_CHECKSIG]*num_singlesigops +
             [OP_ENDIF, OP_TRUE]
         )
-        # use a 256-byte data-push as lower bound in the output script, in order
-        # to avoid having to compensate for tx size changes caused by varying
-        # length serialization sizes (both for scriptPubKey and data-push lengths)
-        tx = self.create_p2wsh_spending_tx(witness_script, CScript([OP_RETURN, b'X'*256]))
 
-        # bump the tx to reach the sigop-limit equivalent size by padding the datacarrier output
-        assert_greater_than_or_equal(sigop_equivalent_vsize, tx.get_vsize())
-        vsize_to_pad = sigop_equivalent_vsize - tx.get_vsize()
-        tx.vout[0].scriptPubKey = CScript([OP_RETURN, b'X'*(256+vsize_to_pad)])
-        assert_equal(sigop_equivalent_vsize, tx.get_vsize())
+        # Create transaction ONCE with a small output
+        # This creates ONE funding transaction in the mempool
+        tx = self.create_p2wsh_spending_tx(witness_script, CScript([OP_RETURN, b'test123']))
+
+        # Helper function to pad transaction to target vsize using multiple OP_RETURN outputs
+        def pad_tx_to_vsize(tx, target_vsize):
+            """Adjust transaction size by adding/removing multiple OP_RETURN outputs"""
+            # Keep only the first output, remove all padding outputs
+            while len(tx.vout) > 1:
+                tx.vout.pop()
+
+            # MAX_OUTPUT_DATA_SIZE = 83, so max script is: OP_RETURN + 82 bytes data
+            max_script_size = MAX_OUTPUT_DATA_SIZE
+
+            # Iteratively add outputs until we reach or slightly exceed the target
+            while True:
+                current_vsize = tx.get_vsize()
+                if current_vsize >= target_vsize:
+                    break
+
+                vsize_needed = target_vsize - current_vsize
+
+                # CTxOut serialization: nValue (8) + compact_size(script_len) + script
+                # For script_len <= 252: compact_size = 1 byte
+                # So total = 8 + 1 + script_len = 9 + script_len
+
+                # Maximum output: 8 + 1 + 83 = 92 vbytes
+                if vsize_needed >= 92:
+                    # Add a max-size output
+                    tx.vout.append(CTxOut(nValue=0, scriptPubKey=CScript([OP_RETURN] + [OP_1] * (max_script_size - 1))))
+                elif vsize_needed >= 10:
+                    # Need to add exactly vsize_needed bytes
+                    # 8 + 1 + script_len = vsize_needed
+                    # script_len = vsize_needed - 9
+                    script_len = vsize_needed - 9
+                    # Script is [OP_RETURN] + data, so len = 1 + data_len
+                    # data_len = script_len - 1
+                    data_len = script_len - 1
+                    if data_len >= 0:
+                        tx.vout.append(CTxOut(nValue=0, scriptPubKey=CScript([OP_RETURN] + [OP_1] * data_len)))
+                    else:
+                        # Just add the minimum and overshoot slightly
+                        tx.vout.append(CTxOut(nValue=0, scriptPubKey=CScript([OP_RETURN])))
+                        break
+                else:
+                    # vsize_needed < 10, can't add a new output
+                    # Instead, adjust the first output's size by adding to its script
+                    if vsize_needed > 0 and len(tx.vout[0].scriptPubKey) < max_script_size:
+                        # Extend the first output's script
+                        current_script = tx.vout[0].scriptPubKey
+                        # Add vsize_needed more bytes to the script
+                        new_script = bytes(current_script) + bytes([OP_1] * vsize_needed)
+                        # But cap at max_script_size
+                        if len(new_script) <= max_script_size:
+                            tx.vout[0].scriptPubKey = CScript(new_script)
+                    break
+
+            # If we overshot, try to trim the last output
+            if tx.get_vsize() > target_vsize and len(tx.vout) > 1:
+                tx.vout.pop()
+                # Try again with a smaller output
+                current_vsize = tx.get_vsize()
+                vsize_needed = target_vsize - current_vsize
+                if vsize_needed >= 10:
+                    script_len = vsize_needed - 9
+                    data_len = script_len - 1
+                    if data_len >= 0:
+                        tx.vout.append(CTxOut(nValue=0, scriptPubKey=CScript([OP_RETURN] + [OP_1] * data_len)))
+
+        # Pad to reach sigop-limit equivalent size
+        pad_tx_to_vsize(tx, sigop_equivalent_vsize)
+        if tx.get_vsize() != sigop_equivalent_vsize:
+            self.log.error(f"Padding failed: got {tx.get_vsize()}, expected {sigop_equivalent_vsize}")
+            self.log.error(f"Number of outputs: {len(tx.vout)}")
+            for i, out in enumerate(tx.vout):
+                self.log.error(f"Output {i}: scriptPubKey len={len(out.scriptPubKey)}, vout entry size={8 + 1 + len(out.scriptPubKey)}")
+        assert_equal(tx.get_vsize(), sigop_equivalent_vsize)
 
         res = self.nodes[0].testmempoolaccept([tx.serialize().hex()])[0]
         assert_equal(res['allowed'], True)
@@ -102,7 +169,7 @@ def test_sigops_limit(self, bytes_per_sigop, num_sigops):
 
         # increase the tx's vsize to be right above the sigop-limit equivalent size
         # => tx's vsize in mempool should also grow accordingly
-        tx.vout[0].scriptPubKey = CScript([OP_RETURN, b'X'*(256+vsize_to_pad+1)])
+        pad_tx_to_vsize(tx, sigop_equivalent_vsize + 1)
         res = self.nodes[0].testmempoolaccept([tx.serialize().hex()])[0]
         assert_equal(res['allowed'], True)
         assert_equal(res['vsize'], sigop_equivalent_vsize+1)
@@ -111,7 +178,7 @@ def test_sigops_limit(self, bytes_per_sigop, num_sigops):
         # => tx's vsize in mempool should stick at the sigop-limit equivalent
         # bytes level, as it is higher than the tx's serialized vsize
         # (the maximum of both is taken)
-        tx.vout[0].scriptPubKey = CScript([OP_RETURN, b'X'*(256+vsize_to_pad-1)])
+        pad_tx_to_vsize(tx, sigop_equivalent_vsize - 1)
         res = self.nodes[0].testmempoolaccept([tx.serialize().hex()])[0]
         assert_equal(res['allowed'], True)
         assert_equal(res['vsize'], sigop_equivalent_vsize)
@@ -121,6 +188,8 @@ def test_sigops_limit(self, bytes_per_sigop, num_sigops):
         # (to keep it simple, we only test the case here where the sigop vsize
         # is much larger than the serialized vsize, i.e. we create a small child
         # tx by getting rid of the large padding output)
+        while len(tx.vout) > 1:
+            tx.vout.pop()
         tx.vout[0].scriptPubKey = CScript([OP_RETURN, b'test123'])
         assert_greater_than(sigop_equivalent_vsize, tx.get_vsize())
         self.nodes[0].sendrawtransaction(hexstring=tx.serialize().hex(), maxburnamount='1.0')
@@ -145,28 +214,72 @@ def test_sigops_package(self):
         self.log.info("Test a overly-large sigops-vbyte hits package limits")
         # Make a 2-transaction package which fails vbyte checks even though
         # separately they would work.
-        self.restart_node(0, extra_args=["-bytespersigop=5000","-permitbaremultisig=1"])
-
-        def create_bare_multisig_tx(utxo_to_spend=None):
-            _, pubkey = generate_keypair()
-            amount_for_bare = 50000
-            tx_dict = self.wallet.create_self_transfer(fee=Decimal("3"), utxo_to_spend=utxo_to_spend)
-            tx_utxo = tx_dict["new_utxo"]
-            tx = tx_dict["tx"]
-            tx.vout.append(CTxOut(amount_for_bare, keys_to_multisig_script([pubkey], k=1)))
-            tx.vout[0].nValue -= amount_for_bare
-            tx_utxo["txid"] = tx.txid_hex
-            tx_utxo["value"] -= Decimal("0.00005000")
-            return (tx_utxo, tx)
-
-        tx_parent_utxo, tx_parent = create_bare_multisig_tx()
-        _tx_child_utxo, tx_child = create_bare_multisig_tx(tx_parent_utxo)
+        #
+        # Using P2WSH multisig instead of bare multisig to comply with REDUCED_DATA
+        # output size limits (34 bytes max). Witness sigops are discounted by 4x,
+        # so we use multiple CHECKMULTISIG ops to achieve sufficient sigop-adjusted vsize.
+        self.restart_node(0, extra_args=["-bytespersigop=5000"])
+
+        # With -bytespersigop=5000 and witness discount of 4:
+        # - Each CHECKMULTISIG = 20 sigops
+        # - Adjusted vsize per CHECKMULTISIG = 20 * 5000 / 4 = 25,000
+        # - Need > 101,000 / 2 = 50,500 per tx to exceed limit as package
+        # - Use 3 CHECKMULTISIG ops = 60 sigops = 75,000 adjusted vsize per tx
+        # - Two txs together = 150,000 > 101,000 (fails package limit)
+        # - Each tx alone = 75,000 < 101,000 (passes individually)
+        NUM_CHECKMULTISIG_OPS = 3
+        expected_sigops_per_tx = NUM_CHECKMULTISIG_OPS * MAX_PUBKEYS_PER_MULTISIG  # 60
+        expected_vsize_per_tx = expected_sigops_per_tx * 5000 // WITNESS_SCALE_FACTOR  # 75,000
+
+        # Create witness script with multiple CHECKMULTISIG ops (sigops counted even in unexecuted branches)
+        witness_script = CScript(
+            [OP_FALSE, OP_IF] +
+            [OP_CHECKMULTISIG] * NUM_CHECKMULTISIG_OPS +
+            [OP_ENDIF, OP_TRUE]
+        )
+        p2wsh_script = script_to_p2wsh_script(witness_script)
+
+        # Pre-fund two P2WSH outputs that we'll spend as parent and child
+        funding_amount = 1000000
+        fund_parent = self.wallet.send_to(
+            from_node=self.nodes[0],
+            scriptPubKey=p2wsh_script,
+            amount=funding_amount,
+        )
+        fund_child = self.wallet.send_to(
+            from_node=self.nodes[0],
+            scriptPubKey=p2wsh_script,
+            amount=funding_amount,
+        )
+        self.generate(self.nodes[0], 1)
+
+        # Parent tx: spends first P2WSH (high sigops), outputs to wallet
+        tx_parent = CTransaction()
+        tx_parent.vin = [CTxIn(COutPoint(int(fund_parent["txid"], 16), fund_parent["sent_vout"]))]
+        tx_parent.wit.vtxinwit = [CTxInWitness()]
+        tx_parent.wit.vtxinwit[0].scriptWitness.stack = [bytes(witness_script)]
+        # Output back to a standard address (MiniWallet's default)
+        tx_parent.vout = [CTxOut(funding_amount - 10000, self.wallet.get_output_script())]
+        # tx_parent hashes are computed automatically via txid_hex/wtxid_hex properties
+
+        # Child tx: spends second P2WSH (high sigops) AND spends parent's output (to form package)
+        tx_child = CTransaction()
+        tx_child.vin = [
+            CTxIn(COutPoint(int(fund_child["txid"], 16), fund_child["sent_vout"])),  # P2WSH input (sigops)
+            CTxIn(COutPoint(tx_parent.txid_int, 0)),  # Parent's output (links as child)
+        ]
+        tx_child.wit.vtxinwit = [CTxInWitness(), CTxInWitness()]
+        tx_child.wit.vtxinwit[0].scriptWitness.stack = [bytes(witness_script)]  # For P2WSH input
+        tx_child.wit.vtxinwit[1].scriptWitness.stack = [b'']  # Placeholder for wallet input
+        tx_child.vout = [CTxOut(2 * funding_amount - 30000, self.wallet.get_output_script())]
+        # tx_child hashes are computed automatically via txid_hex/wtxid_hex properties
 
         # Separately, the parent tx is ok
         parent_individual_testres = self.nodes[0].testmempoolaccept([tx_parent.serialize().hex()])[0]
+        if not parent_individual_testres["allowed"]:
+            self.log.error(f"Parent tx rejected: {parent_individual_testres}")
         assert parent_individual_testres["allowed"]
-        max_multisig_vsize = MAX_PUBKEYS_PER_MULTISIG * 5000
-        assert_equal(parent_individual_testres["vsize"], max_multisig_vsize)
+        assert_equal(parent_individual_testres["vsize"], expected_vsize_per_tx)
 
         # But together, it's exceeding limits in the *package* context. If sigops adjusted vsize wasn't being checked
         # here, it would get further in validation and give too-large-cluster error instead.
diff --git a/test/functional/p2p_segwit.py b/test/functional/p2p_segwit.py
index 17f8085b44f0..1cce3ee56f5a 100755
--- a/test/functional/p2p_segwit.py
+++ b/test/functional/p2p_segwit.py
@@ -84,6 +84,7 @@
     assert_not_equal,
     assert_greater_than_or_equal,
     assert_equal,
+    assert_equal_without_usage,
     assert_raises_rpc_error,
     ensure_for,
     softfork_active,
@@ -611,7 +612,7 @@ def test_standardness_v0(self):
             testres3 = self.nodes[0].testmempoolaccept([tx3.serialize_with_witness().hex()])
             testres3[0]["fees"].pop("effective-feerate")
             testres3[0]["fees"].pop("effective-includes")
-            assert_equal(testres3,
+            assert_equal_without_usage(testres3,
                 [{
                     'txid': tx3.txid_hex,
                     'wtxid': tx3.wtxid_hex,
@@ -629,7 +630,7 @@ def test_standardness_v0(self):
             testres3_replaced = self.nodes[0].testmempoolaccept([tx3.serialize_with_witness().hex()])
             testres3_replaced[0]["fees"].pop("effective-feerate")
             testres3_replaced[0]["fees"].pop("effective-includes")
-            assert_equal(testres3_replaced,
+            assert_equal_without_usage(testres3_replaced,
                 [{
                     'txid': tx3.txid_hex,
                     'wtxid': tx3.wtxid_hex,
@@ -1347,7 +1348,7 @@ def test_segwit_versions(self):
             # First try to spend to a future version segwit script_pubkey.
             if version == OP_1:
                 # Don't use 32-byte v1 witness (used by Taproot; see BIP 341)
-                script_pubkey = CScript([CScriptOp(version), witness_hash + b'\x00'])
+                script_pubkey = CScript([CScriptOp(version), witness_hash[:31]])
             else:
                 script_pubkey = CScript([CScriptOp(version), witness_hash])
             tx.vin = [CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b"")]
diff --git a/test/functional/rpc_getdescriptoractivity.py b/test/functional/rpc_getdescriptoractivity.py
index a1d5add13889..0346e1b818ed 100755
--- a/test/functional/rpc_getdescriptoractivity.py
+++ b/test/functional/rpc_getdescriptoractivity.py
@@ -206,7 +206,8 @@ def test_receive_then_spend(self, node, wallet):
 
     def test_no_address(self, node, wallet):
         self.log.info("Test that activity is still reported for scripts without an associated address")
-        raw_wallet = MiniWallet(self.nodes[0], mode=MiniWalletMode.RAW_P2PK)
+        self.restart_node(0, extra_args=["-acceptnonstdtxn=1"])
+        raw_wallet = MiniWallet(self.nodes[0], mode=MiniWalletMode.RAW_OP_TRUE)
         self.generate(raw_wallet, 100)
 
         no_addr_tx = raw_wallet.send_self_transfer(from_node=node)
diff --git a/test/functional/rpc_packages.py b/test/functional/rpc_packages.py
index 12e086212a24..404e78b7508a 100755
--- a/test/functional/rpc_packages.py
+++ b/test/functional/rpc_packages.py
@@ -19,6 +19,7 @@
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
+    assert_equal_without_usage,
     assert_fee_amount,
     assert_raises_rpc_error,
 )
@@ -48,7 +49,7 @@ def assert_testres_equal(self, package_hex, testres_expected):
         random.shuffle(shuffled_indices)
         shuffled_package = [package_hex[i] for i in shuffled_indices]
         shuffled_testres = [testres_expected[i] for i in shuffled_indices]
-        assert_equal(shuffled_testres, self.nodes[0].testmempoolaccept(shuffled_package))
+        assert_equal_without_usage(self.nodes[0].testmempoolaccept(shuffled_package), shuffled_testres)
 
     def run_test(self):
         node = self.nodes[0]
@@ -120,7 +121,7 @@ def test_independent(self, coin):
         # transactions here but empty results in other cases.
         tx_bad_sig_txid = tx_bad_sig.txid_hex
         tx_bad_sig_wtxid = tx_bad_sig.wtxid_hex
-        assert_equal(testres_bad_sig, self.independent_txns_testres + [{
+        assert_equal_without_usage(testres_bad_sig, self.independent_txns_testres + [{
             "txid": tx_bad_sig_txid,
             "wtxid": tx_bad_sig_wtxid, "allowed": False,
             "reject-reason": "mempool-script-verify-flag-failed (Operation not valid with the current stack size)",
@@ -131,12 +132,12 @@ def test_independent(self, coin):
         self.log.info("Check testmempoolaccept reports txns in packages that exceed max feerate")
         tx_high_fee = self.wallet.create_self_transfer(fee=Decimal("0.999"))
         testres_high_fee = node.testmempoolaccept([tx_high_fee["hex"]])
-        assert_equal(testres_high_fee, [
+        assert_equal_without_usage(testres_high_fee, [
             {"txid": tx_high_fee["txid"], "wtxid": tx_high_fee["wtxid"], "allowed": False, "reject-reason": "max-fee-exceeded"}
         ])
         package_high_fee = [tx_high_fee["hex"]] + self.independent_txns_hex
         testres_package_high_fee = node.testmempoolaccept(package_high_fee)
-        assert_equal(testres_package_high_fee, testres_high_fee + self.independent_txns_testres_blank)
+        assert_equal_without_usage(testres_package_high_fee, testres_high_fee + self.independent_txns_testres_blank)
 
     def test_chain(self):
         node = self.nodes[0]
@@ -146,7 +147,7 @@ def test_chain(self):
         chain_txns = [t["tx"] for t in chain]
 
         self.log.info("Check that testmempoolaccept requires packages to be sorted by dependency")
-        assert_equal(node.testmempoolaccept(rawtxs=chain_hex[::-1]),
+        assert_equal_without_usage(node.testmempoolaccept(rawtxs=chain_hex[::-1]),
                 [{"txid": tx.txid_hex, "wtxid": tx.wtxid_hex, "package-error": "package-not-sorted"} for tx in chain_txns[::-1]])
 
         self.log.info("Testmempoolaccept a chain of 25 transactions")
@@ -159,7 +160,7 @@ def test_chain(self):
             testres_single.append(testres[0])
             # Submit the transaction now so its child should have no problem validating
             node.sendrawtransaction(rawtx)
-        assert_equal(testres_single, testres_multiple)
+        assert_equal_without_usage(testres_single, testres_multiple)
 
         # Clean up by clearing the mempool
         self.generate(node, 1)
@@ -236,14 +237,14 @@ def test_conflicting(self):
 
         self.log.info("Test duplicate transactions in the same package")
         testres = node.testmempoolaccept([tx1["hex"], tx1["hex"]])
-        assert_equal(testres, [
+        assert_equal_without_usage(testres, [
             {"txid": tx1["txid"], "wtxid": tx1["wtxid"], "package-error": "package-contains-duplicates"},
             {"txid": tx1["txid"], "wtxid": tx1["wtxid"], "package-error": "package-contains-duplicates"}
         ])
 
         self.log.info("Test conflicting transactions in the same package")
         testres = node.testmempoolaccept([tx1["hex"], tx2["hex"]])
-        assert_equal(testres, [
+        assert_equal_without_usage(testres, [
             {"txid": tx1["txid"], "wtxid": tx1["wtxid"], "package-error": "conflict-in-package"},
             {"txid": tx2["txid"], "wtxid": tx2["wtxid"], "package-error": "conflict-in-package"}
         ])
@@ -256,7 +257,7 @@ def test_conflicting(self):
 
         testres = node.testmempoolaccept([tx1["hex"], tx2["hex"], tx_child["hex"]])
 
-        assert_equal(testres, [
+        assert_equal_without_usage(testres, [
             {"txid": tx1["txid"], "wtxid": tx1["wtxid"], "package-error": "conflict-in-package"},
             {"txid": tx2["txid"], "wtxid": tx2["wtxid"], "package-error": "conflict-in-package"},
             {"txid": tx_child["txid"], "wtxid": tx_child["wtxid"], "package-error": "conflict-in-package"}
@@ -309,7 +310,7 @@ def test_rbf(self):
         # Replacement transaction is identical except has double the fee
         replacement_tx = self.wallet.create_self_transfer(utxo_to_spend=coin, sequence=MAX_BIP125_RBF_SEQUENCE, fee = 2 * fee)
         testres_rbf_conflicting = node.testmempoolaccept([replaceable_tx["hex"], replacement_tx["hex"]])
-        assert_equal(testres_rbf_conflicting, [
+        assert_equal_without_usage(testres_rbf_conflicting, [
             {"txid": replaceable_tx["txid"], "wtxid": replaceable_tx["wtxid"], "package-error": "conflict-in-package"},
             {"txid": replacement_tx["txid"], "wtxid": replacement_tx["wtxid"], "package-error": "conflict-in-package"}
         ])
diff --git a/test/functional/test_framework/mempool_util.py b/test/functional/test_framework/mempool_util.py
index 2ee1f03ddc65..2b6e23cbfa25 100644
--- a/test/functional/test_framework/mempool_util.py
+++ b/test/functional/test_framework/mempool_util.py
@@ -83,6 +83,15 @@ def fill_mempool(test_framework, node, *, tx_sync_fun=None):
     confirmed_utxos = [ephemeral_miniwallet.get_utxo(confirmed_only=True) for _ in range(num_of_batches * tx_batch_size + 1)]
     assert_equal(len(confirmed_utxos), num_of_batches * tx_batch_size + 1)
 
+    # Calibrate dummy tx memory usage, since we rely on filling maxmempool
+    target_tx_usage = 68064
+    tx = ephemeral_miniwallet.create_self_transfer(utxo_to_spend=confirmed_utxos[0])["tx"]
+    tx.vout.extend(txouts)
+    res = node.testmempoolaccept([tx.serialize().hex()])[0]
+    if res['usage'] > target_tx_usage:
+        excess_outputs = len(txouts) - (target_tx_usage * len(txouts) // res['usage'])
+        txouts = txouts[excess_outputs:]
+
     test_framework.log.debug("Create a mempool tx that will be evicted")
     tx_to_be_evicted_id = ephemeral_miniwallet.send_self_transfer(
         from_node=node, utxo_to_spend=confirmed_utxos.pop(0), fee_rate=minrelayfee)["txid"]
diff --git a/test/functional/test_framework/messages.py b/test/functional/test_framework/messages.py
index f6dfc4618837..3c668303acc9 100755
--- a/test/functional/test_framework/messages.py
+++ b/test/functional/test_framework/messages.py
@@ -81,6 +81,9 @@
 # Default setting for -datacarriersize.
 MAX_OP_RETURN_RELAY = 100_000
 
+# BIP-110: Maximum size of an output script (OP_RETURN or otherwise) when OutputSizeLimit is enforced.
+MAX_OUTPUT_DATA_SIZE = 83
+
 
 DEFAULT_MEMPOOL_EXPIRY_HOURS = 336  # hours
 
diff --git a/test/functional/test_framework/script.py b/test/functional/test_framework/script.py
index 16bd871bb23b..93912bc8c3d7 100644
--- a/test/functional/test_framework/script.py
+++ b/test/functional/test_framework/script.py
@@ -33,6 +33,7 @@
 SEQUENCE_LOCKTIME_GRANULARITY = 9 # this is a bit-shift
 SEQUENCE_LOCKTIME_MASK = 0x0000ffff
 
+TAPROOT_CONTROL_MAX_NODE_COUNT_REDUCED = 7
 LEAF_VERSION_TAPSCRIPT = 0xc0
 
 def hash160(s):
diff --git a/test/functional/test_framework/util.py b/test/functional/test_framework/util.py
index d2d5d56fbf70..f74627a5b0ba 100644
--- a/test/functional/test_framework/util.py
+++ b/test/functional/test_framework/util.py
@@ -84,6 +84,29 @@ def assert_not_equal(thing1, thing2, *, error_message=""):
         raise AssertionError(f"Both values are {thing1}{f', {error_message}' if error_message else ''}")
 
 
+def assert_equal_without_usage(actual, expected):
+    """
+    Assert that testmempoolaccept results match expected values, ignoring the 'usage' field.
+    This helper is for tests that were written before the 'usage' field was added.
+    """
+    if isinstance(actual, list) and isinstance(expected, list):
+        assert_equal(len(actual), len(expected))
+        for act, exp in zip(actual, expected):
+            assert_equal_without_usage(act, exp)
+    elif isinstance(actual, dict) and isinstance(expected, dict):
+        # Check that all expected keys match
+        for key in expected:
+            assert key in actual, f"Expected key '{key}' not in actual result"
+            if key != 'usage':  # Skip usage comparison
+                assert_equal(actual[key], expected[key])
+        # Verify usage exists and is positive if transaction was validated
+        if 'usage' in actual:
+            assert isinstance(actual['usage'], int), "usage should be an integer"
+            assert actual['usage'] > 0, "usage should be positive"
+    else:
+        assert_equal(actual, expected)
+
+
 def assert_greater_than(thing1, thing2):
     if thing1 <= thing2:
         raise AssertionError("%s <= %s" % (str(thing1), str(thing2)))
@@ -678,7 +701,8 @@ def check_node_connections(*, node, num_in, num_out):
 def gen_return_txouts():
     from .messages import CTxOut
     from .script import CScript, OP_RETURN
-    txouts = [CTxOut(nValue=0, scriptPubKey=CScript([OP_RETURN, b'\x01'*67437]))]
+    txouts = [CTxOut(nValue=0, scriptPubKey=CScript([OP_RETURN, b'\x01'*80]))] * 733
+    txouts.append(CTxOut(nValue=0, scriptPubKey=CScript([OP_RETURN, b'\x01'*9])))
     assert_equal(sum([len(txout.serialize()) for txout in txouts]), 67456)
     return txouts
 
diff --git a/test/functional/test_framework/wallet.py b/test/functional/test_framework/wallet.py
index fc8b639bd64a..e60f9ceab380 100644
--- a/test/functional/test_framework/wallet.py
+++ b/test/functional/test_framework/wallet.py
@@ -33,9 +33,12 @@
     CTxInWitness,
     CTxOut,
     hash256,
+    MAX_OUTPUT_DATA_SIZE,
+    ser_compact_size,
 )
 from test_framework.script import (
     CScript,
+    OP_1,
     OP_NOP,
     OP_RETURN,
     OP_TRUE,
@@ -43,8 +46,6 @@
     taproot_construct,
 )
 from test_framework.script_util import (
-    bulk_vout,
-    key_to_p2pk_script,
     key_to_p2pkh_script,
     key_to_p2sh_p2wpkh_script,
     key_to_p2wpkh_script,
@@ -77,7 +78,7 @@ class MiniWalletMode(Enum):
     ----------------+-------------------+-----------+----------+------------+----------
     ADDRESS_OP_TRUE | anyone-can-spend  |  bech32m  |   yes    |    no      |   no
     RAW_OP_TRUE     | anyone-can-spend  |  - (raw)  |   no     |    yes     |   no
-    RAW_P2PK        | pay-to-public-key |  - (raw)  |   yes    |    yes     |   yes
+    RAW_P2PK        | p2pkh             |  base58   |   yes    |    yes     |   yes
     """
     ADDRESS_OP_TRUE = 1
     RAW_OP_TRUE = 2
@@ -100,7 +101,7 @@ def __init__(self, test_node, *, mode=MiniWalletMode.ADDRESS_OP_TRUE, tag_name=N
             self._priv_key = ECKey()
             self._priv_key.set((1).to_bytes(32, 'big'), True)
             pub_key = self._priv_key.get_pubkey()
-            self._scriptPubKey = key_to_p2pk_script(pub_key.get_bytes())
+            self._scriptPubKey = key_to_p2pkh_script(pub_key.get_bytes())
         elif mode == MiniWalletMode.ADDRESS_OP_TRUE:
             internal_key = None if tag_name is None else compute_xonly_pubkey(hash256(tag_name.encode()))[0]
             self._address, self._taproot_info = create_deterministic_address_bcrt1_p2tr_op_true(internal_key)
@@ -120,9 +121,31 @@ def _bulk_tx(self, tx, target_vsize):
         """Pad a transaction with extra outputs until it reaches a target vsize.
         returns the tx
         """
-        tx.vout.append(CTxOut(nValue=0, scriptPubKey=CScript([OP_RETURN])))
-        bulk_vout(tx, target_vsize)
-
+        if target_vsize < tx.get_vsize():
+            raise RuntimeError(f"target_vsize {target_vsize} is less than transaction virtual size {tx.get_vsize()}")
+
+        dummy_vbytes = target_vsize - tx.get_vsize()
+        if dummy_vbytes > 0:
+            # Use multiple OP_RETURN outputs, each within MAX_OUTPUT_DATA_SIZE (83 bytes script).
+            # Each output costs 8 (nValue) + 1 (scriptLen) + script_size bytes.
+            max_output_size = 8 + 1 + MAX_OUTPUT_DATA_SIZE  # 92
+            n_outputs = -(-dummy_vbytes // max_output_size)  # ceiling division
+            n_outputs_before = len(tx.vout)
+
+            # Distribute bytes evenly across outputs
+            for i in range(n_outputs):
+                out_size = dummy_vbytes // n_outputs + (1 if i < dummy_vbytes % n_outputs else 0)
+                script_size = out_size - 8 - 1  # subtract nValue and scriptLen
+                tx.vout.append(CTxOut(nValue=0, scriptPubKey=CScript([OP_RETURN] + [OP_1] * (script_size - 1))))
+
+            # Compensate for the increase of the compact-size encoded output count
+            extra_len_size = len(ser_compact_size(len(tx.vout))) - len(ser_compact_size(n_outputs_before))
+            if extra_len_size > 0:
+                first_pad = tx.vout[n_outputs_before]
+                assert first_pad.scriptPubKey[-extra_len_size:] == bytes([OP_1] * extra_len_size)
+                tx.vout[n_outputs_before] = CTxOut(nValue=0, scriptPubKey=CScript(first_pad.scriptPubKey[:-extra_len_size]))
+
+        assert_equal(tx.get_vsize(), target_vsize)
 
     def get_balance(self):
         return sum(u['value'] for u in self._utxos)
@@ -173,8 +196,9 @@ def sign_tx(self, tx, fixed_length=True):
             # with the DER header/skeleton data of 6 bytes added, plus 2 bytes scriptSig overhead
             # (OP_PUSHn and SIGHASH_ALL), this leads to a scriptSig target size of 73 bytes
             tx.vin[0].scriptSig = b''
-            while not len(tx.vin[0].scriptSig) == 73:
-                tx.vin[0].scriptSig = b''
+            while not len(tx.vin[0].scriptSig) == 107:
+                pub_key = self._priv_key.get_pubkey()
+                tx.vin[0].scriptSig = CScript([pub_key.get_bytes()])
                 sign_input_legacy(tx, 0, self._scriptPubKey, self._priv_key)
                 if not fixed_length:
                     break
@@ -366,7 +390,7 @@ def create_self_transfer(
         if self._mode in (MiniWalletMode.RAW_OP_TRUE, MiniWalletMode.ADDRESS_OP_TRUE):
             vsize = Decimal(104)  # anyone-can-spend
         elif self._mode == MiniWalletMode.RAW_P2PK:
-            vsize = Decimal(168)  # P2PK (73 bytes scriptSig + 35 bytes scriptPubKey + 60 bytes other)
+            vsize = Decimal(192)  # P2PK (73+34 bytes scriptSig + 25 bytes scriptPubKey + 60 bytes other)
         else:
             assert False
         if target_vsize and not fee:  # respect fee_rate if target vsize is passed
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index cef49a3845e0..da222158414e 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -103,6 +103,9 @@
     # vv Tests less than 5m vv
     'feature_fee_estimation.py',
     'feature_taproot.py',
+    'feature_reduced_data_temporary_deployment.py',
+    'feature_bip9_max_activation_height.py',
+    'feature_rdts.py',
     'feature_block.py',
     'mempool_ephemeral_dust.py',
     'wallet_conflicts.py',
@@ -146,6 +149,7 @@
     'p2p_headers_sync_with_minchainwork.py',
     'p2p_feefilter.py',
     'feature_csv_activation.py',
+    'feature_reduced_data_utxo_height.py',
     'p2p_sendheaders.py',
     'feature_config_args.py',
     'wallet_listtransactions.py',
diff --git a/test/functional/tool_utxo_to_sqlite.py b/test/functional/tool_utxo_to_sqlite.py
index d1f3e7e19348..5f5efbf5af9c 100755
--- a/test/functional/tool_utxo_to_sqlite.py
+++ b/test/functional/tool_utxo_to_sqlite.py
@@ -86,29 +86,43 @@ def run_test(self):
         wallet = MiniWallet(node)
         key = ECKey()
 
-        self.log.info('Create UTXOs with various output script types')
+        self.log.info('Test that oversized output scripts are rejected')
+        key.generate(compressed=False)
+        uncompressed_pubkey = key.get_pubkey().get_bytes()
+        key.generate(compressed=True)
+        pubkey = key.get_pubkey().get_bytes()
+
+        # Test that scripts exceeding MAX_OUTPUT_SCRIPT_SIZE=34 are rejected
+        invalid_scripts = [
+            (key_to_p2pk_script(pubkey), "P2PK compressed (35 bytes)"),
+            (key_to_p2pk_script(uncompressed_pubkey), "P2PK uncompressed (67 bytes)"),
+            (keys_to_multisig_script([pubkey]), "Bare multisig 1-of-1 (37 bytes)"),
+            (keys_to_multisig_script([uncompressed_pubkey]*2), "Bare multisig 2-of-2 uncompressed"),
+            (CScript([CScriptOp.encode_op_n(1)]*1000), "Large script (1000 bytes)"),
+        ]
+
+        for script, description in invalid_scripts:
+            try:
+                wallet.send_to(from_node=node, scriptPubKey=script, amount=1, fee=20000)
+                raise AssertionError(f"{description} should have been rejected")
+            except Exception as e:
+                assert 'bad-txns-vout-script-toolarge' in str(e), \
+                    f"{description} rejected with wrong error: {e}"
+                self.log.info(f"  ✓ {description} correctly rejected")
+
+        self.log.info('Create UTXOs with valid output script types (≤34 bytes)')
         for i in range(1, 10+1):
-            key.generate(compressed=False)
-            uncompressed_pubkey = key.get_pubkey().get_bytes()
             key.generate(compressed=True)
             pubkey = key.get_pubkey().get_bytes()
 
-            # add output scripts for compressed script type 0 (P2PKH), type 1 (P2SH),
-            # types 2-3 (P2PK compressed), types 4-5 (P2PK uncompressed) and
-            # for uncompressed scripts (bare multisig, segwit, etc.)
+            # Only include output scripts that comply with MAX_OUTPUT_SCRIPT_SIZE=34
             output_scripts = (
-                key_to_p2pkh_script(pubkey),
-                script_to_p2sh_script(key_to_p2pkh_script(pubkey)),
-                key_to_p2pk_script(pubkey),
-                key_to_p2pk_script(uncompressed_pubkey),
-
-                keys_to_multisig_script([pubkey]*i),
-                keys_to_multisig_script([uncompressed_pubkey]*i),
-                key_to_p2wpkh_script(pubkey),
-                script_to_p2wsh_script(key_to_p2pkh_script(pubkey)),
-                output_key_to_p2tr_script(pubkey[1:]),
-                PAY_TO_ANCHOR,
-                CScript([CScriptOp.encode_op_n(i)]*(1000*i)),  # large script (up to 10000 bytes)
+                key_to_p2pkh_script(pubkey),                        # 25 bytes
+                script_to_p2sh_script(key_to_p2pkh_script(pubkey)), # 23 bytes
+                key_to_p2wpkh_script(pubkey),                       # 22 bytes
+                script_to_p2wsh_script(key_to_p2pkh_script(pubkey)),# 34 bytes
+                output_key_to_p2tr_script(pubkey[1:]),              # 34 bytes
+                PAY_TO_ANCHOR,                                      # 4 bytes
             )
 
             # create outputs and mine them in a block