Inside Bitcoin

251    const CAmount normal_fee{CENT/10};
252
253    // low feerate parent with normal feerate child
254    const auto tx1 = make_tx(/*inputs=*/ {m_coinbase_txns[0], m_coinbase_txns[1]}, /*output_values=*/ {10 * COIN});
255    TryAddToMempool(pool, entry.Fee(low_fee).FromTx(tx1));
256    const auto tx2 = make_tx(/*inputs=*/ {tx1}, /*output_values=*/ {995 * CENT});
257    TryAddToMempool(pool, entry.Fee(normal_fee).FromTx(tx2));
258
259    const auto entry1 = pool.GetIter(tx1->GetHash()).value();
260    const auto tx1_fee = entry1->GetModifiedFee();
261    const auto entry2 = pool.GetIter(tx2->GetHash()).value();
262    const auto tx2_fee = entry2->GetModifiedFee();
263
264    // conflicting transactions
265    const auto tx1_conflict = make_tx(/*inputs=*/ {m_coinbase_txns[0], m_coinbase_txns[2]}, /*output_values=*/ {10 * COIN});
266    const auto tx3 = make_tx(/*inputs=*/ {tx1_conflict}, /*output_values=*/ {995 * CENT});
267    auto entry3 = entry.FromTx(tx3);
268
269    // Now test ImprovesFeerateDiagram with various levels of "package rbf" feerates
270
271    // It doesn't improve itself
272    auto changeset = pool.GetChangeSet();
273    changeset->StageRemoval(entry1);
274    changeset->StageRemoval(entry2);
275    changeset->StageAddition(tx1_conflict, tx1_fee, 0, 1, 0, false, 4, LockPoints());
276    changeset->StageAddition(tx3, tx2_fee, 0, 1, 0, false, 4, LockPoints());
277    const auto res1 = ImprovesFeerateDiagram(*changeset);
278    BOOST_CHECK(res1.has_value());
279    BOOST_CHECK(res1.value().first == DiagramCheckError::FAILURE);
280    BOOST_CHECK(res1.value().second == "insufficient feerate: does not improve feerate diagram");
281
282    // With one more satoshi it does
283    changeset.reset();
284    changeset = pool.GetChangeSet();
285    changeset->StageRemoval(entry1);
286    changeset->StageRemoval(entry2);
287    changeset->StageAddition(tx1_conflict, tx1_fee+1, 0, 1, 0, false, 4, LockPoints());
288    changeset->StageAddition(tx3, tx2_fee, 0, 1, 0, false, 4, LockPoints());
289    BOOST_CHECK(ImprovesFeerateDiagram(*changeset) == std::nullopt);
290
291    changeset.reset();
292    // With prioritisation of in-mempool conflicts, it affects the results of the comparison using the same args as just above
293    pool.PrioritiseTransaction(entry1->GetSharedTx()->GetHash(), /*nFeeDelta=*/1);
294    changeset = pool.GetChangeSet();
295    changeset->StageRemoval(entry1);
296    changeset->StageRemoval(entry2);
297    changeset->StageAddition(tx1_conflict, tx1_fee+1, 0, 1, 0, false, 4, LockPoints());
298    changeset->StageAddition(tx3, tx2_fee, 0, 1, 0, false, 4, LockPoints());
299    const auto res2 = ImprovesFeerateDiagram(*changeset);
300    BOOST_CHECK(res2.has_value());
301    BOOST_CHECK(res2.value().first == DiagramCheckError::FAILURE);
302    BOOST_CHECK(res2.value().second == "insufficient feerate: does not improve feerate diagram");
303    changeset.reset();
304
305    pool.PrioritiseTransaction(entry1->GetSharedTx()->GetHash(), /*nFeeDelta=*/-1);
306
307    // With fewer vbytes it does
308    CMutableTransaction tx4{entry3.GetTx()};
309    tx4.vin[0].scriptWitness = CScriptWitness(); // Clear out the witness, to reduce size
310    auto entry4 = entry.FromTx(MakeTransactionRef(tx4));
311    changeset = pool.GetChangeSet();
312    changeset->StageRemoval(entry1);
313    changeset->StageRemoval(entry2);
314    changeset->StageAddition(tx1_conflict, tx1_fee, 0, 1, 0, false, 4, LockPoints());
315    changeset->StageAddition(entry4.GetSharedTx(), tx2_fee, 0, 1, 0, false, 4, LockPoints());
316    BOOST_CHECK(ImprovesFeerateDiagram(*changeset) == std::nullopt);
317    changeset.reset();
318
319    // Adding a grandchild makes the cluster size 3, which is also calculable
320    const auto tx5 = make_tx(/*inputs=*/ {tx2}, /*output_values=*/ {995 * CENT});
321    TryAddToMempool(pool, entry.Fee(normal_fee).FromTx(tx5));
322    const auto entry5 = pool.GetIter(tx5->GetHash()).value();
323
324    changeset = pool.GetChangeSet();
325    changeset->StageRemoval(entry1);
326    changeset->StageRemoval(entry2);
327    changeset->StageRemoval(entry5);
328    changeset->StageAddition(tx1_conflict, tx1_fee, 0, 1, 0, false, 4, LockPoints());
329    changeset->StageAddition(entry4.GetSharedTx(), tx2_fee + entry5->GetModifiedFee() + 1, 0, 1, 0, false, 4, LockPoints());
330    const auto res3 = ImprovesFeerateDiagram(*changeset);
331    BOOST_CHECK(res3 == std::nullopt);
332}
333
334BOOST_FIXTURE_TEST_CASE(calc_feerate_diagram_rbf, TestChain100Setup)
335{
336    CTxMemPool& pool = *Assert(m_node.mempool);
337    LOCK2(::cs_main, pool.cs);
338    TestMemPoolEntryHelper entry;
339
340    const CAmount low_fee{CENT/100};
341    const CAmount high_fee{CENT};
342
343    // low -> high -> medium fee transactions that would result in two chunks together since they
344    // are all same size
345    const auto low_tx = make_tx(/*inputs=*/ {m_coinbase_txns[0]}, /*output_values=*/ {10 * COIN});
346    TryAddToMempool(pool, entry.Fee(low_fee).FromTx(low_tx));
347
348    const auto entry_low = pool.GetIter(low_tx->GetHash()).value();
349    const auto low_size = entry_low->GetAdjustedWeight();
350
351    const auto replacement_tx = make_tx(/*inputs=*/ {m_coinbase_txns[0]}, /*output_values=*/ {9 * COIN});
352    auto entry_replacement = entry.FromTx(replacement_tx);
353
354    // Replacement of size 1
355    {
356        auto changeset = pool.GetChangeSet();
357        changeset->StageRemoval(entry_low);
358        changeset->StageAddition(replacement_tx, 0, 0, 1, 0, false, 4, LockPoints());
359        const auto replace_one{changeset->CalculateChunksForRBF()};
360        BOOST_CHECK(replace_one.has_value());
361        std::vector<FeeFrac> expected_old_chunks{{low_fee, low_size}};
362        BOOST_CHECK(replace_one->first == expected_old_chunks);
363        std::vector<FeeFrac> expected_new_chunks{{0, entry_replacement.GetAdjustedWeight()}};
364        BOOST_CHECK(replace_one->second == expected_new_chunks);
365    }
366
367    // Non-zero replacement fee/size
368    {
369        auto changeset = pool.GetChangeSet();
370        changeset->StageRemoval(entry_low);
371        changeset->StageAddition(replacement_tx, high_fee, 0, 1, 0, false, 4, LockPoints());
372        const auto replace_one_fee{changeset->CalculateChunksForRBF()};
373        BOOST_CHECK(replace_one_fee.has_value());
374        std::vector<FeeFrac> expected_old_diagram{{low_fee, low_size}};
375        BOOST_CHECK(replace_one_fee->first == expected_old_diagram);
376        std::vector<FeeFrac> expected_new_diagram{{high_fee, entry_replacement.GetAdjustedWeight()}};
377        BOOST_CHECK(replace_one_fee->second == expected_new_diagram);
378    }
379
380    // Add a second transaction to the cluster that will make a single chunk, to be evicted in the RBF
381    const auto high_tx = make_tx(/*inputs=*/ {low_tx}, /*output_values=*/ {995 * CENT});
382    TryAddToMempool(pool, entry.Fee(high_fee).FromTx(high_tx));
383    const auto entry_high = pool.GetIter(high_tx->GetHash()).value();
384    const auto high_size = entry_high->GetAdjustedWeight();
385
386    {
387        auto changeset = pool.GetChangeSet();
388        changeset->StageRemoval(entry_low);
389        changeset->StageRemoval(entry_high);
390        changeset->StageAddition(replacement_tx, high_fee, 0, 1, 0, false, 4, LockPoints());
391        const auto replace_single_chunk{changeset->CalculateChunksForRBF()};
392        BOOST_CHECK(replace_single_chunk.has_value());
393        std::vector<FeeFrac> expected_old_chunks{{low_fee + high_fee, low_size + high_size}};
394        BOOST_CHECK(replace_single_chunk->first == expected_old_chunks);
395        std::vector<FeeFrac> expected_new_chunks{{high_fee, entry_replacement.GetAdjustedWeight()}};
396        BOOST_CHECK(replace_single_chunk->second == expected_new_chunks);
397    }
398
399    // Conflict with the 2nd tx, resulting in new diagram with three entries
400    {
401        auto changeset = pool.GetChangeSet();
402        changeset->StageRemoval(entry_high);
403        changeset->StageAddition(replacement_tx, high_fee, 0, 1, 0, false, 4, LockPoints());
404        const auto replace_cpfp_child{changeset->CalculateChunksForRBF()};
405        BOOST_CHECK(replace_cpfp_child.has_value());
406        std::vector<FeeFrac> expected_old_chunks{{low_fee + high_fee, low_size + high_size}};
407        BOOST_CHECK(replace_cpfp_child->first == expected_old_chunks);
408        std::vector<FeeFrac> expected_new_chunks{{high_fee, entry_replacement.GetAdjustedWeight()}, {low_fee, low_size}};
409        BOOST_CHECK(replace_cpfp_child->second == expected_new_chunks);
410    }
411
412    // Make a size 2 cluster that is itself two chunks; evict both txns
413    const auto high_tx_2 = make_tx(/*inputs=*/ {m_coinbase_txns[1]}, /*output_values=*/ {10 * COIN});
414    TryAddToMempool(pool, entry.Fee(high_fee).FromTx(high_tx_2));
415    const auto entry_high_2 = pool.GetIter(high_tx_2->GetHash()).value();
416    const auto high_size_2 = entry_high_2->GetAdjustedWeight();
417
418    const auto low_tx_2 = make_tx(/*inputs=*/ {high_tx_2}, /*output_values=*/ {9 * COIN});
419    TryAddToMempool(pool, entry.Fee(low_fee).FromTx(low_tx_2));
420    const auto entry_low_2 = pool.GetIter(low_tx_2->GetHash()).value();
421    const auto low_size_2 = entry_low_2->GetAdjustedWeight();
422
423    {
424        auto changeset = pool.GetChangeSet();
425        changeset->StageRemoval(entry_high_2);
426        changeset->StageRemoval(entry_low_2);
427        changeset->StageAddition(replacement_tx, high_fee, 0, 1, 0, false, 4, LockPoints());
428        const auto replace_two_chunks_single_cluster{changeset->CalculateChunksForRBF()};
429        BOOST_CHECK(replace_two_chunks_single_cluster.has_value());
430        std::vector<FeeFrac> expected_old_chunks{{high_fee, high_size_2}, {low_fee, low_size_2}};
431        BOOST_CHECK(replace_two_chunks_single_cluster->first == expected_old_chunks);
432        std::vector<FeeFrac> expected_new_chunks{{high_fee, low_size_2}};
433        BOOST_CHECK(replace_two_chunks_single_cluster->second == expected_new_chunks);
434    }
435
436    // You can have more than two direct conflicts
437    const auto conflict_1 = make_tx(/*inputs=*/ {m_coinbase_txns[2]}, /*output_values=*/ {10 * COIN});
438    TryAddToMempool(pool, entry.Fee(low_fee).FromTx(conflict_1));
439    const auto conflict_1_entry = pool.GetIter(conflict_1->GetHash()).value();
440
441    const auto conflict_2 = make_tx(/*inputs=*/ {m_coinbase_txns[3]}, /*output_values=*/ {10 * COIN});
442    TryAddToMempool(pool, entry.Fee(low_fee).FromTx(conflict_2));
443    const auto conflict_2_entry = pool.GetIter(conflict_2->GetHash()).value();
444
445    const auto conflict_3 = make_tx(/*inputs=*/ {m_coinbase_txns[4]}, /*output_values=*/ {10 * COIN});
446    TryAddToMempool(pool, entry.Fee(low_fee).FromTx(conflict_3));
447    const auto conflict_3_entry = pool.GetIter(conflict_3->GetHash()).value();
448
449    {
450        auto changeset = pool.GetChangeSet();
451        changeset->StageRemoval(conflict_1_entry);
452        changeset->StageRemoval(conflict_2_entry);
453        changeset->StageRemoval(conflict_3_entry);
454        changeset->StageAddition(replacement_tx, high_fee, 0, 1, 0, false, 4, LockPoints());
455        const auto replace_multiple_clusters{changeset->CalculateChunksForRBF()};
456        BOOST_CHECK(replace_multiple_clusters.has_value());
457        BOOST_CHECK(replace_multiple_clusters->first.size() == 3);
458        BOOST_CHECK(replace_multiple_clusters->second.size() == 1);
459    }
460
461    // Add a child transaction to conflict_1 and make it cluster size 2, two chunks due to same feerate
462    const auto conflict_1_child = make_tx(/*inputs=*/{conflict_1}, /*output_values=*/ {995 * CENT});
463    TryAddToMempool(pool, entry.Fee(low_fee).FromTx(conflict_1_child));
464    const auto conflict_1_child_entry = pool.GetIter(conflict_1_child->GetHash()).value();
465
466    {
467        auto changeset = pool.GetChangeSet();
468        changeset->StageRemoval(conflict_1_entry);
469        changeset->StageRemoval(conflict_2_entry);
470        changeset->StageRemoval(conflict_3_entry);
471        changeset->StageRemoval(conflict_1_child_entry);
472        changeset->StageAddition(replacement_tx, high_fee, 0, 1, 0, false, 4, LockPoints());
473        const auto replace_multiple_clusters_2{changeset->CalculateChunksForRBF()};
474
475        BOOST_CHECK(replace_multiple_clusters_2.has_value());
476        BOOST_CHECK(replace_multiple_clusters_2->first.size() == 4);
477        BOOST_CHECK(replace_multiple_clusters_2->second.size() == 1);
478    }
479}
480
481BOOST_AUTO_TEST_CASE(feerate_chunks_utilities)
482{
483    // Sanity check the correctness of the feerate chunks comparison.
484
485    // A strictly better case.
486    std::vector<FeeFrac> old_chunks{{{950, 300}, {100, 100}}};
487    std::vector<FeeFrac> new_chunks{{{1000, 300}, {50, 100}}};
488
489    BOOST_CHECK(std::is_lt(CompareChunks(old_chunks, new_chunks)));
490    BOOST_CHECK(std::is_gt(CompareChunks(new_chunks, old_chunks)));
491
492    // Incomparable diagrams
493    old_chunks = {{950, 300}, {100, 100}};
494    new_chunks = {{1000, 300}, {0, 100}};
495
496    BOOST_CHECK(CompareChunks(old_chunks, new_chunks) == std::partial_ordering::unordered);
497    BOOST_CHECK(CompareChunks(new_chunks, old_chunks) == std::partial_ordering::unordered);
498
499    // Strictly better but smaller size.
500    old_chunks = {{950, 300}, {100, 100}};