From a0cbc4ac9efdfff3993b52c2ef217dbebd71fa66 Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Tue, 25 Aug 2026 10:33:47 +0200
Subject: [PATCH 1/7] feat(consensus): compute version 2 asset unlock txids
 with the quorum signing info zeroed

Version 2 asset unlock payloads are serialized identically to version 1; the version byte, gated on DEPLOYMENT_V24, changes how the transaction is hashed: the txid excludes the trailing requestedHeight, quorumHash and quorumSig payload fields - exactly the fields Platform changes when it re-signs an expired withdrawal - so every re-signed instance of one withdrawal is the same transaction. Spends of its outputs reference that stable txid and stay valid across re-signs with no aliasing in the mempool, UTXO or wallet layers.

The full-serialization hash remains available as GetInstanceHash() to distinguish the instances of one withdrawal for relay and for the coinbase commitment introduced in the next commit. The signed message is unchanged: it zeroes only quorumSig and must be computed from the full serialization, never via GetHash().
---
 src/evo/assetlocktx.cpp           |  18 +++--
 src/evo/assetlocktx.h             |  11 +++-
 src/evo/specialtxman.cpp          |   8 ++-
 src/primitives/transaction.cpp    |  31 ++++++++-
 src/primitives/transaction.h      |  32 +++++++++
 src/test/evo_assetlocks_tests.cpp | 105 +++++++++++++++++++++++++++---
 6 files changed, 180 insertions(+), 25 deletions(-)

diff --git a/src/evo/assetlocktx.cpp b/src/evo/assetlocktx.cpp
index 9388e1c29b15..d8d9a27fbaaa 100644
--- a/src/evo/assetlocktx.cpp
+++ b/src/evo/assetlocktx.cpp
@@ -175,7 +175,8 @@ bool CAssetUnlockPayload::VerifySig(const llmq::CQuorumManager& qman, const CCha
 template <typename VerifySig>
 static bool CheckAssetUnlockTxImpl(const BlockManager& blockman, VerifySig&& verify_sig, const CTransaction& tx,
                                    gsl::not_null<const CBlockIndex*> pindexPrev,
-                                   const std::optional<CRangesSet>& indexes, TxValidationState& state)
+                                   const std::optional<CRangesSet>& indexes, bool is_v24_active,
+                                   TxValidationState& state)
 {
     // Some checks depends from blockchain status also, such as `known indexes` and `withdrawal limits`
     // They are omitted here and done by CCreditPool
@@ -200,6 +201,9 @@ static bool CheckAssetUnlockTxImpl(const BlockManager& blockman, VerifySig&& ver
     if (assetUnlockTx.getVersion() == 0 || assetUnlockTx.getVersion() > CAssetUnlockPayload::CURRENT_VERSION) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetunlocktx-version");
     }
+    if (!is_v24_active && assetUnlockTx.getVersion() > CAssetUnlockPayload::INITIAL_VERSION) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetunlocktx-version-2");
+    }
 
     if (indexes != std::nullopt && indexes->Contains(assetUnlockTx.getIndex())) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-assetunlock-duplicated-index");
@@ -214,30 +218,32 @@ static bool CheckAssetUnlockTxImpl(const BlockManager& blockman, VerifySig&& ver
     const CAssetUnlockPayload payload_copy{assetUnlockTx.getVersion(), assetUnlockTx.getIndex(), assetUnlockTx.getFee(), assetUnlockTx.getRequestedHeight(), assetUnlockTx.getQuorumHash(), CBLSSignature{}};
     SetTxPayload(tx_copy, payload_copy);
 
-    uint256 msgHash = tx_copy.GetHash();
+    // The signed message must commit to requestedHeight and quorumHash even though the version 2
+    // txid excludes them, so hash the full serialization rather than using GetHash().
+    uint256 msgHash = ::SerializeHash(tx_copy);
 
     return verify_sig(assetUnlockTx, msgHash, pindexPrev, state);
 }
 
 bool CheckAssetUnlockTx(const BlockManager& blockman, const llmq::CQuorumManager& qman, const CTransaction& tx,
                         gsl::not_null<const CBlockIndex*> pindexPrev, const std::optional<CRangesSet>& indexes,
-                        TxValidationState& state)
+                        bool is_v24_active, TxValidationState& state)
 {
     return CheckAssetUnlockTxImpl(blockman, [&](const CAssetUnlockPayload& payload, const uint256& msg_hash,
                                                 const CBlockIndex* pindex, TxValidationState& tx_state) {
         return payload.VerifySig(qman, msg_hash, pindex, tx_state);
-    }, tx, pindexPrev, indexes, state);
+    }, tx, pindexPrev, indexes, is_v24_active, state);
 }
 
 bool CheckAssetUnlockTx(const BlockManager& blockman, const llmq::CQuorumManager& qman, const CChain& chain,
                         const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
-                        const std::optional<CRangesSet>& indexes, TxValidationState& state)
+                        const std::optional<CRangesSet>& indexes, bool is_v24_active, TxValidationState& state)
 {
     AssertLockHeld(::cs_main);
     return CheckAssetUnlockTxImpl(blockman, [&](const CAssetUnlockPayload& payload, const uint256& msg_hash,
                                                 const CBlockIndex* pindex, TxValidationState& tx_state) NO_THREAD_SAFETY_ANALYSIS {
         return payload.VerifySig(qman, chain, msg_hash, pindex, tx_state);
-    }, tx, pindexPrev, indexes, state);
+    }, tx, pindexPrev, indexes, is_v24_active, state);
 }
 
 bool GetAssetUnlockFee(const CTransaction& tx, CAmount& txfee, TxValidationState& state)
diff --git a/src/evo/assetlocktx.h b/src/evo/assetlocktx.h
index 3dea2c5e13a8..ae1165f402b0 100644
--- a/src/evo/assetlocktx.h
+++ b/src/evo/assetlocktx.h
@@ -75,8 +75,13 @@ class CAssetLockPayload
 class CAssetUnlockPayload
 {
 public:
-    static constexpr uint8_t CURRENT_VERSION = 1;
+    static constexpr uint8_t INITIAL_VERSION = 1;
+    /** Serialized identically to version 1, but the transaction hash excludes the quorum signing
+     *  info (requestedHeight, quorumHash, quorumSig) so every re-signed instance of one withdrawal
+     *  shares one txid; see IsAssetUnlockWithStableTxid(). Gated on DEPLOYMENT_V24. */
+    static constexpr uint8_t CURRENT_VERSION = 2;
     static constexpr auto SPECIALTX_TYPE = TRANSACTION_ASSET_UNLOCK;
+    static_assert(CURRENT_VERSION >= ASSET_UNLOCK_STABLE_TXID_VERSION);
 
     static constexpr size_t MAXIMUM_WITHDRAWALS = 32;
 
@@ -163,10 +168,10 @@ class CAssetUnlockPayload
 };
 
 bool CheckAssetLockTx(const CTransaction& tx, TxValidationState& state, bool is_v24_active);
-bool CheckAssetUnlockTx(const node::BlockManager& blockman, const llmq::CQuorumManager& qman, const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, const std::optional<CRangesSet>& indexes, TxValidationState& state);
+bool CheckAssetUnlockTx(const node::BlockManager& blockman, const llmq::CQuorumManager& qman, const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, const std::optional<CRangesSet>& indexes, bool is_v24_active, TxValidationState& state);
 bool CheckAssetUnlockTx(const node::BlockManager& blockman, const llmq::CQuorumManager& qman, const CChain& chain,
                         const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
-                        const std::optional<CRangesSet>& indexes, TxValidationState& state)
+                        const std::optional<CRangesSet>& indexes, bool is_v24_active, TxValidationState& state)
     EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 bool GetAssetUnlockFee(const CTransaction& tx, CAmount& txfee, TxValidationState& state);
 
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index d8b89b43a89b..53659fd1708b 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -241,9 +241,11 @@ static bool CheckSpecialTxInner(CDeterministicMNManager& dmnman, llmq::CQuorumSn
                            CheckMNHFTx(chainman, qman, tx, pindexPrev, state);
         case TRANSACTION_ASSET_LOCK:
             return CheckAssetLockTx(tx, state, DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24));
-        case TRANSACTION_ASSET_UNLOCK:
-            return chain ? CheckAssetUnlockTx(chainman.m_blockman, qman, *chain, tx, pindexPrev, indexes, state) :
-                           CheckAssetUnlockTx(chainman.m_blockman, qman, tx, pindexPrev, indexes, state);
+        case TRANSACTION_ASSET_UNLOCK: {
+            const bool is_v24_active{DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24)};
+            return chain ? CheckAssetUnlockTx(chainman.m_blockman, qman, *chain, tx, pindexPrev, indexes, is_v24_active, state) :
+                           CheckAssetUnlockTx(chainman.m_blockman, qman, tx, pindexPrev, indexes, is_v24_active, state);
+        }
         }
     } catch (const std::exception& e) {
         LogPrintf("%s -- failed: %s\n", __func__, e.what());
diff --git a/src/primitives/transaction.cpp b/src/primitives/transaction.cpp
index a56f8c3677f4..04ce81e0c841 100644
--- a/src/primitives/transaction.cpp
+++ b/src/primitives/transaction.cpp
@@ -9,6 +9,7 @@
 #include <hash.h>
 #include <script/script.h>
 #include <serialize.h>
+#include <streams.h>
 #include <tinyformat.h>
 #include <uint256.h>
 #include <util/strencodings.h>
@@ -70,8 +71,26 @@ std::string CTxOut::ToString() const
 CMutableTransaction::CMutableTransaction() : nVersion(CTransaction::CURRENT_VERSION), nType(TRANSACTION_NORMAL), nLockTime(0) {}
 CMutableTransaction::CMutableTransaction(const CTransaction& tx) : vin(tx.vin), vout(tx.vout), nVersion(tx.nVersion), nType(tx.nType), nLockTime(tx.nLockTime), vExtraPayload(tx.vExtraPayload) {}
 
+namespace {
+/** The txid of a version 2+ asset unlock excludes the quorum signing info - the fields Platform
+ *  changes when it re-signs an expired withdrawal - so every re-signed instance of one withdrawal
+ *  shares one txid and spends of its outputs stay valid across re-signs. The payload is the last
+ *  field serialized (see CTransaction::Serialize), so the signing info occupies the trailing bytes
+ *  of the stream. The full-serialization hash remains available as CTransaction::GetInstanceHash()
+ *  and is committed to by the coinbase transaction. */
+template <typename TxType>
+uint256 ComputeStableUnlockHash(const TxType& tx)
+{
+    CDataStream ss(SER_GETHASH, PROTOCOL_VERSION);
+    ss << tx;
+    std::fill(ss.end() - ASSET_UNLOCK_QUORUM_INFO_SIZE, ss.end(), std::byte{0});
+    return Hash(ss);
+}
+} // anonymous namespace
+
 uint256 CMutableTransaction::GetHash() const
 {
+    if (IsAssetUnlockWithStableTxid(*this)) return ComputeStableUnlockHash(*this);
     return SerializeHash(*this);
 }
 
@@ -93,13 +112,19 @@ std::string CMutableTransaction::ToString() const
     return str;
 }
 
-uint256 CTransaction::ComputeHash() const
+uint256 CTransaction::ComputeInstanceHash() const
 {
     return SerializeHash(*this);
 }
 
-CTransaction::CTransaction(const CMutableTransaction& tx) : vin(tx.vin), vout(tx.vout), nVersion(tx.nVersion), nType(tx.nType), nLockTime(tx.nLockTime), vExtraPayload(tx.vExtraPayload), hash{ComputeHash()} {}
-CTransaction::CTransaction(CMutableTransaction&& tx) : vin(std::move(tx.vin)), vout(std::move(tx.vout)), nVersion(tx.nVersion), nType(tx.nType), nLockTime(tx.nLockTime), vExtraPayload(tx.vExtraPayload), hash{ComputeHash()} {}
+uint256 CTransaction::ComputeHash() const
+{
+    if (IsAssetUnlockWithStableTxid(*this)) return ComputeStableUnlockHash(*this);
+    return m_instance_hash;
+}
+
+CTransaction::CTransaction(const CMutableTransaction& tx) : vin(tx.vin), vout(tx.vout), nVersion(tx.nVersion), nType(tx.nType), nLockTime(tx.nLockTime), vExtraPayload(tx.vExtraPayload), m_instance_hash{ComputeInstanceHash()}, hash{ComputeHash()} {}
+CTransaction::CTransaction(CMutableTransaction&& tx) : vin(std::move(tx.vin)), vout(std::move(tx.vout)), nVersion(tx.nVersion), nType(tx.nType), nLockTime(tx.nLockTime), vExtraPayload(tx.vExtraPayload), m_instance_hash{ComputeInstanceHash()}, hash{ComputeHash()} {}
 
 CAmount CTransaction::GetValueOut() const
 {
diff --git a/src/primitives/transaction.h b/src/primitives/transaction.h
index 2a1f4a11de63..e26cf33c0cb6 100644
--- a/src/primitives/transaction.h
+++ b/src/primitives/transaction.h
@@ -36,6 +36,17 @@ enum {
     TRANSACTION_ASSET_UNLOCK = 9,
 };
 
+/** Size of the trailing payload fields holding the quorum signing info (requestedHeight,
+ *  quorumHash, quorumSig) - the only fields Platform changes when it re-signs an expired
+ *  withdrawal. */
+static constexpr size_t ASSET_UNLOCK_QUORUM_INFO_SIZE{4 + 32 + 96};
+/** Serialized size of the asset unlock (credit withdrawal) special transaction payload:
+ *  version (1) + index (8) + fee (4) + the quorum signing info. */
+static constexpr size_t ASSET_UNLOCK_PAYLOAD_SIZE{1 + 8 + 4 + ASSET_UNLOCK_QUORUM_INFO_SIZE};
+/** First asset unlock payload version whose transaction hash excludes the quorum signing info,
+ *  so that every re-signed instance of one withdrawal shares one txid. */
+static constexpr uint8_t ASSET_UNLOCK_STABLE_TXID_VERSION{2};
+
 /** An outpoint - a combination of a transaction hash and an index n into its vout */
 class COutPoint
 {
@@ -237,9 +248,13 @@ class CTransaction
     const std::vector<uint8_t> vExtraPayload; // only available for special transaction types
 
 private:
+    /** Memory only. The full-serialization hash; equal to `hash` for all transactions except
+     *  version 2+ asset unlocks, where it identifies one signed instance of the withdrawal. */
+    const uint256 m_instance_hash;
     /** Memory only. */
     const uint256 hash;
 
+    uint256 ComputeInstanceHash() const;
     uint256 ComputeHash() const;
 
 public:
@@ -269,6 +284,12 @@ class CTransaction
 
     const uint256& GetHash() const LIFETIMEBOUND { return hash; }
 
+    /** The full-serialization hash. For version 2+ asset unlocks GetHash() excludes the quorum
+     *  signing info, so this hash distinguishes the re-signed instances of one withdrawal; it is
+     *  used for their relay and for the coinbase asset unlock commitment. Equal to GetHash() for
+     *  all other transactions. */
+    const uint256& GetInstanceHash() const LIFETIMEBOUND { return m_instance_hash; }
+
     // Return sum of txouts.
     CAmount GetValueOut() const;
 
@@ -351,6 +372,17 @@ struct CMutableTransaction
     std::string ToString() const;
 };
 
+/** Whether this (mutable or immutable) transaction is an asset unlock whose hash is computed with
+ *  the quorum signing info zeroed (payload version 2 or higher). Judged from the raw payload bytes
+ *  because hashing happens before payload validation. */
+template <typename TxType>
+inline bool IsAssetUnlockWithStableTxid(const TxType& tx)
+{
+    return tx.nVersion >= CTransaction::SPECIAL_VERSION && tx.nType == TRANSACTION_ASSET_UNLOCK &&
+           tx.vExtraPayload.size() == ASSET_UNLOCK_PAYLOAD_SIZE &&
+           tx.vExtraPayload[0] >= ASSET_UNLOCK_STABLE_TXID_VERSION;
+}
+
 typedef std::shared_ptr<const CTransaction> CTransactionRef;
 template <typename Tx> static inline CTransactionRef MakeTransactionRef(Tx&& txIn) { return std::make_shared<const CTransaction>(std::forward<Tx>(txIn)); }
 
diff --git a/src/test/evo_assetlocks_tests.cpp b/src/test/evo_assetlocks_tests.cpp
index d3f7e9f41d9c..99e700f1a697 100644
--- a/src/test/evo_assetlocks_tests.cpp
+++ b/src/test/evo_assetlocks_tests.cpp
@@ -429,7 +429,7 @@ BOOST_FIXTURE_TEST_CASE(evo_assetunlock, TestChain100Setup)
     auto& qman = *Assert(m_node.llmq_ctx)->qman;
 
     const CBlockIndex *block_index = m_node.chainman->ActiveChain().Tip();
-    BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(tx), block_index, std::nullopt, tx_state));
+    BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(tx), block_index, std::nullopt, /*is_v24_active=*/true, tx_state));
     BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlock-quorum-hash");
 
     {
@@ -447,7 +447,7 @@ BOOST_FIXTURE_TEST_CASE(evo_assetunlock, TestChain100Setup)
         std::string reason;
         BOOST_CHECK(IsStandardTx(CTransaction(tx), reason));
 
-        BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txNonemptyInput), block_index, std::nullopt, tx_state));
+        BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txNonemptyInput), block_index, std::nullopt, /*is_v24_active=*/true, tx_state));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlocktx-have-input");
     }
 
@@ -462,7 +462,7 @@ BOOST_FIXTURE_TEST_CASE(evo_assetunlock, TestChain100Setup)
         // Wrong type "Asset Lock TX" instead "Asset Unlock TX"
         CMutableTransaction txWrongType(tx);
         txWrongType.nType = TRANSACTION_ASSET_LOCK;
-        BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txWrongType), block_index, std::nullopt, tx_state));
+        BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txWrongType), block_index, std::nullopt, /*is_v24_active=*/true, tx_state));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlocktx-type");
 
         // Check version of tx and payload
@@ -476,16 +476,101 @@ BOOST_FIXTURE_TEST_CASE(evo_assetunlock, TestChain100Setup)
                 unlockPayload->getQuorumSig()};
             CMutableTransaction txWrongVersion(tx);
             SetTxPayload(txWrongVersion, unlockPayload_tmp);
-            if (payload_version != 1) {
-                BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txWrongVersion), block_index, std::nullopt, tx_state));
+            if (payload_version == 0 || payload_version > CAssetUnlockPayload::CURRENT_VERSION) {
+                BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txWrongVersion), block_index, std::nullopt, /*is_v24_active=*/true, tx_state));
                 BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlocktx-version");
+            } else if (payload_version == 2) {
+                BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txWrongVersion), block_index, std::nullopt, /*is_v24_active=*/false, tx_state));
+                BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlocktx-version-2");
+                BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txWrongVersion), block_index, std::nullopt, /*is_v24_active=*/true, tx_state));
+                BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlock-quorum-hash");
             } else {
-                BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txWrongVersion), block_index, std::nullopt, tx_state));
+                // Version 1 must not hit the version-2 gate regardless of v24 state
+                BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txWrongVersion), block_index, std::nullopt, /*is_v24_active=*/false, tx_state));
+                BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlock-quorum-hash");
+                BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txWrongVersion), block_index, std::nullopt, /*is_v24_active=*/true, tx_state));
                 BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlock-quorum-hash");
             }
         }
     }
 
+    {
+        // The txid of a version 2 payload is invariant across the quorum signing info - the fields
+        // Platform changes on re-sign - and nothing else; the instance hash still covers them
+        const auto unlockPayload = GetTxPayload<CAssetUnlockPayload>(tx);
+        BOOST_CHECK(unlockPayload.has_value());
+
+        auto make_unlock_tx = [&](uint8_t version, uint64_t index, uint32_t fee, uint32_t requested_height,
+                                  const uint256& quorum_hash) {
+            CMutableTransaction tx_tmp(tx);
+            SetTxPayload(tx_tmp, CAssetUnlockPayload{version, index, fee, requested_height, quorum_hash,
+                                                     unlockPayload->getQuorumSig()});
+            return CTransaction(tx_tmp);
+        };
+
+        // Version 1 hashes the full serialization
+        const CTransaction tx_v1{make_unlock_tx(1, 0x11, 2000, 500, uint256::ONE)};
+        BOOST_CHECK(!IsAssetUnlockWithStableTxid(tx_v1));
+        BOOST_CHECK(tx_v1.GetHash() == tx_v1.GetInstanceHash());
+        BOOST_CHECK(tx_v1.GetHash() == ::SerializeHash(tx_v1));
+
+        const CTransaction tx_v2{make_unlock_tx(2, 0x11, 2000, 500, uint256::ONE)};
+        BOOST_CHECK(IsAssetUnlockWithStableTxid(tx_v2));
+        BOOST_CHECK(tx_v2.vExtraPayload.size() == ASSET_UNLOCK_PAYLOAD_SIZE);
+        BOOST_CHECK(tx_v2.GetHash() != tx_v2.GetInstanceHash());
+        BOOST_CHECK(tx_v2.GetInstanceHash() == ::SerializeHash(tx_v2));
+
+        // Re-signing changes requestedHeight and quorumHash but not the txid; the instance
+        // hash tells the two instances apart
+        const CTransaction tx_v2_resigned{make_unlock_tx(2, 0x11, 2000, 700, uint256::TWO)};
+        BOOST_CHECK(tx_v2_resigned.GetHash() == tx_v2.GetHash());
+        BOOST_CHECK(tx_v2_resigned.GetInstanceHash() != tx_v2.GetInstanceHash());
+        // A different withdrawal (index or fee) has a different txid
+        BOOST_CHECK(make_unlock_tx(2, 0x12, 2000, 500, uint256::ONE).GetHash() != tx_v2.GetHash());
+        BOOST_CHECK(make_unlock_tx(2, 0x11, 3000, 500, uint256::ONE).GetHash() != tx_v2.GetHash());
+
+        // CMutableTransaction applies the same rule
+        BOOST_CHECK(CMutableTransaction(tx_v2).GetHash() == tx_v2.GetHash());
+
+        // The txid equals the full-serialization hash with the quorum signing info zeroed
+        CMutableTransaction tx_zeroed(tx_v2);
+        SetTxPayload(tx_zeroed, CAssetUnlockPayload{2, 0x11, 2000, /*requestedHeight=*/0,
+                                                    /*quorumHash=*/uint256(), CBLSSignature{}});
+        BOOST_CHECK(::SerializeHash(tx_zeroed) == tx_v2.GetHash());
+
+        // The signed message zeroes only quorumSig: it commits to the signing info even though
+        // the txid does not, and must never be computed with GetHash()
+        auto msg_hash = [](const CTransaction& t) {
+            const auto p = GetTxPayload<CAssetUnlockPayload>(t);
+            CMutableTransaction copy(t);
+            SetTxPayload(copy, CAssetUnlockPayload{p->getVersion(), p->getIndex(), p->getFee(),
+                                                   p->getRequestedHeight(), p->getQuorumHash(), CBLSSignature{}});
+            return ::SerializeHash(copy);
+        };
+        BOOST_CHECK(msg_hash(tx_v2) != msg_hash(tx_v2_resigned));
+        BOOST_CHECK(msg_hash(tx_v2) != tx_v2.GetHash());
+    }
+
+    {
+        // DIP-0027 worked examples for the version 2 txid (dip-0027/dip-0027-txid-calc.py)
+        auto dip_example_tx = [](uint64_t index) {
+            CMutableTransaction tx_dip;
+            tx_dip.nVersion = 3;
+            tx_dip.nType = TRANSACTION_ASSET_UNLOCK;
+            uint160 pubkey_hash;
+            std::fill(pubkey_hash.begin(), pubkey_hash.end(), 0x11);
+            const CScript script{GetScriptForDestination(PKHash{pubkey_hash})};
+            tx_dip.vout.emplace_back(100000000, script);
+            SetTxPayload(tx_dip, CAssetUnlockPayload{2, index, /*fee=*/70000, /*requestedHeight=*/500,
+                                                     uint256::ONE, CBLSSignature{}});
+            return CTransaction(tx_dip);
+        };
+        BOOST_CHECK_EQUAL(dip_example_tx(101).GetHash().ToString(),
+                          "3c4db73c8356407a5d7c78df5045bd280f2dc4fd644b06c4bfbdead3d5ae41cf");
+        BOOST_CHECK_EQUAL(dip_example_tx(123456789).GetHash().ToString(),
+                          "a67e1107ae6e04b813bc8e81348266f5206d1ca93d305dc4323940e18cdbaf34");
+    }
+
     {
         // Exactly 32 withdrawal is fine
         CMutableTransaction txManyOutputs(tx);
@@ -496,15 +581,15 @@ BOOST_FIXTURE_TEST_CASE(evo_assetunlock, TestChain100Setup)
             out.scriptPubKey = GetScriptForDestination(PKHash(key.GetPubKey()));
         }
 
-        BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txManyOutputs), block_index, std::nullopt, tx_state));
+        BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txManyOutputs), block_index, std::nullopt, /*is_v24_active=*/true, tx_state));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlock-quorum-hash");
 
         // Basic checks for CRangesSet
         CRangesSet indexes;
-        BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txManyOutputs), block_index, indexes, tx_state));
+        BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txManyOutputs), block_index, indexes, /*is_v24_active=*/true, tx_state));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlock-quorum-hash");
         BOOST_CHECK(indexes.Add(0x001122334455667788L));
-        BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txManyOutputs), block_index, indexes, tx_state));
+        BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txManyOutputs), block_index, indexes, /*is_v24_active=*/true, tx_state));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlock-duplicated-index");
 
 
@@ -512,7 +597,7 @@ BOOST_FIXTURE_TEST_CASE(evo_assetunlock, TestChain100Setup)
         txManyOutputs.vout.resize(outputsLimit + 1);
         txManyOutputs.vout.back().nValue = CENT;
         txManyOutputs.vout.back().scriptPubKey = GetScriptForDestination(PKHash(key.GetPubKey()));
-        BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txManyOutputs), block_index, std::nullopt, tx_state));
+        BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txManyOutputs), block_index, std::nullopt, /*is_v24_active=*/true, tx_state));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlocktx-too-many-outs");
     }
 

From 50053291ee7c65d72223e148675a8ce07c0fca96 Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Tue, 25 Aug 2026 10:42:30 +0200
Subject: [PATCH 2/7] feat(consensus): commit to asset unlock instance hashes
 in the coinbase transaction

Version 2 asset unlock txids exclude the quorum signing info, so the block merkle root no longer commits to those bytes. Coinbase transaction version 4, required once v24 activates, adds merkleRootAssetUnlocks: a merkle root over the instance hashes of the block's version 2 asset unlocks in block order, null when there are none. The root is verified in CheckMerkleRoot as a mutation check, mirroring segwit's witness commitment: a middleman can alter signing-info bytes without breaking the merkle root, and treating the mismatch as block invalidity would let it poison an honest block's hash.

Compact block short IDs are computed from instance hashes (equal to the txid for every other transaction), so a mempool entry holding a different re-signed instance of a withdrawal is requested via getblocktxn instead of being spliced into the reconstructed block; the FillBlock mutation check backstops any remaining short ID collision.
---
 src/blockencodings.cpp                  |  6 ++++-
 src/evo/cbtx.cpp                        | 27 ++++++++++++++++++---
 src/evo/cbtx.h                          | 11 ++++++++-
 src/evo/core_write.cpp                  |  3 +++
 src/evo/specialtxman.cpp                |  5 ++--
 src/net_processing.cpp                  |  2 +-
 src/node/miner.cpp                      |  9 ++++++-
 src/rpc/json_help.cpp                   |  1 +
 src/test/evo_assetlocks_tests.cpp       | 32 +++++++++++++++++++++++++
 src/test/util/setup_common.cpp          |  3 +++
 src/txmempool.cpp                       |  2 +-
 src/txmempool.h                         |  2 +-
 src/validation.cpp                      | 16 +++++++++++++
 test/lint/lint-circular-dependencies.py |  1 +
 14 files changed, 109 insertions(+), 11 deletions(-)

diff --git a/src/blockencodings.cpp b/src/blockencodings.cpp
index f12b45b49354..9c5fbc71d32a 100644
--- a/src/blockencodings.cpp
+++ b/src/blockencodings.cpp
@@ -26,7 +26,11 @@ CBlockHeaderAndShortTxIDs::CBlockHeaderAndShortTxIDs(const CBlock& block) :
     prefilledtxn[0] = {0, block.vtx[0]};
     for (size_t i = 1; i < block.vtx.size(); i++) {
         const CTransaction& tx = *block.vtx[i];
-        shorttxids[i - 1] = GetShortID(tx.GetHash());
+        // Short IDs are computed from instance hashes so that a mempool entry holding a different
+        // re-signed instance of a version 2 asset unlock (same txid, different quorum signing
+        // info) is treated as missing and requested, instead of being spliced into the block and
+        // failing the coinbase asset unlock commitment.
+        shorttxids[i - 1] = GetShortID(tx.GetInstanceHash());
     }
 }
 
diff --git a/src/evo/cbtx.cpp b/src/evo/cbtx.cpp
index 856d8d74ee6c..ad9f6f2e8fef 100644
--- a/src/evo/cbtx.cpp
+++ b/src/evo/cbtx.cpp
@@ -21,7 +21,7 @@
 
 using node::ReadBlockFromDisk;
 
-bool CheckCbTx(const CCbTx& cbTx, const CBlockIndex* pindexPrev, TxValidationState& state)
+bool CheckCbTx(const CCbTx& cbTx, const CBlockIndex* pindexPrev, bool is_v24_active, TxValidationState& state)
 {
     if (cbTx.nVersion == CCbTx::Version::INVALID || cbTx.nVersion >= CCbTx::Version::UNKNOWN) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-cbtx-version");
@@ -41,6 +41,11 @@ bool CheckCbTx(const CCbTx& cbTx, const CBlockIndex* pindexPrev, TxValidationSta
         if ((isV20 && cbTx.nVersion < CCbTx::Version::CLSIG_AND_BALANCE) || (!isV20 && cbTx.nVersion >= CCbTx::Version::CLSIG_AND_BALANCE)) {
             return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-cbtx-version");
         }
+
+        if ((is_v24_active && cbTx.nVersion < CCbTx::Version::MERKLE_ROOT_ASSETUNLOCKS) ||
+            (!is_v24_active && cbTx.nVersion >= CCbTx::Version::MERKLE_ROOT_ASSETUNLOCKS)) {
+            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-cbtx-version");
+        }
     }
 
     return true;
@@ -147,11 +152,27 @@ bool CalcCbTxMerkleRootQuorums(const CBlock& block, const CBlockIndex* pindexPre
     return true;
 }
 
+uint256 CalcCbTxMerkleRootAssetUnlocks(const CBlock& block)
+{
+    // Instance hashes cover the quorum signing info that the txids of these transactions - and
+    // therefore the block's merkle root - exclude. Two instances of one withdrawal share a txid,
+    // so duplicate leaves imply a duplicate transaction, which the block merkle-root check
+    // (CheckMerkleRoot, run before this) already rejects; no mutated check is needed here.
+    std::vector<uint256> instance_hashes;
+    for (const auto& tx : block.vtx) {
+        // The miner calls this while the coinbase slot is still an empty placeholder
+        if (tx && IsAssetUnlockWithStableTxid(*tx)) {
+            instance_hashes.push_back(tx->GetInstanceHash());
+        }
+    }
+    return ComputeMerkleRoot(std::move(instance_hashes));
+}
+
 std::string CCbTx::ToString() const
 {
-    return strprintf("CCbTx(nVersion=%d, nHeight=%d, merkleRootMNList=%s, merkleRootQuorums=%s, bestCLHeightDiff=%d, bestCLSig=%s, creditPoolBalance=%d.%08d)",
+    return strprintf("CCbTx(nVersion=%d, nHeight=%d, merkleRootMNList=%s, merkleRootQuorums=%s, bestCLHeightDiff=%d, bestCLSig=%s, creditPoolBalance=%d.%08d, merkleRootAssetUnlocks=%s)",
         static_cast<uint16_t>(nVersion), nHeight, merkleRootMNList.ToString(), merkleRootQuorums.ToString(), bestCLHeightDiff, bestCLSignature.ToString(),
-        creditPoolBalance / COIN, creditPoolBalance % COIN);
+        creditPoolBalance / COIN, creditPoolBalance % COIN, merkleRootAssetUnlocks.ToString());
 }
 
 std::optional<std::pair<CBLSSignature, uint32_t>> GetNonNullCoinbaseChainlock(const CBlockIndex* pindex)
diff --git a/src/evo/cbtx.h b/src/evo/cbtx.h
index da6d92f802a8..bb552a78c653 100644
--- a/src/evo/cbtx.h
+++ b/src/evo/cbtx.h
@@ -34,6 +34,7 @@ class CCbTx
         MERKLE_ROOT_MNLIST = 1,
         MERKLE_ROOT_QUORUMS = 2,
         CLSIG_AND_BALANCE = 3,
+        MERKLE_ROOT_ASSETUNLOCKS = 4,
         UNKNOWN,
     };
 
@@ -45,6 +46,10 @@ class CCbTx
     uint32_t bestCLHeightDiff{0};
     CBLSSignature bestCLSignature;
     CAmount creditPoolBalance{0};
+    /** Merkle root over the instance hashes of the block's version 2+ asset unlock transactions
+     *  (block order; null when there are none). Their txids exclude the quorum signing info, so
+     *  the block's merkle root does not commit to it; this root restores that commitment. */
+    uint256 merkleRootAssetUnlocks;
 
     SERIALIZE_METHODS(CCbTx, obj)
     {
@@ -56,6 +61,9 @@ class CCbTx
                 READWRITE(COMPACTSIZE(obj.bestCLHeightDiff));
                 READWRITE(obj.bestCLSignature);
                 READWRITE(obj.creditPoolBalance);
+                if (obj.nVersion >= Version::MERKLE_ROOT_ASSETUNLOCKS) {
+                    READWRITE(obj.merkleRootAssetUnlocks);
+                }
             }
         }
 
@@ -68,11 +76,12 @@ class CCbTx
 };
 template<> struct is_serializable_enum<CCbTx::Version> : std::true_type {};
 
-bool CheckCbTx(const CCbTx& cbTx, const CBlockIndex* pindexPrev, TxValidationState& state);
+bool CheckCbTx(const CCbTx& cbTx, const CBlockIndex* pindexPrev, bool is_v24_active, TxValidationState& state);
 
 bool CalcCbTxMerkleRootQuorums(const CBlock& block, const CBlockIndex* pindexPrev,
                                const llmq::CQuorumBlockProcessor& quorum_block_processor, uint256& merkleRootRet,
                                BlockValidationState& state);
+uint256 CalcCbTxMerkleRootAssetUnlocks(const CBlock& block);
 
 std::optional<std::pair<CBLSSignature, uint32_t>> GetNonNullCoinbaseChainlock(const CBlockIndex* pindex);
 
diff --git a/src/evo/core_write.cpp b/src/evo/core_write.cpp
index 4ebe78675f2d..3d97569ad215 100644
--- a/src/evo/core_write.cpp
+++ b/src/evo/core_write.cpp
@@ -143,6 +143,9 @@ UniValue CCbTx::ToJson() const
             ret.pushKV("bestCLHeightDiff", bestCLHeightDiff);
             ret.pushKV("bestCLSignature", bestCLSignature.ToString());
             ret.pushKV("creditPoolBalance", ValueFromAmount(creditPoolBalance));
+            if (nVersion >= CCbTx::Version::MERKLE_ROOT_ASSETUNLOCKS) {
+                ret.pushKV("merkleRootAssetUnlocks", merkleRootAssetUnlocks.ToString());
+            }
         }
     }
     return ret;
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index 53659fd1708b..26c122ee44d1 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -229,7 +229,7 @@ static bool CheckSpecialTxInner(CDeterministicMNManager& dmnman, llmq::CQuorumSn
                 return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-cbtx-invalid");
             }
             if (const auto opt_cbTx = GetTxPayload<CCbTx>(tx)) {
-                return CheckCbTx(*opt_cbTx, pindexPrev, state);
+                return CheckCbTx(*opt_cbTx, pindexPrev, DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24), state);
             } else {
                 return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-cbtx-payload");
             }
@@ -716,7 +716,8 @@ bool CSpecialTxProcessor::ProcessSpecialTxsInBlock(Chainstate& chainstate, const
             }
             if (opt_cbTx = GetTxPayload<CCbTx>(*tx); opt_cbTx) {
                 TxValidationState tx_state;
-                if (!CheckCbTx(*opt_cbTx, pindex->pprev, tx_state)) {
+                if (!CheckCbTx(*opt_cbTx, pindex->pprev,
+                               DeploymentActiveAfter(pindex->pprev, m_chainman, Consensus::DEPLOYMENT_V24), tx_state)) {
                     assert(tx_state.GetResult() == TxValidationResult::TX_CONSENSUS ||
                            tx_state.GetResult() == TxValidationResult::TX_BAD_SPECIAL);
                     return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, tx_state.GetRejectReason(),
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index e25a9a1230c5..7f722df29be8 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -1871,7 +1871,7 @@ void PeerManagerImpl::AddToCompactExtraTransactions(const CTransactionRef& tx)
         return;
     if (!vExtraTxnForCompact.size())
         vExtraTxnForCompact.resize(max_extra_txn);
-    vExtraTxnForCompact[vExtraTxnForCompactIt] = std::make_pair(tx->GetHash(), tx);
+    vExtraTxnForCompact[vExtraTxnForCompactIt] = std::make_pair(tx->GetInstanceHash(), tx);
     vExtraTxnForCompactIt = (vExtraTxnForCompactIt + 1) % max_extra_txn;
 }
 
diff --git a/src/node/miner.cpp b/src/node/miner.cpp
index f40d761d46a3..e061e4928dbe 100644
--- a/src/node/miner.cpp
+++ b/src/node/miner.cpp
@@ -199,6 +199,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
     const bool fDIP0003Active_context{DeploymentActiveAfter(pindexPrev, chainparams.GetConsensus(), Consensus::DEPLOYMENT_DIP0003)};
     const bool fDIP0008Active_context{DeploymentActiveAfter(pindexPrev, chainparams.GetConsensus(), Consensus::DEPLOYMENT_DIP0008)};
     const bool fV20Active_context{DeploymentActiveAfter(pindexPrev, chainparams.GetConsensus(), Consensus::DEPLOYMENT_V20)};
+    const bool fV24Active_context{DeploymentActiveAfter(pindexPrev, m_chainstate.m_chainman, Consensus::DEPLOYMENT_V24)};
 
     // Limit size to between 1K and MaxBlockSize()-1K for sanity:
     m_options.nBlockMaxSize = std::max<unsigned int>(1000, std::min<unsigned int>(MaxBlockSize(fDIP0001Active_context) - 1000, m_options.nBlockMaxSize));
@@ -268,7 +269,9 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
 
         CCbTx cbTx;
 
-        if (fV20Active_context) {
+        if (fV24Active_context) {
+            cbTx.nVersion = CCbTx::Version::MERKLE_ROOT_ASSETUNLOCKS;
+        } else if (fV20Active_context) {
             cbTx.nVersion = CCbTx::Version::CLSIG_AND_BALANCE;
         } else if (fDIP0008Active_context) {
             cbTx.nVersion = CCbTx::Version::MERKLE_ROOT_QUORUMS;
@@ -304,6 +307,10 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
                 }
 
                 cbTx.creditPoolBalance = creditPoolDiff->GetTotalLocked();
+
+                if (fV24Active_context) {
+                    cbTx.merkleRootAssetUnlocks = CalcCbTxMerkleRootAssetUnlocks(*pblock);
+                }
             }
         }
 
diff --git a/src/rpc/json_help.cpp b/src/rpc/json_help.cpp
index 8bae35f01a2e..3c1a8682369b 100644
--- a/src/rpc/json_help.cpp
+++ b/src/rpc/json_help.cpp
@@ -140,6 +140,7 @@ RPCResult CCbTx::GetJsonHelp(const std::string& key, bool optional)
         {RPCResult::Type::NUM, "bestCLHeightDiff", /*optional=*/true, "Blocks between the current block and the last known block with a ChainLock"},
         {RPCResult::Type::STR_HEX, "bestCLSignature", /*optional=*/true, "Best ChainLock signature known by the miner"},
         {RPCResult::Type::NUM, "creditPoolBalance", /*optional=*/true, "Balance in the Platform credit pool"},
+        {RPCResult::Type::STR_HEX, "merkleRootAssetUnlocks", /*optional=*/true, "Merkle root of the instance hashes of the block's version 2 asset unlock transactions"},
     }};
 }
 
diff --git a/src/test/evo_assetlocks_tests.cpp b/src/test/evo_assetlocks_tests.cpp
index 99e700f1a697..1fc0d396a510 100644
--- a/src/test/evo_assetlocks_tests.cpp
+++ b/src/test/evo_assetlocks_tests.cpp
@@ -8,6 +8,7 @@
 #include <consensus/tx_check.h>
 #include <consensus/validation.h>
 #include <evo/assetlocktx.h>
+#include <evo/cbtx.h>
 #include <evo/creditpool.h>
 #include <evo/specialtx.h>
 #include <llmq/context.h>
@@ -603,6 +604,37 @@ BOOST_FIXTURE_TEST_CASE(evo_assetunlock, TestChain100Setup)
 
 }
 
+BOOST_FIXTURE_TEST_CASE(evo_assetunlock_cbtx_merkle_root, BasicTestingSetup)
+{
+    auto make_unlock = [](uint8_t version, uint64_t index, uint32_t requested_height) {
+        CMutableTransaction mtx;
+        mtx.nVersion = 3;
+        mtx.nType = TRANSACTION_ASSET_UNLOCK;
+        SetTxPayload(mtx, CAssetUnlockPayload{version, index, /*fee=*/2000, requested_height,
+                                              uint256::ONE, CBLSSignature{}});
+        return MakeTransactionRef(mtx);
+    };
+
+    // Only version 2 unlocks are committed to; a block without them commits to null
+    CBlock block;
+    block.vtx.push_back(make_unlock(1, 1, 500));
+    BOOST_CHECK(CalcCbTxMerkleRootAssetUnlocks(block).IsNull());
+
+    const auto unlock_a = make_unlock(2, 1, 500);
+    block.vtx.push_back(unlock_a);
+    const uint256 root_one{CalcCbTxMerkleRootAssetUnlocks(block)};
+    BOOST_CHECK(root_one == unlock_a->GetInstanceHash());
+
+    block.vtx.push_back(make_unlock(2, 2, 500));
+    const uint256 root_two{CalcCbTxMerkleRootAssetUnlocks(block)};
+    BOOST_CHECK(root_two != root_one);
+
+    // A different re-signed instance keeps the txid but changes the committed root
+    block.vtx.back() = make_unlock(2, 2, 700);
+    BOOST_CHECK(block.vtx.back()->GetHash() == make_unlock(2, 2, 500)->GetHash());
+    BOOST_CHECK(CalcCbTxMerkleRootAssetUnlocks(block) != root_two);
+}
+
 BOOST_FIXTURE_TEST_CASE(credit_pool_package_atomicity, TestChain100Setup)
 {
     LOCK(cs_main);
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index 7a1d2adb99d7..0b1f2f106d65 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -592,6 +592,9 @@ CBlock TestChainSetup::CreateBlock(
         if (!CalcCbTxMerkleRootQuorums(block, chainstate.m_chain.Tip(), *m_node.llmq_ctx->quorum_block_processor, cbTx->merkleRootQuorums, state)) {
             Assert(false);
         }
+        if (cbTx->nVersion >= CCbTx::Version::MERKLE_ROOT_ASSETUNLOCKS) {
+            cbTx->merkleRootAssetUnlocks = CalcCbTxMerkleRootAssetUnlocks(block);
+        }
         CMutableTransaction tmpTx{*block.vtx[0]};
         SetTxPayload(tmpTx, *cbTx);
         block.vtx[0] = MakeTransactionRef(tmpTx);
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index a7754ea05052..3844cec8ee8b 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -504,7 +504,7 @@ void CTxMemPool::addUnchecked(const CTxMemPoolEntry &entry, setEntries &setAnces
         minerPolicyEstimator->processTransaction(entry, validFeeEstimate);
     }
 
-    vTxHashes.emplace_back(entry.GetTx().GetHash(), newit);
+    vTxHashes.emplace_back(entry.GetTx().GetInstanceHash(), newit);
     newit->vTxHashesIdx = vTxHashes.size() - 1;
 
     // Invalid ProTxes should never get this far because transactions should be
diff --git a/src/txmempool.h b/src/txmempool.h
index 429a4d2a44ed..88f165ed2465 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -528,7 +528,7 @@ class CTxMemPool
     indexed_transaction_set mapTx GUARDED_BY(cs);
 
     using txiter = indexed_transaction_set::nth_index<0>::type::const_iterator;
-    std::vector<std::pair<uint256, txiter> > vTxHashes GUARDED_BY(cs); //!< All tx hashes/entries in mapTx, in random order
+    std::vector<std::pair<uint256, txiter> > vTxHashes GUARDED_BY(cs); //!< All tx instance hashes (see CTransaction::GetInstanceHash)/entries in mapTx, in random order
 
     typedef std::set<txiter, CompareIteratorByHash> setEntries;
 
diff --git a/src/validation.cpp b/src/validation.cpp
index e1cc33d909ac..0f897d8b122b 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -54,6 +54,7 @@
 #include <warnings.h>
 
 #include <chainlock/chainlock.h>
+#include <evo/cbtx.h>
 #include <evo/chainhelper.h>
 #include <evo/deterministicmns.h>
 #include <evo/evodb.h>
@@ -4042,6 +4043,21 @@ static bool CheckMerkleRoot(const CBlock& block, BlockValidationState& state)
             /*debug_message=*/"duplicate transaction");
     }
 
+    // Version 2 asset unlock txids exclude the quorum signing info, so the merkle root above does
+    // not commit to it; the coinbase commits to their instance hashes instead. A mismatch is a
+    // mutation, not block invalidity: a middleman can alter signing-info bytes without breaking
+    // the merkle root, and treating that as invalid would let it poison an honest block's hash.
+    if (!block.vtx.empty() && block.vtx[0]->nType == TRANSACTION_COINBASE) {
+        if (const auto opt_cbTx = GetTxPayload<CCbTx>(*block.vtx[0], /*assert_type=*/false);
+            opt_cbTx && opt_cbTx->nVersion >= CCbTx::Version::MERKLE_ROOT_ASSETUNLOCKS &&
+            opt_cbTx->merkleRootAssetUnlocks != CalcCbTxMerkleRootAssetUnlocks(block)) {
+            return state.Invalid(
+                /*result=*/BlockValidationResult::BLOCK_MUTATED,
+                /*reject_reason=*/"bad-cbtx-assetunlockmerkleroot",
+                /*debug_message=*/"asset unlock instance merkle root mismatch");
+        }
+    }
+
     block.m_checked_merkle_root = true;
     return true;
 }
diff --git a/test/lint/lint-circular-dependencies.py b/test/lint/lint-circular-dependencies.py
index 13d3b388c268..a1d409c64715 100755
--- a/test/lint/lint-circular-dependencies.py
+++ b/test/lint/lint-circular-dependencies.py
@@ -39,6 +39,7 @@
     "consensus/tx_verify -> evo/assetlocktx -> llmq/commitment -> validation -> consensus/tx_verify",
     "consensus/tx_verify -> evo/assetlocktx -> llmq/commitment -> validation -> txmempool -> consensus/tx_verify",
     "evo/assetlocktx -> llmq/commitment -> validation -> txmempool -> evo/assetlocktx",
+    "evo/cbtx -> llmq/blockprocessor -> validation -> evo/cbtx",
     "evo/chainhelper -> evo/creditpool -> validation -> evo/chainhelper",
     "evo/deterministicmns -> node/blockstorage -> validation -> evo/deterministicmns",
     "evo/deterministicmns -> node/blockstorage -> validation -> masternode/payments -> evo/deterministicmns",

From 24d3dad17d4c1bb928b1cb562cef11b3a56053fb Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Tue, 25 Aug 2026 11:41:05 +0200
Subject: [PATCH 3/7] fix(evo): only write credit pool disk snapshots inside a
 block-scoped EvoDB transaction

CCreditPoolManager::AddToCache persists a snapshot every 576th height via evoDb.WriteDerived. When a pool is constructed on a cold cache from a transaction-less context - mempool acceptance or block template creation right after startup - that write lands in an EvoDB transaction nobody commits and trips the clean-transaction assertion (evodb.cpp:99) at the next root commit, aborting the node at flush/shutdown. Skip the optional snapshot outside a block-scoped transaction; a skipped snapshot is simply reconstructed from an earlier one.
---
 src/evo/creditpool.cpp |  6 +++++-
 src/evo/evodb.h        | 10 ++++++++++
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/src/evo/creditpool.cpp b/src/evo/creditpool.cpp
index 239b951a27d0..668e01a3d8f9 100644
--- a/src/evo/creditpool.cpp
+++ b/src/evo/creditpool.cpp
@@ -137,7 +137,11 @@ std::optional<CCreditPool> CCreditPoolManager::GetFromCache(const CBlockIndex& b
 
 void CCreditPoolManager::AddToCache(const uint256& block_hash, int height, const CCreditPool &pool)
 {
-    if (height % DISK_SNAPSHOT_PERIOD == 0) {
+    // The disk snapshot is an optimization; skip it outside a block-scoped EvoDB transaction
+    // (e.g. a pool constructed on a cold cache during mempool acceptance or template creation),
+    // where the write would never be committed and would trip the clean-transaction assertion
+    // at the next root commit. A skipped snapshot is reconstructed from an earlier one.
+    if (height % DISK_SNAPSHOT_PERIOD == 0 && evoDb.HasActiveTransaction()) {
         if (!evoDb.WriteDerived(std::make_pair(DB_CREDITPOOL_SNAPSHOT, block_hash), pool)) {
             // A mismatch is local EvoDB corruption, not a statement about the
             // block. Abort here: some callers (miner, RPC) never pass through a
diff --git a/src/evo/evodb.h b/src/evo/evodb.h
index 40d37b48229d..11b47ed0ec6a 100644
--- a/src/evo/evodb.h
+++ b/src/evo/evodb.h
@@ -115,6 +115,16 @@ class CEvoDB
 
     std::unique_ptr<CEvoDBScopedCommitter> BeginTransaction(EvoDbIdentity identity = EvoDbIdentity::NORMAL) EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
+    /** Whether a block-scoped transaction is open. Writes performed outside one are never
+     *  committed and trip the clean-transaction assertion at the next root commit, so callers
+     *  reachable from transaction-less contexts (mempool acceptance, mining, RPC) must skip
+     *  optional persistence when this is false. */
+    bool HasActiveTransaction() const EXCLUSIVE_LOCKS_REQUIRED(!cs)
+    {
+        LOCK(cs);
+        return active_transaction.has_value();
+    }
+
     CurTransaction& GetCurTransaction() EXCLUSIVE_LOCKS_REQUIRED(cs)
     {
         AssertLockHeld(cs); // lock must be held from outside as long as the DB transaction is used

From 7cfc29613c83afa1bcb913553c4e8bb805cfbe61 Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Tue, 25 Aug 2026 10:51:14 +0200
Subject: [PATCH 4/7] feat(mempool): refresh pending withdrawals in place and
 lock spends of unmined version 2 asset unlocks

A re-signed instance of a pending withdrawal shares the mempool entry's txid; AcceptToMemoryPool routes it through a refresh path that fully validates the fresh instance and, when its requestedHeight is higher, swaps it into the existing entry in place - descendants, ancestry and fee accounting are untouched because everything the txid covers is identical. Stale or duplicate instances are rejected (assetunlock-stale-instance). BroadcastTransaction submits such refreshes instead of short-circuiting on the known txid.

Version 2 unlocks are not expiry-evicted: an expired instance stays in the mempool awaiting its replacement so descendants never die with it, and the miner instead skips instances that are not currently minable. InstantSend can lock spends of unmined version 2 unlocks: once quorum-signed the withdrawal is irreversible on Platform and will be re-signed until mined under the same txid.
---
 src/instantsend/signing.cpp             |  6 +++
 src/node/miner.cpp                      | 14 +++++
 src/node/transaction.cpp                |  8 ++-
 src/txmempool.cpp                       | 51 ++++++++++++++++--
 src/txmempool.h                         | 21 +++++++-
 src/validation.cpp                      | 71 +++++++++++++++++++++++++
 test/lint/lint-circular-dependencies.py |  2 +
 7 files changed, 167 insertions(+), 6 deletions(-)

diff --git a/src/instantsend/signing.cpp b/src/instantsend/signing.cpp
index 73a42cd099c3..d14e7646a408 100644
--- a/src/instantsend/signing.cpp
+++ b/src/instantsend/signing.cpp
@@ -189,6 +189,12 @@ bool InstantSendSigner::CheckCanLock(const COutPoint& outpoint, bool printDebug,
 
     auto mempoolTx = m_mempool.get(outpoint.hash);
     if (mempoolTx) {
+        if (IsAssetUnlockWithStableTxid(*mempoolTx)) {
+            // An unmined version 2 asset unlock was quorum-signed, so the withdrawal is
+            // irreversible on Platform and will be re-signed until mined under this same txid.
+            // Spends of its outputs may therefore be locked before it is mined.
+            return outpoint.n < mempoolTx->vout.size();
+        }
         if (printDebug) {
             LogPrint(BCLog::INSTANTSEND, "%s -- txid=%s: parent mempool TX %s is not locked\n", __func__,
                      txHash.ToString(), outpoint.hash.ToString());
diff --git a/src/node/miner.cpp b/src/node/miner.cpp
index e061e4928dbe..4579d08fc03c 100644
--- a/src/node/miner.cpp
+++ b/src/node/miner.cpp
@@ -629,6 +629,20 @@ void BlockAssembler::addPackageTxs(const CTxMemPool& mempool, int& nPackagesSele
                 }
             }
             if (tx.IsSpecialTxVersion() && (tx.nType == TRANSACTION_ASSET_LOCK || tx.nType == TRANSACTION_ASSET_UNLOCK)) {
+                // Version 2 asset unlocks are not expiry-evicted: an expired instance stays in
+                // the mempool awaiting a re-signed replacement. Skip instances that are not
+                // currently minable (expired height window or stale quorum) instead of
+                // producing an invalid template.
+                if (IsAssetUnlockWithStableTxid(tx)) {
+                    TxValidationState state;
+                    if (!m_chain_helper.special_tx->CheckSpecialTx(tx, m_chainstate.m_chain.Tip(),
+                                                                   m_chainstate.CoinsTip(), /*check_sigs=*/true, state)) {
+                        LogPrintf("%s: package tx %s skipped, asset unlock instance not currently minable: %s\n", __func__,
+                                  tx.GetHash().ToString(), state.ToString());
+                        validPackage = false;
+                        break;
+                    }
+                }
                 creditPoolTransactions.emplace_back(entry->GetSharedTx());
             }
         }
diff --git a/src/node/transaction.cpp b/src/node/transaction.cpp
index a66c036bbfda..51cc1fd8e46e 100644
--- a/src/node/transaction.cpp
+++ b/src/node/transaction.cpp
@@ -55,7 +55,13 @@ TransactionError BroadcastTransaction(NodeContext& node, const CTransactionRef t
             // So if the output does exist, then this transaction exists in the chain.
             if (!existingCoin.IsSpent()) return TransactionError::ALREADY_IN_CHAIN;
         }
-        if (auto mempool_tx = node.mempool->get(txid); mempool_tx) {
+        const auto mempool_tx = node.mempool->get(txid);
+        // A version 2 asset unlock sharing a mempool entry's txid but carrying different quorum
+        // signing info is a re-signed instance of that withdrawal and must reach the mempool,
+        // which accepts it as an in-place refresh.
+        const bool is_unlock_refresh{mempool_tx && IsAssetUnlockWithStableTxid(*tx) &&
+                                     mempool_tx->GetInstanceHash() != tx->GetInstanceHash()};
+        if (mempool_tx && !is_unlock_refresh) {
             // There's already a transaction in the mempool with this txid. Don't
             // try to submit this transaction to the mempool (since it'll be
             // rejected as a TX_CONFLICT), but do attempt to reannounce the mempool
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 3844cec8ee8b..939417e6c7e6 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -684,8 +684,15 @@ void CTxMemPool::addUncheckedProTx(indexed_transaction_set::iterator& newit, con
             newit->isKeyChangeProTx = true;
         }
     } else if (tx.nType == TRANSACTION_ASSET_UNLOCK) {
-        auto assetUnlockTx = *Assert(GetTxPayload<CAssetUnlockPayload>(tx));
-        mapAssetUnlockExpiry.insert({tx_hash, assetUnlockTx.getHeightToExpiry()});
+        if (IsAssetUnlockWithStableTxid(tx)) {
+            // Re-signed instances of one withdrawal share the txid. The withdrawal is kept while
+            // expired, awaiting a fresher instance, instead of being expiry-evicted (which would
+            // take its descendants with it); relay identifies instances by instance hash.
+            m_asset_unlock_instances.emplace(tx.GetInstanceHash(), tx_hash);
+        } else {
+            auto assetUnlockTx = *Assert(GetTxPayload<CAssetUnlockPayload>(tx));
+            mapAssetUnlockExpiry.insert({tx_hash, assetUnlockTx.getHeightToExpiry()});
+        }
     } else if (tx.nType == TRANSACTION_MNHF_SIGNAL) {
         PrioritiseTransaction(tx_hash, 0.1 * COIN);
     }
@@ -779,10 +786,39 @@ void CTxMemPool::removeUncheckedProTx(const CTransaction& tx)
         auto proTx = *Assert(GetTxPayload<CProUpRevTx>(tx));
         eraseProTxRef(proTx.proTxHash, tx_hash);
     } else if (tx.nType == TRANSACTION_ASSET_UNLOCK) {
-        mapAssetUnlockExpiry.erase(tx_hash);
+        if (IsAssetUnlockWithStableTxid(tx)) {
+            m_asset_unlock_instances.erase(tx.GetInstanceHash());
+        } else {
+            mapAssetUnlockExpiry.erase(tx_hash);
+        }
     }
 }
 
+CTransactionRef CTxMemPool::GetAssetUnlockByInstanceHash(const uint256& instance_hash) const
+{
+    LOCK(cs);
+    auto it = m_asset_unlock_instances.find(instance_hash);
+    if (it == m_asset_unlock_instances.end()) return nullptr;
+    return get(it->second);
+}
+
+void CTxMemPool::ReplaceAssetUnlockInstance(const CTransactionRef& tx)
+{
+    AssertLockHeld(cs);
+    auto it = mapTx.find(tx->GetHash());
+    assert(it != mapTx.end());
+    const uint256 old_instance_hash{it->GetTx().GetInstanceHash()};
+    // Sharing a txid implies everything but the quorum signing info is identical, so all cached
+    // entry values (size, fee, ancestry) and multi-index keys remain valid; modify() cannot fail.
+    Assume(it->GetTx().GetTotalSize() == tx->GetTotalSize());
+    const bool modified{mapTx.modify(it, [&tx](CTxMemPoolEntry& e) { e.ReplaceAssetUnlockTx(tx); })};
+    assert(modified);
+    vTxHashes[it->vTxHashesIdx].first = tx->GetInstanceHash();
+    m_asset_unlock_instances.erase(old_instance_hash);
+    m_asset_unlock_instances.emplace(tx->GetInstanceHash(), tx->GetHash());
+    nTransactionsUpdated++;
+}
+
 // Calculates descendants of entry that are not already in setDescendants, and adds to
 // setDescendants. Assumes entryit is already a tx in the mempool and CTxMemPoolEntry::m_children
 // is correct for tx and all descendants.
@@ -1137,6 +1173,7 @@ void CTxMemPool::_clear()
     mapProTxAddresses.clear();
     mapProTxPubKeyIDs.clear();
     mapProTxPlatformNodeIDs.clear();
+    m_asset_unlock_instances.clear();
     totalTxSize = 0;
     m_total_fee = 0;
     cachedInnerUsage = 0;
@@ -1166,6 +1203,7 @@ void CTxMemPool::check(const CCoinsViewCache& active_coins_tip, int64_t spendhei
     CAmount check_total_fee{0};
     uint64_t innerUsage = 0;
     uint64_t prev_ancestor_count{0};
+    size_t check_asset_unlock_instances{0};
 
     CCoinsViewCache mempoolDuplicate(const_cast<CCoinsViewCache*>(&active_coins_tip));
 
@@ -1175,6 +1213,12 @@ void CTxMemPool::check(const CCoinsViewCache& active_coins_tip, int64_t spendhei
         innerUsage += it->DynamicMemoryUsage();
         const CTransaction& tx = it->GetTx();
         innerUsage += memusage::DynamicUsage(it->GetMemPoolParentsConst()) + memusage::DynamicUsage(it->GetMemPoolChildrenConst());
+        if (IsAssetUnlockWithStableTxid(tx)) {
+            ++check_asset_unlock_instances;
+            auto instance_it = m_asset_unlock_instances.find(tx.GetInstanceHash());
+            assert(instance_it != m_asset_unlock_instances.end());
+            assert(instance_it->second == tx.GetHash());
+        }
         CTxMemPoolEntry::Parents setParentCheck;
         for (const CTxIn &txin : tx.vin) {
             // Check that every mempool transaction's inputs refer to available coins, or other mempool tx's.
@@ -1257,6 +1301,7 @@ void CTxMemPool::check(const CCoinsViewCache& active_coins_tip, int64_t spendhei
     assert(totalTxSize == checkTotal);
     assert(m_total_fee == check_total_fee);
     assert(innerUsage == cachedInnerUsage);
+    assert(check_asset_unlock_instances == m_asset_unlock_instances.size());
 }
 
 bool CTxMemPool::CompareDepthAndScore(const uint256& hasha, const uint256& hashb)
diff --git a/src/txmempool.h b/src/txmempool.h
index 88f165ed2465..3d5ae769ce79 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -30,6 +30,7 @@
 #include <pubkey.h>
 #include <random.h>
 #include <sync.h>
+#include <util/check.h>
 #include <util/epochguard.h>
 #include <util/hasher.h>
 
@@ -110,7 +111,7 @@ class CTxMemPoolEntry
     struct ExplicitCopyTag {
         explicit ExplicitCopyTag() = default;
     };
-    const CTransactionRef tx;
+    CTransactionRef tx; //!< Only replaced by ReplaceAssetUnlockTx(), which preserves the txid
     mutable Parents m_parents;
     mutable Children m_children;
     const CAmount nFee;             //!< Cached to avoid expensive parent-transaction lookups
@@ -150,6 +151,13 @@ class CTxMemPoolEntry
     static constexpr ExplicitCopyTag ExplicitCopy{};
     const CTransaction& GetTx() const { return *this->tx; }
     CTransactionRef GetSharedTx() const { return this->tx; }
+    /** Swap in a re-signed instance of a version 2 asset unlock sharing this entry's txid. The
+     *  instances differ only in the quorum signing info, so all cached values remain valid. */
+    void ReplaceAssetUnlockTx(CTransactionRef new_tx)
+    {
+        Assume(new_tx->GetHash() == tx->GetHash());
+        tx = std::move(new_tx);
+    }
     const CAmount& GetFee() const { return nFee; }
     size_t GetTxSize() const;
     std::chrono::seconds GetTime() const { return std::chrono::seconds{nTime}; }
@@ -549,7 +557,10 @@ class CTxMemPool
     std::map<uint256, uint256> mapProTxBlsPubKeyHashes;
     std::map<uint160, uint256> mapProTxPlatformNodeIDs;
     std::map<COutPoint, uint256> mapProTxCollaterals;
-    std::map<uint256, int /* expiry height */> mapAssetUnlockExpiry; // tx hash -> height
+    std::map<uint256, int /* expiry height */> mapAssetUnlockExpiry; // tx hash -> height (version 1 only)
+    /** Instance hash (see CTransaction::GetInstanceHash) -> txid of version 2+ asset unlocks.
+     *  Relay identifies the re-signed instances of one withdrawal by instance hash. */
+    std::map<uint256, uint256> m_asset_unlock_instances GUARDED_BY(cs);
 
     void UpdateParent(txiter entry, txiter parent, bool add) EXCLUSIVE_LOCKS_REQUIRED(cs);
     void UpdateChild(txiter entry, txiter child, bool add) EXCLUSIVE_LOCKS_REQUIRED(cs);
@@ -820,6 +831,12 @@ class CTxMemPool
     TxMempoolInfo info(const uint256& hash) const;
     std::vector<TxMempoolInfo> infoAll() const;
 
+    /** Get the transaction holding this version 2 asset unlock instance hash, if any. */
+    CTransactionRef GetAssetUnlockByInstanceHash(const uint256& instance_hash) const;
+    /** Replace the held instance of a pending withdrawal with a fresher re-signed instance
+     *  sharing its txid. The caller has fully validated the new instance. */
+    void ReplaceAssetUnlockInstance(const CTransactionRef& tx) EXCLUSIVE_LOCKS_REQUIRED(cs);
+
     bool existsProviderTxConflict(const CTransaction &tx) const;
 
     /**
diff --git a/src/validation.cpp b/src/validation.cpp
index 0f897d8b122b..5178bf052bc4 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -54,8 +54,10 @@
 #include <warnings.h>
 
 #include <chainlock/chainlock.h>
+#include <evo/assetlocktx.h>
 #include <evo/cbtx.h>
 #include <evo/chainhelper.h>
+#include <evo/creditpool.h>
 #include <evo/deterministicmns.h>
 #include <evo/evodb.h>
 #include <evo/specialtx.h>
@@ -725,6 +727,12 @@ class MemPoolAccept
     // only tests that are fast should be done here (to avoid CPU DoS).
     bool PreChecks(ATMPArgs& args, Workspace& ws) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
 
+    // If ptx is a version 2 asset unlock whose txid is already in the mempool, handle it as a
+    // re-signed instance of that withdrawal: validate it and, when fresher, swap it into the
+    // existing entry in place. Returns std::nullopt when the normal acceptance path should run.
+    std::optional<MempoolAcceptResult> TryAssetUnlockRefresh(const CTransactionRef& ptx, const ATMPArgs& args)
+        EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
+
     // Enforce package mempool ancestor/descendant limits (distinct from individual
     // ancestor/descendant limits done in PreChecks).
     bool PackageMempoolChecks(const std::vector<CTransactionRef>& txns,
@@ -874,6 +882,19 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
     m_view.SetBackend(m_viewmempool);
 
     const CCoinsViewCache& coins_cache = m_active_chainstate.CoinsTip();
+
+    // Asset unlocks have no inputs, so the missing-inputs check below cannot detect that this
+    // withdrawal was already mined - and a coin check is not reliable either, since the outputs
+    // may have been spent in the very block that mined it. The credit pool's mined-index set is
+    // authoritative. Version 2 unlocks are never expiry-evicted, so an already-mined instance
+    // admitted here would linger indefinitely. GetCreditPool reads from an LRU cache; the first
+    // call after startup may reconstruct the pool from the nearest disk snapshot.
+    if (const auto opt_unlock = tx.IsPlatformTransfer() ? GetTxPayload<CAssetUnlockPayload>(tx) : std::nullopt;
+        opt_unlock && m_chain_helper.credit_pool_manager->GetCreditPool(m_active_chainstate.m_chain.Tip())
+                          .indexes.Contains(opt_unlock->getIndex())) {
+        return state.Invalid(TxValidationResult::TX_CONFLICT, "txn-already-known");
+    }
+
     // do all inputs exist?
     for (const CTxIn& txin : tx.vin) {
         if (!coins_cache.HaveCoinInCache(txin.prevout)) {
@@ -1221,12 +1242,62 @@ bool MemPoolAccept::SubmitPackage(const ATMPArgs& args, std::vector<Workspace>&
     return all_submitted;
 }
 
+std::optional<MempoolAcceptResult> MemPoolAccept::TryAssetUnlockRefresh(const CTransactionRef& ptx, const ATMPArgs& args)
+{
+    AssertLockHeld(cs_main);
+    AssertLockHeld(m_pool.cs);
+
+    if (!IsAssetUnlockWithStableTxid(*ptx)) return std::nullopt;
+    const auto held_it = m_pool.GetIter(ptx->GetHash());
+    if (!held_it) return std::nullopt;
+    const CTransactionRef held = (*held_it)->GetSharedTx();
+
+    TxValidationState state;
+    if (held->GetInstanceHash() == ptx->GetInstanceHash()) {
+        state.Invalid(TxValidationResult::TX_CONFLICT, "txn-already-in-mempool");
+        return MempoolAcceptResult::Failure(state);
+    }
+
+    const auto held_payload = GetTxPayload<CAssetUnlockPayload>(*held);
+    const auto new_payload = GetTxPayload<CAssetUnlockPayload>(*ptx);
+    // Reject cheaply, before any signature work, unless this is a plausibly minable fresher
+    // instance: its requestedHeight must strictly exceed the held instance's and place the tip
+    // inside the withdrawal's validity window. This bounds how much quorum-signature verification
+    // a peer can force by resubmitting instances that share the mempool entry's txid.
+    const int tip_height = m_active_chainstate.m_chain.Height();
+    if (!Assume(held_payload) || !new_payload ||
+        new_payload->getRequestedHeight() <= held_payload->getRequestedHeight() ||
+        static_cast<int64_t>(new_payload->getRequestedHeight()) > tip_height ||
+        new_payload->getHeightToExpiry() <= tip_height) {
+        state.Invalid(TxValidationResult::TX_CONFLICT, "assetunlock-stale-instance");
+        return MempoolAcceptResult::Failure(state);
+    }
+
+    // Full consensus validation of the fresh instance: payload, quorum recency, height window
+    // and quorum signature. Everything the txid covers is identical to the held instance and
+    // was validated when it was admitted.
+    if (!m_chain_helper.special_tx->CheckSpecialTx(*ptx, m_active_chainstate.m_chain.Tip(),
+                                                   m_active_chainstate.CoinsTip(), /*check_sigs=*/true, state)) {
+        return MempoolAcceptResult::Failure(state);
+    }
+
+    const int64_t vsize = (*held_it)->GetTxSize();
+    const CAmount fee = (*held_it)->GetFee();
+    if (!args.m_test_accept) {
+        m_pool.ReplaceAssetUnlockInstance(ptx);
+        GetMainSignals().TransactionAddedToMempool(ptx, args.m_accept_time, m_pool.GetAndIncrementSequence());
+    }
+    return MempoolAcceptResult::Success(vsize, fee);
+}
+
 MempoolAcceptResult MemPoolAccept::AcceptSingleTransaction(const CTransactionRef& ptx, ATMPArgs& args)
 {
     auto start = Now<SteadyMilliseconds>();
     AssertLockHeld(cs_main);
     LOCK(m_pool.cs); // mempool "read lock" (held through GetMainSignals().TransactionAddedToMempool())
 
+    if (auto refresh_result = TryAssetUnlockRefresh(ptx, args)) return *refresh_result;
+
     Workspace ws(ptx);
 
     if (!PreChecks(args, ws)) return MempoolAcceptResult::Failure(ws.m_state);
diff --git a/test/lint/lint-circular-dependencies.py b/test/lint/lint-circular-dependencies.py
index a1d409c64715..a3049bb7e45b 100755
--- a/test/lint/lint-circular-dependencies.py
+++ b/test/lint/lint-circular-dependencies.py
@@ -38,9 +38,11 @@
     "common/bloom -> evo/assetlocktx -> llmq/quorumsman -> llmq/blockprocessor -> net -> common/bloom",
     "consensus/tx_verify -> evo/assetlocktx -> llmq/commitment -> validation -> consensus/tx_verify",
     "consensus/tx_verify -> evo/assetlocktx -> llmq/commitment -> validation -> txmempool -> consensus/tx_verify",
+    "evo/assetlocktx -> llmq/commitment -> validation -> evo/assetlocktx",
     "evo/assetlocktx -> llmq/commitment -> validation -> txmempool -> evo/assetlocktx",
     "evo/cbtx -> llmq/blockprocessor -> validation -> evo/cbtx",
     "evo/chainhelper -> evo/creditpool -> validation -> evo/chainhelper",
+    "evo/creditpool -> validation -> evo/creditpool",
     "evo/deterministicmns -> node/blockstorage -> validation -> evo/deterministicmns",
     "evo/deterministicmns -> node/blockstorage -> validation -> masternode/payments -> evo/deterministicmns",
     "evo/deterministicmns -> node/blockstorage -> validation -> txmempool -> evo/deterministicmns",

From 06a45c48e8c7795133a69539783b638eb8946bd8 Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Tue, 25 Aug 2026 11:00:41 +0200
Subject: [PATCH 5/7] feat(net): relay version 2 asset unlocks by instance hash

Re-signed instances of one withdrawal share a txid, so txid-based announcement can never propagate a refresh: peers holding the stale instance see a known txid and don't fetch, and a rejected stale instance in the rejects filter would poison the fresh one. A new MSG_ASSET_UNLOCK inventory type (protocol 70242) announces these transactions by instance hash; getdata for it is answered with a plain tx message, requests and rejects are tracked per instance, and AlreadyHave consults the mempool's instance map. Peers on older protocol versions receive a plain MSG_TX announcement of the current instance and never see refreshes.
---
 src/net_processing.cpp | 98 +++++++++++++++++++++++++++++++++---------
 src/protocol.cpp       |  3 ++
 src/protocol.h         |  4 +-
 src/version.h          |  6 ++-
 4 files changed, 89 insertions(+), 22 deletions(-)

diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 7f722df29be8..f838b0ddc152 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -669,10 +669,14 @@ class PeerManagerImpl final : public PeerManager
     void AddObjectAnnouncement(const CNode& node, const CInv& inv, std::chrono::microseconds current_time)
         EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
-    /** Delete all announcements of a transaction across all peers, under both inv types it may
+    /** Delete all announcements of a transaction across all peers, under the inv types it may
      *  have been announced with (MSG_TX and MSG_DSTX). */
     void ForgetTx(const uint256& txid) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
+    /** As above, additionally forgetting the MSG_ASSET_UNLOCK announcement (by instance hash)
+     *  used for version 2 asset unlocks. */
+    void ForgetTx(const CTransaction& tx) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+
     /** Helper to process result of external handlers of message */
     void PostProcessMessage(MessageProcessingResult&& ret, NodeId node) override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
 
@@ -1638,6 +1642,14 @@ void PeerManagerImpl::ForgetTx(const uint256& txid)
     m_object_request.ForgetTxHash(CInv(MSG_DSTX, txid));
 }
 
+void PeerManagerImpl::ForgetTx(const CTransaction& tx)
+{
+    ForgetTx(tx.GetHash());
+    if (IsAssetUnlockWithStableTxid(tx)) {
+        m_object_request.ForgetTxHash(CInv(MSG_ASSET_UNLOCK, tx.GetInstanceHash()));
+    }
+}
+
 size_t PeerManagerImpl::GetRequestedObjectCount(NodeId nodeid) const
 {
     AssertLockHeld(cs_main);
@@ -2122,7 +2134,7 @@ void PeerManagerImpl::BlockConnected(const std::shared_ptr<const CBlock>& pblock
         }
         for (const auto& ptx : pblock->vtx) {
             // Confirmed transactions no longer need to be requested.
-            ForgetTx(ptx->GetHash());
+            ForgetTx(*ptx);
         }
     }
 
@@ -2132,6 +2144,11 @@ void PeerManagerImpl::BlockConnected(const std::shared_ptr<const CBlock>& pblock
         LOCK(m_recent_confirmed_transactions_mutex);
         for (const auto& ptx : pblock->vtx) {
             m_recent_confirmed_transactions.insert(ptx->GetHash());
+            // Version 2 asset unlocks are announced and deduplicated by instance hash; record the
+            // mined instance so AlreadyHave() stops re-requesting it once it leaves the mempool.
+            if (IsAssetUnlockWithStableTxid(*ptx)) {
+                m_recent_confirmed_transactions.insert(ptx->GetInstanceHash());
+            }
         }
     }
 
@@ -2293,6 +2310,7 @@ bool PeerManagerImpl::AlreadyHave(const CInv& inv)
     {
     case MSG_TX:
     case MSG_DSTX:
+    case MSG_ASSET_UNLOCK:
         {
             if (m_chainman.ActiveChain().Tip()->GetBlockHash() != hashRecentRejectsChainTip)
             {
@@ -2304,6 +2322,19 @@ bool PeerManagerImpl::AlreadyHave(const CInv& inv)
                 m_recent_rejects.reset();
             }
 
+            if (inv.IsMsgAssetUnlock()) {
+                // inv.hash is the instance hash of a version 2 asset unlock. Rejects and mined
+                // instances are tracked by instance hash, so a rejected or already-mined stale
+                // instance never blocks a fresher re-signed instance of the same withdrawal
+                // (which shares its txid) yet is not endlessly re-requested either.
+                if (WITH_LOCK(m_recent_confirmed_transactions_mutex,
+                              return m_recent_confirmed_transactions.contains(inv.hash))) {
+                    return true;
+                }
+                return m_recent_rejects.contains(inv.hash) ||
+                       m_mempool.GetAssetUnlockByInstanceHash(inv.hash) != nullptr;
+            }
+
             if (m_orphanage.HaveTx(inv.hash)) return true;
 
             {
@@ -2825,6 +2856,12 @@ void PeerManagerImpl::ProcessGetBlockData(CNode& pfrom, Peer& peer, const CInv&
 CTransactionRef PeerManagerImpl::FindTxForGetData(const CNode* peer, const uint256& txid, const std::chrono::seconds mempool_req, const std::chrono::seconds now)
 {
     auto txinfo = m_mempool.info(txid);
+    if (!txinfo.tx) {
+        // A MSG_ASSET_UNLOCK getdata identifies a version 2 asset unlock by its instance hash
+        if (const auto unlock_tx = m_mempool.GetAssetUnlockByInstanceHash(txid)) {
+            txinfo = m_mempool.info(unlock_tx->GetHash());
+        }
+    }
     if (txinfo.tx) {
         // If a TX could have been INVed in reply to a MEMPOOL request,
         // or is older than UNCONDITIONAL_RELAY_DELAY, permit the request
@@ -3536,6 +3573,18 @@ static bool CanAnnounceDstxTo(const CCoinJoinBroadcastTx& dstx, int peer_version
            peer_version >= COINJOIN_REBALANCE_VERSION;
 }
 
+//! The inventory type and hash to announce a mempool transaction with to a peer at the given
+//! negotiated protocol version. Version 2 asset unlocks are announced by instance hash (MSG_ASSET_UNLOCK)
+//! so a re-signed instance of a withdrawal the peer already has (sharing its txid) is still announced;
+//! a getdata for it is served as a plain `tx`. Older peers get MSG_TX and never learn of refreshes.
+static std::pair<int, uint256> GetTxAnnouncement(const CTransaction& tx, int peer_version)
+{
+    if (IsAssetUnlockWithStableTxid(tx) && peer_version >= ASSET_UNLOCK_INV_VERSION) {
+        return {MSG_ASSET_UNLOCK, tx.GetInstanceHash()};
+    }
+    return {MSG_TX, tx.GetHash()};
+}
+
 // do_return signals the caller to stop further processing of the DSTX.
 struct DSTXValidationResult {
     DSTXValidationScore score;
@@ -4772,9 +4821,15 @@ void PeerManagerImpl::ProcessMessage(
         const CTransaction& tx = *ptx;
 
         const uint256& txid = ptx->GetHash();
-        AddKnownInv(*peer, txid);
-
-        CInv inv(nInvType, tx.GetHash());
+        // Version 2 asset unlocks are announced, requested and deduplicated by instance hash so
+        // that a re-signed instance of a withdrawal already in the mempool (sharing its txid)
+        // still propagates.
+        const bool is_stable_unlock{IsAssetUnlockWithStableTxid(tx)};
+        if (is_stable_unlock) nInvType = MSG_ASSET_UNLOCK;
+        const uint256& relay_hash{is_stable_unlock ? tx.GetInstanceHash() : txid};
+        AddKnownInv(*peer, relay_hash);
+
+        CInv inv(nInvType, relay_hash);
         {
             LOCK(cs_main);
             // A MSG_TX request may be answered with a DSTX message and vice versa (a getdata for
@@ -4782,6 +4837,9 @@ void PeerManagerImpl::ProcessMessage(
             // type the request was tracked under.
             m_object_request.ReceivedResponse(pfrom.GetId(), CInv(MSG_TX, txid));
             m_object_request.ReceivedResponse(pfrom.GetId(), CInv(MSG_DSTX, txid));
+            if (is_stable_unlock) {
+                m_object_request.ReceivedResponse(pfrom.GetId(), CInv(MSG_ASSET_UNLOCK, relay_hash));
+            }
         }
 
         // Process custom logic, no matter if tx will be accepted to mempool later or not
@@ -4825,7 +4883,7 @@ void PeerManagerImpl::ProcessMessage(
                 m_dstxman.AddDSTX(dstx);
             }
 
-            ForgetTx(tx.GetHash());
+            ForgetTx(tx);
             _RelayTransaction(tx.GetHash());
             m_orphanage.AddChildrenToWorkSet(tx, peer->m_id);
 
@@ -4892,8 +4950,8 @@ void PeerManagerImpl::ProcessMessage(
                 m_isman.TransactionIsRemoved(ptx);
             }
         } else {
-            m_recent_rejects.insert(tx.GetHash());
-            ForgetTx(tx.GetHash());
+            m_recent_rejects.insert(relay_hash);
+            ForgetTx(tx);
             if (RecursiveDynamicUsage(*ptx) < 100000) {
                 AddToCompactExtraTransactions(ptx);
             }
@@ -6492,7 +6550,7 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
                     tx_relay->m_tx_inventory_to_send.erase(hash);
                     if (tx_relay->m_bloom_filter && !tx_relay->m_bloom_filter->IsRelevantAndUpdate(*txinfo.tx)) continue;
 
-                    int nInvType = MSG_TX;
+                    auto [nInvType, announce_hash] = GetTxAnnouncement(*txinfo.tx, pto->GetCommonVersion());
                     // A DSTX this peer would reject as malformed is announced as a plain
                     // transaction instead of being dropped: the peer still gets the transaction
                     // (ProcessGetData serves a NetMsgType::TX for it), just without the mixing
@@ -6500,8 +6558,8 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
                     if (const auto dstx = m_dstxman.GetDSTX(hash); dstx && CanAnnounceDstxTo(dstx, pto->GetCommonVersion())) {
                         nInvType = MSG_DSTX;
                     }
-                    tx_relay->m_tx_inventory_known_filter.insert(hash);
-                    queueAndMaybePushInv(CInv(nInvType, hash));
+                    tx_relay->m_tx_inventory_known_filter.insert(announce_hash);
+                    queueAndMaybePushInv(CInv(nInvType, announce_hash));
 
                     const auto islock = m_isman.GetInstantSendLockByTxid(hash);
                     if (islock == nullptr) continue;
@@ -6550,17 +6608,17 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
                     uint256 hash = *it;
                     // Remove it from the to-be-sent set
                     tx_relay->m_tx_inventory_to_send.erase(it);
-                    // Check if not in the filter already
-                    if (tx_relay->m_tx_inventory_known_filter.contains(hash)) {
-                        continue;
-                    }
                     // Not in the mempool anymore? don't bother sending it.
                     auto txinfo = m_mempool.info(hash);
                     if (!txinfo.tx) {
                         continue;
                     }
+                    auto [nInvType, announce_hash] = GetTxAnnouncement(*txinfo.tx, pto->GetCommonVersion());
+                    // Check if not in the filter already
+                    if (tx_relay->m_tx_inventory_known_filter.contains(announce_hash)) {
+                        continue;
+                    }
                     if (tx_relay->m_bloom_filter && !tx_relay->m_bloom_filter->IsRelevantAndUpdate(*txinfo.tx)) continue;
-                    int nInvType = MSG_TX;
                     // See the mempool-request path above: a DSTX this peer would reject as
                     // malformed is downgraded to a plain transaction announcement rather than
                     // withheld, so pre-rebalance peers still receive it.
@@ -6568,7 +6626,7 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
                         nInvType = MSG_DSTX;
                     }
                     // Send
-                    State(pto->GetId())->m_recently_announced_invs.insert(hash);
+                    State(pto->GetId())->m_recently_announced_invs.insert(announce_hash);
                     nRelayedTransactions++;
                     {
                         // Expire old relay messages
@@ -6578,13 +6636,13 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
                             g_relay_expiration.pop_front();
                         }
 
-                        auto ret = mapRelay.emplace(hash, std::move(txinfo.tx));
+                        auto ret = mapRelay.emplace(announce_hash, std::move(txinfo.tx));
                         if (ret.second) {
                             g_relay_expiration.emplace_back(current_time + RELAY_TX_CACHE_TIME, ret.first);
                         }
                     }
-                    tx_relay->m_tx_inventory_known_filter.insert(hash);
-                    queueAndMaybePushInv(CInv(nInvType, hash));
+                    tx_relay->m_tx_inventory_known_filter.insert(announce_hash);
+                    queueAndMaybePushInv(CInv(nInvType, announce_hash));
                 }
             }
         }
diff --git a/src/protocol.cpp b/src/protocol.cpp
index c5683a16dc9d..180649352341 100644
--- a/src/protocol.cpp
+++ b/src/protocol.cpp
@@ -300,6 +300,9 @@ const char* CInv::GetCommandInternal() const
         case MSG_ISDLOCK:                       return NetMsgType::ISDLOCK;
         case MSG_DSQ:                           return NetMsgType::DSQUEUE;
         case MSG_PLATFORM_BAN:                  return NetMsgType::PLATFORMBAN;
+        // Version 2 asset unlocks are announced by instance hash but carried in plain `tx`
+        // messages; this also puts them in the blocks-only violation list, like MSG_TX
+        case MSG_ASSET_UNLOCK:                  return NetMsgType::TX;
         default:
             return nullptr;
     }
diff --git a/src/protocol.h b/src/protocol.h
index 6e39faa23dd0..d616c06f56fc 100644
--- a/src/protocol.h
+++ b/src/protocol.h
@@ -524,6 +524,7 @@ enum GetDataMsg : uint32_t {
     MSG_ISDLOCK = 31,
     MSG_DSQ = 32,
     MSG_PLATFORM_BAN = 33,                            // Platform service ban (DIP-0031)
+    MSG_ASSET_UNLOCK = 34,                            //!< Version 2 asset unlock announced by instance hash; getdata is answered with a `tx` message
 };
 
 /** inv message data */
@@ -546,13 +547,14 @@ class CInv
     bool IsMsgTx()        const { return type == MSG_TX; }
     bool IsMsgBlk() const { return type == MSG_BLOCK; }
     bool IsMsgDstx()       const { return type == MSG_DSTX; }
+    bool IsMsgAssetUnlock() const { return type == MSG_ASSET_UNLOCK; }
     bool IsMsgFilteredBlk() const { return type == MSG_FILTERED_BLOCK; }
     bool IsMsgCmpctBlk() const { return type == MSG_CMPCT_BLOCK; }
 
     // Combined-message helper methods
     bool IsGenTxMsg() const
     {
-        return type == MSG_TX || type == MSG_DSTX;
+        return type == MSG_TX || type == MSG_DSTX || type == MSG_ASSET_UNLOCK;
     }
     bool IsGenBlkMsg() const
     {
diff --git a/src/version.h b/src/version.h
index fdc04635d490..d3a38073a652 100644
--- a/src/version.h
+++ b/src/version.h
@@ -11,7 +11,7 @@
  */
 
 
-static const int PROTOCOL_VERSION = 70241;
+static const int PROTOCOL_VERSION = 70242;
 
 //! initial proto version, to be increased after version/verack negotiation
 static const int INIT_PROTO_VERSION = 209;
@@ -72,6 +72,10 @@ static const int PLATFORMBAN_V2_SHORT_ID_VERSION = 70240;
 //! may join rebalance-capable mixing sessions
 static const int COINJOIN_REBALANCE_VERSION = 70241;
 
+//! MSG_ASSET_UNLOCK inventory type added: version 2 asset unlocks are announced by instance hash
+//! so that re-signed instances of one withdrawal (sharing its txid) propagate
+static const int ASSET_UNLOCK_INV_VERSION = 70242;
+
 // Make sure that none of the values above collide with `ADDRV2_FORMAT`.
 
 #endif // BITCOIN_VERSION_H

From 9aeefcb4350081b63e8bc45066ec3849181e4ffe Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Tue, 25 Aug 2026 11:01:55 +0200
Subject: [PATCH 6/7] feat(rpc): expose asset unlock instance hashes and align
 platform signing with withdrawal re-signs

Transaction JSON for version 2 asset unlocks gains instanceHash, the full-serialization hash distinguishing the re-signed instances that share one txid.

platformsign allows signing a request id again with a different message hash, truncating the previously recovered signature so the new session is not short-circuited, and ProcessRecoveredSig lets a fresher recovered signature supersede the stored one for the platform quorum type. Platform legitimately re-signs one withdrawal (one request id) with changing message hashes - the message hash commits to the signing height and quorum - so the one-recovered-sig-per-id constraint must not pin the first signature forever. This also removes a narrow pre-existing race for EHF signals.
---
 src/core_write.cpp          |  3 +++
 src/llmq/signing.cpp        | 21 ++++++++++++++++-----
 src/llmq/signing_shares.cpp |  3 +++
 src/rpc/quorums.cpp         |  7 ++++++-
 src/rpc/rawtransaction.cpp  |  1 +
 5 files changed, 29 insertions(+), 6 deletions(-)

diff --git a/src/core_write.cpp b/src/core_write.cpp
index e94b0af4add7..fe45f3eca039 100644
--- a/src/core_write.cpp
+++ b/src/core_write.cpp
@@ -324,6 +324,9 @@ void TxToUniv(const CTransaction& tx, const uint256& block_hash, UniValue& entry
         if (const auto opt_assetUnlockTx = GetTxPayload<CAssetUnlockPayload>(tx)) {
             entry.pushKV("assetUnlockTx", opt_assetUnlockTx->ToJson());
         }
+        if (IsAssetUnlockWithStableTxid(tx)) {
+            entry.pushKV("instanceHash", tx.GetInstanceHash().ToString());
+        }
     }
 
     if (have_undo) {
diff --git a/src/llmq/signing.cpp b/src/llmq/signing.cpp
index 21824b2f687b..e8e33588762b 100644
--- a/src/llmq/signing.cpp
+++ b/src/llmq/signing.cpp
@@ -542,16 +542,27 @@ bool CSigningManager::ProcessRecoveredSig(const std::shared_ptr<const CRecovered
         if (db.GetRecoveredSigById(llmqType, recoveredSig->getId(), otherRecoveredSig)) {
             auto otherSignHash = otherRecoveredSig.buildSignHash();
             if (signHash.Get() != otherSignHash.Get()) {
-                // this should really not happen, as each masternode is participating in only one vote,
-                // even if it's a member of multiple quorums. so a majority is only possible on one quorum and one msgHash per id
-                LogPrintf("CSigningManager::%s -- conflicting recoveredSig for signHash=%s, id=%s, msgHash=%s, otherSignHash=%s\n", __func__,
-                          signHash.ToString(), recoveredSig->getId().ToString(), recoveredSig->getMsgHash().ToString(), otherSignHash.ToString());
+                if (llmqType == Params().GetConsensus().llmqTypePlatform) {
+                    // Platform re-signs expired withdrawals under the same request id with a new
+                    // message hash; the latest recovered sig supersedes the previous one. The
+                    // truncate and the write below are separate batches; a crash in between only
+                    // loses a sig that Platform will produce again on the next re-sign.
+                    LogPrint(BCLog::LLMQ, "CSigningManager::%s -- replacing recoveredSig for platform signHash=%s, id=%s, msgHash=%s, otherSignHash=%s\n", __func__,
+                             signHash.ToString(), recoveredSig->getId().ToString(), recoveredSig->getMsgHash().ToString(), otherSignHash.ToString());
+                    db.TruncateRecoveredSig(llmqType, recoveredSig->getId());
+                } else {
+                    // this should really not happen, as each masternode is participating in only one vote,
+                    // even if it's a member of multiple quorums. so a majority is only possible on one quorum and one msgHash per id
+                    LogPrintf("CSigningManager::%s -- conflicting recoveredSig for signHash=%s, id=%s, msgHash=%s, otherSignHash=%s\n", __func__,
+                              signHash.ToString(), recoveredSig->getId().ToString(), recoveredSig->getMsgHash().ToString(), otherSignHash.ToString());
+                    return false;
+                }
             } else {
                 // Looks like we're trying to process a recSig that is already known. This might happen if the same
                 // recSig comes in through regular QRECSIG messages and at the same time through some other message
                 // which allowed to reconstruct a recSig (e.g. ISLOCK). In this case, just bail out.
+                return false;
             }
-            return false;
         } else {
             // This case is very unlikely. It can only happen when cleanup caused this specific recSig to vanish
             // between the HasRecoveredSigForId and GetRecoveredSigById call. If that happens, treat it as if we
diff --git a/src/llmq/signing_shares.cpp b/src/llmq/signing_shares.cpp
index 87b9864edbb9..ae693ec8c7c4 100644
--- a/src/llmq/signing_shares.cpp
+++ b/src/llmq/signing_shares.cpp
@@ -812,6 +812,9 @@ bool CSigSharesManager::AsyncSignIfMember(Consensus::LLMQType llmqType, const ui
                     LogPrintf("%s -- already voted for id=%s and msgHash=%s. Signing for different " /* Continued */
                               "msgHash=%s\n",
                               __func__, id.ToString(), prevMsgHash.ToString(), msgHash.ToString());
+                    // Drop any recovered sig for the previous message so the new signing session
+                    // is not short-circuited by the by-id lookups in the share pipeline
+                    sigman.TruncateRecoveredSig(llmqType, id);
                     hasVoted = false;
                 } else {
                     LogPrintf("%s -- already voted for id=%s and msgHash=%s. Not voting on " /* Continued */
diff --git a/src/rpc/quorums.cpp b/src/rpc/quorums.cpp
index 5bd168e9b0bf..2dc5620a80b5 100644
--- a/src/rpc/quorums.cpp
+++ b/src/rpc/quorums.cpp
@@ -536,7 +536,12 @@ static UniValue quorum_sign_helper(const JSONRPCRequest& request, Consensus::LLM
                            "Quorum signing is disabled until snapshot background validation completes");
     }
     if (fSubmit) {
-        return CHECK_NONFATAL(node.active_ctx)->shareman->AsyncSignIfMember(llmqType, id, msgHash, quorumHash);
+        // Platform re-signs expired withdrawals under the same request id with a new message
+        // hash, so platform-type sessions must not refuse a changed message
+        const bool allow_diff_msghash{llmqType == Params().GetConsensus().llmqTypePlatform};
+        return CHECK_NONFATAL(node.active_ctx)
+            ->shareman->AsyncSignIfMember(llmqType, id, msgHash, quorumHash, /*allowReSign=*/false,
+                                          /*allowDiffMsgHashSigning=*/allow_diff_msghash);
     } else {
         const auto pQuorum = [&]() {
             if (quorumHash.IsNull()) {
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 9d55adcc00cb..34527f5baf70 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -221,6 +221,7 @@ static std::vector<RPCResult> DecodeTxDoc(const std::string& txid_field_doc)
         MNHFTxPayload::GetJsonHelp(/*key=*/"mnhfTx", /*optional=*/true),
         CAssetLockPayload::GetJsonHelp(/*key=*/"assetLockTx", /*optional=*/true),
         CAssetUnlockPayload::GetJsonHelp(/*key=*/"assetUnlockTx", /*optional=*/true),
+        {RPCResult::Type::STR_HEX, "instanceHash", /*optional=*/true, "Full-serialization hash distinguishing this re-signed instance of the withdrawal; the txid is shared by all instances. Only present for version 2 Asset Unlock special TXs"},
     };
 }
 

From da4385684625918ae221f74a890ee1bd50c49dab Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Tue, 25 Aug 2026 11:43:31 +0200
Subject: [PATCH 7/7] test: cover version 2 asset unlocks in
 feature_asset_locks.py

Pre-fork rejection; spending an unmined version 2 unlock by its stable txid; an in-place refresh by a fresher re-signed instance with the child untouched and the instanceHash rotating; MSG_ASSET_UNLOCK announcements observed for both the initial instance and the refresh; stale-instance rejection; survival of the expired instance and its child; flushing leftover withdrawals and clearing the window; and mining a fresh re-sign together with the child, asserting the CbTx version 4 commitment against the mined instance hash.

sync_mempools() compares txid sets and is satisfied before a refresh (same txid) has propagated, so a sync_unlock_instance helper waits for every node to hold the exact instance. The test framework negotiates protocol 70242 to receive MSG_ASSET_UNLOCK invs.
---
 test/functional/feature_asset_locks.py     | 153 ++++++++++++++++++++-
 test/functional/test_framework/messages.py |   2 +
 test/functional/test_framework/p2p.py      |   6 +-
 3 files changed, 154 insertions(+), 7 deletions(-)

diff --git a/test/functional/feature_asset_locks.py b/test/functional/feature_asset_locks.py
index ae1821e4e481..204d4087b296 100755
--- a/test/functional/feature_asset_locks.py
+++ b/test/functional/feature_asset_locks.py
@@ -23,10 +23,12 @@
     CTransaction,
     CTxIn,
     CTxOut,
+    MSG_ASSET_UNLOCK,
     tx_from_hex,
     hash256,
     ser_string,
 )
+from test_framework.p2p import P2PInterface
 from test_framework.script import (
     CScript,
     hash160,
@@ -49,10 +51,22 @@
 
 llmq_type_test = 106 # LLMQType::LLMQ_TEST_PLATFORM
 MNEHF_SIGNAL_TX_TYPE = 7 # TRANSACTION_MNHF_SIGNAL
+ASSET_UNLOCK_TX_TYPE = 9 # TRANSACTION_ASSET_UNLOCK
 tiny_amount = int(Decimal("0.0007") * COIN)
 blocks_in_one_day = 100
 HEIGHT_DIFF_EXPIRING = 48
 
+class InvListener(P2PInterface):
+    def __init__(self):
+        super().__init__()
+        self.asset_unlock_invs = []
+
+    def on_inv(self, message):
+        for i in message.inv:
+            if i.type == MSG_ASSET_UNLOCK:
+                self.asset_unlock_invs.append(i.hash)
+
+
 class AssetLocksTest(DashTestFramework):
     def add_options(self, parser):
         self.add_wallet_options(parser)
@@ -106,7 +120,7 @@ def create_assetunlock_request_id(self, index):
         return hash256(request_id_buf)[::-1].hex()
 
 
-    def create_assetunlock(self, index, withdrawal, pubkey=None, fee=tiny_amount):
+    def create_assetunlock(self, index, withdrawal, pubkey=None, fee=tiny_amount, version=1):
         node_wallet = self.nodes[0]
         mninfo = self.mninfo
         assert_greater_than(int(withdrawal), fee)
@@ -119,7 +133,7 @@ def create_assetunlock(self, index, withdrawal, pubkey=None, fee=tiny_amount):
         quorumHash = mninfo[0].get_node(self).quorum("selectquorum", llmq_type_test, request_id)["quorumHash"]
         self.log.info(f"Used quorum hash: {quorumHash}")
         unlockTx_payload = CAssetUnlockTx(
-            version = 1,
+            version = version,
             index = index,
             fee = fee,
             requestedHeight = height,
@@ -143,6 +157,33 @@ def create_assetunlock(self, index, withdrawal, pubkey=None, fee=tiny_amount):
         return unlock_tx
 
 
+    def sync_unlock_instance(self, txid, instance_hash):
+        # A re-signed instance shares the held entry's txid, so sync_mempools() is satisfied
+        # before the refresh has propagated; wait for every node to hold this exact instance.
+        # Refreshes travel as MSG_ASSET_UNLOCK invs on the trickle schedule, which needs time
+        # to advance.
+        def synced():
+            self.bump_mocktime(1)
+            return all(node.getrawtransaction(txid, 1).get('instanceHash') == instance_hash
+                       for node in self.nodes)
+        self.wait_until(synced, timeout=60)
+
+    def get_v2_txid(self, unlock_tx):
+        # The txid of a v2 asset unlock: the tx hashed with the requestedHeight, quorumHash and
+        # quorumSig payload fields zeroed - the fields Platform changes when it re-signs - so
+        # every re-signed instance of one withdrawal shares one txid. The python-side rehash()
+        # of the full serialization is the instance hash instead.
+        payload = CAssetUnlockTx()
+        payload.deserialize(BytesIO(unlock_tx.vExtraPayload))
+        payload.requestedHeight = 0
+        payload.quorumHash = 0
+        payload.quorumSig = b'\x00' * 96
+        tx_copy = copy.deepcopy(unlock_tx)
+        tx_copy.vExtraPayload = payload.serialize()
+        tx_copy.rehash()
+        return tx_copy.hash
+
+
     def create_assetunlock_for_oldest_quorum(self, start_index, withdrawal, pubkey):
         expected_quorum_hash = self.nodes[0].quorum('list')['llmq_test_platform'][-1]
         # Quorum selection depends on the request ID. Scan 100 candidates to
@@ -188,9 +229,9 @@ def check_mempool_size(self):
                    if node.getrawtransaction(txid, 1)['type'] != MNEHF_SIGNAL_TX_TYPE]
             assert_equal(len(own), self.mempool_size)
 
-    def check_mempool_result(self, result_expected, tx):
+    def check_mempool_result(self, result_expected, tx, txid=None):
         """Wrapper to check result of testmempoolaccept on node_0's mempool"""
-        result_expected['txid'] = tx.rehash()
+        result_expected['txid'] = txid or tx.rehash()
         if result_expected['allowed']:
             result_expected['vsize'] = tx.get_vsize()
 
@@ -303,6 +344,7 @@ def run_test(self):
         self.test_withdrawals_fork(node_wallet, node, pubkey)
         self.test_asset_locks_v2_pre_v24(node_wallet, node, pubkey)
         self.test_v24_fork(node_wallet, node, pubkey)
+        self.test_asset_unlock_v2(node_wallet, node, pubkey)
         self.test_non_standard(node_wallet, node, pubkey)
 
 
@@ -807,6 +849,102 @@ def test_asset_unlock_ancestor_package(self, node_wallet, asset_unlock_tx, asset
         assert asset_unlock_txid not in template_txids
         assert child_txid not in template_txids
 
+    def test_asset_unlock_v2(self, node_wallet, node, pubkey):
+        self.log.info("Testing v2 asset unlocks with stable txids...")
+        assert softfork_active(node_wallet, 'v24')
+
+        # The withdrawal window is exhausted by the earlier 3999 DASH unlock, so v2 instances
+        # created here stay unminable in the mempool until the window clears
+        index = 800
+        listener = node_wallet.add_p2p_connection(InvListener())
+        unlock_a = self.create_assetunlock(index, COIN, pubkey, version=2)
+        stable_txid = self.get_v2_txid(unlock_a)
+        instance_a = unlock_a.rehash()
+        assert stable_txid != instance_a
+
+        assert_equal(self.send_tx_simple(unlock_a), stable_txid)
+        self.sync_mempools()
+        rpc_tx = node_wallet.getrawtransaction(stable_txid, 1)
+        assert_equal(rpc_tx['txid'], stable_txid)
+        assert_equal(rpc_tx['instanceHash'], instance_a)
+
+        self.log.info("The v2 unlock is announced by instance hash")
+        self.wait_until(lambda: int(instance_a, 16) in listener.asset_unlock_invs)
+
+        self.log.info("Spend the unmined v2 unlock by its stable txid")
+        child_value = Decimal(unlock_a.vout[0].nValue - tiny_amount) / COIN
+        child_hex = node_wallet.createrawtransaction(
+            [{'txid': stable_txid, 'vout': 0}],
+            {node_wallet.getnewaddress(): child_value})
+        signed_child = node_wallet.signrawtransactionwithwallet(child_hex)
+        assert signed_child['complete']
+        child_txid = node_wallet.sendrawtransaction(signed_child['hex'])
+        self.sync_mempools()
+        assert child_txid in node_wallet.getrawmempool()
+
+        self.log.info("A fresher re-signed instance refreshes the entry in place; same txid, child untouched")
+        self.generate(node, 1)
+        unlock_a2 = self.create_assetunlock(index, COIN, pubkey, version=2)
+        assert_equal(self.get_v2_txid(unlock_a2), stable_txid)
+        instance_a2 = unlock_a2.rehash()
+        assert instance_a2 != instance_a
+        assert_equal(self.send_tx_simple(unlock_a2), stable_txid)
+        self.sync_unlock_instance(stable_txid, instance_a2)
+        mempool = node_wallet.getrawmempool()
+        assert stable_txid in mempool
+        assert child_txid in mempool
+        self.log.info("The refresh is announced under its own instance hash")
+        self.wait_until(lambda: int(instance_a2, 16) in listener.asset_unlock_invs)
+
+        self.log.info("A stale instance does not refresh a fresher one")
+        assert_raises_rpc_error(-26, 'assetunlock-stale-instance', self.send_tx_simple, unlock_a)
+
+        self.log.info("Expire the v2 instance; it and its child must survive in the mempool")
+        self.generate_batch(HEIGHT_DIFF_EXPIRING + 1)
+        mempool = node_wallet.getrawmempool()
+        assert stable_txid in mempool
+        assert child_txid in mempool
+
+        self.log.info("Flush leftover withdrawals from earlier phases and clear the window; the expired instance keeps waiting for a re-sign")
+        # Pending unlocks from the limit tests would otherwise consume the cleared window and
+        # crowd this test's withdrawal out of the block. Mine until each of them is either mined
+        # or expired and evicted; the expired instance under test cannot be mined and stays.
+
+        def other_unlocks_pending():
+            self.sync_mempools()
+            return any(txid != stable_txid and node_wallet.getrawtransaction(txid, 1)['type'] == ASSET_UNLOCK_TX_TYPE
+                       for txid in node_wallet.getrawmempool())
+        flushed = 0
+        while other_unlocks_pending():
+            self.generate(node, 1)
+            flushed += 1
+            assert flushed <= 2 * blocks_in_one_day, "leftover withdrawals never left the mempool"
+        self.generate_batch(101)
+        mempool = node_wallet.getrawmempool()
+        assert stable_txid in mempool
+        assert child_txid in mempool
+
+        self.log.info("Refresh the expired instance with a fresh re-sign and mine it with the child")
+        unlock_b = self.create_assetunlock(index, COIN, pubkey, version=2)
+        assert_equal(self.get_v2_txid(unlock_b), stable_txid)
+        assert_equal(self.send_tx_simple(unlock_b), stable_txid)
+        self.sync_unlock_instance(stable_txid, unlock_b.rehash())
+
+        tip_hash = self.generate(node, 1)[0]
+        block = node_wallet.getblock(tip_hash, 2)
+        mined_txids = [t['txid'] for t in block['tx']]
+        assert stable_txid in mined_txids
+        assert child_txid in mined_txids
+        # The coinbase commits to the mined instance's hash; a single leaf is its own merkle root
+        assert_equal(block['cbTx']['merkleRootAssetUnlocks'], unlock_b.rehash())
+        assert_equal(node_wallet.getassetunlockstatuses([str(index)])[0]['status'], 'mined')
+        child_rpc = node_wallet.getrawtransaction(child_txid, 1)
+        assert_equal(child_rpc['vin'][0]['txid'], stable_txid)
+
+        node_wallet.disconnect_p2ps()
+        self.mempool_size = node_wallet.getmempoolinfo()['size']
+        self.check_mempool_size()
+
     def test_asset_locks_v2_pre_v24(self, node_wallet, node, pubkey):
         self.log.info("Testing asset lock v2 rejection before v24 activation...")
         assert not softfork_active(node_wallet, 'v24')
@@ -820,6 +958,13 @@ def test_asset_locks_v2_pre_v24(self, node_wallet, node, pubkey):
             result_expected={'allowed': False, 'reject-reason': 'bad-assetlocktx-version-2'})
         self.log.info("v2 asset lock correctly rejected pre-v24")
 
+        self.log.info("Testing asset unlock v2 rejection before v24 activation...")
+        unlock_tx_v2 = self.create_assetunlock(590, COIN, pubkey, version=2)
+        # The stable-txid hashing rule applies to any v2 payload, even pre-fork rejected ones
+        self.check_mempool_result(tx=unlock_tx_v2, txid=self.get_v2_txid(unlock_tx_v2),
+            result_expected={'allowed': False, 'reject-reason': 'bad-assetunlocktx-version-2'})
+        self.log.info("v2 asset unlock correctly rejected pre-v24")
+
         self.log.info("Spending RPCs refuse to pay a Platform address before the fork")
         assert_raises_rpc_error(-8, "only valid after v24 activation", node_wallet.sendtoaddress,
                                 encode_platform_p2pkh('tdash', hash160(pubkey)), 1)
diff --git a/test/functional/test_framework/messages.py b/test/functional/test_framework/messages.py
index 1843be6ce083..173a3d830ec2 100755
--- a/test/functional/test_framework/messages.py
+++ b/test/functional/test_framework/messages.py
@@ -61,6 +61,7 @@
 MSG_GOVERNANCE_OBJECT = 17
 MSG_GOVERNANCE_OBJECT_VOTE = 18
 MSG_CMPCT_BLOCK = 20
+MSG_ASSET_UNLOCK = 34
 MSG_TYPE_MASK = 0xffffffff >> 2
 
 FILTER_TYPE_BASIC = 0
@@ -408,6 +409,7 @@ class CInv:
         MSG_GOVERNANCE_OBJECT: "Governance Object",
         MSG_GOVERNANCE_OBJECT_VOTE: "Governance Vote",
         MSG_CMPCT_BLOCK: "CompactBlock",
+        MSG_ASSET_UNLOCK: "Asset Unlock",
     }
 
     def __init__(self, t=0, h=0):
diff --git a/test/functional/test_framework/p2p.py b/test/functional/test_framework/p2p.py
index a76d956a0301..eb669c3237eb 100755
--- a/test/functional/test_framework/p2p.py
+++ b/test/functional/test_framework/p2p.py
@@ -102,9 +102,9 @@
 # The minimum P2P version that this test framework supports
 MIN_P2P_VERSION_SUPPORTED = 60001
 # The P2P version that this test framework implements and sends in its `version` message
-# Version 70241 introduced CoinJoin rebalance (promotion/demotion) sessions and a
-# version-gated flags field in the dsa message
-P2P_VERSION = 70241
+# Version 70242 introduced the MSG_ASSET_UNLOCK inventory type; 70241 introduced CoinJoin
+# rebalance (promotion/demotion) sessions and a version-gated flags field in the dsa message
+P2P_VERSION = 70242
 # The services that this test framework offers in its `version` message
 P2P_SERVICES = NODE_NETWORK | NODE_HEADERS_COMPRESSED
 # The P2P user agent string that this test framework sends in its `version` message