Inside Bitcoin

1// Copyright (c) 2017-present The Bitcoin Core developers
2// Distributed under the MIT software license, see the accompanying
3// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5#include <consensus/validation.h>
6#include <key_io.h>
7#include <policy/packages.h>
8#include <policy/policy.h>
9#include <policy/ephemeral_policy.h>
10#include <policy/truc_policy.h>
11#include <primitives/transaction.h>
12#include <random.h>
13#include <script/script.h>
14#include <test/util/common.h>
15#include <test/util/setup_common.h>
16#include <test/util/txmempool.h>
17#include <validation.h>
18
19#include <boost/test/unit_test.hpp>
20
21
22BOOST_AUTO_TEST_SUITE(txvalidation_tests)
23
24/**
25 * Ensure that the mempool won't accept coinbase transactions.
26 */
27BOOST_FIXTURE_TEST_CASE(tx_mempool_reject_coinbase, TestChain100Setup)
28{
29    CScript scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
30    CMutableTransaction coinbaseTx;
31
32    coinbaseTx.version = 1;
33    coinbaseTx.vin.resize(1);
34    coinbaseTx.vout.resize(1);
35    coinbaseTx.vin[0].scriptSig = CScript() << OP_11 << OP_EQUAL;
36    coinbaseTx.vout[0].nValue = 1 * CENT;
37    coinbaseTx.vout[0].scriptPubKey = scriptPubKey;
38
39    BOOST_CHECK(CTransaction(coinbaseTx).IsCoinBase());
40
41    LOCK(cs_main);
42
43    unsigned int initialPoolSize = m_node.mempool->size();
44    const MempoolAcceptResult result = m_node.chainman->ProcessTransaction(MakeTransactionRef(coinbaseTx));
45
46    BOOST_CHECK(result.m_result_type == MempoolAcceptResult::ResultType::INVALID);
47
48    // Check that the transaction hasn't been added to mempool.
49    BOOST_CHECK_EQUAL(m_node.mempool->size(), initialPoolSize);
50
51    // Check that the validation state reflects the unsuccessful attempt.
52    BOOST_CHECK(result.m_state.IsInvalid());
53    BOOST_CHECK_EQUAL(result.m_state.GetRejectReason(), "coinbase");
54    BOOST_CHECK(result.m_state.GetResult() == TxValidationResult::TX_CONSENSUS);
55}
56
57// Generate a number of random, nonexistent outpoints.
58static inline std::vector<COutPoint> random_outpoints(size_t num_outpoints) {
59    std::vector<COutPoint> outpoints;
60    for (size_t i{0}; i < num_outpoints; ++i) {
61        outpoints.emplace_back(Txid::FromUint256(GetRandHash()), 0);
62    }
63    return outpoints;
64}
65
66static inline std::vector<CPubKey> random_keys(size_t num_keys) {
67    std::vector<CPubKey> keys;
68    keys.reserve(num_keys);
69    for (size_t i{0}; i < num_keys; ++i) {
70        CKey key;
71        key.MakeNewKey(true);
72        keys.emplace_back(key.GetPubKey());
73    }
74    return keys;
75}
76
77// Creates a placeholder tx (not valid) with 25 outputs. Specify the version and the inputs.
78static inline CTransactionRef make_tx(const std::vector<COutPoint>& inputs, int32_t version)
79{
80    CMutableTransaction mtx = CMutableTransaction{};
81    mtx.version = version;
82    mtx.vin.resize(inputs.size());
83    mtx.vout.resize(25);
84    for (size_t i{0}; i < inputs.size(); ++i) {
85        mtx.vin[i].prevout = inputs[i];
86    }
87    for (auto i{0}; i < 25; ++i) {
88        mtx.vout[i].scriptPubKey = CScript() << OP_TRUE;
89        mtx.vout[i].nValue = 10000;
90    }
91    return MakeTransactionRef(mtx);
92}
93
94static constexpr auto NUM_EPHEMERAL_TX_OUTPUTS = 3;
95static constexpr auto EPHEMERAL_DUST_INDEX = NUM_EPHEMERAL_TX_OUTPUTS - 1;
96
97// Same as make_tx but adds 2 normal outputs and 0-value dust to end of vout
98static inline CTransactionRef make_ephemeral_tx(const std::vector<COutPoint>& inputs, int32_t version)
99{
100    CMutableTransaction mtx = CMutableTransaction{};
101    mtx.version = version;
102    mtx.vin.resize(inputs.size());
103    for (size_t i{0}; i < inputs.size(); ++i) {
104        mtx.vin[i].prevout = inputs[i];
105    }
106    mtx.vout.resize(NUM_EPHEMERAL_TX_OUTPUTS);
107    for (auto i{0}; i < NUM_EPHEMERAL_TX_OUTPUTS; ++i) {
108        mtx.vout[i].scriptPubKey = CScript() << OP_TRUE;
109        mtx.vout[i].nValue = (i == EPHEMERAL_DUST_INDEX) ? 0 : 10000;
110    }
111    return MakeTransactionRef(mtx);
112}
113
114BOOST_FIXTURE_TEST_CASE(ephemeral_tests, RegTestingSetup)
115{
116    CTxMemPool& pool = *Assert(m_node.mempool);
117    LOCK2(cs_main, pool.cs);
118    TestMemPoolEntryHelper entry;
119
120    TxValidationState child_state;
121    Wtxid child_wtxid;
122
123    // Arbitrary non-0 feerate for these tests
124    CFeeRate dustrelay(DUST_RELAY_TX_FEE);
125
126    // Basic transaction with dust
127    auto grandparent_tx_1 = make_ephemeral_tx(random_outpoints(1), /*version=*/2);
128    const auto dust_txid = grandparent_tx_1->GetHash();
129
130    // Child transaction spending dust
131    auto dust_spend = make_tx({COutPoint{dust_txid, EPHEMERAL_DUST_INDEX}}, /*version=*/2);
132
133    // We first start with nothing "in the mempool", using package checks
134
135    // Trivial single transaction with no dust
136    BOOST_CHECK(CheckEphemeralSpends({dust_spend}, dustrelay, pool, child_state, child_wtxid));
137    BOOST_CHECK(child_state.IsValid());
138    BOOST_CHECK_EQUAL(child_wtxid, Wtxid());
139
140    // Now with dust, ok because the tx has no dusty parents
141    BOOST_CHECK(CheckEphemeralSpends({grandparent_tx_1}, dustrelay, pool, child_state, child_wtxid));
142    BOOST_CHECK(child_state.IsValid());
143    BOOST_CHECK_EQUAL(child_wtxid, Wtxid());
144
145    // Dust checks pass
146    BOOST_CHECK(CheckEphemeralSpends({grandparent_tx_1, dust_spend}, CFeeRate(0), pool, child_state, child_wtxid));
147    BOOST_CHECK(child_state.IsValid());
148    BOOST_CHECK_EQUAL(child_wtxid, Wtxid());
149    BOOST_CHECK(CheckEphemeralSpends({grandparent_tx_1, dust_spend}, dustrelay, pool, child_state, child_wtxid));
150    BOOST_CHECK(child_state.IsValid());
151    BOOST_CHECK_EQUAL(child_wtxid, Wtxid());
152
153    auto dust_non_spend = make_tx({COutPoint{dust_txid, EPHEMERAL_DUST_INDEX - 1}}, /*version=*/2);
154
155    // Child spending non-dust only from parent should be disallowed even if dust otherwise spent
156    const auto dust_non_spend_wtxid{dust_non_spend->GetWitnessHash()};
157    BOOST_CHECK(!CheckEphemeralSpends({grandparent_tx_1, dust_non_spend, dust_spend}, dustrelay, pool, child_state, child_wtxid));
158    BOOST_CHECK(!child_state.IsValid());
159    BOOST_CHECK_EQUAL(child_wtxid, dust_non_spend_wtxid);
160    child_state = TxValidationState();
161    child_wtxid = Wtxid();
162
163    BOOST_CHECK(!CheckEphemeralSpends({grandparent_tx_1, dust_spend, dust_non_spend}, dustrelay, pool, child_state, child_wtxid));
164    BOOST_CHECK(!child_state.IsValid());
165    BOOST_CHECK_EQUAL(child_wtxid, dust_non_spend_wtxid);
166    child_state = TxValidationState();
167    child_wtxid = Wtxid();
168
169    BOOST_CHECK(!CheckEphemeralSpends({grandparent_tx_1, dust_non_spend}, dustrelay, pool, child_state, child_wtxid));
170    BOOST_CHECK(!child_state.IsValid());
171    BOOST_CHECK_EQUAL(child_wtxid, dust_non_spend_wtxid);
172    child_state = TxValidationState();
173    child_wtxid = Wtxid();
174
175    auto grandparent_tx_2 = make_ephemeral_tx(random_outpoints(1), /*version=*/2);
176    const auto dust_txid_2 = grandparent_tx_2->GetHash();
177
178    // Spend dust from one but not another is ok, as long as second grandparent has no child
179    BOOST_CHECK(CheckEphemeralSpends({grandparent_tx_1, grandparent_tx_2, dust_spend}, dustrelay, pool, child_state, child_wtxid));
180    BOOST_CHECK(child_state.IsValid());
181    BOOST_CHECK_EQUAL(child_wtxid, Wtxid());
182
183    auto dust_non_spend_both_parents = make_tx({COutPoint{dust_txid, EPHEMERAL_DUST_INDEX}, COutPoint{dust_txid_2, EPHEMERAL_DUST_INDEX - 1}}, /*version=*/2);
184    // But if we spend from the parent, it must spend dust
185    BOOST_CHECK(!CheckEphemeralSpends({grandparent_tx_1, grandparent_tx_2, dust_non_spend_both_parents}, dustrelay, pool, child_state, child_wtxid));
186    BOOST_CHECK(!child_state.IsValid());
187    BOOST_CHECK_EQUAL(child_wtxid, dust_non_spend_both_parents->GetWitnessHash());
188    child_state = TxValidationState();
189    child_wtxid = Wtxid();
190
191    auto dust_spend_both_parents = make_tx({COutPoint{dust_txid, EPHEMERAL_DUST_INDEX}, COutPoint{dust_txid_2, EPHEMERAL_DUST_INDEX}}, /*version=*/2);
192    BOOST_CHECK(CheckEphemeralSpends({grandparent_tx_1, grandparent_tx_2, dust_spend_both_parents}, dustrelay, pool, child_state, child_wtxid));
193    BOOST_CHECK(child_state.IsValid());
194    BOOST_CHECK_EQUAL(child_wtxid, Wtxid());
195
196    // Spending other outputs is also correct, as long as the dusty one is spent
197    const std::vector<COutPoint> all_outpoints{COutPoint(dust_txid, 0), COutPoint(dust_txid, 1), COutPoint(dust_txid, 2),
198        COutPoint(dust_txid_2, 0), COutPoint(dust_txid_2, 1), COutPoint(dust_txid_2, 2)};
199    auto dust_spend_all_outpoints = make_tx(all_outpoints, /*version=*/2);
200    BOOST_CHECK(CheckEphemeralSpends({grandparent_tx_1, grandparent_tx_2, dust_spend_all_outpoints}, dustrelay, pool, child_state, child_wtxid));
201    BOOST_CHECK(child_state.IsValid());
202    BOOST_CHECK_EQUAL(child_wtxid, Wtxid());
203
204    // 2 grandparents with dust <- 1 dust-spending parent with dust <- child with no dust
205    auto parent_with_dust = make_ephemeral_tx({COutPoint{dust_txid, EPHEMERAL_DUST_INDEX}, COutPoint{dust_txid_2, EPHEMERAL_DUST_INDEX}}, /*version=*/2);
206    // Ok for parent to have dust
207    BOOST_CHECK(CheckEphemeralSpends({grandparent_tx_1, grandparent_tx_2, parent_with_dust}, dustrelay, pool, child_state, child_wtxid));
208    BOOST_CHECK(child_state.IsValid());
209    BOOST_CHECK_EQUAL(child_wtxid, Wtxid());
210    auto child_no_dust = make_tx({COutPoint{parent_with_dust->GetHash(), EPHEMERAL_DUST_INDEX}}, /*version=*/2);
211    BOOST_CHECK(CheckEphemeralSpends({grandparent_tx_1, grandparent_tx_2, parent_with_dust, child_no_dust}, dustrelay, pool, child_state, child_wtxid));
212    BOOST_CHECK(child_state.IsValid());
213    BOOST_CHECK_EQUAL(child_wtxid, Wtxid());
214
215    // 2 grandparents with dust <- 1 dust-spending parent with dust <- child with dust
216    auto child_with_dust = make_ephemeral_tx({COutPoint{parent_with_dust->GetHash(), EPHEMERAL_DUST_INDEX}}, /*version=*/2);
217    BOOST_CHECK(CheckEphemeralSpends({grandparent_tx_1, grandparent_tx_2, parent_with_dust, child_with_dust}, dustrelay, pool, child_state, child_wtxid));
218    BOOST_CHECK(child_state.IsValid());
219    BOOST_CHECK_EQUAL(child_wtxid, Wtxid());
220
221    // Tests with parents in mempool
222
223    // Nothing in mempool, this should pass for any transaction
224    BOOST_CHECK(CheckEphemeralSpends({grandparent_tx_1}, dustrelay, pool, child_state, child_wtxid));
225    BOOST_CHECK(child_state.IsValid());
226    BOOST_CHECK_EQUAL(child_wtxid, Wtxid());
227
228    // Add first grandparent to mempool and fetch entry
229    TryAddToMempool(pool, entry.FromTx(grandparent_tx_1));
230
231    // Ignores ancestors that aren't direct parents
232    BOOST_CHECK(CheckEphemeralSpends({child_no_dust}, dustrelay, pool, child_state, child_wtxid));
233    BOOST_CHECK(child_state.IsValid());
234    BOOST_CHECK_EQUAL(child_wtxid, Wtxid());
235
236    // Valid spend of dust with grandparent in mempool
237    BOOST_CHECK(CheckEphemeralSpends({parent_with_dust}, dustrelay, pool, child_state, child_wtxid));
238    BOOST_CHECK(child_state.IsValid());
239    BOOST_CHECK_EQUAL(child_wtxid, Wtxid());
240
241    // Second grandparent in same package
242    BOOST_CHECK(CheckEphemeralSpends({parent_with_dust, grandparent_tx_2}, dustrelay, pool, child_state, child_wtxid));
243    BOOST_CHECK(child_state.IsValid());
244    BOOST_CHECK_EQUAL(child_wtxid, Wtxid());
245
246    // Order in package doesn't matter
247    BOOST_CHECK(CheckEphemeralSpends({grandparent_tx_2, parent_with_dust}, dustrelay, pool, child_state, child_wtxid));
248    BOOST_CHECK(child_state.IsValid());
249    BOOST_CHECK_EQUAL(child_wtxid, Wtxid());
250