diff --git a/src/consensus/validation.h b/src/consensus/validation.h
index 2b2dd4bb6865..8d9f5b4ea805 100644
--- a/src/consensus/validation.h
+++ b/src/consensus/validation.h
@@ -17,6 +17,22 @@ static constexpr int NO_WITNESS_COMMITMENT{-1};
 /** Minimum size of a witness commitment structure. Defined in BIP 141. **/
 static constexpr size_t MINIMUM_WITNESS_COMMITMENT{38};
 
+struct ValidationIssue {
+    enum class Level { ERROR, WARNING };
+    std::string check;     // e.g. "pow", "merkle", "witness_commitment", "tx[12].inputs"
+    std::string message;   // human detail
+    Level       level{Level::ERROR};
+};
+
+struct BlockDiagnostics {
+    uint256 block_hash{};
+    std::vector<ValidationIssue> issues;
+    bool ok() const { return issues.empty(); }
+    void add(const std::string& check, const std::string& msg, ValidationIssue::Level lvl = ValidationIssue::Level::ERROR) {
+        issues.push_back(ValidationIssue{check, msg, lvl});
+    }
+};
+
 /** A "reason" why a transaction was invalid, suitable for determining whether the
   * provider of the transaction should be banned/ignored/disconnected/etc.
   */
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 9287a67a04ea..5a157b2b65f0 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -312,7 +312,7 @@ struct Peer {
         std::chrono::microseconds m_next_inv_send_time GUARDED_BY(m_tx_inventory_mutex){0};
         /** The mempool sequence num at which we sent the last `inv` message to this peer.
          *  Can relay txs with lower sequence numbers than this (see CTxMempool::info_for_relay). */
-        uint64_t m_last_inv_sequence GUARDED_BY(NetEventsInterface::g_msgproc_mutex){1};
+        uint64_t m_last_inv_sequence GUARDED_BY(m_tx_inventory_mutex){1};
 
         /** Minimum fee rate with which to filter transaction announcements to this node. See BIP133. */
         std::atomic<CAmount> m_fee_filter_received{0};
@@ -942,7 +942,7 @@ class PeerManagerImpl final : public PeerManager
 
     /** Determine whether or not a peer can request a transaction, and return it (or nullptr if not found or not allowed). */
     CTransactionRef FindTxForGetData(const Peer::TxRelay& tx_relay, const GenTxid& gtxid)
-        EXCLUSIVE_LOCKS_REQUIRED(!m_most_recent_block_mutex, NetEventsInterface::g_msgproc_mutex);
+        EXCLUSIVE_LOCKS_REQUIRED(!m_most_recent_block_mutex, !tx_relay.m_tx_inventory_mutex);
 
     void ProcessGetData(CNode& pfrom, Peer& peer, const std::atomic<bool>& interruptMsgProc)
         EXCLUSIVE_LOCKS_REQUIRED(!m_most_recent_block_mutex, peer.m_getdata_requests_mutex, NetEventsInterface::g_msgproc_mutex)
@@ -1728,9 +1728,13 @@ bool PeerManagerImpl::GetNodeStateStats(NodeId nodeid, CNodeStateStats& stats) c
     if (auto tx_relay = peer->GetTxRelay(); tx_relay != nullptr) {
         stats.m_relay_txs = WITH_LOCK(tx_relay->m_bloom_filter_mutex, return tx_relay->m_relay_txs);
         stats.m_fee_filter_received = tx_relay->m_fee_filter_received.load();
+        LOCK(tx_relay->m_tx_inventory_mutex);
+        stats.m_last_inv_seq = tx_relay->m_last_inv_sequence;
+        stats.m_inv_to_send = tx_relay->m_tx_inventory_to_send.size();
     } else {
         stats.m_relay_txs = false;
         stats.m_fee_filter_received = 0;
+        stats.m_inv_to_send = 0;
     }
 
     stats.m_ping_wait = ping_wait;
@@ -2362,8 +2366,8 @@ CTransactionRef PeerManagerImpl::FindTxForGetData(const Peer::TxRelay& tx_relay,
 {
     // If a tx was in the mempool prior to the last INV for this peer, permit the request.
     auto txinfo{std::visit(
-        [&](const auto& id) EXCLUSIVE_LOCKS_REQUIRED(NetEventsInterface::g_msgproc_mutex) {
-            return m_mempool.info_for_relay(id, tx_relay.m_last_inv_sequence);
+        [&](const auto& id) {
+            return m_mempool.info_for_relay(id, WITH_LOCK(tx_relay.m_tx_inventory_mutex, return tx_relay.m_last_inv_sequence));
         },
         gtxid)};
     if (txinfo.tx) {
diff --git a/src/net_processing.h b/src/net_processing.h
index 8c140d98ad66..6eb4a5e16a2c 100644
--- a/src/net_processing.h
+++ b/src/net_processing.h
@@ -54,6 +54,8 @@ struct CNodeStateStats {
     std::chrono::microseconds m_ping_wait;
     std::vector<int> vHeightInFlight;
     bool m_relay_txs;
+    int m_inv_to_send = 0;
+    uint64_t m_last_inv_seq{0};
     CAmount m_fee_filter_received;
     uint64_t m_addr_processed = 0;
     uint64_t m_addr_rate_limited = 0;
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 850cdb70c4e3..e8bb9e0f4f20 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -1094,6 +1094,83 @@ static RPCHelpMan submitblock()
     };
 }
 
+static RPCHelpMan diagnoseblock()
+{
+    return RPCHelpMan{
+        "diagnoseblock",
+        "Decode a raw block and run comprehensive diagnostics without early exit.\n"
+        "Returns all detected issues (PoW/merkle/commitment/tx inputs/scripts/context).\n",
+        {
+            {"hexdata", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Hex-encoded block"},
+        },
+        RPCResult{
+            RPCResult::Type::OBJ, "", "",
+            {
+                {RPCResult::Type::BOOL, "ok", "true if no issues found"},
+                {RPCResult::Type::STR_HEX, "blockhash", "hash of the provided block"},
+                {RPCResult::Type::ARR, "issues", "list of problems found",
+                    {
+                        {RPCResult::Type::OBJ, "", "",
+                            {
+                                {RPCResult::Type::STR, "level", "\"error\" or \"warning\""},
+                                {RPCResult::Type::STR, "check", "which check failed (e.g. pow, merkle, tx[i].inputs, ... )"},
+                                {RPCResult::Type::STR, "message", "human-readable detail"},
+                            }
+                        },
+                    }
+                },
+            }
+        },
+        RPCExamples{
+            HelpExampleCli("diagnoseblock", "\"<blockhex>\"") +
+            HelpExampleRpc("diagnoseblock", "\"<blockhex>\"")
+        },
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+        {
+            // Parse block
+            CBlock block;
+            if (!DecodeHexBlk(block, request.params[0].get_str())) {
+                throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block decode failed");
+            }
+
+            ChainstateManager& chainman = EnsureAnyChainman(request.context);
+
+            // If we know the parent, fill in uncommitted structures so witness commitment checks reflect reality.
+            {
+                LOCK(cs_main);
+                if (const CBlockIndex* pindexPrev = chainman.m_blockman.LookupBlockIndex(block.hashPrevBlock)) {
+                    chainman.UpdateUncommittedBlockStructures(block, pindexPrev);
+                }
+            }
+
+            // Run diagnostics
+            BlockDiagnostics diag;
+            {
+                LOCK(cs_main);
+                Chainstate& active = chainman.ActiveChainstate();
+                DiagnoseBlock(block, active, diag);
+            }
+
+            // Build result
+            UniValue out(UniValue::VOBJ);
+            out.pushKV("ok", diag.ok());
+            out.pushKV("blockhash", diag.block_hash.GetHex());
+
+            UniValue issues(UniValue::VARR);
+            for (const auto& iss : diag.issues) {
+                UniValue it(UniValue::VOBJ);
+                it.pushKV("level", iss.level == ValidationIssue::Level::ERROR ? "error" : "warning");
+                it.pushKV("check", iss.check);
+                it.pushKV("message", iss.message);
+                issues.push_back(std::move(it));
+            }
+            out.pushKV("issues", std::move(issues));
+            return out;
+        }
+    };
+}
+
+
 static RPCHelpMan submitheader()
 {
     return RPCHelpMan{
@@ -1149,6 +1226,7 @@ void RegisterMiningRPCCommands(CRPCTable& t)
         {"hidden", &generatetodescriptor},
         {"hidden", &generateblock},
         {"hidden", &generate},
+        {"mining", &diagnoseblock},
     };
     for (const auto& c : commands) {
         t.appendCommand(c.name, &c);
diff --git a/src/rpc/net.cpp b/src/rpc/net.cpp
index fbb70d72161d..ba74283d237c 100644
--- a/src/rpc/net.cpp
+++ b/src/rpc/net.cpp
@@ -142,6 +142,8 @@ static RPCHelpMan getpeerinfo()
                         {RPCResult::Type::STR, "SERVICE_NAME", "the service name if it is recognised"}
                     }},
                     {RPCResult::Type::BOOL, "relaytxes", "Whether we relay transactions to this peer"},
+                    {RPCResult::Type::NUM, "last_inv_sequence", "Mempool sequence number of this peer's last INV"},
+                    {RPCResult::Type::NUM, "inv_to_send", "How many txs we have queued to announce to this peer"},
                     {RPCResult::Type::NUM_TIME, "lastsend", "The " + UNIX_EPOCH_TIME + " of the last send"},
                     {RPCResult::Type::NUM_TIME, "lastrecv", "The " + UNIX_EPOCH_TIME + " of the last receive"},
                     {RPCResult::Type::NUM_TIME, "last_transaction", "The " + UNIX_EPOCH_TIME + " of the last valid transaction received from this peer"},
@@ -238,6 +240,8 @@ static RPCHelpMan getpeerinfo()
         obj.pushKV("services", strprintf("%016x", services));
         obj.pushKV("servicesnames", GetServicesNames(services));
         obj.pushKV("relaytxes", statestats.m_relay_txs);
+        obj.pushKV("last_inv_sequence", statestats.m_last_inv_seq);
+        obj.pushKV("inv_to_send", statestats.m_inv_to_send);
         obj.pushKV("lastsend", count_seconds(stats.m_last_send));
         obj.pushKV("lastrecv", count_seconds(stats.m_last_recv));
         obj.pushKV("last_transaction", count_seconds(stats.m_last_tx_time));
diff --git a/src/validation.cpp b/src/validation.cpp
index 8fcc719a6848..f48227a90e8e 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -6,6 +6,11 @@
 #include <bitcoin-build-config.h> // IWYU pragma: keep
 
 #include <validation.h>
+#include <core_io.h>
+
+#include <coins.h>
+#include <script/interpreter.h>
+#include <script/script_error.h>
 
 #include <arith_uint256.h>
 #include <chain.h>
@@ -6541,3 +6546,334 @@ std::pair<int, int> ChainstateManager::GetPruneRange(const Chainstate& chainstat
 
     return {prune_start, prune_end};
 }
+
+static void CheckPoWNoThrow(const CBlockHeader& header, const Consensus::Params& params, BlockDiagnostics& out) {
+    if (!CheckProofOfWork(header.GetHash(), header.nBits, params)) {
+        out.add("pow", strprintf("invalid PoW for nBits=%08x", header.nBits));
+    }
+}
+
+static void CheckMerkleNoThrow(const CBlock& block, BlockDiagnostics& out) {
+    bool mutated = false;
+    if (BlockMerkleRoot(block, &mutated) != block.hashMerkleRoot) {
+        out.add("merkle", "merkle root mismatch");
+    }
+    if (mutated) {
+        out.add("merkle", "merkle tree mutated");
+    }
+}
+
+static void CheckWitnessCommitmentNoThrow(const CBlock& block, BlockDiagnostics& out) {
+    // If no segwit anywhere, nothing to check.
+    const bool any_wit = std::any_of(block.vtx.begin(), block.vtx.end(),
+        [](const CTransactionRef& tx){ return tx->HasWitness(); });
+    if (!any_wit) return;
+
+    const int commitpos = GetWitnessCommitmentIndex(block);
+    if (commitpos == NO_WITNESS_COMMITMENT) {
+        out.add("witness_commitment", "missing witness commitment with segwit txs present");
+        return;
+    }
+
+    // Coinbase witness reserved value must be exactly one 32-byte item.
+    const auto& wstack = block.vtx[0]->vin[0].scriptWitness.stack;
+    if (wstack.size() != 1 || wstack[0].size() != 32) {
+        out.add("witness_commitment", "coinbase witness reserved value missing or wrong size");
+        return;
+    }
+
+    // Compute witness merkle root
+    bool malleated = false;
+    const uint256 wmr = BlockWitnessMerkleRoot(block, &malleated);
+    if (malleated) {
+        out.add("witness_commitment", "witness merkle tree mutated");
+        return;
+    }
+
+    // expected = dSHA256( wmr || reserved )
+    uint256 expected;
+    {
+        CHash256 hasher;
+        hasher.Write(std::span<const unsigned char>(wmr.begin(), 32));
+        hasher.Write(std::span<const unsigned char>(wstack[0].data(), 32));
+        hasher.Finalize(std::span<unsigned char>(expected.begin(), 32));
+    }
+
+
+    // Parse the OP_RETURN script and extract the 36-byte payload: 0xaa21a9ed || 32-byte commitment
+    static const unsigned char WIT_MAGIC[4] = {0xaa, 0x21, 0xa9, 0xed};
+    const CScript& spk = block.vtx[0]->vout[commitpos].scriptPubKey;
+
+    opcodetype opcode;
+    CScript::const_iterator pc = spk.begin();
+
+    if (!spk.GetOp(pc, opcode) || opcode != OP_RETURN) {
+        out.add("witness_commitment", "commitment output is not OP_RETURN");
+        return;
+    }
+
+    std::vector<unsigned char> pushed;
+    if (!spk.GetOp(pc, opcode, pushed) || opcode > OP_PUSHDATA4 || pushed.size() != 36) {
+        out.add("witness_commitment", "commitment push not 36 bytes");
+        return;
+    }
+
+    if (std::memcmp(pushed.data(), WIT_MAGIC, 4) != 0) {
+        out.add("witness_commitment", "commitment magic header mismatch");
+        return;
+    }
+
+    if (std::memcmp(pushed.data() + 4, expected.begin(), 32) != 0) {
+        out.add("witness_commitment", "commitment mismatch");
+        return;
+    }
+}
+
+
+
+
+
+static void CheckBlockPolicylessNoThrow(const CBlock& block, const Consensus::Params& params, BlockDiagnostics& out) {
+    // Re-implement parts of CheckBlock() in a non-returning fashion.
+    if (block.vtx.empty() || !block.vtx[0]->IsCoinBase()) {
+        out.add("structure", "coinbase missing or not first");
+    }
+    for (size_t i = 1; i < block.vtx.size(); ++i) {
+        if (block.vtx[i]->IsCoinBase()) out.add("structure", strprintf("tx[%u] is coinbase", (unsigned)i));
+    }
+    // Size/weight limits:
+    if (GetBlockWeight(block) > MAX_BLOCK_WEIGHT) {
+        out.add("limits", strprintf("block weight %d > %d", GetBlockWeight(block), MAX_BLOCK_WEIGHT));
+    }
+    CheckMerkleNoThrow(block, out);
+    CheckWitnessCommitmentNoThrow(block, out);
+    // Per-transaction consensus checks (non-contextual):
+    for (size_t i = 0; i < block.vtx.size(); ++i) {
+        const CTransaction& tx = *block.vtx[i];
+        const std::string txid  = tx.GetHash().GetHex();
+        const std::string wtxid = tx.GetWitnessHash().GetHex();
+        const std::string shortid = txid.substr(0, 8);
+
+        TxValidationState tx_state;
+        if (!CheckTransaction(tx, tx_state)) {
+            // Hex only on failure
+            const std::string txhex = EncodeHexTx(tx); // or DataStream+TX_WITH_WITNESS
+            out.add(
+                strprintf("tx[%u](%s)", (unsigned)i, shortid),
+                strprintf("%s; txid=%s; wtxid=%s; txhex=%s",
+                          tx_state.ToString(), txid, wtxid, txhex)
+            );
+        }
+    }
+}
+
+bool DiagnoseBlock(const CBlock& block, Chainstate& chainstate, BlockDiagnostics& out)
+{
+    LOCK(::cs_main);
+
+    const CChainParams& chainparams = chainstate.m_chainman.GetParams();
+    const Consensus::Params& params = chainparams.GetConsensus();
+    out.block_hash = block.GetHash();
+
+    // Stateless
+    CheckPoWNoThrow(block, params, out);
+    CheckBlockPolicylessNoThrow(block, params, out);
+
+    const CBlockIndex* tip  = chainstate.m_chain.Tip();
+    if (tip == nullptr) {
+        out.add("no tip", "cannot evaluate: no active tip (chainstate not loaded)");
+        return out.ok();
+    }
+
+    const CBlockIndex* prev = chainstate.m_blockman.LookupBlockIndex(block.hashPrevBlock);
+    const CBlockIndex* base = prev ? prev : tip;
+    const bool utxo_context_valid = (prev == tip);
+
+    const bool prev_on_active = chainstate.m_chain.Contains(prev);
+    if (!prev_on_active) out.add("context", "parent is not on active chain (forked branch)");
+
+    if (!prev) out.add("context", "prev block not known; flags/height/view may be wrong");
+    if (block.hashPrevBlock != tip->GetBlockHash()) out.add("context", "candidate does not build on active tip");
+
+    {
+        BlockValidationState st;
+        if (!ContextualCheckBlockHeader(block, st, chainstate.m_blockman, chainstate.m_chainman, base))
+            out.add("context-header", st.ToString());
+    }
+    {
+        BlockValidationState st;
+        if (!ContextualCheckBlock(block, st, chainstate.m_chainman, base))
+            out.add("context-block", st.ToString());
+    }
+
+    CCoinsViewCache view(&chainstate.CoinsTip());
+    if (prev) view.SetBestBlock(prev->GetBlockHash());
+
+    const int spend_height = base->nHeight + 1;
+    const int64_t candidate_mtp = base->GetMedianTimePast();
+    const unsigned int script_flags = GetBlockScriptFlags(*base, chainstate.m_chainman);
+
+    static ValidationCache validation_cache(
+        DEFAULT_SCRIPT_EXECUTION_CACHE_BYTES,
+        DEFAULT_VALIDATION_CACHE_BYTES
+    );
+
+    CAmount total_fees = 0;
+    bool fees_ok = true;
+
+    const int64_t mtp = base->GetMedianTimePast();
+
+    for (size_t idx = 1; idx < block.vtx.size(); ++idx) {
+        CAmount txfee = 0;
+        bool tx_ok = true;
+        const CTransaction& tx = *block.vtx[idx];
+
+        // 1) Absolute locktime (BIP113 via MTP)
+        if (!IsFinalTx(tx, spend_height, mtp)) {
+            const std::string sid = tx.GetHash().GetHex().substr(0,8);
+            const std::string txhex = EncodeHexTx(tx);
+            const std::string txid  = tx.GetHash().GetHex();
+            const std::string wtxid = tx.GetWitnessHash().GetHex();
+            out.add(strprintf("tx[%u](%s).finality", (unsigned)idx, sid),
+                    strprintf("%s; txid=%s; wtxid=%s; txhex=%s",
+                              "non-final (nLockTime)", txid, wtxid, txhex));
+            tx_ok = false;
+        }
+
+        // 2) Inputs/fees (existence + maturity + fee compute). No view mutation yet.
+        if (utxo_context_valid)
+        {
+            TxValidationState tx_st;
+            if (!Consensus::CheckTxInputs(tx, tx_st, view, spend_height, txfee)) {
+                const std::string txhex = EncodeHexTx(tx);
+                const std::string txid  = tx.GetHash().GetHex();
+                const std::string wtxid = tx.GetWitnessHash().GetHex();
+                const std::string shortid = txid.substr(0, 8);
+                out.add(strprintf("tx[%u](%s).inputs", (unsigned)idx, shortid),
+                        strprintf("%s; txid=%s; wtxid=%s; txhex=%s",
+                                  tx_st.ToString(), txid, wtxid, txhex));
+                tx_ok = false;
+            }
+            if (txfee < 0) {
+                const std::string txhex = EncodeHexTx(tx);
+                const std::string txid  = tx.GetHash().GetHex();
+                const std::string wtxid = tx.GetWitnessHash().GetHex();
+                const std::string shortid = txid.substr(0, 8);
+                out.add(strprintf("tx[%u].inputs", (unsigned)idx),
+                        strprintf("%s; txid=%s; wtxid=%s; txhex=%s",
+                                  "negative fee (input<output)", txid, wtxid, txhex)
+                        );
+                tx_ok = false;
+            }
+        }
+
+        //// 3) Relative locktime (BIP68) — use Core helpers always
+        if (utxo_context_valid)
+        {
+            std::vector<int> prev_heights;
+            prev_heights.reserve(tx.vin.size());
+
+            bool missing_input = false;
+            for (const CTxIn& in : tx.vin) {
+                const Coin& coin = view.AccessCoin(in.prevout);
+                if (coin.IsSpent()) {
+                    // don't need to report it since the error is added by other checks
+                    missing_input = true;
+                    tx_ok = false;
+                    break;
+                }
+                prev_heights.push_back(static_cast<int>(coin.nHeight));
+            }
+            if (!missing_input) {
+                // BIP68/113 standard flags (sequence + MTP)
+                const int flags = STANDARD_LOCKTIME_VERIFY_FLAGS;
+
+                // On master this returns pair<min_height, min_mtp>. Earlier you tried "m_value";
+                // use .first and .second here.
+                const auto seq = CalculateSequenceLocks(tx, flags, prev_heights, *base);
+                const int required_height = seq.first;
+                const int64_t required_mtp = seq.second;
+
+                // Height-based relative lock fail?
+                if (spend_height < required_height) {
+                    // (prev_h shown for context: the max prevout height)
+                    const int prev_h = prev_heights.empty() ? -1
+                                                            : *std::max_element(prev_heights.begin(), prev_heights.end());
+                    const std::string txhex = EncodeHexTx(tx);
+                    const std::string txid  = tx.GetHash().GetHex();
+                    const std::string wtxid = tx.GetWitnessHash().GetHex();
+                    const std::string shortid = txid.substr(0, 8);
+                    out.add(
+                        strprintf("tx[%u].relativelock", (unsigned)idx),
+                        strprintf("height lock: cand_h=%d < req_h=%d (prev_h=%d; txid=%s; wtxid=%s; txhex=%s)",
+                                  spend_height, required_height, prev_h, txid, wtxid, txhex)
+                        );
+                    tx_ok = false;
+                }
+
+                // Time-based relative lock fail? (compared to tip MTP)
+                if (candidate_mtp < required_mtp) {
+                    const std::string txhex = EncodeHexTx(tx);
+                    const std::string txid  = tx.GetHash().GetHex();
+                    const std::string wtxid = tx.GetWitnessHash().GetHex();
+                    const std::string shortid = txid.substr(0, 8);
+                    out.add(
+                        strprintf("tx[%u].relativelock", (unsigned)idx),
+                        strprintf("time lock: cand_mtp=%d < req_mtp=%d (tip_mtp=%d; txid=%s; wtxid=%s; txhex=%s)",
+                                  int(candidate_mtp), int(required_mtp), int(candidate_mtp), txid, wtxid, txhex)
+                        );
+                    tx_ok = false;
+                }
+            }
+        }
+
+        // 4) Scripts via CheckInputScripts (use the shared cache)
+        if (utxo_context_valid)
+        {
+            TxValidationState stx;
+            PrecomputedTransactionData txdata(tx);
+            if (!CheckInputScripts(tx, stx, view, script_flags,
+                                   /*cacheSigStore=*/false,
+                                   /*cacheFullScriptStore=*/false,
+                                   txdata,
+                                   validation_cache,
+                                   /*pvChecks=*/nullptr)) {
+                const std::string txhex = EncodeHexTx(tx);
+                const std::string txid  = tx.GetHash().GetHex();
+                const std::string wtxid = tx.GetWitnessHash().GetHex();
+                const std::string shortid = txid.substr(0, 8);
+                out.add(strprintf("tx[%u](%s).scripts", (unsigned)idx, shortid),
+                        strprintf("%s; txid=%s; wtxid=%s; txhex=%s",
+                                  stx.ToString(), txid, wtxid, txhex));
+                tx_ok = false;
+            }
+        }
+
+        if (!tx_ok && txfee > 0 && utxo_context_valid) {
+            fees_ok = false;
+        }
+
+        if (tx_ok && utxo_context_valid) {
+            for (const CTxIn& in : tx.vin) view.SpendCoin(in.prevout);
+            AddCoins(view, tx, spend_height, /*check_overwrite=*/true);
+            total_fees += txfee;
+        }
+    }
+
+    // 5) Fee accounting vs coinbase
+    if (fees_ok && utxo_context_valid) {
+        const CAmount subsidy = GetBlockSubsidy(spend_height, params);
+        const CAmount coinbase_out = block.vtx[0]->GetValueOut();
+        const CAmount limit = subsidy + total_fees;
+        if (coinbase_out > limit) {
+            out.add("coinbase", strprintf("coinbase pays too much: %s > subsidy+fees=%s",
+                                          FormatMoney(coinbase_out), FormatMoney(limit)));
+        } else if (coinbase_out < limit) {
+            out.add("coinbase-info", strprintf("coinbase underpays by %s (allowed)",
+                                               FormatMoney(limit - coinbase_out)));
+        }
+    }
+
+    return out.ok();
+}
+
diff --git a/src/validation.h b/src/validation.h
index 644d4f7310d8..388bf7d042fa 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -67,6 +67,13 @@ namespace util {
 class SignalInterrupt;
 } // namespace util
 
+struct BlockDiagnostics;
+class Chainstate;
+
+
+bool DiagnoseBlock(const CBlock& block, Chainstate& chainstate, BlockDiagnostics& out)
+    EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+
 /** Block files containing a block-height within MIN_BLOCKS_TO_KEEP of ActiveChain().Tip() will not be pruned. */
 static const unsigned int MIN_BLOCKS_TO_KEEP = 288;
 static const signed int DEFAULT_CHECKBLOCKS = 6;
diff --git a/test/functional/p2p_leak_tx.py b/test/functional/p2p_leak_tx.py
index a1a00751d12a..42e586fca3dd 100755
--- a/test/functional/p2p_leak_tx.py
+++ b/test/functional/p2p_leak_tx.py
@@ -12,6 +12,7 @@
 )
 from test_framework.wallet import MiniWallet
 
+import time
 
 class P2PNode(P2PDataStore):
     def on_inv(self, msg):
@@ -36,8 +37,24 @@ def test_tx_in_block(self):
 
         self.log.debug("Generate transaction and block")
         inbound_peer.last_message.pop("inv", None)
+
+        self.gen_node.setmocktime(int(time.time())) # pause time based activities
         wtxid = self.miniwallet.send_self_transfer(from_node=self.gen_node)["wtxid"]
+        rawmp = self.gen_node.getrawmempool(False, True)
+        pi = self.gen_node.getpeerinfo()[0]
+        assert_equal(rawmp["mempool_sequence"], 2) # our tx cause mempool activity
+        assert_equal(pi["last_inv_sequence"], 1) # that is after the last inv
+        assert_equal(pi["inv_to_send"], 1) # and our tx has been queued
+        self.gen_node.setmocktime(0)
+
         inbound_peer.wait_until(lambda: "inv" in inbound_peer.last_message and inbound_peer.last_message.get("inv").inv[0].hash == int(wtxid, 16))
+
+        rawmp = self.gen_node.getrawmempool(False, True)
+        pi = self.gen_node.getpeerinfo()[0]
+        assert_equal(rawmp["mempool_sequence"], 2) # no mempool update
+        assert_equal(pi["last_inv_sequence"], 2) # announced the current mempool
+        assert_equal(pi["inv_to_send"], 0) # nothing left in the queue
+
         want_tx = msg_getdata(inv=inbound_peer.last_message.get("inv").inv)
         self.generate(self.gen_node, 1)
 
diff --git a/test/functional/rpc_net.py b/test/functional/rpc_net.py
index 41ecbbed22d9..aeaf20c23d58 100755
--- a/test/functional/rpc_net.py
+++ b/test/functional/rpc_net.py
@@ -166,6 +166,8 @@ def test_getpeerinfo(self):
                 "permissions": [],
                 "presynced_headers": -1,
                 "relaytxes": False,
+                "inv_to_send": 0,
+                "last_inv_sequence": 0,
                 "services": "0000000000000000",
                 "servicesnames": [],
                 "session_id": "" if not self.options.v2transport else no_version_peer.v2_state.peer['session_id'].hex(),