Inside Bitcoin

751            BOOST_CHECK(it_grandchild->second.m_result_type == MempoolAcceptResult::ResultType::VALID);
752        }
753    }
754
755    // A package Package{parent1, parent2, parent3, child} where the parents are a mixture of
756    // identical-tx-in-mempool, same-txid-different-witness-in-mempool, and new transactions.
757    Package package_mixed;
758
759    // Give all the parents anyone-can-spend scripts so we don't have to deal with signing the child.
760    CScript acs_script = CScript() << OP_TRUE;
761    CScript acs_spk = GetScriptForDestination(WitnessV0ScriptHash(acs_script));
762    CScriptWitness acs_witness;
763    acs_witness.stack.emplace_back(acs_script.begin(), acs_script.end());
764
765    // parent1 will already be in the mempool
766    auto mtx_parent1 = CreateValidMempoolTransaction(/*input_transaction=*/m_coinbase_txns[1], /*input_vout=*/0,
767                                                     /*input_height=*/0, /*input_signing_key=*/coinbaseKey,
768                                                     /*output_destination=*/acs_spk,
769                                                     /*output_amount=*/CAmount(49 * COIN), /*submit=*/true);
770    CTransactionRef ptx_parent1 = MakeTransactionRef(mtx_parent1);
771    package_mixed.push_back(ptx_parent1);
772
773    // parent2 will have a same-txid-different-witness tx already in the mempool
774    CScript grandparent2_script = CScript() << OP_DROP << OP_TRUE;
775    CScript grandparent2_spk = GetScriptForDestination(WitnessV0ScriptHash(grandparent2_script));
776    CScriptWitness parent2_witness1;
777    parent2_witness1.stack.emplace_back(1);
778    parent2_witness1.stack.emplace_back(grandparent2_script.begin(), grandparent2_script.end());
779    CScriptWitness parent2_witness2;
780    parent2_witness2.stack.emplace_back(2);
781    parent2_witness2.stack.emplace_back(grandparent2_script.begin(), grandparent2_script.end());
782
783    // Create grandparent2 creating an output with multiple spending paths. Submit to mempool.
784    auto mtx_grandparent2 = CreateValidMempoolTransaction(/*input_transaction=*/m_coinbase_txns[2], /*input_vout=*/0,
785                                                          /*input_height=*/0, /*input_signing_key=*/coinbaseKey,
786                                                          /*output_destination=*/grandparent2_spk,
787                                                          /*output_amount=*/CAmount(49 * COIN), /*submit=*/true);
788    CTransactionRef ptx_grandparent2 = MakeTransactionRef(mtx_grandparent2);
789
790    CMutableTransaction mtx_parent2_v1;
791    mtx_parent2_v1.version = 1;
792    mtx_parent2_v1.vin.resize(1);
793    mtx_parent2_v1.vin[0].prevout.hash = ptx_grandparent2->GetHash();
794    mtx_parent2_v1.vin[0].prevout.n = 0;
795    mtx_parent2_v1.vin[0].scriptSig = CScript();
796    mtx_parent2_v1.vin[0].scriptWitness = parent2_witness1;
797    mtx_parent2_v1.vout.resize(1);
798    mtx_parent2_v1.vout[0].nValue = CAmount(48 * COIN);
799    mtx_parent2_v1.vout[0].scriptPubKey = acs_spk;
800
801    CMutableTransaction mtx_parent2_v2{mtx_parent2_v1};
802    mtx_parent2_v2.vin[0].scriptWitness = parent2_witness2;
803
804    CTransactionRef ptx_parent2_v1 = MakeTransactionRef(mtx_parent2_v1);
805    CTransactionRef ptx_parent2_v2 = MakeTransactionRef(mtx_parent2_v2);
806    // Put parent2_v1 in the package, submit parent2_v2 to the mempool.
807    const MempoolAcceptResult parent2_v2_result = m_node.chainman->ProcessTransaction(ptx_parent2_v2);
808    BOOST_CHECK(parent2_v2_result.m_result_type == MempoolAcceptResult::ResultType::VALID);
809    package_mixed.push_back(ptx_parent2_v1);
810
811    // parent3 will be a new transaction. Put a low feerate to make it invalid on its own.
812    auto mtx_parent3 = CreateValidMempoolTransaction(/*input_transaction=*/m_coinbase_txns[3], /*input_vout=*/0,
813                                                     /*input_height=*/0, /*input_signing_key=*/coinbaseKey,
814                                                     /*output_destination=*/acs_spk,
815                                                     /*output_amount=*/CAmount(50 * COIN - low_fee_amt), /*submit=*/false);
816    CTransactionRef ptx_parent3 = MakeTransactionRef(mtx_parent3);
817    package_mixed.push_back(ptx_parent3);
818    BOOST_CHECK(m_node.mempool->GetMinFee().GetFee(GetVirtualTransactionSize(*ptx_parent3)) > low_fee_amt);
819    BOOST_CHECK(m_node.mempool->m_opts.min_relay_feerate.GetFee(GetVirtualTransactionSize(*ptx_parent3)) <= low_fee_amt);
820
821    // child spends parent1, parent2, and parent3
822    CKey mixed_grandchild_key = GenerateRandomKey();
823    CScript mixed_child_spk = GetScriptForDestination(WitnessV0KeyHash(mixed_grandchild_key.GetPubKey()));
824
825    CMutableTransaction mtx_mixed_child;
826    mtx_mixed_child.vin.emplace_back(COutPoint(ptx_parent1->GetHash(), 0));
827    mtx_mixed_child.vin.emplace_back(COutPoint(ptx_parent2_v1->GetHash(), 0));
828    mtx_mixed_child.vin.emplace_back(COutPoint(ptx_parent3->GetHash(), 0));
829    mtx_mixed_child.vin[0].scriptWitness = acs_witness;
830    mtx_mixed_child.vin[1].scriptWitness = acs_witness;
831    mtx_mixed_child.vin[2].scriptWitness = acs_witness;
832    mtx_mixed_child.vout.emplace_back((48 + 49 + 50 - 1) * COIN, mixed_child_spk);
833    CTransactionRef ptx_mixed_child = MakeTransactionRef(mtx_mixed_child);
834    package_mixed.push_back(ptx_mixed_child);
835
836    // Submit package:
837    // parent1 should be ignored
838    // parent2_v1 should be ignored (and v2 wtxid returned)
839    // parent3 should be accepted
840    // child should be accepted
841    {
842        const auto mixed_result = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool, package_mixed, false, /*client_maxfeerate=*/{});
843        if (auto err_mixed{CheckPackageMempoolAcceptResult(package_mixed, mixed_result, /*expect_valid=*/true, m_node.mempool.get())}) {
844            BOOST_ERROR(err_mixed.value());
845        } else {
846            auto it_parent1 = mixed_result.m_tx_results.find(ptx_parent1->GetWitnessHash());
847            auto it_parent2 = mixed_result.m_tx_results.find(ptx_parent2_v1->GetWitnessHash());
848            auto it_parent3 = mixed_result.m_tx_results.find(ptx_parent3->GetWitnessHash());
849            auto it_child = mixed_result.m_tx_results.find(ptx_mixed_child->GetWitnessHash());
850
851            BOOST_CHECK(it_parent1->second.m_result_type == MempoolAcceptResult::ResultType::MEMPOOL_ENTRY);
852            BOOST_CHECK(it_parent2->second.m_result_type == MempoolAcceptResult::ResultType::DIFFERENT_WITNESS);
853            BOOST_CHECK(it_parent3->second.m_result_type == MempoolAcceptResult::ResultType::VALID);
854            BOOST_CHECK(it_child->second.m_result_type == MempoolAcceptResult::ResultType::VALID);
855            BOOST_CHECK_EQUAL(ptx_parent2_v2->GetWitnessHash(), it_parent2->second.m_other_wtxid.value());
856
857            // package feerate should include parent3 and child. It should not include parent1 or parent2_v1.
858            const CFeeRate expected_feerate(1 * COIN, GetVirtualTransactionSize(*ptx_parent3) + GetVirtualTransactionSize(*ptx_mixed_child));
859            BOOST_CHECK(it_parent3->second.m_effective_feerate.value() == expected_feerate);
860            BOOST_CHECK(it_child->second.m_effective_feerate.value() == expected_feerate);
861            std::vector<Wtxid> expected_wtxids({ptx_parent3->GetWitnessHash(), ptx_mixed_child->GetWitnessHash()});
862            BOOST_CHECK(it_parent3->second.m_wtxids_fee_calculations.value() == expected_wtxids);
863            BOOST_CHECK(it_child->second.m_wtxids_fee_calculations.value() == expected_wtxids);
864        }
865    }
866}
867
868BOOST_AUTO_TEST_CASE(package_cpfp_tests)
869{
870    mineBlocks(5);
871    MockMempoolMinFee(CFeeRate(5000), *m_node.mempool);
872    LOCK(::cs_main);
873    size_t expected_pool_size = m_node.mempool->size();
874    CKey child_key = GenerateRandomKey();
875    CScript parent_spk = GetScriptForDestination(WitnessV0KeyHash(child_key.GetPubKey()));
876    CKey grandchild_key = GenerateRandomKey();
877    CScript child_spk = GetScriptForDestination(WitnessV0KeyHash(grandchild_key.GetPubKey()));
878
879    // low-fee parent and high-fee child package
880    const CAmount coinbase_value{50 * COIN};
881    const CAmount parent_value{coinbase_value - low_fee_amt};
882    const CAmount child_value{parent_value - COIN};
883
884    Package package_cpfp;
885    auto mtx_parent = CreateValidMempoolTransaction(/*input_transaction=*/m_coinbase_txns[0], /*input_vout=*/0,
886                                                    /*input_height=*/0, /*input_signing_key=*/coinbaseKey,
887                                                    /*output_destination=*/parent_spk,
888                                                    /*output_amount=*/parent_value, /*submit=*/false);
889    CTransactionRef tx_parent = MakeTransactionRef(mtx_parent);
890    package_cpfp.push_back(tx_parent);
891
892    auto mtx_child = CreateValidMempoolTransaction(/*input_transaction=*/tx_parent, /*input_vout=*/0,
893                                                   /*input_height=*/101, /*input_signing_key=*/child_key,
894                                                   /*output_destination=*/child_spk,
895                                                   /*output_amount=*/child_value, /*submit=*/false);
896    CTransactionRef tx_child = MakeTransactionRef(mtx_child);
897    package_cpfp.push_back(tx_child);
898
899    // Package feerate is calculated using modified fees, and prioritisetransaction accepts negative
900    // fee deltas. This should be taken into account. De-prioritise the parent transaction
901    // to bring the package feerate to 0.
902    m_node.mempool->PrioritiseTransaction(tx_parent->GetHash(), child_value - coinbase_value);
903    {
904        BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
905        const auto submit_cpfp_deprio = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool,
906                                                   package_cpfp, /*test_accept=*/ false, /*client_maxfeerate=*/{});
907        if (auto err_cpfp_deprio{CheckPackageMempoolAcceptResult(package_cpfp, submit_cpfp_deprio, /*expect_valid=*/false, m_node.mempool.get())}) {
908            BOOST_ERROR(err_cpfp_deprio.value());
909        } else {
910            BOOST_CHECK_EQUAL(submit_cpfp_deprio.m_state.GetResult(), PackageValidationResult::PCKG_TX);
911            BOOST_CHECK_EQUAL(submit_cpfp_deprio.m_tx_results.find(tx_parent->GetWitnessHash())->second.m_state.GetResult(),
912                              TxValidationResult::TX_RECONSIDERABLE);
913            BOOST_CHECK_EQUAL(submit_cpfp_deprio.m_tx_results.find(tx_child->GetWitnessHash())->second.m_state.GetResult(),
914                              TxValidationResult::TX_RECONSIDERABLE);
915            BOOST_CHECK_EQUAL(submit_cpfp_deprio.m_tx_results.find(tx_parent->GetWitnessHash())->second.m_state.GetRejectReason(), "mempool min fee not met");
916            BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
917        }
918    }
919
920    // Clear the prioritisation of the parent transaction.
921    WITH_LOCK(m_node.mempool->cs, m_node.mempool->ClearPrioritisation(tx_parent->GetHash()));
922
923    // Package CPFP: Even though the parent's feerate is below the mempool minimum feerate, the
924    // child pays enough for the package feerate to meet the threshold.
925    {
926        BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
927        const auto submit_cpfp = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool,
928                                                   package_cpfp, /*test_accept=*/ false, /*client_maxfeerate=*/{});
929        if (auto err_cpfp{CheckPackageMempoolAcceptResult(package_cpfp, submit_cpfp, /*expect_valid=*/true, m_node.mempool.get())}) {
930            BOOST_ERROR(err_cpfp.value());
931        } else {
932            auto it_parent = submit_cpfp.m_tx_results.find(tx_parent->GetWitnessHash());
933            auto it_child = submit_cpfp.m_tx_results.find(tx_child->GetWitnessHash());
934            BOOST_CHECK(it_parent->second.m_result_type == MempoolAcceptResult::ResultType::VALID);
935            BOOST_CHECK(it_parent->second.m_base_fees.value() == coinbase_value - parent_value);
936            BOOST_CHECK(it_child->second.m_result_type == MempoolAcceptResult::ResultType::VALID);
937            BOOST_CHECK(it_child->second.m_base_fees.value() == COIN);
938
939            const CFeeRate expected_feerate(coinbase_value - child_value,
940                                            GetVirtualTransactionSize(*tx_parent) + GetVirtualTransactionSize(*tx_child));
941            BOOST_CHECK(it_parent->second.m_effective_feerate.value() == expected_feerate);
942            BOOST_CHECK(it_child->second.m_effective_feerate.value() == expected_feerate);
943            std::vector<Wtxid> expected_wtxids({tx_parent->GetWitnessHash(), tx_child->GetWitnessHash()});
944            BOOST_CHECK(it_parent->second.m_wtxids_fee_calculations.value() == expected_wtxids);
945            BOOST_CHECK(it_child->second.m_wtxids_fee_calculations.value() == expected_wtxids);
946            BOOST_CHECK(expected_feerate.GetFeePerK() > 1000);
947        }
948        expected_pool_size += 2;
949        BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
950    }
951
952    // Just because we allow low-fee parents doesn't mean we allow low-feerate packages.
953    // The mempool minimum feerate is 5sat/vB, but this package just pays 800 satoshis total.
954    // The child fees would be able to pay for itself, but isn't enough for the entire package.
955    Package package_still_too_low;
956    const CAmount parent_fee{200};
957    const CAmount child_fee{600};
958    auto mtx_parent_cheap = CreateValidMempoolTransaction(/*input_transaction=*/m_coinbase_txns[1], /*input_vout=*/0,
959                                                          /*input_height=*/0, /*input_signing_key=*/coinbaseKey,
960                                                          /*output_destination=*/parent_spk,
961                                                          /*output_amount=*/coinbase_value - parent_fee, /*submit=*/false);
962    CTransactionRef tx_parent_cheap = MakeTransactionRef(mtx_parent_cheap);
963    package_still_too_low.push_back(tx_parent_cheap);
964    BOOST_CHECK(m_node.mempool->GetMinFee().GetFee(GetVirtualTransactionSize(*tx_parent_cheap)) > parent_fee);
965    BOOST_CHECK(m_node.mempool->m_opts.min_relay_feerate.GetFee(GetVirtualTransactionSize(*tx_parent_cheap)) <= parent_fee);
966
967    auto mtx_child_cheap = CreateValidMempoolTransaction(/*input_transaction=*/tx_parent_cheap, /*input_vout=*/0,
968                                                         /*input_height=*/101, /*input_signing_key=*/child_key,
969                                                         /*output_destination=*/child_spk,
970                                                         /*output_amount=*/coinbase_value - parent_fee - child_fee, /*submit=*/false);
971    CTransactionRef tx_child_cheap = MakeTransactionRef(mtx_child_cheap);
972    package_still_too_low.push_back(tx_child_cheap);
973    BOOST_CHECK(m_node.mempool->GetMinFee().GetFee(GetVirtualTransactionSize(*tx_child_cheap)) <= child_fee);
974    BOOST_CHECK(m_node.mempool->GetMinFee().GetFee(GetVirtualTransactionSize(*tx_parent_cheap) + GetVirtualTransactionSize(*tx_child_cheap)) > parent_fee + child_fee);
975    BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
976
977    // Cheap package should fail for being too low fee.
978    {
979        const auto submit_package_too_low = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool,
980                                                   package_still_too_low, /*test_accept=*/false, /*client_maxfeerate=*/{});
981        if (auto err_package_too_low{CheckPackageMempoolAcceptResult(package_still_too_low, submit_package_too_low, /*expect_valid=*/false, m_node.mempool.get())}) {
982            BOOST_ERROR(err_package_too_low.value());
983        } else {
984            // Individual feerate of parent is too low.
985            BOOST_CHECK_EQUAL(submit_package_too_low.m_tx_results.at(tx_parent_cheap->GetWitnessHash()).m_state.GetResult(),
986                              TxValidationResult::TX_RECONSIDERABLE);
987            BOOST_CHECK(submit_package_too_low.m_tx_results.at(tx_parent_cheap->GetWitnessHash()).m_effective_feerate.value() ==
988                        CFeeRate(parent_fee, GetVirtualTransactionSize(*tx_parent_cheap)));
989            // Package feerate of parent + child is too low.
990            BOOST_CHECK_EQUAL(submit_package_too_low.m_tx_results.at(tx_child_cheap->GetWitnessHash()).m_state.GetResult(),
991                              TxValidationResult::TX_RECONSIDERABLE);
992            BOOST_CHECK(submit_package_too_low.m_tx_results.at(tx_child_cheap->GetWitnessHash()).m_effective_feerate.value() ==
993                        CFeeRate(parent_fee + child_fee, GetVirtualTransactionSize(*tx_parent_cheap) + GetVirtualTransactionSize(*tx_child_cheap)));
994        }
995        BOOST_CHECK_EQUAL(submit_package_too_low.m_state.GetResult(), PackageValidationResult::PCKG_TX);
996        BOOST_CHECK_EQUAL(submit_package_too_low.m_state.GetRejectReason(), "transaction failed");
997        BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
998    }
999
1000    // Package feerate includes the modified fees of the transactions.