Merge #6803: test: add CoinJoin DSTX and inouts tests

PastaPastaPasta · PastaPastaPasta · commit 55fd18249f0b · 2025-08-09T14:29:33.000-05:00
f038f0a chore: run clang-format (pasta) c0df94c refactor: use wildcard pattern for CoinJoin test files in non-backported.txt (pasta) da4b39b test: address review feedback for CoinJoin test improvements (pasta) dc9a4f8 test: add CoinJoin base manager and queue tests (pasta) 1951a27 feat: add GetConfirmedHeight method to CoinJoin class (pasta) 0e154f7 test: enhance CoinJoin DSTX height management tests (pasta) 4b00a0e test: add CoinJoin DSTX and inouts tests (pasta) Pull request description: ## Issue being fixed or feature implemented This commit introduces two new test files: `coinjoin_dstxmanager_tests.cpp` and `coinjoin_inouts_tests.cpp`. The `coinjoin_dstxmanager_tests` file includes tests for managing CoinJoin broadcast transactions, while the `coinjoin_inouts_tests` file focuses on validating the structure and behavior of CoinJoin transactions. Both files are added to the test suite in the Makefile for comprehensive testing coverage. ## What was done? ## How Has This Been Tested? Tests pass locally ## Breaking Changes None ## Checklist: _Go over all the following points, and put an `x` in all the boxes that apply._ - [ ] I have performed a self-review of my own code - [ ] I have commented my code, particularly in hard-to-understand areas - [ ] I have added or updated relevant unit/integration/functional/e2e tests - [ ] I have made corresponding changes to the documentation - [x] I have assigned this pull request to a milestone _(for repository code-owners and collaborators only)_ ACKs for top commit: UdjinM6: utACK f038f0a knst: utACK f038f0a Tree-SHA512: 3b137eea5b804568287725daad261bab1d4948c4cd7e2775b7a0c19e7433545c1a798740ed0faaa534d187cbbcf0bafba54c0ff5547fc32cd1a921f5053f66a0
diff --git a/src/Makefile.test.include b/src/Makefile.test.include
@@ -120,6 +120,10 @@ BITCOIN_TESTS =\
   test/fs_tests.cpp \
   test/getarg_tests.cpp \
   test/governance_validators_tests.cpp \
+  test/coinjoin_inouts_tests.cpp \
+  test/coinjoin_dstxmanager_tests.cpp \
+  test/coinjoin_basemanager_tests.cpp \
+  test/coinjoin_queue_tests.cpp \
   test/hash_tests.cpp \
   test/httpserver_tests.cpp \
   test/i2p_tests.cpp \
diff --git a/src/coinjoin/coinjoin.h b/src/coinjoin/coinjoin.h
@@ -287,6 +287,8 @@ class CCoinJoinBroadcastTx
     bool Sign(const CActiveMasternodeManager& mn_activeman);
     [[nodiscard]] bool CheckSignature(const CBLSPublicKey& blsPubKey) const;
 
+    // Used only for unit tests
+    [[nodiscard]] std::optional<int> GetConfirmedHeight() const { return nConfirmedHeight; }
     void SetConfirmedHeight(std::optional<int> nConfirmedHeightIn) { assert(nConfirmedHeightIn == std::nullopt || *nConfirmedHeightIn > 0); nConfirmedHeight = nConfirmedHeightIn; }
     bool IsExpired(const CBlockIndex* pindex, const llmq::CChainLocksHandler& clhandler) const;
     [[nodiscard]] bool IsValidStructure() const;
diff --git a/src/test/coinjoin_basemanager_tests.cpp b/src/test/coinjoin_basemanager_tests.cpp
@@ -0,0 +1,74 @@
+// Copyright (c) 2025 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <test/util/setup_common.h>
+
+#include <coinjoin/coinjoin.h>
+#include <cstddef>
+#include <uint256.h>
+
+#include <boost/test/unit_test.hpp>
+
+class TestBaseManager : public CCoinJoinBaseManager
+{
+public:
+    void PushQueue(const CCoinJoinQueue& q)
+    {
+        LOCK(cs_vecqueue);
+        vecCoinJoinQueue.push_back(q);
+    }
+    size_t QueueSize() const
+    {
+        LOCK(cs_vecqueue);
+        return vecCoinJoinQueue.size();
+    }
+    void CallCheckQueue() { CheckQueue(); }
+};
+
+BOOST_FIXTURE_TEST_SUITE(coinjoin_basemanager_tests, BasicTestingSetup)
+
+static CCoinJoinQueue MakeQueue(int denom, int64_t nTime, bool fReady, const COutPoint& outpoint)
+{
+    CCoinJoinQueue q;
+    q.nDenom = denom;
+    q.masternodeOutpoint = outpoint;
+    q.m_protxHash = uint256::ONE;
+    q.nTime = nTime;
+    q.fReady = fReady;
+    return q;
+}
+
+BOOST_AUTO_TEST_CASE(checkqueue_removes_timeouts)
+{
+    TestBaseManager man;
+    const int denom = CoinJoin::AmountToDenomination(CoinJoin::GetSmallestDenomination());
+    const int64_t now = GetAdjustedTime();
+    // Non-expired
+    man.PushQueue(MakeQueue(denom, now, false, COutPoint(uint256S("11"), 0)));
+    // Expired (too old)
+    man.PushQueue(MakeQueue(denom, now - COINJOIN_QUEUE_TIMEOUT - 1, false, COutPoint(uint256S("12"), 0)));
+
+    BOOST_CHECK_EQUAL(man.QueueSize(), 2U);
+    man.CallCheckQueue();
+    // One should be removed
+    BOOST_CHECK_EQUAL(man.QueueSize(), 1U);
+}
+
+BOOST_AUTO_TEST_CASE(getqueueitem_marks_tried_once)
+{
+    TestBaseManager man;
+    const int denom = CoinJoin::AmountToDenomination(CoinJoin::GetSmallestDenomination());
+    const int64_t now = GetAdjustedTime();
+    CCoinJoinQueue dsq = MakeQueue(denom, now, false, COutPoint(uint256S("21"), 0));
+    man.PushQueue(dsq);
+
+    CCoinJoinQueue picked;
+    // First retrieval should succeed
+    BOOST_CHECK(man.GetQueueItemAndTry(picked));
+    // No other items left to try (picked is marked tried inside)
+    CCoinJoinQueue picked2;
+    BOOST_CHECK(!man.GetQueueItemAndTry(picked2));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/coinjoin_dstxmanager_tests.cpp b/src/test/coinjoin_dstxmanager_tests.cpp
@@ -0,0 +1,85 @@
+// Copyright (c) 2025 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <test/util/setup_common.h>
+
+#include <chain.h>
+#include <coinjoin/coinjoin.h>
+#include <coinjoin/common.h>
+#include <coinjoin/context.h>
+#include <script/script.h>
+#include <uint256.h>
+
+#include <algorithm>
+#include <array>
+#include <vector>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(coinjoin_dstxmanager_tests, TestingSetup)
+
+static CCoinJoinBroadcastTx MakeDSTX(int vin_vout_count = 3)
+{
+    CCoinJoinBroadcastTx dstx;
+    CMutableTransaction mtx;
+    const int count = std::max(vin_vout_count, 1);
+    for (int i = 0; i < count; ++i) {
+        mtx.vin.emplace_back(COutPoint(uint256S("0a"), i));
+        // Use denominated P2PKH outputs
+        CScript spk;
+        spk << OP_DUP << OP_HASH160 << std::vector<unsigned char>(20, i) << OP_EQUALVERIFY << OP_CHECKSIG;
+        mtx.vout.emplace_back(CoinJoin::GetSmallestDenomination(), spk);
+    }
+    dstx.tx = MakeTransactionRef(mtx);
+    dstx.m_protxHash = uint256::ONE;
+    return dstx;
+}
+
+BOOST_AUTO_TEST_CASE(add_get_dstx)
+{
+    CCoinJoinBroadcastTx dstx = MakeDSTX();
+    auto& man = *Assert(Assert(m_node.cj_ctx)->dstxman);
+    // Not present initially
+    BOOST_CHECK(!man.GetDSTX(dstx.tx->GetHash()));
+    // Add
+    man.AddDSTX(dstx);
+    // Fetch back
+    auto got = man.GetDSTX(dstx.tx->GetHash());
+    BOOST_CHECK(static_cast<bool>(got));
+    BOOST_CHECK_EQUAL(got.tx->GetHash().ToString(), dstx.tx->GetHash().ToString());
+}
+
+BOOST_AUTO_TEST_CASE(update_heights_block_connect_disconnect)
+{
+    CCoinJoinBroadcastTx dstx = MakeDSTX();
+    auto& man = *Assert(Assert(m_node.cj_ctx)->dstxman);
+    man.AddDSTX(dstx);
+
+    // Create a fake block containing the tx
+    auto block = std::make_shared<CBlock>();
+    block->vtx.push_back(dstx.tx);
+    CBlockIndex index;
+    index.nHeight = 100;
+    uint256 bh = uint256S("0b");
+    index.phashBlock = &bh;
+
+    // Height should set to 100 on connect
+    man.BlockConnected(block, &index);
+    {
+        auto got = man.GetDSTX(dstx.tx->GetHash());
+        BOOST_CHECK(static_cast<bool>(got));
+        BOOST_CHECK(got.GetConfirmedHeight().has_value());
+        BOOST_CHECK_EQUAL(*got.GetConfirmedHeight(), 100);
+    }
+
+    // Height should clear on disconnect
+    man.BlockDisconnected(block, nullptr);
+    {
+        auto got = man.GetDSTX(dstx.tx->GetHash());
+        BOOST_CHECK(static_cast<bool>(got));
+        BOOST_CHECK(!got.GetConfirmedHeight().has_value());
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/coinjoin_inouts_tests.cpp b/src/test/coinjoin_inouts_tests.cpp
@@ -0,0 +1,136 @@
+// Copyright (c) 2025 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <test/util/setup_common.h>
+
+#include <algorithm>
+#include <array>
+#include <cstdint>
+#include <vector>
+
+#include <chain.h>
+#include <chainlock/chainlock.h>
+#include <coinjoin/coinjoin.h>
+#include <coinjoin/common.h>
+#include <llmq/context.h>
+#include <script/script.h>
+#include <uint256.h>
+#include <util/check.h>
+#include <util/time.h>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(coinjoin_inouts_tests, TestingSetup)
+
+static CScript P2PKHScript(uint8_t tag = 0x01)
+{
+    // OP_DUP OP_HASH160 <20-byte-tag> OP_EQUALVERIFY OP_CHECKSIG
+    std::vector<unsigned char> hash(20, tag);
+    return CScript{} << OP_DUP << OP_HASH160 << hash << OP_EQUALVERIFY << OP_CHECKSIG;
+}
+
+BOOST_AUTO_TEST_CASE(broadcasttx_isvalidstructure_good_and_bad)
+{
+    // Good: equal vin/vout sizes, vin count >= min participants, <= max*entry_size, P2PKH outputs with standard denominations
+    CCoinJoinBroadcastTx good;
+    {
+        CMutableTransaction mtx;
+        // Use min pool participants (e.g. 3). Build 3 inputs and 3 denominated outputs
+        const int participants = std::max(3, CoinJoin::GetMinPoolParticipants());
+        for (int i = 0; i < participants; ++i) {
+            CTxIn in;
+            in.prevout = COutPoint(uint256::ONE, static_cast<uint32_t>(i));
+            mtx.vin.push_back(in);
+            // Pick the smallest denomination
+            CTxOut out{CoinJoin::GetSmallestDenomination(), P2PKHScript(static_cast<uint8_t>(i))};
+            mtx.vout.push_back(out);
+        }
+        good.tx = MakeTransactionRef(mtx);
+        good.m_protxHash = uint256::ONE; // at least one of (outpoint, protxhash) must be set
+    }
+    BOOST_CHECK(good.IsValidStructure());
+
+    // Bad: both identifiers null
+    CCoinJoinBroadcastTx bad_ids = good;
+    bad_ids.m_protxHash = uint256{};
+    bad_ids.masternodeOutpoint.SetNull();
+    BOOST_CHECK(!bad_ids.IsValidStructure());
+
+    // Bad: vin/vout size mismatch
+    CCoinJoinBroadcastTx bad_sizes = good;
+    {
+        CMutableTransaction mtx(*good.tx);
+        mtx.vout.pop_back();
+        bad_sizes.tx = MakeTransactionRef(mtx);
+    }
+    BOOST_CHECK(!bad_sizes.IsValidStructure());
+
+    // Bad: non-P2PKH output
+    CCoinJoinBroadcastTx bad_script = good;
+    {
+        CMutableTransaction mtx(*good.tx);
+        mtx.vout[0].scriptPubKey = CScript() << OP_RETURN << std::vector<unsigned char>{'x'};
+        bad_script.tx = MakeTransactionRef(mtx);
+    }
+    BOOST_CHECK(!bad_script.IsValidStructure());
+
+    // Bad: non-denominated amount
+    CCoinJoinBroadcastTx bad_amount = good;
+    {
+        CMutableTransaction mtx(*good.tx);
+        mtx.vout[0].nValue = 42; // not a valid denom
+        bad_amount.tx = MakeTransactionRef(mtx);
+    }
+    BOOST_CHECK(!bad_amount.IsValidStructure());
+}
+
+BOOST_AUTO_TEST_CASE(queue_timeout_bounds)
+{
+    CCoinJoinQueue dsq;
+    dsq.nDenom = CoinJoin::AmountToDenomination(CoinJoin::GetSmallestDenomination());
+    dsq.m_protxHash = uint256::ONE;
+    dsq.nTime = GetAdjustedTime();
+    // current time -> not out of bounds
+    BOOST_CHECK(!dsq.IsTimeOutOfBounds());
+
+    // Too old (beyond COINJOIN_QUEUE_TIMEOUT)
+    SetMockTime(GetTime() + (COINJOIN_QUEUE_TIMEOUT + 1));
+    BOOST_CHECK(dsq.IsTimeOutOfBounds());
+
+    // Too far in the future
+    SetMockTime(GetTime() - 2 * (COINJOIN_QUEUE_TIMEOUT + 1)); // move back to anchor baseline
+    dsq.nTime = GetAdjustedTime() + (COINJOIN_QUEUE_TIMEOUT + 1);
+    BOOST_CHECK(dsq.IsTimeOutOfBounds());
+
+    // Reset mock time
+    SetMockTime(0);
+}
+
+BOOST_AUTO_TEST_CASE(broadcasttx_expiry_height_logic)
+{
+    // Build a valid-looking CCoinJoinBroadcastTx with confirmed height
+    CCoinJoinBroadcastTx dstx;
+    {
+        CMutableTransaction mtx;
+        const int participants = std::max(3, CoinJoin::GetMinPoolParticipants());
+        for (int i = 0; i < participants; ++i) {
+            mtx.vin.emplace_back(COutPoint(uint256::TWO, i));
+            mtx.vout.emplace_back(CoinJoin::GetSmallestDenomination(), P2PKHScript(static_cast<uint8_t>(i)));
+        }
+        dstx.tx = MakeTransactionRef(mtx);
+        dstx.m_protxHash = uint256::ONE;
+        // mark as confirmed at height 100
+        dstx.SetConfirmedHeight(100);
+    }
+
+    // Minimal CBlockIndex with required fields
+    // Create a minimal block index to satisfy the interface
+    CBlockIndex index;
+    uint256 blk_hash = uint256S("03");
+    index.nHeight = 125; // 125 - 100 == 25 > 24 → expired by height
+    index.phashBlock = &blk_hash;
+    BOOST_CHECK(dstx.IsExpired(&index, *Assert(m_node.llmq_ctx->clhandler)));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/coinjoin_queue_tests.cpp b/src/test/coinjoin_queue_tests.cpp
@@ -0,0 +1,56 @@
+// Copyright (c) 2025 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <test/util/setup_common.h>
+
+#include <bls/bls.h>
+#include <coinjoin/coinjoin.h>
+#include <masternode/node.h>
+#include <uint256.h>
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_SUITE(coinjoin_queue_tests, BasicTestingSetup)
+
+static CBLSSecretKey MakeSecretKey()
+{
+    // Generate a dummy operator keypair for signing
+    CBLSSecretKey sk;
+    sk.MakeNewKey();
+    return sk;
+}
+
+BOOST_AUTO_TEST_CASE(queue_sign_and_verify)
+{
+    // Build active MN manager with operator key using node context wiring
+    CActiveMasternodeManager mn_activeman(MakeSecretKey(), *Assert(m_node.connman), m_node.dmnman);
+
+    CCoinJoinQueue q;
+    q.nDenom = CoinJoin::AmountToDenomination(CoinJoin::GetSmallestDenomination());
+    q.masternodeOutpoint = COutPoint(uint256S("aa"), 1);
+    q.m_protxHash = uint256::ONE;
+    q.nTime = GetAdjustedTime();
+    q.fReady = false;
+
+    // Sign and verify with corresponding pubkey
+    BOOST_CHECK(q.Sign(mn_activeman));
+    const CBLSPublicKey pub = mn_activeman.GetPubKey();
+    BOOST_CHECK(q.CheckSignature(pub));
+}
+
+BOOST_AUTO_TEST_CASE(queue_hashes_and_equality)
+{
+    CCoinJoinQueue a, b;
+    a.nDenom = b.nDenom = CoinJoin::AmountToDenomination(CoinJoin::GetSmallestDenomination());
+    a.masternodeOutpoint = b.masternodeOutpoint = COutPoint(uint256S("bb"), 2);
+    a.m_protxHash = b.m_protxHash = uint256::ONE;
+    a.nTime = b.nTime = GetAdjustedTime();
+    a.fReady = b.fReady = true;
+
+    BOOST_CHECK(a == b);
+    BOOST_CHECK(a.GetHash() == b.GetHash());
+    BOOST_CHECK(a.GetSignatureHash() == b.GetSignatureHash());
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/util/data/non-backported.txt b/test/util/data/non-backported.txt
@@ -39,6 +39,7 @@ src/stats/*.cpp
 src/stats/*.h
 src/test/block_reward_reallocation_tests.cpp
 src/test/bls_tests.cpp
+src/test/coinjoin_*.cpp
 src/test/dip0020opcodes_tests.cpp
 src/test/dynamic_activation*.cpp
 src/test/evo*.cpp
