Fix block rejection: witness tx relay, MWEB state, mempool validation

Three fixes for blocks rejected by litecoind:

1. Request MSG_WITNESS_TX (not MSG_TX) for P2P inv announcements so
   segwit transactions arrive with witness data — fixes CheckQueue
   script verification failures when mempool txs are included in blocks.

2. MWEBTracker rejects blocks older than current state, preventing
   bootstrap's 288 historical blocks from overwriting the tip's HogEx
   reference with stale outpoints — fixes bad-txns-inputs-missingorspent
   on blocks with only coinbase + HogEx.

3. Mempool UTXO guard at template selection time + revalidate_inputs()
   after block connection evicts stale txs whose inputs were spent by
   confirmed blocks — prevents inclusion of double-spend transactions.

Also: BIP 152 v2 compact blocks now use wtxid for short IDs, and
getblocktxn handler serves missing txs from cached sent blocks.

Tested on LTC testnet: 5 consecutive blocks accepted (including blocks
with 1 and 3 mempool transactions), zero validation failures.

Author: frstrtr

src/c2pool/c2pool_refactored.cpp

@@ -1383,6 +1383,7 @@ int main(int argc, char* argv[]) {
                     ltc_utxo_db = std::make_unique<core::coin::UTXOViewDB>(utxo_path, utxo_opts);
                     if (ltc_utxo_db->open()) {
                         ltc_utxo_cache = std::make_unique<core::coin::UTXOViewCache>(ltc_utxo_db.get());
+                        embedded_pool->set_utxo(ltc_utxo_cache.get());
                         LOG_INFO << "[EMB-LTC] UTXO set opened: best_height=" << ltc_utxo_db->get_best_height()
                                  << " best_block=" << ltc_utxo_db->get_best_block().GetHex().substr(0, 16);
                     } else {
@@ -1815,9 +1816,15 @@ int main(int argc, char* argv[]) {
                                 // may now be in the UTXO set (especially bootstrap blocks).
                                 if (utxo) {
                                     int resolved = pool->recompute_unknown_fees(utxo);
-                                    if (resolved > 0) {
-                                        // Fees changed — trigger template rebuild so
-                                        // coinbasevalue includes the newly-resolved fees.
+                                    // Evict fee-known txs whose inputs are now spent.
+                                    // remove_for_block() only catches direct conflicts
+                                    // via m_spent_outputs; this catches any remaining
+                                    // stale txs (e.g., inputs spent by a tx the mempool
+                                    // never tracked).
+                                    int evicted = pool->revalidate_inputs(utxo);
+                                    if (resolved > 0 || evicted > 0) {
+                                        // Fees changed or stale txs evicted — trigger
+                                        // template rebuild so miners get clean work.
                                         web_server.trigger_work_refresh_debounced();
                                     }
                                 }
@@ -3605,6 +3612,7 @@ int main(int argc, char* argv[]) {
                             doge_utxo_db = std::make_unique<core::coin::UTXOViewDB>(utxo_path, utxo_opts);
                             if (doge_utxo_db->open()) {
                                 doge_utxo_cache = std::make_unique<core::coin::UTXOViewCache>(doge_utxo_db.get());
+                                if (doge_pool) doge_pool->set_utxo(doge_utxo_cache.get());
                                 LOG_INFO << "[EMB-DOGE] UTXO set opened: best_height=" << doge_utxo_db->get_best_height();
                             } else {
                                 LOG_WARNING << "[EMB-DOGE] UTXO DB failed to open — fees will be unknown";
@@ -3903,9 +3911,11 @@ int main(int argc, char* argv[]) {
                                             }
                                             if (utxo) {
                                                 int resolved = pool->recompute_unknown_fees(utxo);
-                                                if (resolved > 0) {
+                                                int evicted = pool->revalidate_inputs(utxo);
+                                                if (resolved > 0 || evicted > 0) {
                                                     LOG_INFO << "[EMB-DOGE] Fee revalidation: resolved=" << resolved
-                                                             << " pool_size=" << after;
+                                                             << " evicted=" << evicted
+                                                             << " pool_size=" << pool->size();
                                                     web_server.trigger_work_refresh_debounced();
                                                 }
                                             }

src/impl/ltc/coin/compact_blocks.hpp

@@ -218,12 +218,14 @@ inline CompactBlock BuildCompactBlock(const BlockHeaderType& header,
     }
 
     // Remaining txs as short IDs (pre-compute SipHash keys once)
+    // BIP 152 v2: use wtxid (witness serialization hash) for short IDs.
     if (txs.size() > 1) {
         uint64_t k0, k1;
         cb.GetSipHashKeys(k0, k1);
         for (size_t i = 1; i < txs.size(); ++i) {
-            uint256 txid = compute_txid(txs[i]);
-            cb.short_ids.push_back(CompactBlock::GetShortID(k0, k1, txid));
+            auto packed = pack(TX_WITH_WITNESS(txs[i]));
+            uint256 wtxid = Hash(packed.get_span());
+            cb.short_ids.push_back(CompactBlock::GetShortID(k0, k1, wtxid));
         }
     }
 
@@ -241,7 +243,7 @@ struct CompactBlockReconstructionResult {
 
 /// Attempt to reconstruct a full block from a compact block + known transactions.
 /// @param cb        The received compact block.
-/// @param known_txs Map of txid → transaction (typically from mempool).
+/// @param known_txs Map of wtxid → transaction (BIP 152 v2 uses wtxid for short ID matching).
 /// @return          Result with reconstructed block (if complete) or missing indexes.
 inline CompactBlockReconstructionResult ReconstructBlock(
     const CompactBlock& cb,

src/impl/ltc/coin/mempool.hpp

@@ -18,6 +18,7 @@
 #include <core/log.hpp>
 #include <core/coin/utxo_view_cache.hpp>
 
+#include <atomic>
 #include <map>
 #include <mutex>
 #include <set>
@@ -91,6 +92,7 @@ class Mempool {
     /// Update the current chain tip height (for coinbase maturity checks).
     /// Call after each block connection.
     void set_tip_height(uint32_t h) { m_tip_height = h; }
+    void set_utxo(core::coin::UTXOViewCache* u) { m_utxo.store(u); }
 
     // Disable copy
     Mempool(const Mempool&) = delete;
@@ -350,13 +352,33 @@ class Mempool {
         std::set<uint256> selected;
 
         // Pass 1: highest feerate first (known-fee txs)
+        auto* utxo = m_utxo.load();
         for (auto it = m_feerate_index.begin(); it != m_feerate_index.end(); ++it) {
             auto pit = m_pool.find(it->second);
             if (pit == m_pool.end()) continue;
             const auto& entry = pit->second;
             if (!entry.fee_known) continue;
             if (total_weight + entry.weight > max_weight) continue;
 
+            // Guard: verify inputs still exist in UTXO (or parent mempool tx).
+            // Catches stale txs in the window between tip-change and full_block arrival.
+            if (utxo) {
+                bool inputs_ok = true;
+                for (const auto& vin : entry.tx.vin) {
+                    core::coin::Outpoint op(vin.prevout.hash, vin.prevout.index);
+                    core::coin::Coin coin;
+                    if (!utxo->get_coin(op, coin)) {
+                        // Check if parent is in mempool (CPFP chain)
+                        if (!m_pool.count(vin.prevout.hash) ||
+                            vin.prevout.index >= m_pool.at(vin.prevout.hash).tx.vout.size()) {
+                            inputs_ok = false;
+                            break;
+                        }
+                    }
+                }
+                if (!inputs_ok) continue;  // skip stale tx
+            }
+
             total_weight += entry.weight;
             total_fees += entry.fee;
             result.push_back({entry.tx, entry.fee, true});
@@ -399,6 +421,43 @@ class Mempool {
         return resolved;
     }
 
+    /// Re-validate all fee-known mempool transactions against the UTXO set.
+    /// Evicts any transaction whose inputs are no longer in the UTXO set
+    /// (i.e., were spent by a confirmed block but not caught by remove_for_block's
+    /// conflict detection — e.g., when the spending tx wasn't tracked in m_spent_outputs).
+    /// Call after remove_for_block() + UTXO connect to catch stale transactions.
+    /// Returns the number of evicted transactions.
+    int revalidate_inputs(core::coin::UTXOViewCache* utxo) {
+        if (!utxo) return 0;
+        std::lock_guard<std::mutex> lock(m_mutex);
+
+        std::vector<uint256> to_remove;
+        for (const auto& [txid, entry] : m_pool) {
+            if (!entry.fee_known) continue;  // already quarantined
+            for (const auto& vin : entry.tx.vin) {
+                core::coin::Outpoint op(vin.prevout.hash, vin.prevout.index);
+                core::coin::Coin coin;
+                if (!utxo->get_coin(op, coin)) {
+                    // Input not in UTXO — check if parent is in mempool (CPFP)
+                    if (m_pool.count(vin.prevout.hash) &&
+                        vin.prevout.index < m_pool.at(vin.prevout.hash).tx.vout.size())
+                        continue;  // parent still in mempool, tx is valid
+                    to_remove.push_back(txid);
+                    break;
+                }
+            }
+        }
+
+        for (const auto& txid : to_remove)
+            remove_tx_locked(txid);
+
+        if (!to_remove.empty()) {
+            LOG_INFO << "[EMB] Mempool revalidate: evicted " << to_remove.size()
+                     << " stale txs (inputs spent), remaining=" << m_pool.size();
+        }
+        return static_cast<int>(to_remove.size());
+    }
+
     /// Snapshot of all txids currently in the pool.
     std::vector<uint256> all_txids() const {
         std::lock_guard<std::mutex> lock(m_mutex);
@@ -418,6 +477,18 @@ class Mempool {
         return out;
     }
 
+    /// Return all transactions keyed by wtxid (BIP 152 v2 compact block reconstruction).
+    std::map<uint256, MutableTransaction> all_txs_map_wtxid() const {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        std::map<uint256, MutableTransaction> out;
+        for (const auto& [txid, entry] : m_pool) {
+            auto packed = pack(TX_WITH_WITNESS(entry.tx));
+            uint256 wtxid = Hash(packed.get_span());
+            out[wtxid] = entry.tx;
+        }
+        return out;
+    }
+
 private:
     // ─── Internal (caller holds mutex) ───────────────────────────────────
 
@@ -568,6 +639,7 @@ class Mempool {
     time_t m_expiry_sec;
     core::coin::ChainLimits m_limits;   // MoneyRange + maturity constants
     uint32_t m_tip_height{0};           // current chain tip (for maturity checks)
+    std::atomic<core::coin::UTXOViewCache*> m_utxo{nullptr};  // for template-time input validation
 };
 
 } // namespace coin

src/impl/ltc/coin/mweb_builder.hpp

@@ -388,6 +388,8 @@ class MWEBTracker {
 public:
     /// Update state from a full block.
     /// Called when a new block is received via P2P.
+    /// Only accepts blocks that advance the state — bootstrap/historical blocks
+    /// are silently ignored to prevent stale HogEx references.
     bool update(const BlockType& block, uint32_t height,
                 const std::vector<unsigned char>& mweb_raw) {
         if (mweb_raw.empty()) {
@@ -400,6 +402,12 @@ class MWEBTracker {
         if (!MWEBBuilder::extract_mweb_header_from_raw(mweb_raw, new_state))
             return false;
         std::lock_guard<std::mutex> lock(m_mutex);
+        // Only accept blocks that advance or match current height.
+        // Bootstrap delivers hundreds of old blocks whose HogEx references
+        // are long spent — accepting them would produce invalid templates.
+        if (m_state.valid && height < m_state.captured_at_height) {
+            return false;
+        }
         m_state = std::move(new_state);
         return true;
     }

src/impl/ltc/coin/p2p_node.hpp

@@ -77,6 +77,9 @@ class NodeP2P : public core::ICommunicator, public core::INetwork, public core::
     // Compact block reconstruction state: pending compact block awaiting blocktxn
     std::unique_ptr<CompactBlock> m_pending_cmpct;
     std::vector<uint32_t> m_pending_missing_indexes;
+    // Last compact block we SENT — cached to serve getblocktxn requests
+    BlockType m_sent_cmpct_block;
+    uint256   m_sent_cmpct_hash;
     // External mempool for compact block tx matching
     Mempool* m_mempool{nullptr};
 
@@ -314,7 +317,8 @@ class NodeP2P : public core::ICommunicator, public core::INetwork, public core::
     void enable_mempool_request() { m_request_mempool_on_connect = true; }
 
     /// Relay a pre-serialized block via P2P.
-    /// Automatically uses compact block format for peers that support it.
+    /// Uses compact block format (BIP 152 v2) for peers that support it,
+    /// falling back to full block otherwise.
     void submit_block_raw(const std::vector<unsigned char>& block_bytes)
     {
         if (!m_peer) return;
@@ -332,6 +336,11 @@ class NodeP2P : public core::ICommunicator, public core::INetwork, public core::
 
                 auto packed_hdr = pack(static_cast<BlockHeaderType&>(block));
                 auto blockhash = Hash(packed_hdr.get_span());
+
+                // Cache the full block so we can serve getblocktxn requests.
+                m_sent_cmpct_block = std::move(block);
+                m_sent_cmpct_hash  = blockhash;
+
                 LOG_INFO << "[" << m_chain_label << "] Sent compact block "
                          << blockhash.GetHex()
                          << " (" << cb.short_ids.size() << " short IDs, "
@@ -535,7 +544,11 @@ class NodeP2P : public core::ICommunicator, public core::INetwork, public core::
             switch (btype)
             {
             case inventory_type::tx:
-                vinv.push_back(inv);
+                // Always request with witness (MSG_WITNESS_TX) so segwit
+                // transactions arrive with their witness data intact.
+                // Without this, P2WPKH/P2WSH spends arrive stripped and
+                // fail CheckQueue when included in blocks.
+                vinv.push_back(inventory_type(inventory_type::witness_tx, inv.m_hash));
                 break;
             case inventory_type::block:
                 m_coin->new_block.happened(inv.m_hash);
@@ -733,16 +746,20 @@ class NodeP2P : public core::ICommunicator, public core::INetwork, public core::
         m_coin->new_block.happened(blockhash);
 
         // Attempt reconstruction from mempool + known_txs
+        // BIP 152 v2: short IDs are keyed by wtxid (witness txid).
         std::map<uint256, MutableTransaction> known;
 
-        // Gather from node's known_txs
+        // Gather from node's known_txs (re-key by wtxid)
         for (const auto& [txid, tx] : m_coin->known_txs) {
-            known[txid] = MutableTransaction(tx);
+            MutableTransaction mtx(tx);
+            auto packed = pack(TX_WITH_WITNESS(mtx));
+            uint256 wtxid = Hash(packed.get_span());
+            known[wtxid] = std::move(mtx);
         }
 
-        // Gather from mempool
+        // Gather from mempool (wtxid-keyed)
         if (m_mempool) {
-            auto mp_txs = m_mempool->all_txs_map();
+            auto mp_txs = m_mempool->all_txs_map_wtxid();
             known.merge(mp_txs);
         }
 
@@ -776,10 +793,32 @@ class NodeP2P : public core::ICommunicator, public core::INetwork, public core::
 
     ADD_P2P_HANDLER(getblocktxn)
     {
-        // BIP 152: Peer requests missing transactions — we don't serve blocks
-        LOG_DEBUG_COIND << "[" << m_chain_label << "] Peer requests "
-                        << msg->m_request.indexes.size() << " txs via getblocktxn for "
-                        << msg->m_request.blockhash.GetHex() << " (ignored, we don't serve blocks)";
+        auto& req = msg->m_request;
+
+        // Only serve our most recently sent compact block
+        if (req.blockhash != m_sent_cmpct_hash || m_sent_cmpct_block.m_txs.empty()) {
+            LOG_DEBUG_COIND << "[" << m_chain_label << "] getblocktxn for unknown block "
+                            << req.blockhash.GetHex() << " — ignoring";
+            return;
+        }
+
+        BlockTransactionsResponse resp;
+        resp.blockhash = req.blockhash;
+        resp.txs.reserve(req.indexes.size());
+
+        for (uint32_t idx : req.indexes) {
+            if (idx >= m_sent_cmpct_block.m_txs.size()) {
+                LOG_WARNING << "[" << m_chain_label << "] getblocktxn: index " << idx
+                            << " out of range (block has " << m_sent_cmpct_block.m_txs.size() << " txs)";
+                return;  // malformed request — drop
+            }
+            resp.txs.push_back(m_sent_cmpct_block.m_txs[idx]);
+        }
+
+        auto rmsg = message_blocktxn::make_raw(resp);
+        m_peer->write(rmsg);
+        LOG_INFO << "[" << m_chain_label << "] Served " << resp.txs.size()
+                 << " txs via blocktxn for " << req.blockhash.GetHex();
     }
 
     ADD_P2P_HANDLER(blocktxn)