Inside Bitcoin

501
502        Package package_missing_parent{tx_parent_1, tx_child_missing_parent};
503
504        const auto result_missing_parent = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool,
505                                                             package_missing_parent, /*test_accept=*/false, /*client_maxfeerate=*/{});
506        if (auto err_missing_parent{CheckPackageMempoolAcceptResult(package_missing_parent, result_missing_parent, /*expect_valid=*/false, m_node.mempool.get())}) {
507            BOOST_ERROR(err_missing_parent.value());
508        } else {
509            auto it_parent = result_missing_parent.m_tx_results.find(tx_parent_1->GetWitnessHash());
510            auto it_child = result_missing_parent.m_tx_results.find(tx_child_missing_parent->GetWitnessHash());
511
512            BOOST_CHECK_EQUAL(result_missing_parent.m_state.GetResult(), PackageValidationResult::PCKG_TX);
513            BOOST_CHECK_EQUAL(result_missing_parent.m_state.GetRejectReason(), "transaction failed");
514
515            BOOST_CHECK_EQUAL(it_parent->second.m_state.GetResult(), TxValidationResult::TX_RECONSIDERABLE);
516            BOOST_CHECK_EQUAL(it_child->second.m_state.GetResult(), TxValidationResult::TX_MISSING_INPUTS);
517            BOOST_CHECK_EQUAL(it_child->second.m_state.GetRejectReason(), "bad-txns-inputs-missingorspent");
518            BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
519        }
520
521        // Submit parent2 ahead of time, should become ok.
522        Package package_just_parent2{tx_parent_2};
523        expected_pool_size += 1;
524        const auto result_just_parent2 = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool,
525                                                           package_just_parent2, /*test_accept=*/false, /*client_maxfeerate=*/{});
526        if (auto err_parent2{CheckPackageMempoolAcceptResult(package_just_parent2, result_just_parent2, /*expect_valid=*/true, m_node.mempool.get())}) {
527            BOOST_ERROR(err_parent2.value());
528        }
529        BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
530
531        const auto result_parent_already_in = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool,
532                                                                package_missing_parent, /*test_accept=*/false, /*client_maxfeerate=*/{});
533        expected_pool_size += 2;
534        if (auto err_parent_already_in{CheckPackageMempoolAcceptResult(package_missing_parent, result_parent_already_in, /*expect_valid=*/true, m_node.mempool.get())}) {
535            BOOST_ERROR(err_parent_already_in.value());
536        }
537        BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
538    }
539}
540
541// Tests for packages containing a single transaction
542BOOST_AUTO_TEST_CASE(package_single_tx)
543{
544    // Mine blocks to mature coinbases.
545    mineBlocks(3);
546    LOCK(cs_main);
547    auto expected_pool_size{m_node.mempool->size()};
548
549    const CAmount high_fee{1000};
550
551    // No unconfirmed parents
552    CKey single_key = GenerateRandomKey();
553    CScript single_locking_script = GetScriptForDestination(PKHash(single_key.GetPubKey()));
554    auto mtx_single = CreateValidMempoolTransaction(/*input_transaction=*/m_coinbase_txns[0], /*input_vout=*/0,
555                                                    /*input_height=*/0, /*input_signing_key=*/coinbaseKey,
556                                                    /*output_destination=*/single_locking_script,
557                                                    /*output_amount=*/CAmount(49 * COIN), /*submit=*/false);
558    CTransactionRef tx_single = MakeTransactionRef(mtx_single);
559    Package package_tx_single{tx_single};
560    const auto result_single_tx = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool,
561                                                    package_tx_single, /*test_accept=*/false, /*client_maxfeerate=*/{});
562    expected_pool_size += 1;
563    BOOST_CHECK_MESSAGE(result_single_tx.m_state.IsValid(),
564                        "Package validation unexpectedly failed: " << result_single_tx.m_state.ToString());
565    BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
566
567    // Parent and Child. Both submitted by themselves through the ProcessNewPackage interface.
568    CKey parent_key = GenerateRandomKey();
569    CScript parent_locking_script = GetScriptForDestination(WitnessV0KeyHash(parent_key.GetPubKey()));
570    auto mtx_parent = CreateValidMempoolTransaction(/*input_transaction=*/m_coinbase_txns[1], /*input_vout=*/0,
571                                                    /*input_height=*/0, /*input_signing_key=*/coinbaseKey,
572                                                    /*output_destination=*/parent_locking_script,
573                                                    /*output_amount=*/CAmount(50 * COIN) - high_fee, /*submit=*/false);
574    CTransactionRef tx_parent = MakeTransactionRef(mtx_parent);
575    Package package_just_parent{tx_parent};
576    const auto result_just_parent = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool, package_just_parent, /*test_accept=*/false, /*client_maxfeerate=*/{});
577    if (auto err_parent_child{CheckPackageMempoolAcceptResult(package_just_parent, result_just_parent, /*expect_valid=*/true, nullptr)}) {
578        BOOST_ERROR(err_parent_child.value());
579    } else {
580        auto it_parent = result_just_parent.m_tx_results.find(tx_parent->GetWitnessHash());
581        BOOST_CHECK_MESSAGE(it_parent->second.m_state.IsValid(), it_parent->second.m_state.ToString());
582        BOOST_CHECK(it_parent->second.m_effective_feerate.value().GetFee(GetVirtualTransactionSize(*tx_parent)) == high_fee);
583        BOOST_CHECK_EQUAL(it_parent->second.m_wtxids_fee_calculations.value().size(), 1);
584        BOOST_CHECK_EQUAL(it_parent->second.m_wtxids_fee_calculations.value().front(), tx_parent->GetWitnessHash());
585    }
586    expected_pool_size += 1;
587    BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
588
589    CKey child_key = GenerateRandomKey();
590    CScript child_locking_script = GetScriptForDestination(WitnessV0KeyHash(child_key.GetPubKey()));
591    auto mtx_child = CreateValidMempoolTransaction(/*input_transaction=*/tx_parent, /*input_vout=*/0,
592                                                   /*input_height=*/101, /*input_signing_key=*/parent_key,
593                                                   /*output_destination=*/child_locking_script,
594                                                   /*output_amount=*/CAmount(50 * COIN) - 2 * high_fee, /*submit=*/false);
595    CTransactionRef tx_child = MakeTransactionRef(mtx_child);
596    Package package_just_child{tx_child};
597    const auto result_just_child = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool, package_just_child, /*test_accept=*/false, /*client_maxfeerate=*/{});
598    if (auto err_parent_child{CheckPackageMempoolAcceptResult(package_just_child, result_just_child, /*expect_valid=*/true, nullptr)}) {
599        BOOST_ERROR(err_parent_child.value());
600    } else {
601        auto it_child = result_just_child.m_tx_results.find(tx_child->GetWitnessHash());
602        BOOST_CHECK_MESSAGE(it_child->second.m_state.IsValid(), it_child->second.m_state.ToString());
603        BOOST_CHECK(it_child->second.m_effective_feerate.value().GetFee(GetVirtualTransactionSize(*tx_child)) == high_fee);
604        BOOST_CHECK_EQUAL(it_child->second.m_wtxids_fee_calculations.value().size(), 1);
605        BOOST_CHECK_EQUAL(it_child->second.m_wtxids_fee_calculations.value().front(), tx_child->GetWitnessHash());
606    }
607    expected_pool_size += 1;
608    BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
609
610    // Too-low fee to RBF tx_single
611    auto mtx_single_low_fee = CreateValidMempoolTransaction(/*input_transaction=*/m_coinbase_txns[0], /*input_vout=*/0,
612                                                    /*input_height=*/0, /*input_signing_key=*/coinbaseKey,
613                                                    /*output_destination=*/single_locking_script,
614                                                    /*output_amount=*/CAmount(49 * COIN - 1), /*submit=*/false);
615    CTransactionRef tx_single_low_fee = MakeTransactionRef(mtx_single_low_fee);
616    Package package_tx_single_low_fee{tx_single_low_fee};
617    const auto result_single_tx_low_fee = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool,
618                                                    package_tx_single_low_fee, /*test_accept=*/false, /*client_maxfeerate=*/{});
619
620    BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
621
622    BOOST_CHECK(!result_single_tx_low_fee.m_state.IsValid());
623    BOOST_CHECK_EQUAL(result_single_tx_low_fee.m_state.GetResult(), PackageValidationResult::PCKG_TX);
624    auto it_low_fee = result_single_tx_low_fee.m_tx_results.find(tx_single_low_fee->GetWitnessHash());
625    BOOST_CHECK_EQUAL(it_low_fee->second.m_state.GetResult(), TxValidationResult::TX_RECONSIDERABLE);
626    if (auto err_single{CheckPackageMempoolAcceptResult(package_tx_single_low_fee, result_single_tx_low_fee, /*expect_valid=*/false, m_node.mempool.get())}) {
627        BOOST_ERROR(err_single.value());
628    }
629    BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
630}
631
632// Tests for packages containing transactions that have same-txid-different-witness equivalents in
633// the mempool.
634BOOST_AUTO_TEST_CASE(package_witness_swap_tests)
635{
636    // Mine blocks to mature coinbases.
637    mineBlocks(5);
638    MockMempoolMinFee(CFeeRate(5000), *m_node.mempool);
639    LOCK(cs_main);
640
641    // Transactions with a same-txid-different-witness transaction in the mempool should be ignored,
642    // and the mempool entry's wtxid returned.
643    CScript witnessScript = CScript() << OP_DROP << OP_TRUE;
644    CScript scriptPubKey = GetScriptForDestination(WitnessV0ScriptHash(witnessScript));
645    auto mtx_parent = CreateValidMempoolTransaction(/*input_transaction=*/m_coinbase_txns[0], /*input_vout=*/0,
646                                                    /*input_height=*/0, /*input_signing_key=*/coinbaseKey,
647                                                    /*output_destination=*/scriptPubKey,
648                                                    /*output_amount=*/CAmount(49 * COIN), /*submit=*/false);
649    CTransactionRef ptx_parent = MakeTransactionRef(mtx_parent);
650
651    // Make two children with the same txid but different witnesses.
652    CScriptWitness witness1;
653    witness1.stack.emplace_back(1);
654    witness1.stack.emplace_back(witnessScript.begin(), witnessScript.end());
655
656    CScriptWitness witness2(witness1);
657    witness2.stack.emplace_back(2);
658    witness2.stack.emplace_back(witnessScript.begin(), witnessScript.end());
659
660    CKey child_key = GenerateRandomKey();
661    CScript child_locking_script = GetScriptForDestination(WitnessV0KeyHash(child_key.GetPubKey()));
662    CMutableTransaction mtx_child1;
663    mtx_child1.version = 1;
664    mtx_child1.vin.resize(1);
665    mtx_child1.vin[0].prevout.hash = ptx_parent->GetHash();
666    mtx_child1.vin[0].prevout.n = 0;
667    mtx_child1.vin[0].scriptSig = CScript();
668    mtx_child1.vin[0].scriptWitness = witness1;
669    mtx_child1.vout.resize(1);
670    mtx_child1.vout[0].nValue = CAmount(48 * COIN);
671    mtx_child1.vout[0].scriptPubKey = child_locking_script;
672
673    CMutableTransaction mtx_child2{mtx_child1};
674    mtx_child2.vin[0].scriptWitness = witness2;
675
676    CTransactionRef ptx_child1 = MakeTransactionRef(mtx_child1);
677    CTransactionRef ptx_child2 = MakeTransactionRef(mtx_child2);
678
679    // child1 and child2 have the same txid
680    BOOST_CHECK_EQUAL(ptx_child1->GetHash(), ptx_child2->GetHash());
681    // child1 and child2 have different wtxids
682    BOOST_CHECK(ptx_child1->GetWitnessHash() != ptx_child2->GetWitnessHash());
683    // Check that they have different package hashes
684    BOOST_CHECK(GetPackageHash({ptx_parent, ptx_child1}) != GetPackageHash({ptx_parent, ptx_child2}));
685
686    // Try submitting Package1{parent, child1} and Package2{parent, child2} where the children are
687    // same-txid-different-witness.
688    {
689        Package package_parent_child1{ptx_parent, ptx_child1};
690        const auto submit_witness1 = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool,
691                                                       package_parent_child1, /*test_accept=*/false, /*client_maxfeerate=*/{});
692        if (auto err_witness1{CheckPackageMempoolAcceptResult(package_parent_child1, submit_witness1, /*expect_valid=*/true, m_node.mempool.get())}) {
693            BOOST_ERROR(err_witness1.value());
694        }
695
696        // Child2 would have been validated individually.
697        Package package_parent_child2{ptx_parent, ptx_child2};
698        const auto submit_witness2 = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool,
699                                                       package_parent_child2, /*test_accept=*/false, /*client_maxfeerate=*/{});
700        if (auto err_witness2{CheckPackageMempoolAcceptResult(package_parent_child2, submit_witness2, /*expect_valid=*/true, m_node.mempool.get())}) {
701            BOOST_ERROR(err_witness2.value());
702        } else {
703            auto it_parent2_deduped = submit_witness2.m_tx_results.find(ptx_parent->GetWitnessHash());
704            auto it_child2 = submit_witness2.m_tx_results.find(ptx_child2->GetWitnessHash());
705            BOOST_CHECK(it_parent2_deduped->second.m_result_type == MempoolAcceptResult::ResultType::MEMPOOL_ENTRY);
706            BOOST_CHECK(it_child2->second.m_result_type == MempoolAcceptResult::ResultType::DIFFERENT_WITNESS);
707            BOOST_CHECK_EQUAL(ptx_child1->GetWitnessHash(), it_child2->second.m_other_wtxid.value());
708        }
709
710        // Deduplication should work when wtxid != txid. Submit package with the already-in-mempool
711        // transactions again, which should not fail.
712        const auto submit_segwit_dedup = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool,
713                                                           package_parent_child1, /*test_accept=*/false, /*client_maxfeerate=*/{});
714        if (auto err_segwit_dedup{CheckPackageMempoolAcceptResult(package_parent_child1, submit_segwit_dedup, /*expect_valid=*/true, m_node.mempool.get())}) {
715            BOOST_ERROR(err_segwit_dedup.value());
716        } else {
717            auto it_parent_dup = submit_segwit_dedup.m_tx_results.find(ptx_parent->GetWitnessHash());
718            auto it_child_dup = submit_segwit_dedup.m_tx_results.find(ptx_child1->GetWitnessHash());
719            BOOST_CHECK(it_parent_dup->second.m_result_type == MempoolAcceptResult::ResultType::MEMPOOL_ENTRY);
720            BOOST_CHECK(it_child_dup->second.m_result_type == MempoolAcceptResult::ResultType::MEMPOOL_ENTRY);
721        }
722    }
723
724    // Try submitting Package1{child2, grandchild} where child2 is same-txid-different-witness as
725    // the in-mempool transaction, child1. Since child1 exists in the mempool and its outputs are
726    // available, child2 should be ignored and grandchild should be accepted.
727    //
728    // This tests a potential censorship vector in which an attacker broadcasts a competing package
729    // where a parent's witness is mutated. The honest package should be accepted despite the fact
730    // that we don't allow witness replacement.
731    CKey grandchild_key = GenerateRandomKey();
732    CScript grandchild_locking_script = GetScriptForDestination(WitnessV0KeyHash(grandchild_key.GetPubKey()));
733    auto mtx_grandchild = CreateValidMempoolTransaction(/*input_transaction=*/ptx_child2, /*input_vout=*/0,
734                                                        /*input_height=*/0, /*input_signing_key=*/child_key,
735                                                        /*output_destination=*/grandchild_locking_script,
736                                                        /*output_amount=*/CAmount(47 * COIN), /*submit=*/false);
737    CTransactionRef ptx_grandchild = MakeTransactionRef(mtx_grandchild);
738    // Check that they have different package hashes
739    BOOST_CHECK(GetPackageHash({ptx_child1, ptx_grandchild}) != GetPackageHash({ptx_child2, ptx_grandchild}));
740    // We already submitted child1 above.
741    {
742        Package package_child2_grandchild{ptx_child2, ptx_grandchild};
743        const auto submit_spend_ignored = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool,
744                                                            package_child2_grandchild, /*test_accept=*/false, /*client_maxfeerate=*/{});
745        if (auto err_spend_ignored{CheckPackageMempoolAcceptResult(package_child2_grandchild, submit_spend_ignored, /*expect_valid=*/true, m_node.mempool.get())}) {
746            BOOST_ERROR(err_spend_ignored.value());
747        } else {
748            auto it_child2_ignored = submit_spend_ignored.m_tx_results.find(ptx_child2->GetWitnessHash());
749            auto it_grandchild = submit_spend_ignored.m_tx_results.find(ptx_grandchild->GetWitnessHash());
750            BOOST_CHECK(it_child2_ignored->second.m_result_type == MempoolAcceptResult::ResultType::DIFFERENT_WITNESS);