Inside Bitcoin

1001    // This means a child with its fee delta from prioritisetransaction can pay for a parent.
1002    m_node.mempool->PrioritiseTransaction(tx_child_cheap->GetHash(), 1 * COIN);
1003    // Now that the child's fees have "increased" by 1 BTC, the cheap package should succeed.
1004    {
1005        const auto submit_prioritised_package = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool,
1006                                                                  package_still_too_low, /*test_accept=*/false, /*client_maxfeerate=*/{});
1007        if (auto err_prioritised{CheckPackageMempoolAcceptResult(package_still_too_low, submit_prioritised_package, /*expect_valid=*/true, m_node.mempool.get())}) {
1008            BOOST_ERROR(err_prioritised.value());
1009        } else {
1010            const CFeeRate expected_feerate(1 * COIN + parent_fee + child_fee,
1011                GetVirtualTransactionSize(*tx_parent_cheap) + GetVirtualTransactionSize(*tx_child_cheap));
1012            BOOST_CHECK_EQUAL(submit_prioritised_package.m_tx_results.size(), package_still_too_low.size());
1013            auto it_parent = submit_prioritised_package.m_tx_results.find(tx_parent_cheap->GetWitnessHash());
1014            auto it_child = submit_prioritised_package.m_tx_results.find(tx_child_cheap->GetWitnessHash());
1015            BOOST_CHECK(it_parent->second.m_result_type == MempoolAcceptResult::ResultType::VALID);
1016            BOOST_CHECK(it_parent->second.m_base_fees.value() == parent_fee);
1017            BOOST_CHECK(it_parent->second.m_effective_feerate.value() == expected_feerate);
1018            BOOST_CHECK(it_child->second.m_result_type == MempoolAcceptResult::ResultType::VALID);
1019            BOOST_CHECK(it_child->second.m_base_fees.value() == child_fee);
1020            BOOST_CHECK(it_child->second.m_effective_feerate.value() == expected_feerate);
1021            std::vector<Wtxid> expected_wtxids({tx_parent_cheap->GetWitnessHash(), tx_child_cheap->GetWitnessHash()});
1022            BOOST_CHECK(it_parent->second.m_wtxids_fee_calculations.value() == expected_wtxids);
1023            BOOST_CHECK(it_child->second.m_wtxids_fee_calculations.value() == expected_wtxids);
1024        }
1025        expected_pool_size += 2;
1026        BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
1027    }
1028
1029    // Package feerate is calculated without topology in mind; it's just aggregating fees and sizes.
1030    // However, this should not allow parents to pay for children. Each transaction should be
1031    // validated individually first, eliminating sufficient-feerate parents before they are unfairly
1032    // included in the package feerate. It's also important that the low-fee child doesn't prevent
1033    // the parent from being accepted.
1034    Package package_rich_parent;
1035    const CAmount high_parent_fee{1 * COIN};
1036    auto mtx_parent_rich = CreateValidMempoolTransaction(/*input_transaction=*/m_coinbase_txns[2], /*input_vout=*/0,
1037                                                         /*input_height=*/0, /*input_signing_key=*/coinbaseKey,
1038                                                         /*output_destination=*/parent_spk,
1039                                                         /*output_amount=*/coinbase_value - high_parent_fee, /*submit=*/false);
1040    CTransactionRef tx_parent_rich = MakeTransactionRef(mtx_parent_rich);
1041    package_rich_parent.push_back(tx_parent_rich);
1042
1043    auto mtx_child_poor = CreateValidMempoolTransaction(/*input_transaction=*/tx_parent_rich, /*input_vout=*/0,
1044                                                        /*input_height=*/101, /*input_signing_key=*/child_key,
1045                                                        /*output_destination=*/child_spk,
1046                                                        /*output_amount=*/coinbase_value - high_parent_fee, /*submit=*/false);
1047    CTransactionRef tx_child_poor = MakeTransactionRef(mtx_child_poor);
1048    package_rich_parent.push_back(tx_child_poor);
1049
1050    // Parent pays 1 BTC and child pays none. The parent should be accepted without the child.
1051    {
1052        BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
1053        const auto submit_rich_parent = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool,
1054                                                          package_rich_parent, /*test_accept=*/false, /*client_maxfeerate=*/{});
1055        if (auto err_rich_parent{CheckPackageMempoolAcceptResult(package_rich_parent, submit_rich_parent, /*expect_valid=*/false, m_node.mempool.get())}) {
1056            BOOST_ERROR(err_rich_parent.value());
1057        } else {
1058            // The child would have been validated on its own and failed.
1059            BOOST_CHECK_EQUAL(submit_rich_parent.m_state.GetResult(), PackageValidationResult::PCKG_TX);
1060            BOOST_CHECK_EQUAL(submit_rich_parent.m_state.GetRejectReason(), "transaction failed");
1061
1062            auto it_parent = submit_rich_parent.m_tx_results.find(tx_parent_rich->GetWitnessHash());
1063            auto it_child = submit_rich_parent.m_tx_results.find(tx_child_poor->GetWitnessHash());
1064            BOOST_CHECK(it_parent->second.m_result_type == MempoolAcceptResult::ResultType::VALID);
1065            BOOST_CHECK(it_child->second.m_result_type == MempoolAcceptResult::ResultType::INVALID);
1066            BOOST_CHECK(it_parent->second.m_state.GetRejectReason() == "");
1067            BOOST_CHECK_MESSAGE(it_parent->second.m_base_fees.value() == high_parent_fee,
1068                    strprintf("rich parent: expected fee %s, got %s", high_parent_fee, it_parent->second.m_base_fees.value()));
1069            BOOST_CHECK(it_parent->second.m_effective_feerate == CFeeRate(high_parent_fee, GetVirtualTransactionSize(*tx_parent_rich)));
1070            BOOST_CHECK_EQUAL(it_child->second.m_result_type, MempoolAcceptResult::ResultType::INVALID);
1071            BOOST_CHECK_EQUAL(it_child->second.m_state.GetResult(), TxValidationResult::TX_RECONSIDERABLE);
1072            BOOST_CHECK_EQUAL(it_child->second.m_state.GetRejectReason(), "mempool min fee not met");
1073        }
1074        expected_pool_size += 1;
1075        BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
1076    }
1077}
1078
1079BOOST_AUTO_TEST_CASE(package_rbf_tests)
1080{
1081    mineBlocks(5);
1082    LOCK(::cs_main);
1083    size_t expected_pool_size = m_node.mempool->size();
1084    CKey child_key{GenerateRandomKey()};
1085    CScript parent_spk = GetScriptForDestination(WitnessV0KeyHash(child_key.GetPubKey()));
1086    CKey grandchild_key{GenerateRandomKey()};
1087    CScript child_spk = GetScriptForDestination(WitnessV0KeyHash(grandchild_key.GetPubKey()));
1088
1089    const CAmount coinbase_value{50 * COIN};
1090    // Test that de-duplication works. This is not actually package rbf.
1091    {
1092        // 1 parent paying 200sat, 1 child paying 300sat
1093        Package package1;
1094        // 1 parent paying 200sat, 1 child paying 500sat
1095        Package package2;
1096        // Package1 and package2 have the same parent. The children conflict.
1097        auto mtx_parent = CreateValidMempoolTransaction(/*input_transaction=*/m_coinbase_txns[0], /*input_vout=*/0,
1098                                                        /*input_height=*/0, /*input_signing_key=*/coinbaseKey,
1099                                                        /*output_destination=*/parent_spk,
1100                                                        /*output_amount=*/coinbase_value - low_fee_amt, /*submit=*/false);
1101        CTransactionRef tx_parent = MakeTransactionRef(mtx_parent);
1102        package1.push_back(tx_parent);
1103        package2.push_back(tx_parent);
1104
1105        CTransactionRef tx_child_1 = MakeTransactionRef(CreateValidMempoolTransaction(tx_parent, 0, 101, child_key, child_spk, coinbase_value - low_fee_amt - 300, false));
1106        package1.push_back(tx_child_1);
1107        CTransactionRef tx_child_2 = MakeTransactionRef(CreateValidMempoolTransaction(tx_parent, 0, 101, child_key, child_spk, coinbase_value - low_fee_amt - 500, false));
1108        package2.push_back(tx_child_2);
1109
1110        LOCK(m_node.mempool->cs);
1111        const auto submit1 = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool, package1, /*test_accept=*/false, std::nullopt);
1112        if (auto err_1{CheckPackageMempoolAcceptResult(package1, submit1, /*expect_valid=*/true, m_node.mempool.get())}) {
1113            BOOST_ERROR(err_1.value());
1114        }
1115
1116        // Check precise ResultTypes and mempool size. We know it_parent_1 and it_child_1 exist from above call
1117        auto it_parent_1 = submit1.m_tx_results.find(tx_parent->GetWitnessHash());
1118        auto it_child_1 = submit1.m_tx_results.find(tx_child_1->GetWitnessHash());
1119        BOOST_CHECK_EQUAL(it_parent_1->second.m_result_type, MempoolAcceptResult::ResultType::VALID);
1120        BOOST_CHECK_EQUAL(it_child_1->second.m_result_type, MempoolAcceptResult::ResultType::VALID);
1121        expected_pool_size += 2;
1122        BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
1123
1124        const auto submit2 = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool, package2, /*test_accept=*/false, std::nullopt);
1125        if (auto err_2{CheckPackageMempoolAcceptResult(package2, submit2, /*expect_valid=*/true, m_node.mempool.get())}) {
1126            BOOST_ERROR(err_2.value());
1127        }
1128
1129        // Check precise ResultTypes and mempool size. We know it_parent_2 and it_child_2 exist from above call
1130        auto it_parent_2 = submit2.m_tx_results.find(tx_parent->GetWitnessHash());
1131        auto it_child_2 = submit2.m_tx_results.find(tx_child_2->GetWitnessHash());
1132        BOOST_CHECK_EQUAL(it_parent_2->second.m_result_type, MempoolAcceptResult::ResultType::MEMPOOL_ENTRY);
1133        BOOST_CHECK_EQUAL(it_child_2->second.m_result_type, MempoolAcceptResult::ResultType::VALID);
1134        BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
1135
1136        // child1 has been replaced
1137        BOOST_CHECK(!m_node.mempool->exists(tx_child_1->GetHash()));
1138    }
1139
1140    // Test package rbf.
1141    {
1142        CTransactionRef tx_parent_1 = MakeTransactionRef(CreateValidMempoolTransaction(
1143            m_coinbase_txns[1], /*input_vout=*/0, /*input_height=*/0,
1144            coinbaseKey, parent_spk, coinbase_value - 200, /*submit=*/false));
1145        CTransactionRef tx_child_1 = MakeTransactionRef(CreateValidMempoolTransaction(
1146            tx_parent_1, /*input_vout=*/0, /*input_height=*/101,
1147            child_key, child_spk, coinbase_value - 400, /*submit=*/false));
1148
1149        CTransactionRef tx_parent_2 = MakeTransactionRef(CreateValidMempoolTransaction(
1150            m_coinbase_txns[1], /*input_vout=*/0, /*input_height=*/0,
1151            coinbaseKey, parent_spk, coinbase_value - 800, /*submit=*/false));
1152        CTransactionRef tx_child_2 = MakeTransactionRef(CreateValidMempoolTransaction(
1153            tx_parent_2, /*input_vout=*/0, /*input_height=*/101,
1154            child_key, child_spk, coinbase_value - 800 - 200, /*submit=*/false));
1155
1156        CTransactionRef tx_parent_3 = MakeTransactionRef(CreateValidMempoolTransaction(
1157            m_coinbase_txns[1], /*input_vout=*/0, /*input_height=*/0,
1158            coinbaseKey, parent_spk, coinbase_value - 199, /*submit=*/false));
1159        CTransactionRef tx_child_3 = MakeTransactionRef(CreateValidMempoolTransaction(
1160            tx_parent_3, /*input_vout=*/0, /*input_height=*/101,
1161            child_key, child_spk, coinbase_value - 199 - 1300, /*submit=*/false));
1162
1163        // In all packages, the parents conflict with each other
1164        BOOST_CHECK(tx_parent_1->GetHash() != tx_parent_2->GetHash());
1165        BOOST_CHECK(tx_parent_2->GetHash() != tx_parent_3->GetHash());
1166
1167        // 1 parent paying 200sat, 1 child paying 200sat.
1168        Package package1{tx_parent_1, tx_child_1};
1169        // 1 parent paying 800sat, 1 child paying 200sat.
1170        Package package2{tx_parent_2, tx_child_2};
1171        // 1 parent paying 199sat, 1 child paying 1300sat.
1172        Package package3{tx_parent_3, tx_child_3};
1173
1174        const auto submit1 = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool, package1, false, std::nullopt);
1175        if (auto err_1{CheckPackageMempoolAcceptResult(package1, submit1, /*expect_valid=*/true, m_node.mempool.get())}) {
1176            BOOST_ERROR(err_1.value());
1177        }
1178        auto it_parent_1 = submit1.m_tx_results.find(tx_parent_1->GetWitnessHash());
1179        auto it_child_1 = submit1.m_tx_results.find(tx_child_1->GetWitnessHash());
1180        BOOST_CHECK_EQUAL(it_parent_1->second.m_result_type, MempoolAcceptResult::ResultType::VALID);
1181        BOOST_CHECK_EQUAL(it_child_1->second.m_result_type, MempoolAcceptResult::ResultType::VALID);
1182        expected_pool_size += 2;
1183        BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
1184
1185        // This replacement is actually not package rbf; the parent carries enough fees
1186        // to replace the entire package on its own.
1187        const auto submit2 = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool, package2, false, std::nullopt);
1188        if (auto err_2{CheckPackageMempoolAcceptResult(package2, submit2, /*expect_valid=*/true, m_node.mempool.get())}) {
1189            BOOST_ERROR(err_2.value());
1190        }
1191        auto it_parent_2 = submit2.m_tx_results.find(tx_parent_2->GetWitnessHash());
1192        auto it_child_2 = submit2.m_tx_results.find(tx_child_2->GetWitnessHash());
1193        BOOST_CHECK_EQUAL(it_parent_2->second.m_result_type, MempoolAcceptResult::ResultType::VALID);
1194        BOOST_CHECK_EQUAL(it_child_2->second.m_result_type, MempoolAcceptResult::ResultType::VALID);
1195        BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
1196
1197        // Package RBF, in which the replacement transaction's child sponsors the fees to meet RBF feerate rules
1198        const auto submit3 = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool, package3, false, std::nullopt);
1199        if (auto err_3{CheckPackageMempoolAcceptResult(package3, submit3, /*expect_valid=*/true, m_node.mempool.get())}) {
1200            BOOST_ERROR(err_3.value());
1201        }
1202        auto it_parent_3 = submit3.m_tx_results.find(tx_parent_3->GetWitnessHash());
1203        auto it_child_3 = submit3.m_tx_results.find(tx_child_3->GetWitnessHash());
1204        BOOST_CHECK_EQUAL(it_parent_3->second.m_result_type, MempoolAcceptResult::ResultType::VALID);
1205        BOOST_CHECK_EQUAL(it_child_3->second.m_result_type, MempoolAcceptResult::ResultType::VALID);
1206
1207        // package3 was considered as a package to replace both package2 transactions
1208        BOOST_CHECK(it_parent_3->second.m_replaced_transactions.size() == 2);
1209        BOOST_CHECK(it_child_3->second.m_replaced_transactions.empty());
1210
1211        std::vector<Wtxid> expected_package3_wtxids({tx_parent_3->GetWitnessHash(), tx_child_3->GetWitnessHash()});
1212        const auto package3_total_vsize{GetVirtualTransactionSize(*tx_parent_3) + GetVirtualTransactionSize(*tx_child_3)};
1213        BOOST_CHECK(it_parent_3->second.m_wtxids_fee_calculations.value() == expected_package3_wtxids);
1214        BOOST_CHECK(it_child_3->second.m_wtxids_fee_calculations.value() == expected_package3_wtxids);
1215        BOOST_CHECK_EQUAL(it_parent_3->second.m_effective_feerate.value().GetFee(package3_total_vsize), 199 + 1300);
1216        BOOST_CHECK_EQUAL(it_child_3->second.m_effective_feerate.value().GetFee(package3_total_vsize), 199 + 1300);
1217
1218        BOOST_CHECK_EQUAL(m_node.mempool->size(), expected_pool_size);
1219
1220        // Finally, check that we can prioritise tx_child_1 to get package1 into the mempool.
1221        // It should not be possible to resubmit package1 and get it in without prioritisation.
1222        const auto submit4 = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool, package1, false, std::nullopt);
1223        if (auto err_4{CheckPackageMempoolAcceptResult(package1, submit4, /*expect_valid=*/false, m_node.mempool.get())}) {
1224            BOOST_ERROR(err_4.value());
1225        }
1226        m_node.mempool->PrioritiseTransaction(tx_child_1->GetHash(), 1363);
1227        const auto submit5 = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool, package1, false, std::nullopt);
1228        if (auto err_5{CheckPackageMempoolAcceptResult(package1, submit5, /*expect_valid=*/true, m_node.mempool.get())}) {
1229            BOOST_ERROR(err_5.value());
1230        }
1231        it_parent_1 = submit5.m_tx_results.find(tx_parent_1->GetWitnessHash());
1232        it_child_1 = submit5.m_tx_results.find(tx_child_1->GetWitnessHash());
1233        BOOST_CHECK_EQUAL(it_parent_1->second.m_result_type, MempoolAcceptResult::ResultType::VALID);
1234        BOOST_CHECK_EQUAL(it_child_1->second.m_result_type, MempoolAcceptResult::ResultType::VALID);
1235        LOCK(m_node.mempool->cs);
1236        BOOST_CHECK(m_node.mempool->GetIter(tx_parent_1->GetHash()).has_value());
1237        BOOST_CHECK(m_node.mempool->GetIter(tx_child_1->GetHash()).has_value());
1238    }
1239}
1240BOOST_AUTO_TEST_SUITE_END()
1241