Inside Bitcoin

251    // Add second grandparent to mempool
252    TryAddToMempool(pool, entry.FromTx(grandparent_tx_2));
253
254    // Only spends single dust out of two direct parents
255    BOOST_CHECK(!CheckEphemeralSpends({dust_non_spend_both_parents}, dustrelay, pool, child_state, child_wtxid));
256    BOOST_CHECK(!child_state.IsValid());
257    BOOST_CHECK_EQUAL(child_wtxid, dust_non_spend_both_parents->GetWitnessHash());
258    child_state = TxValidationState();
259    child_wtxid = Wtxid();
260
261    // Spends both parents' dust
262    BOOST_CHECK(CheckEphemeralSpends({parent_with_dust}, dustrelay, pool, child_state, child_wtxid));
263    BOOST_CHECK(child_state.IsValid());
264    BOOST_CHECK_EQUAL(child_wtxid, Wtxid());
265
266    // Now add dusty parent to mempool
267    TryAddToMempool(pool, entry.FromTx(parent_with_dust));
268
269    // Passes dust checks even with non-parent ancestors
270    BOOST_CHECK(CheckEphemeralSpends({child_no_dust}, dustrelay, pool, child_state, child_wtxid));
271    BOOST_CHECK(child_state.IsValid());
272    BOOST_CHECK_EQUAL(child_wtxid, Wtxid());
273}
274
275BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
276{
277    // Test TRUC policy helper functions
278    CTxMemPool& pool = *Assert(m_node.mempool);
279    LOCK2(cs_main, pool.cs);
280    TestMemPoolEntryHelper entry;
281    std::set<Txid> empty_conflicts_set;
282    std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef> empty_parents;
283
284    auto mempool_tx_v3 = make_tx(random_outpoints(1), /*version=*/3);
285    TryAddToMempool(pool, entry.FromTx(mempool_tx_v3));
286    auto mempool_tx_v2 = make_tx(random_outpoints(1), /*version=*/2);
287    TryAddToMempool(pool, entry.FromTx(mempool_tx_v2));
288
289    // Cannot spend from an unconfirmed TRUC transaction unless this tx is also TRUC.
290    {
291        // mempool_tx_v3
292        //      ^
293        // tx_v2_from_v3
294        auto tx_v2_from_v3 = make_tx({COutPoint{mempool_tx_v3->GetHash(), 0}}, /*version=*/2);
295        auto parents_v2_from_v3 = pool.GetParents(entry.FromTx(tx_v2_from_v3));
296        const auto expected_error_str{strprintf("non-version=3 tx %s (wtxid=%s) cannot spend from version=3 tx %s (wtxid=%s)",
297            tx_v2_from_v3->GetHash().ToString(), tx_v2_from_v3->GetWitnessHash().ToString(),
298            mempool_tx_v3->GetHash().ToString(), mempool_tx_v3->GetWitnessHash().ToString())};
299        auto result_v2_from_v3{SingleTRUCChecks(pool, tx_v2_from_v3, parents_v2_from_v3, empty_conflicts_set, GetVirtualTransactionSize(*tx_v2_from_v3))};
300        BOOST_CHECK_EQUAL(result_v2_from_v3->first, expected_error_str);
301        BOOST_CHECK_EQUAL(result_v2_from_v3->second, nullptr);
302
303        Package package_v3_v2{mempool_tx_v3, tx_v2_from_v3};
304        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v2_from_v3, GetVirtualTransactionSize(*tx_v2_from_v3), package_v3_v2, empty_parents), expected_error_str);
305        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v2_from_v3, GetVirtualTransactionSize(*tx_v2_from_v3), {tx_v2_from_v3}, parents_v2_from_v3), expected_error_str);
306
307        // mempool_tx_v3  mempool_tx_v2
308        //            ^    ^
309        //    tx_v2_from_v2_and_v3
310        auto tx_v2_from_v2_and_v3 = make_tx({COutPoint{mempool_tx_v3->GetHash(), 0}, COutPoint{mempool_tx_v2->GetHash(), 0}}, /*version=*/2);
311        auto parents_2_from_both{pool.GetParents(entry.FromTx(tx_v2_from_v2_and_v3))};
312        const auto expected_error_str_2{strprintf("non-version=3 tx %s (wtxid=%s) cannot spend from version=3 tx %s (wtxid=%s)",
313            tx_v2_from_v2_and_v3->GetHash().ToString(), tx_v2_from_v2_and_v3->GetWitnessHash().ToString(),
314            mempool_tx_v3->GetHash().ToString(), mempool_tx_v3->GetWitnessHash().ToString())};
315        auto result_v2_from_both{SingleTRUCChecks(pool, tx_v2_from_v2_and_v3, parents_2_from_both, empty_conflicts_set, GetVirtualTransactionSize(*tx_v2_from_v2_and_v3))};
316        BOOST_CHECK_EQUAL(result_v2_from_both->first, expected_error_str_2);
317        BOOST_CHECK_EQUAL(result_v2_from_both->second, nullptr);
318
319        Package package_v3_v2_v2{mempool_tx_v3, mempool_tx_v2, tx_v2_from_v2_and_v3};
320        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v2_from_v2_and_v3, GetVirtualTransactionSize(*tx_v2_from_v2_and_v3), package_v3_v2_v2, empty_parents), expected_error_str_2);
321    }
322
323    // TRUC cannot spend from an unconfirmed non-TRUC transaction.
324    {
325        // mempool_tx_v2
326        //      ^
327        // tx_v3_from_v2
328        auto tx_v3_from_v2 = make_tx({COutPoint{mempool_tx_v2->GetHash(), 0}}, /*version=*/3);
329        auto parents_v3_from_v2{pool.GetParents(entry.FromTx(tx_v3_from_v2))};
330        const auto expected_error_str{strprintf("version=3 tx %s (wtxid=%s) cannot spend from non-version=3 tx %s (wtxid=%s)",
331            tx_v3_from_v2->GetHash().ToString(), tx_v3_from_v2->GetWitnessHash().ToString(),
332            mempool_tx_v2->GetHash().ToString(), mempool_tx_v2->GetWitnessHash().ToString())};
333        auto result_v3_from_v2{SingleTRUCChecks(pool, tx_v3_from_v2, parents_v3_from_v2,  empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_from_v2))};
334        BOOST_CHECK_EQUAL(result_v3_from_v2->first, expected_error_str);
335        BOOST_CHECK_EQUAL(result_v3_from_v2->second, nullptr);
336
337        Package package_v2_v3{mempool_tx_v2, tx_v3_from_v2};
338        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v3_from_v2, GetVirtualTransactionSize(*tx_v3_from_v2), package_v2_v3, empty_parents), expected_error_str);
339        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v3_from_v2, GetVirtualTransactionSize(*tx_v3_from_v2), {tx_v3_from_v2}, parents_v3_from_v2), expected_error_str);
340
341        // mempool_tx_v3  mempool_tx_v2
342        //            ^    ^
343        //    tx_v3_from_v2_and_v3
344        auto tx_v3_from_v2_and_v3 = make_tx({COutPoint{mempool_tx_v3->GetHash(), 0}, COutPoint{mempool_tx_v2->GetHash(), 0}}, /*version=*/3);
345        auto parents_v3_from_both{pool.GetParents(entry.FromTx(tx_v3_from_v2_and_v3))};
346        const auto expected_error_str_2{strprintf("version=3 tx %s (wtxid=%s) cannot spend from non-version=3 tx %s (wtxid=%s)",
347            tx_v3_from_v2_and_v3->GetHash().ToString(), tx_v3_from_v2_and_v3->GetWitnessHash().ToString(),
348            mempool_tx_v2->GetHash().ToString(), mempool_tx_v2->GetWitnessHash().ToString())};
349        auto result_v3_from_both{SingleTRUCChecks(pool, tx_v3_from_v2_and_v3, parents_v3_from_both, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_from_v2_and_v3))};
350        BOOST_CHECK_EQUAL(result_v3_from_both->first, expected_error_str_2);
351        BOOST_CHECK_EQUAL(result_v3_from_both->second, nullptr);
352
353        // tx_v3_from_v2_and_v3 also violates TRUC_ANCESTOR_LIMIT.
354        const auto expected_error_str_3{strprintf("tx %s (wtxid=%s) would have too many ancestors",
355            tx_v3_from_v2_and_v3->GetHash().ToString(), tx_v3_from_v2_and_v3->GetWitnessHash().ToString())};
356        Package package_v3_v2_v3{mempool_tx_v3, mempool_tx_v2, tx_v3_from_v2_and_v3};
357        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v3_from_v2_and_v3, GetVirtualTransactionSize(*tx_v3_from_v2_and_v3), package_v3_v2_v3, empty_parents), expected_error_str_3);
358    }
359    // V3 from V3 is ok, and non-V3 from non-V3 is ok.
360    {
361        // mempool_tx_v3
362        //      ^
363        // tx_v3_from_v3
364        auto tx_v3_from_v3 = make_tx({COutPoint{mempool_tx_v3->GetHash(), 0}}, /*version=*/3);
365        auto parents_v3{pool.GetParents(entry.FromTx(tx_v3_from_v3))};
366        BOOST_CHECK(SingleTRUCChecks(pool, tx_v3_from_v3, parents_v3, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_from_v3))
367                    == std::nullopt);
368
369        Package package_v3_v3{mempool_tx_v3, tx_v3_from_v3};
370        BOOST_CHECK(PackageTRUCChecks(pool, tx_v3_from_v3, GetVirtualTransactionSize(*tx_v3_from_v3), package_v3_v3, empty_parents) == std::nullopt);
371
372        // mempool_tx_v2
373        //      ^
374        // tx_v2_from_v2
375        auto tx_v2_from_v2 = make_tx({COutPoint{mempool_tx_v2->GetHash(), 0}}, /*version=*/2);
376        auto parents_v2{pool.GetParents(entry.FromTx(tx_v2_from_v2))};
377        BOOST_CHECK(SingleTRUCChecks(pool, tx_v2_from_v2, parents_v2, empty_conflicts_set, GetVirtualTransactionSize(*tx_v2_from_v2))
378                    == std::nullopt);
379
380        Package package_v2_v2{mempool_tx_v2, tx_v2_from_v2};
381        BOOST_CHECK(PackageTRUCChecks(pool, tx_v2_from_v2, GetVirtualTransactionSize(*tx_v2_from_v2), package_v2_v2, empty_parents) == std::nullopt);
382    }
383
384    // Tx spending TRUC cannot have too many mempool ancestors
385    // Configuration where the tx has multiple direct parents.
386    {
387        Package package_multi_parents;
388        std::vector<COutPoint> mempool_outpoints;
389        mempool_outpoints.emplace_back(mempool_tx_v3->GetHash(), 0);
390        package_multi_parents.emplace_back(mempool_tx_v3);
391        for (size_t i{0}; i < 2; ++i) {
392            auto mempool_tx = make_tx(random_outpoints(i + 1), /*version=*/3);
393            TryAddToMempool(pool, entry.FromTx(mempool_tx));
394            mempool_outpoints.emplace_back(mempool_tx->GetHash(), 0);
395            package_multi_parents.emplace_back(mempool_tx);
396        }
397        auto tx_v3_multi_parent = make_tx(mempool_outpoints, /*version=*/3);
398        package_multi_parents.emplace_back(tx_v3_multi_parent);
399        auto parents{pool.GetParents(entry.FromTx(tx_v3_multi_parent))};
400        BOOST_CHECK_EQUAL(parents.size(), 3);
401        const auto expected_error_str{strprintf("tx %s (wtxid=%s) would have too many ancestors",
402            tx_v3_multi_parent->GetHash().ToString(), tx_v3_multi_parent->GetWitnessHash().ToString())};
403        auto result{SingleTRUCChecks(pool, tx_v3_multi_parent, parents, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_multi_parent))};
404        BOOST_CHECK_EQUAL(result->first, expected_error_str);
405        BOOST_CHECK_EQUAL(result->second, nullptr);
406
407        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v3_multi_parent, GetVirtualTransactionSize(*tx_v3_multi_parent), package_multi_parents, empty_parents),
408                          expected_error_str);
409    }
410
411    // Configuration where the tx is in a multi-generation chain.
412    {
413        Package package_multi_gen;
414        CTransactionRef middle_tx;
415        auto last_outpoint{random_outpoints(1)[0]};
416        for (size_t i{0}; i < 2; ++i) {
417            auto mempool_tx = make_tx({last_outpoint}, /*version=*/3);
418            TryAddToMempool(pool, entry.FromTx(mempool_tx));
419            last_outpoint = COutPoint{mempool_tx->GetHash(), 0};
420            package_multi_gen.emplace_back(mempool_tx);
421            if (i == 1) middle_tx = mempool_tx;
422        }
423        auto tx_v3_multi_gen = make_tx({last_outpoint}, /*version=*/3);
424        package_multi_gen.emplace_back(tx_v3_multi_gen);
425        auto parents{pool.GetParents(entry.FromTx(tx_v3_multi_gen))};
426        const auto expected_error_str{strprintf("tx %s (wtxid=%s) would have too many ancestors",
427            tx_v3_multi_gen->GetHash().ToString(), tx_v3_multi_gen->GetWitnessHash().ToString())};
428        auto result{SingleTRUCChecks(pool, tx_v3_multi_gen, parents, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_multi_gen))};
429        BOOST_CHECK_EQUAL(result->first, expected_error_str);
430        BOOST_CHECK_EQUAL(result->second, nullptr);
431
432        // Middle tx is what triggers a failure for the grandchild:
433        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, middle_tx, GetVirtualTransactionSize(*middle_tx), package_multi_gen, empty_parents), expected_error_str);
434        BOOST_CHECK(PackageTRUCChecks(pool, tx_v3_multi_gen, GetVirtualTransactionSize(*tx_v3_multi_gen), package_multi_gen, empty_parents) == std::nullopt);
435    }
436
437    // Tx spending TRUC cannot be too large in virtual size.
438    auto many_inputs{random_outpoints(100)};
439    many_inputs.emplace_back(mempool_tx_v3->GetHash(), 0);
440    {
441        auto tx_v3_child_big = make_tx(many_inputs, /*version=*/3);
442        const auto vsize{GetVirtualTransactionSize(*tx_v3_child_big)};
443        auto parents{pool.GetParents(entry.FromTx(tx_v3_child_big))};
444        const auto expected_error_str{strprintf("version=3 child tx %s (wtxid=%s) is too big: %u > %u virtual bytes",
445            tx_v3_child_big->GetHash().ToString(), tx_v3_child_big->GetWitnessHash().ToString(), vsize, TRUC_CHILD_MAX_VSIZE)};
446        auto result{SingleTRUCChecks(pool, tx_v3_child_big, parents, empty_conflicts_set, GetVirtualTransactionSize(*tx_v3_child_big))};
447        BOOST_CHECK_EQUAL(result->first, expected_error_str);
448        BOOST_CHECK_EQUAL(result->second, nullptr);
449
450        Package package_child_big{mempool_tx_v3, tx_v3_child_big};
451        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_v3_child_big, GetVirtualTransactionSize(*tx_v3_child_big), package_child_big, empty_parents),
452                          expected_error_str);
453    }
454
455    // Tx spending TRUC cannot have too many sigops.
456    // This child has 10 P2WSH multisig inputs.
457    auto multisig_outpoints{random_outpoints(10)};
458    multisig_outpoints.emplace_back(mempool_tx_v3->GetHash(), 0);
459    auto keys{random_keys(2)};
460    CScript script_multisig;
461    script_multisig << OP_1;
462    for (const auto& key : keys) {
463        script_multisig << ToByteVector(key);
464    }
465    script_multisig << OP_2 << OP_CHECKMULTISIG;
466    {
467        CMutableTransaction mtx_many_sigops = CMutableTransaction{};
468        mtx_many_sigops.version = TRUC_VERSION;
469        for (const auto& outpoint : multisig_outpoints) {
470            mtx_many_sigops.vin.emplace_back(outpoint);
471            mtx_many_sigops.vin.back().scriptWitness.stack.emplace_back(script_multisig.begin(), script_multisig.end());
472        }
473        mtx_many_sigops.vout.resize(1);
474        mtx_many_sigops.vout.back().scriptPubKey = CScript() << OP_TRUE;
475        mtx_many_sigops.vout.back().nValue = 10000;
476        auto tx_many_sigops{MakeTransactionRef(mtx_many_sigops)};
477
478        auto parents{pool.GetParents(entry.FromTx(tx_many_sigops))};
479        // legacy uses fAccurate = false, and the maximum number of multisig keys is used
480        const int64_t total_sigops{static_cast<int64_t>(tx_many_sigops->vin.size()) * static_cast<int64_t>(script_multisig.GetSigOpCount(/*fAccurate=*/false))};
481        BOOST_CHECK_EQUAL(total_sigops, tx_many_sigops->vin.size() * MAX_PUBKEYS_PER_MULTISIG);
482        const int64_t bip141_vsize{GetVirtualTransactionSize(*tx_many_sigops)};
483        // Weight limit is not reached...
484        BOOST_CHECK(SingleTRUCChecks(pool, tx_many_sigops, parents, empty_conflicts_set, bip141_vsize) == std::nullopt);
485        // ...but sigop limit is.
486        const auto expected_error_str{strprintf("version=3 child tx %s (wtxid=%s) is too big: %u > %u virtual bytes",
487            tx_many_sigops->GetHash().ToString(), tx_many_sigops->GetWitnessHash().ToString(),
488            total_sigops * DEFAULT_BYTES_PER_SIGOP / WITNESS_SCALE_FACTOR, TRUC_CHILD_MAX_VSIZE)};
489        auto result{SingleTRUCChecks(pool, tx_many_sigops, parents, empty_conflicts_set,
490                                        GetVirtualTransactionSize(*tx_many_sigops, /*nSigOpCost=*/total_sigops, /*bytes_per_sigop=*/ DEFAULT_BYTES_PER_SIGOP))};
491        BOOST_CHECK_EQUAL(result->first, expected_error_str);
492        BOOST_CHECK_EQUAL(result->second, nullptr);
493
494        Package package_child_sigops{mempool_tx_v3, tx_many_sigops};
495        BOOST_CHECK_EQUAL(*PackageTRUCChecks(pool, tx_many_sigops, total_sigops * DEFAULT_BYTES_PER_SIGOP / WITNESS_SCALE_FACTOR, package_child_sigops, empty_parents),
496                          expected_error_str);
497    }
498
499    // Parent + child with TRUC in the mempool. Child is allowed as long as it is under TRUC_CHILD_MAX_VSIZE.
500    auto tx_mempool_v3_child = make_tx({COutPoint{mempool_tx_v3->GetHash(), 0}}, /*version=*/3);