test/rbf_tests.cpp \

#include <policy/policy.h>

#include <policy/rbf.h>

#include <random.h>

#include <txmempool.h>

#include <util/system.h>

#include <util/time.h>

#include <test/util/setup_common.h>

#include <boost/test/unit_test.hpp>

#include <optional>

#include <vector>

BOOST_FIXTURE_TEST_SUITE(rbf_tests, TestingSetup)

inline CTransactionRef make_tx(const std::vector<CAmount>& output_values,

const std::vector<CTransactionRef>& inputs)

{

CMutableTransaction tx = CMutableTransaction();

tx.vin.resize(inputs.size());

tx.vout.resize(output_values.size());

for (size_t i = 0; i < inputs.size(); ++i) {

tx.vin[i].prevout.hash = inputs[i]->GetHash();

tx.vin[i].prevout.n = 0;

// Add a witness so wtxid != txid

CScriptWitness witness;

witness.stack.push_back(std::vector<unsigned char>(i + 10));

tx.vin[i].scriptWitness = witness;

}

for (size_t i = 0; i < output_values.size(); ++i) {

tx.vout[i].scriptPubKey = CScript() << OP_11 << OP_EQUAL;

tx.vout[i].nValue = output_values[i];

}

return MakeTransactionRef(tx);

}

void add_descendants(const CTransactionRef& tx, CTxMemPool& pool, int32_t num_descendants)

EXCLUSIVE_LOCKS_REQUIRED(cs_main, pool.cs)

{

AssertLockHeld(cs_main);

AssertLockHeld(pool.cs);

TestMemPoolEntryHelper entry;

// Assumes this isn't already spent in mempool

auto tx_to_spend = tx;

for (int32_t i{0}; i < num_descendants; ++i) {

auto next_tx = make_tx(/*output_values=*/ {(50 - i) * CENT}, /*inputs=*/ {tx_to_spend});

pool.addUnchecked(entry.FromTx(next_tx));

tx_to_spend = next_tx;

}

}

BOOST_FIXTURE_TEST_CASE(rbf_helper_functions, TestChain100Setup)

{

CTxMemPool& pool = *Assert(m_node.mempool);

LOCK2(cs_main, pool.cs);

TestMemPoolEntryHelper entry;

const CAmount low_fee{100};

const CAmount normal_fee{10000};

const CAmount high_fee{1 * COIN};

// Create a parent tx1 and child tx2 with normal fees:

CTransactionRef tx1 = make_tx(/*output_values=*/ {10 * COIN}, /*inputs=*/ {m_coinbase_txns[0]});

pool.addUnchecked(entry.Fee(normal_fee).FromTx(tx1));

CTransactionRef tx2 = make_tx(/*output_values=*/ {995 * CENT}, /*inputs=*/ {tx1});

pool.addUnchecked(entry.Fee(normal_fee).FromTx(tx2));

// Create a low-feerate parent tx3 and high-feerate child tx4 (cpfp)

CTransactionRef tx3 = make_tx(/*output_values=*/ {1099 * CENT}, /*inputs=*/ {m_coinbase_txns[1]});

pool.addUnchecked(entry.Fee(low_fee).FromTx(tx3));

CTransactionRef tx4 = make_tx(/*output_values=*/ {999 * CENT}, /*inputs=*/ {tx3});

pool.addUnchecked(entry.Fee(high_fee).FromTx(tx4));

// Create a parent tx5 and child tx6 where both have very low fees

CTransactionRef tx5 = make_tx(/*output_values=*/ {1099 * CENT}, /*inputs=*/ {m_coinbase_txns[2]});

pool.addUnchecked(entry.Fee(low_fee).FromTx(tx5));

CTransactionRef tx6 = make_tx(/*output_values=*/ {1098 * CENT}, /*inputs=*/ {tx3});

pool.addUnchecked(entry.Fee(low_fee).FromTx(tx6));

// Make tx6's modified fee much higher than its base fee. This should cause it to pass

// the fee-related checks despite being low-feerate.

pool.PrioritiseTransaction(tx6->GetHash(), 1 * COIN);

// Two independent high-feerate transactions, tx7 and tx8

CTransactionRef tx7 = make_tx(/*output_values=*/ {999 * CENT}, /*inputs=*/ {m_coinbase_txns[3]});

pool.addUnchecked(entry.Fee(high_fee).FromTx(tx7));

CTransactionRef tx8 = make_tx(/*output_values=*/ {999 * CENT}, /*inputs=*/ {m_coinbase_txns[4]});

pool.addUnchecked(entry.Fee(high_fee).FromTx(tx8));

const auto entry1 = pool.GetIter(tx1->GetHash()).value();

const auto entry2 = pool.GetIter(tx2->GetHash()).value();

const auto entry3 = pool.GetIter(tx3->GetHash()).value();

const auto entry4 = pool.GetIter(tx4->GetHash()).value();

const auto entry5 = pool.GetIter(tx5->GetHash()).value();

const auto entry6 = pool.GetIter(tx6->GetHash()).value();

const auto entry7 = pool.GetIter(tx7->GetHash()).value();

const auto entry8 = pool.GetIter(tx8->GetHash()).value();

BOOST_CHECK_EQUAL(entry1->GetFee(), normal_fee);

BOOST_CHECK_EQUAL(entry2->GetFee(), normal_fee);

BOOST_CHECK_EQUAL(entry3->GetFee(), low_fee);

BOOST_CHECK_EQUAL(entry4->GetFee(), high_fee);

BOOST_CHECK_EQUAL(entry5->GetFee(), low_fee);

BOOST_CHECK_EQUAL(entry6->GetFee(), low_fee);

BOOST_CHECK_EQUAL(entry7->GetFee(), high_fee);

BOOST_CHECK_EQUAL(entry8->GetFee(), high_fee);

CTxMemPool::setEntries set_12_normal{entry1, entry2};

CTxMemPool::setEntries set_34_cpfp{entry3, entry4};

CTxMemPool::setEntries set_56_low{entry5, entry6};

CTxMemPool::setEntries all_entries{entry1, entry2, entry3, entry4, entry5, entry6, entry7, entry8};

CTxMemPool::setEntries empty_set;

const auto unused_txid{GetRandHash()};

// Tests for PaysMoreThanConflicts

// These tests use feerate, not absolute fee.

BOOST_CHECK(PaysMoreThanConflicts(/*iters_conflicting=*/set_12_normal,

/*replacement_feerate=*/CFeeRate(entry1->GetModifiedFee() + 1, entry1->GetTxSize() + 2),

/*txid=*/unused_txid).has_value());

// Replacement must be strictly greater than the originals.

BOOST_CHECK(PaysMoreThanConflicts(set_12_normal, CFeeRate(entry1->GetModifiedFee(), entry1->GetTxSize()), unused_txid).has_value());

BOOST_CHECK(PaysMoreThanConflicts(set_12_normal, CFeeRate(entry1->GetModifiedFee() + 1, entry1->GetTxSize()), unused_txid) == std::nullopt);

// These tests use modified fees (including prioritisation), not base fees.

BOOST_CHECK(PaysMoreThanConflicts({entry5}, CFeeRate(entry5->GetModifiedFee() + 1, entry5->GetTxSize()), unused_txid) == std::nullopt);

BOOST_CHECK(PaysMoreThanConflicts({entry6}, CFeeRate(entry6->GetFee() + 1, entry6->GetTxSize()), unused_txid).has_value());

BOOST_CHECK(PaysMoreThanConflicts({entry6}, CFeeRate(entry6->GetModifiedFee() + 1, entry6->GetTxSize()), unused_txid) == std::nullopt);

// These tests only check individual feerate. Ancestor feerate does not matter.

BOOST_CHECK(PaysMoreThanConflicts(set_34_cpfp, CFeeRate(entry4->GetModifiedFee(), entry4->GetTxSize()), unused_txid).has_value());

// Tests for EntriesAndTxidsDisjoint

BOOST_CHECK(EntriesAndTxidsDisjoint(empty_set, {tx1->GetHash()}, unused_txid) == std::nullopt);

BOOST_CHECK(EntriesAndTxidsDisjoint(set_12_normal, {tx3->GetHash()}, unused_txid) == std::nullopt);

// EntriesAndTxidsDisjoint uses txids, not wtxids.

BOOST_CHECK(EntriesAndTxidsDisjoint({entry2}, {tx2->GetWitnessHash()}, unused_txid) == std::nullopt);

BOOST_CHECK(EntriesAndTxidsDisjoint({entry2}, {tx2->GetHash()}, unused_txid).has_value());

// If entry2 is an ancestor of a tx, that tx cannot replace entry1. However,

// EntriesAndTxidsDisjoint uses the ancestors directly. It does not calculate descendants.

BOOST_CHECK(EntriesAndTxidsDisjoint(set_12_normal, {tx1->GetHash()}, unused_txid).has_value());

BOOST_CHECK(EntriesAndTxidsDisjoint(set_12_normal, {tx2->GetHash()}, unused_txid).has_value());

BOOST_CHECK(EntriesAndTxidsDisjoint({entry2}, {tx1->GetHash()}, unused_txid) == std::nullopt);

// Tests for PaysForRBF

const auto incremental_relay_feerate{CFeeRate(DEFAULT_INCREMENTAL_RELAY_FEE)};

const auto higher_relay_feerate{CFeeRate(2 * DEFAULT_INCREMENTAL_RELAY_FEE)};

// Must pay at least as much as the original.

BOOST_CHECK(PaysForRBF(/*original_fees=*/high_fee,

/*replacement_fees=*/high_fee,

/*replacement_vsize=*/1,

/*relay_fee=*/CFeeRate(0),

/*txid=*/unused_txid)

== std::nullopt);

BOOST_CHECK(PaysForRBF(high_fee, high_fee - 1, 1, CFeeRate(0), unused_txid).has_value());

BOOST_CHECK(PaysForRBF(high_fee + 1, high_fee, 1, CFeeRate(0), unused_txid).has_value());

// Additional fees must cover the replacement's vsize at incremental relay fee

BOOST_CHECK(PaysForRBF(high_fee, high_fee + 1, 2, incremental_relay_feerate, unused_txid).has_value());

BOOST_CHECK(PaysForRBF(high_fee, high_fee + 2, 2, incremental_relay_feerate, unused_txid) == std::nullopt);

BOOST_CHECK(PaysForRBF(high_fee, high_fee + 2, 2, higher_relay_feerate, unused_txid).has_value());

BOOST_CHECK(PaysForRBF(high_fee, high_fee + 4, 2, higher_relay_feerate, unused_txid) == std::nullopt);

BOOST_CHECK(PaysForRBF(low_fee, high_fee, 99999999, incremental_relay_feerate, unused_txid).has_value());

// Tests for GetEntriesForConflicts

CTxMemPool::setEntries all_parents{entry1, entry3, entry5, entry7, entry8};

CTxMemPool::setEntries all_children{entry2, entry4, entry6};

std::vector<CTransactionRef> parent_inputs({m_coinbase_txns[0], m_coinbase_txns[1], m_coinbase_txns[2],

m_coinbase_txns[3], m_coinbase_txns[4]});

CTransactionRef conflicts_with_parents = make_tx({50 * CENT}, parent_inputs);

CTxMemPool::setEntries all_conflicts;

BOOST_CHECK(GetEntriesForConflicts(/*tx=*/ *conflicts_with_parents.get(),

/*pool=*/ pool,

/*iters_conflicting=*/ all_parents,

/*all_conflicts=*/ all_conflicts) == std::nullopt);

BOOST_CHECK(all_conflicts == all_entries);

auto conflicts_size = all_conflicts.size();

all_conflicts.clear();

add_descendants(tx2, pool, 23);

BOOST_CHECK(GetEntriesForConflicts(*conflicts_with_parents.get(), pool, all_parents, all_conflicts) == std::nullopt);

conflicts_size += 23;

BOOST_CHECK_EQUAL(all_conflicts.size(), conflicts_size);

all_conflicts.clear();

add_descendants(tx4, pool, 23);

BOOST_CHECK(GetEntriesForConflicts(*conflicts_with_parents.get(), pool, all_parents, all_conflicts) == std::nullopt);

conflicts_size += 23;

BOOST_CHECK_EQUAL(all_conflicts.size(), conflicts_size);

all_conflicts.clear();

add_descendants(tx6, pool, 23);

BOOST_CHECK(GetEntriesForConflicts(*conflicts_with_parents.get(), pool, all_parents, all_conflicts) == std::nullopt);

conflicts_size += 23;

BOOST_CHECK_EQUAL(all_conflicts.size(), conflicts_size);

all_conflicts.clear();

add_descendants(tx7, pool, 23);

BOOST_CHECK(GetEntriesForConflicts(*conflicts_with_parents.get(), pool, all_parents, all_conflicts) == std::nullopt);

conflicts_size += 23;

BOOST_CHECK_EQUAL(all_conflicts.size(), conflicts_size);

BOOST_CHECK_EQUAL(all_conflicts.size(), 100);

all_conflicts.clear();

// Exceeds maximum number of conflicts.

add_descendants(tx8, pool, 1);

BOOST_CHECK(GetEntriesForConflicts(*conflicts_with_parents.get(), pool, all_parents, all_conflicts).has_value());

// Tests for HasNoNewUnconfirmed

CTransactionRef spends_unconfirmed = make_tx({36 * CENT}, {tx1});

for (const auto& input : spends_unconfirmed->vin) {

// Spends unconfirmed inputs.

BOOST_CHECK(pool.exists(GenTxid::Txid(input.prevout.hash)));

}

BOOST_CHECK(HasNoNewUnconfirmed(/*tx=*/ *spends_unconfirmed.get(),

/*pool=*/ pool,

/*iters_conflicting=*/ all_entries) == std::nullopt);

BOOST_CHECK(HasNoNewUnconfirmed(*spends_unconfirmed.get(), pool, {entry2}) == std::nullopt);

BOOST_CHECK(HasNoNewUnconfirmed(*spends_unconfirmed.get(), pool, empty_set).has_value());

CTransactionRef spends_new_unconfirmed = make_tx({36 * CENT}, {tx1, tx8});

BOOST_CHECK(HasNoNewUnconfirmed(*spends_new_unconfirmed.get(), pool, {entry2}).has_value());

BOOST_CHECK(HasNoNewUnconfirmed(*spends_new_unconfirmed.get(), pool, all_entries).has_value());

}

BOOST_AUTO_TEST_SUITE_END()