From 84351515657e7f5e338c165c4a791093aba24143 Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Tue, 13 Oct 2026 13:14:21 -0500
Subject: [PATCH 1/3] fix(coinjoin): reject only the sender of an invalid
 signature

When a DSSIGNFINALTX input failed AddScriptSig(), the masternode relayed
STATUS_REJECTED to every participant of the session. Each client that
receives it enters POOL_STATE_ERROR, releases its inputs and stops signing,
but the server keeps the session until its signing timeout. There, the
clients that obeyed the rejection are the non-signers, and one of them can
be charged its collateral, while the participant that sent the bad
signature may have signed everything and is not an offender at all. A
participant could abort every session it joined this way, by resending a
signature it had already submitted, and have an honest peer pay for it.

A signature that fails validation comes from the sender, so reject only the
sender and keep the session for everyone else. If the sender never supplies
a valid signature its input stays unsigned, and the timeout treats it as the
non-signer, under the existing probabilistic policy. A duplicate of a
signature that was already accepted no longer affects the session at all.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/coinjoin/server.cpp            |  5 +++-
 src/test/coinjoin_inouts_tests.cpp | 48 ++++++++++++++++++++++++++++++
 2 files changed, 52 insertions(+), 1 deletion(-)

diff --git a/src/coinjoin/server.cpp b/src/coinjoin/server.cpp
index b06652025431..56a7362af324 100644
--- a/src/coinjoin/server.cpp
+++ b/src/coinjoin/server.cpp
@@ -284,7 +284,10 @@ void CCoinJoinServer::ProcessDSSIGNFINALTX(CNode& peer, CDataStream& vRecv)
             if (!AddScriptSig(txin)) {
                 LogPrint(BCLog::COINJOIN, "DSSIGNFINALTX -- AddScriptSig() failed at %d/%d, session: %d\n", nTxInIndex,
                          nTxInsCount, session_id);
-                RelayStatus(STATUS_REJECTED);
+                // Only the sender is at fault, so only the sender is rejected. A session-wide
+                // rejection would let one participant abort the session for everyone, and those
+                // that obeyed it would be counted as non-signers at the timeout.
+                PushStatus(peer, STATUS_REJECTED, ERR_INVALID_INPUT);
                 return;
             }
             LogPrint(BCLog::COINJOIN, "DSSIGNFINALTX -- AddScriptSig() %d/%d success\n", nTxInIndex, nTxInsCount);
diff --git a/src/test/coinjoin_inouts_tests.cpp b/src/test/coinjoin_inouts_tests.cpp
index c5dea2930c42..4e0b319614cd 100644
--- a/src/test/coinjoin_inouts_tests.cpp
+++ b/src/test/coinjoin_inouts_tests.cpp
@@ -17,6 +17,7 @@
 #include <protocol.h>
 #include <script/script.h>
 #include <streams.h>
+#include <test/util/net.h>
 #include <test/util/setup_common.h>
 #include <tinyformat.h>
 #include <uint256.h>
@@ -517,6 +518,53 @@ BOOST_AUTO_TEST_CASE(server_timeout_resets_only_sessions_that_cannot_advance)
     }
 }
 
+BOOST_AUTO_TEST_CASE(server_invalid_signature_rejects_only_its_sender)
+{
+    BOOST_REQUIRE(m_node.mn_sync);
+    m_node.mn_sync->SwitchToNextAsset();
+    BOOST_REQUIRE(m_node.mn_sync->IsBlockchainSynced());
+
+    CActiveMasternodeManager mn_activeman(*Assert(m_node.connman), *Assert(m_node.dmnman), MakeSecretKey());
+    TestableCoinJoinServer server(m_node.peerman.get(), *Assert(m_node.chainman), *Assert(m_node.connman),
+                                  *Assert(m_node.dmnman), *Assert(m_node.dstxman), *Assert(m_node.mn_metaman),
+                                  *Assert(m_node.mempool), mn_activeman, *Assert(m_node.mn_sync),
+                                  *Assert(m_node.isman));
+    auto& connman = static_cast<ConnmanTestMsg&>(*m_node.connman);
+
+    CNode& sender = *MakePeer(/*id=*/7, /*ipv4=*/0x0a000001).release();
+    CNode& other = *MakePeer(/*id=*/8, /*ipv4=*/0x0a000002).release();
+    for (CNode* node : {&sender, &other}) {
+        node->fSuccessfullyConnected = true;
+        connman.AddTestNode(*node);
+        server.SeedParticipant(node->addr);
+    }
+    server.EnterSigningState();
+
+    std::vector<CService> status_recipients;
+    const auto capture_orig{CaptureMessage};
+    m_node.args->ForceSetArg("-capturemessages", "1");
+    CaptureMessage = [&status_recipients](const CAddress& addr, const std::string& msg_type,
+                                          Span<const unsigned char>, bool is_incoming) {
+        if (!is_incoming && msg_type == NetMsgType::DSSTATUSUPDATE) status_recipients.push_back(addr);
+    };
+
+    // A signature that fails validation is the sender's own doing. Only the sender is rejected:
+    // the other participant is not told to abandon a session it can still complete.
+    CDataStream stream{SER_NETWORK, PROTOCOL_VERSION};
+    stream << std::vector<CTxIn>{CTxIn{COutPoint{uint256::ONE, 0}}};
+    BOOST_CHECK_NO_THROW(server.ProcessMessage(sender, NetMsgType::DSSIGNFINALTX, stream));
+
+    CaptureMessage = capture_orig;
+    m_node.args->ForceSetArg("-capturemessages", "0");
+
+    BOOST_CHECK(std::ranges::count(status_recipients, sender.addr) == 1);
+    BOOST_CHECK(std::ranges::count(status_recipients, other.addr) == 0);
+    BOOST_CHECK_EQUAL(server.GetState(), int{POOL_STATE_SIGNING});
+    BOOST_CHECK_EQUAL(server.GetEntriesCount(), 2);
+
+    connman.ClearTestNodes();
+}
+
 BOOST_AUTO_TEST_CASE(entry_deserializes_vectors_through_wire_cap)
 {
     const size_t wire_cap{CoinJoin::GetMaxPoolInputOutputCount()};

From c550e3251ddc426f7c802dacb1f410ea6f9b7ec7 Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Tue, 13 Oct 2026 13:15:03 -0500
Subject: [PATCH 2/3] fix(coinjoin): end a session once a participant is
 unreachable

When the masternode cannot deliver the final transaction or a status update
to one of the participants, RelayStatus() tells every other participant
that the session is terminated. Each client that receives that enters
POOL_STATE_ERROR, releases its inputs and stops, so the session can no
longer complete. The server only reset the session if *every* participant
was unreachable. Otherwise it kept the session until its timeout, where
the clients that had obeyed were counted as participants that never sent
or signed, and one of them could be charged its collateral.

That charged honest participants for a failure the masternode cannot
attribute to them: an unreachable peer is just as likely to be the
masternode's own connection going down. Once the termination has been
relayed, reset the session immediately so its timeout cannot charge
anyone. A participant that never sends or signs while everyone is still
reachable is handled exactly as before.

RelayFinalTransaction() now finishes iterating vecEntries before calling
RelayStatus(), which can now clear it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/coinjoin/server.cpp            | 23 ++++++++---------
 src/test/coinjoin_inouts_tests.cpp | 41 ++++++++++++++++++++++++++++++
 2 files changed, 52 insertions(+), 12 deletions(-)

diff --git a/src/coinjoin/server.cpp b/src/coinjoin/server.cpp
index 56a7362af324..b470d5ec5924 100644
--- a/src/coinjoin/server.cpp
+++ b/src/coinjoin/server.cpp
@@ -1311,17 +1311,16 @@ void CCoinJoinServer::RelayFinalTransaction(const CTransaction& txFinal)
         __func__, nSessionID, nSessionDenom, CoinJoin::DenominationToString(nSessionDenom));
 
     // final mixing tx with empty signatures should be relayed to mixing participants only
-    for (const auto& entry : vecEntries) {
-        bool fOk = connman.ForNode(entry.addr, [&txFinal, this](CNode* pnode) {
+    const bool all_reached = std::ranges::all_of(vecEntries, [&txFinal, this](const auto& entry) {
+        return connman.ForNode(entry.addr, [&txFinal, this](CNode* pnode) {
             CNetMsgMaker msgMaker(pnode->GetCommonVersion());
             connman.PushMessage(pnode, msgMaker.Make(NetMsgType::DSFINALTX, nSessionID.load(), txFinal));
             return true;
         });
-        if (!fOk) {
-            // no such node? maybe this client disconnected or our own connection went down
-            RelayStatus(STATUS_REJECTED);
-            break;
-        }
+    });
+    if (!all_reached) {
+        // no such node? maybe this client disconnected or our own connection went down
+        RelayStatus(STATUS_REJECTED);
     }
 }
 
@@ -1361,11 +1360,11 @@ void CCoinJoinServer::RelayStatus(PoolStatusUpdate nStatusUpdate, PoolMessage nM
         });
     }
 
-    if (nDisconnected == vecEntries.size()) {
-        // all clients disconnected, there is probably some issues with our own connection
-        // do not charge any fees, just reset the pool
-        SetNull();
-    }
+    // The participants told to terminate release their inputs and stop, so the session can no
+    // longer complete. End it now without charging anyone: at the timeout they would look like
+    // participants that never sent or signed, and a peer we cannot reach is no evidence of
+    // misbehavior - our own connection may be the one that failed.
+    SetNull();
 }
 
 void CCoinJoinServer::RelayCompletedTransaction(int session_id, const std::vector<CService>& participants,
diff --git a/src/test/coinjoin_inouts_tests.cpp b/src/test/coinjoin_inouts_tests.cpp
index 4e0b319614cd..fbe0ce826b0a 100644
--- a/src/test/coinjoin_inouts_tests.cpp
+++ b/src/test/coinjoin_inouts_tests.cpp
@@ -565,6 +565,47 @@ BOOST_AUTO_TEST_CASE(server_invalid_signature_rejects_only_its_sender)
     connman.ClearTestNodes();
 }
 
+BOOST_AUTO_TEST_CASE(server_unreachable_participant_ends_session)
+{
+    CActiveMasternodeManager mn_activeman(*Assert(m_node.connman), *Assert(m_node.dmnman), MakeSecretKey());
+    auto& connman = static_cast<ConnmanTestMsg&>(*m_node.connman);
+
+    // Every participant has submitted an entry, so the final transaction is relayed to them. If
+    // one of them can no longer be reached, the others are told to abandon the session; they
+    // cannot be charged at its timeout for obeying, so it must end right away. If everyone can be
+    // reached, it moves on to signing.
+    for (const bool all_reachable : {true, false}) {
+        BOOST_TEST_CONTEXT("all_reachable=" << all_reachable)
+        {
+            TestableCoinJoinServer server(m_node.peerman.get(), *Assert(m_node.chainman), *Assert(m_node.connman),
+                                          *Assert(m_node.dmnman), *Assert(m_node.dstxman),
+                                          *Assert(m_node.mn_metaman), *Assert(m_node.mempool), mn_activeman,
+                                          *Assert(m_node.mn_sync), *Assert(m_node.isman));
+            for (int i = 0; i < CoinJoin::GetMinPoolParticipants(); ++i) {
+                auto peer = MakePeer(/*id=*/i, /*ipv4=*/0x0a000001 + i);
+                CMutableTransaction collateral;
+                collateral.vin.emplace_back(COutPoint{uint256::ONE, static_cast<uint32_t>(i)});
+                server.SeedSessionCollateral(collateral, CoinJoin::MixShape::STANDARD);
+                CCoinJoinEntry entry{{CTxDSIn{CTxIn{COutPoint{uint256::TWO, static_cast<uint32_t>(i)}}, P2PKHScript(), 0}},
+                                     {CTxOut{CoinJoin::GetSmallestDenomination(), P2PKHScript()}},
+                                     CTransaction{collateral}};
+                entry.addr = peer->addr;
+                server.SeedEntry(std::move(entry));
+                if (all_reachable || i == 0) {
+                    peer->fSuccessfullyConnected = true;
+                    connman.AddTestNode(*peer.release());
+                }
+            }
+            server.EnterAcceptingEntriesState();
+
+            server.CreateFinalTransaction(/*session_id=*/1, /*charge_fees=*/false);
+            BOOST_CHECK_EQUAL(server.GetState(), all_reachable ? int{POOL_STATE_SIGNING} : int{POOL_STATE_IDLE});
+
+            connman.ClearTestNodes();
+        }
+    }
+}
+
 BOOST_AUTO_TEST_CASE(entry_deserializes_vectors_through_wire_cap)
 {
     const size_t wire_cap{CoinJoin::GetMaxPoolInputOutputCount()};

From 2f9a7dc39f935b79fe6708ecd9890d76635656ae Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Tue, 13 Oct 2026 13:15:19 -0500
Subject: [PATCH 3/3] fix(coinjoin): count each non-signing participant once

At the signing timeout, SelectCollateralToCharge() added a participant's
collateral once per unsigned input. The offender count is compared with the
number of session collaterals to decide whether almost everyone failed
(charge only sometimes) or everyone failed (charge nobody, since that
points at the masternode rather than the participants). A single
participant that withheld signatures on as many inputs as there are
collaterals therefore looked like "everyone failed", and could abort the
signing phase without ever risking its collateral. A participant with
several inputs was also more likely to be picked than one with a single
input.

Count each participant that left any input unsigned once, and measure the
signing offenders against the participants that were asked to sign rather
than against every session collateral. A session finalized on timeout
moves to signing with only the participants that sent an entry, but keeps
the collaterals of those that did not. Compared with all of them, a
session in which every participant asked to sign failed did not look like
"everyone failed", and one of them could be charged. Per-input counting
mostly hid that, except when every signer held a single input. For the
same reason the "almost everyone failed" threshold is now one below the
number of signers, not one below the number of collaterals.

The offender search and the charge-rate thresholds move into the free
functions FindSessionOffenders() and GetOffenderChargeRate(), so they can
be tested deterministically. SelectCollateralToCharge() keeps the random
sampling, the shuffle and the reservation. Its per-offender log lines are
replaced by one line with the offender and participant counts.

The charging policy itself is unchanged: it is still probabilistic and
still exempts a session in which every participant that was expected to
act failed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/coinjoin/server.cpp            | 88 ++++++++++++++++-------------
 src/coinjoin/server.h              | 28 +++++++++
 src/test/coinjoin_inouts_tests.cpp | 91 ++++++++++++++++++++++++++++++
 3 files changed, 168 insertions(+), 39 deletions(-)

diff --git a/src/coinjoin/server.cpp b/src/coinjoin/server.cpp
index b470d5ec5924..ca1a93c94472 100644
--- a/src/coinjoin/server.cpp
+++ b/src/coinjoin/server.cpp
@@ -543,56 +543,66 @@ CTransactionRef CCoinJoinServer::SelectCollateralToCharge()
     //we don't need to charge collateral for every offence.
     if (GetRand<int>(/*nMax=*/100) > 33) return {};
 
-    std::vector<CTransactionRef> vecOffendersCollaterals;
     const PoolState state{nState};
-    const size_t nSessionCollaterals{m_session_collaterals.size()};
+    auto offenders{FindSessionOffenders(state, m_session_collaterals.txs(), vecEntries)};
+    if (!offenders.collaterals.empty()) {
+        LogPrint(BCLog::COINJOIN, /* Continued */
+                 "CCoinJoinServer::SelectCollateralToCharge -- found %d of %d participants uncooperative (didn't %s)\n",
+                 offenders.collaterals.size(), offenders.participants,
+                 (state == POOL_STATE_SIGNING) ? "sign" : "send transaction");
+    }
+
+    switch (GetOffenderChargeRate(offenders)) {
+    case OffenderChargeRate::NONE:
+        return {};
+    case OffenderChargeRate::REDUCED:
+        if (GetRand<int>(/*nMax=*/100) > 33) return {};
+        break;
+    case OffenderChargeRate::NORMAL:
+        break;
+    }
+
+    // charge one of the offenders randomly
+    Shuffle(offenders.collaterals.begin(), offenders.collaterals.end(), FastRandomContext());
+
+    LogPrint(BCLog::COINJOIN, /* Continued */
+             "CCoinJoinServer::SelectCollateralToCharge -- found uncooperative node (didn't %s transaction), charging "
+             "fees: %s",
+             (state == POOL_STATE_SIGNING) ? "sign" : "send", offenders.collaterals[0]->ToString());
+    m_collaterals_being_charged.push_back(offenders.collaterals[0]);
+    return offenders.collaterals[0];
+}
 
+CoinJoinSessionOffenders FindSessionOffenders(PoolState state, const std::vector<CTransactionRef>& session_collaterals,
+                                              const std::vector<CCoinJoinEntry>& entries)
+{
+    CoinJoinSessionOffenders offenders;
     if (state == POOL_STATE_ACCEPTING_ENTRIES) {
-        for (const auto& txCollateral : m_session_collaterals.txs()) {
-            bool fFound = std::ranges::any_of(vecEntries, [&txCollateral](const auto& entry) {
+        offenders.participants = session_collaterals.size();
+        for (const auto& txCollateral : session_collaterals) {
+            // This queue entry didn't send us the promised transaction
+            const bool fFound = std::ranges::any_of(entries, [&txCollateral](const auto& entry) {
                 return *entry.txCollateral == *txCollateral;
             });
-
-            // This queue entry didn't send us the promised transaction
-            if (!fFound) {
-                LogPrint(BCLog::COINJOIN, /* Continued */
-                         "CCoinJoinServer::SelectCollateralToCharge -- found uncooperative node (didn't send "
-                         "transaction), found offence\n");
-                vecOffendersCollaterals.push_back(txCollateral);
-            }
+            if (!fFound) offenders.collaterals.push_back(txCollateral);
         }
     } else if (state == POOL_STATE_SIGNING) {
-        // who didn't sign?
-        for (const auto& entry : vecEntries) {
-            for (const auto& txdsin : entry.vecTxDSIn) {
-                if (!txdsin.fHasSig) {
-                    LogPrint(BCLog::COINJOIN, /* Continued */
-                             "CCoinJoinServer::SelectCollateralToCharge -- found uncooperative node (didn't sign), "
-                             "found offence\n");
-                    vecOffendersCollaterals.push_back(entry.txCollateral);
-                }
+        offenders.participants = entries.size();
+        for (const auto& entry : entries) {
+            if (std::ranges::any_of(entry.vecTxDSIn, [](const auto& txdsin) { return !txdsin.fHasSig; })) {
+                offenders.collaterals.push_back(entry.txCollateral);
             }
         }
     }
+    return offenders;
+}
 
-    // no offences found
-    if (vecOffendersCollaterals.empty()) return {};
-
-    //mostly offending? Charge sometimes
-    if (vecOffendersCollaterals.size() >= nSessionCollaterals - 1 && GetRand<int>(/*nMax=*/100) > 33) return {};
-
-    //everyone is an offender? That's not right
-    if (vecOffendersCollaterals.size() >= nSessionCollaterals) return {};
-
-    //charge one of the offenders randomly
-    Shuffle(vecOffendersCollaterals.begin(), vecOffendersCollaterals.end(), FastRandomContext());
-
-    LogPrint(BCLog::COINJOIN, /* Continued */
-             "CCoinJoinServer::SelectCollateralToCharge -- found uncooperative node (didn't %s transaction), charging "
-             "fees: %s",
-             (state == POOL_STATE_SIGNING) ? "sign" : "send", vecOffendersCollaterals[0]->ToString());
-    m_collaterals_being_charged.push_back(vecOffendersCollaterals[0]);
-    return vecOffendersCollaterals[0];
+OffenderChargeRate GetOffenderChargeRate(const CoinJoinSessionOffenders& offenders)
+{
+    const size_t failed{offenders.collaterals.size()};
+    if (failed == 0 || failed >= offenders.participants) return OffenderChargeRate::NONE;
+    if (failed == offenders.participants - 1) return OffenderChargeRate::REDUCED;
+    return OffenderChargeRate::NORMAL;
 }
 
 /*
diff --git a/src/coinjoin/server.h b/src/coinjoin/server.h
index d5abb3d218b7..c74f34acbe49 100644
--- a/src/coinjoin/server.h
+++ b/src/coinjoin/server.h
@@ -49,6 +49,34 @@ struct CoinJoinSessionProgress {
  */
 bool ShouldResetTimedOutSession(const CoinJoinSessionProgress& session);
 
+/** The participants of a session that did not do their part at its current stage */
+struct CoinJoinSessionOffenders {
+    //! The collateral of each participant that failed, once per participant
+    std::vector<CTransactionRef> collaterals;
+    //! How many participants were expected to act at this stage
+    size_t participants{0};
+};
+
+/**
+ * Who failed to do their part at this stage of a session? While entries are being accepted, every
+ * admitted participant had to send one. While signing, only the participants whose entries made it
+ * into the final transaction were asked to sign: a session finalized on timeout still holds the
+ * collaterals of those that never sent one. A participant counts once however many of its inputs
+ * are unsigned.
+ */
+CoinJoinSessionOffenders FindSessionOffenders(PoolState state, const std::vector<CTransactionRef>& session_collaterals,
+                                              const std::vector<CCoinJoinEntry>& entries);
+
+/** How readily one of a session's offenders may be charged, on top of the random sampling every charge goes through */
+enum class OffenderChargeRate {
+    //! No offence, or every participant failed, which points at the masternode rather than at any one of them
+    NONE,
+    //! All but one participant failed: charge only some of the time
+    REDUCED,
+    NORMAL,
+};
+OffenderChargeRate GetOffenderChargeRate(const CoinJoinSessionOffenders& offenders);
+
 /** Used to keep track of current status of mixing pool
  */
 class CCoinJoinServer : public CCoinJoinBaseSession, public NetHandler
diff --git a/src/test/coinjoin_inouts_tests.cpp b/src/test/coinjoin_inouts_tests.cpp
index fbe0ce826b0a..ec86770a8640 100644
--- a/src/test/coinjoin_inouts_tests.cpp
+++ b/src/test/coinjoin_inouts_tests.cpp
@@ -30,6 +30,7 @@
 #include <algorithm>
 #include <array>
 #include <cstdint>
+#include <iterator>
 #include <memory>
 #include <vector>
 
@@ -606,6 +607,96 @@ BOOST_AUTO_TEST_CASE(server_unreachable_participant_ends_session)
     }
 }
 
+BOOST_AUTO_TEST_CASE(server_charges_only_attributable_offenders)
+{
+    struct Case {
+        std::string name;
+        PoolState state;
+        int collaterals;
+        //! The submitted entries, entry i belonging to collateral i: {signed inputs, inputs}
+        std::vector<std::pair<int, int>> entries;
+        //! The collaterals expected to be found offending
+        std::vector<int> offenders;
+        size_t participants;
+        OffenderChargeRate rate;
+    };
+    const std::pair<int, int> sent{0, 1}, signed_entry{1, 1}, unsigned_entry{0, 1};
+    const std::vector<Case> cases{
+        {"accepting, two entries missing", POOL_STATE_ACCEPTING_ENTRIES, 5, {sent, sent, sent}, {3, 4}, 5, OffenderChargeRate::NORMAL},
+        {"accepting, every entry in", POOL_STATE_ACCEPTING_ENTRIES, 3, {sent, sent, sent}, {}, 3, OffenderChargeRate::NONE},
+        {"accepting, all entries but one missing", POOL_STATE_ACCEPTING_ENTRIES, 3, {sent}, {1, 2}, 3, OffenderChargeRate::REDUCED},
+        {"accepting, no entry at all", POOL_STATE_ACCEPTING_ENTRIES, 3, {}, {0, 1, 2}, 3, OffenderChargeRate::NONE},
+        // A single non-signer however many inputs it holds. Counted once per input it looked like every
+        // participant had failed, which exempts the session from charging.
+        {"signing, one participant leaves all of its inputs unsigned",
+         POOL_STATE_SIGNING,
+         4,
+         {{0, 4}, signed_entry, signed_entry, signed_entry},
+         {0},
+         4,
+         OffenderChargeRate::NORMAL},
+        {"signing, one participant signs only some of its inputs",
+         POOL_STATE_SIGNING,
+         4,
+         {{2, 3}, signed_entry, signed_entry, signed_entry},
+         {0},
+         4,
+         OffenderChargeRate::NORMAL},
+        {"signing, everyone signed", POOL_STATE_SIGNING, 3, {signed_entry, signed_entry, signed_entry}, {}, 3, OffenderChargeRate::NONE},
+        // Finalized on timeout without the last two participants' entries, so only the first two were asked to
+        // sign. Every one of them failing points at the masternode rather than at any one of them.
+        {"signing after a timeout, every participant asked to sign fails",
+         POOL_STATE_SIGNING,
+         4,
+         {unsigned_entry, unsigned_entry},
+         {0, 1},
+         2,
+         OffenderChargeRate::NONE},
+        {"signing after a timeout, all signers but one fail",
+         POOL_STATE_SIGNING,
+         5,
+         {unsigned_entry, unsigned_entry, signed_entry},
+         {0, 1},
+         3,
+         OffenderChargeRate::REDUCED},
+        {"queue", POOL_STATE_QUEUE, 3, {}, {}, 0, OffenderChargeRate::NONE},
+    };
+
+    for (const auto& [name, state, n_collaterals, entry_shapes, expected_offenders, participants, rate] : cases) {
+        BOOST_TEST_CONTEXT(name)
+        {
+            std::vector<CTransactionRef> collaterals;
+            for (int i = 0; i < n_collaterals; ++i) {
+                CMutableTransaction collateral;
+                collateral.vin.emplace_back(COutPoint{uint256::ONE, static_cast<uint32_t>(i)});
+                collaterals.push_back(MakeTransactionRef(collateral));
+            }
+            std::vector<CCoinJoinEntry> entries;
+            for (size_t i = 0; i < entry_shapes.size(); ++i) {
+                const auto [n_signed, n_inputs] = entry_shapes[i];
+                std::vector<CTxDSIn> inputs;
+                for (int j = 0; j < n_inputs; ++j) {
+                    inputs.emplace_back(CTxIn{COutPoint{uint256::TWO, static_cast<uint32_t>(i * 16 + j)}},
+                                        P2PKHScript(), 0);
+                    inputs.back().fHasSig = j < n_signed;
+                }
+                entries.emplace_back(inputs, std::vector<CTxOut>{}, *collaterals[i]);
+            }
+
+            const auto offenders{FindSessionOffenders(state, collaterals, entries)};
+            // An entry carries its own copy of the collateral, so compare transactions, not pointers
+            std::vector<uint256> found, expected;
+            std::ranges::transform(offenders.collaterals, std::back_inserter(found),
+                                   [](const auto& collateral) { return collateral->GetHash(); });
+            std::ranges::transform(expected_offenders, std::back_inserter(expected),
+                                   [&collaterals](int i) { return collaterals[i]->GetHash(); });
+            BOOST_CHECK_EQUAL_COLLECTIONS(found.begin(), found.end(), expected.begin(), expected.end());
+            BOOST_CHECK_EQUAL(offenders.participants, participants);
+            BOOST_CHECK(GetOffenderChargeRate(offenders) == rate);
+        }
+    }
+}
+
 BOOST_AUTO_TEST_CASE(entry_deserializes_vectors_through_wire_cap)
 {
     const size_t wire_cap{CoinJoin::GetMaxPoolInputOutputCount()};