Bitcoin Core  26.99.0
P2P Digital Currency
rbf.cpp
Go to the documentation of this file.
1 // Copyright (c) 2016-2022 The Bitcoin Core developers
2 // Distributed under the MIT software license, see the accompanying
3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 
5 #include <policy/rbf.h>
6 
7 #include <consensus/amount.h>
8 #include <kernel/mempool_entry.h>
9 #include <policy/feerate.h>
10 #include <primitives/transaction.h>
11 #include <sync.h>
12 #include <tinyformat.h>
13 #include <txmempool.h>
14 #include <uint256.h>
15 #include <util/check.h>
16 #include <util/moneystr.h>
17 #include <util/rbf.h>
18 
19 #include <limits>
20 #include <vector>
21 
23 {
24  AssertLockHeld(pool.cs);
25 
26  // First check the transaction itself.
27  if (SignalsOptInRBF(tx)) {
29  }
30 
31  // If this transaction is not in our mempool, then we can't be sure
32  // we will know about all its inputs.
33  if (!pool.exists(GenTxid::Txid(tx.GetHash()))) {
35  }
36 
37  // If all the inputs have nSequence >= maxint-1, it still might be
38  // signaled for RBF if any unconfirmed parents have signaled.
39  const auto& entry{*Assert(pool.GetEntry(tx.GetHash()))};
40  auto ancestors{pool.AssumeCalculateMemPoolAncestors(__func__, entry, CTxMemPool::Limits::NoLimits(),
41  /*fSearchForParents=*/false)};
42 
43  for (CTxMemPool::txiter it : ancestors) {
44  if (SignalsOptInRBF(it->GetTx())) {
46  }
47  }
49 }
50 
52 {
53  // If we don't have a local mempool we can only check the transaction itself.
55 }
56 
57 std::optional<std::string> GetEntriesForConflicts(const CTransaction& tx,
58  CTxMemPool& pool,
59  const CTxMemPool::setEntries& iters_conflicting,
60  CTxMemPool::setEntries& all_conflicts)
61 {
62  AssertLockHeld(pool.cs);
63  const uint256 txid = tx.GetHash();
64  uint64_t nConflictingCount = 0;
65  for (const auto& mi : iters_conflicting) {
66  nConflictingCount += mi->GetCountWithDescendants();
67  // Rule #5: don't consider replacing more than MAX_REPLACEMENT_CANDIDATES
68  // entries from the mempool. This potentially overestimates the number of actual
69  // descendants (i.e. if multiple conflicts share a descendant, it will be counted multiple
70  // times), but we just want to be conservative to avoid doing too much work.
71  if (nConflictingCount > MAX_REPLACEMENT_CANDIDATES) {
72  return strprintf("rejecting replacement %s; too many potential replacements (%d > %d)\n",
73  txid.ToString(),
74  nConflictingCount,
76  }
77  }
78  // Calculate the set of all transactions that would have to be evicted.
79  for (CTxMemPool::txiter it : iters_conflicting) {
80  pool.CalculateDescendants(it, all_conflicts);
81  }
82  return std::nullopt;
83 }
84 
85 std::optional<std::string> HasNoNewUnconfirmed(const CTransaction& tx,
86  const CTxMemPool& pool,
87  const CTxMemPool::setEntries& iters_conflicting)
88 {
89  AssertLockHeld(pool.cs);
90  std::set<uint256> parents_of_conflicts;
91  for (const auto& mi : iters_conflicting) {
92  for (const CTxIn& txin : mi->GetTx().vin) {
93  parents_of_conflicts.insert(txin.prevout.hash);
94  }
95  }
96 
97  for (unsigned int j = 0; j < tx.vin.size(); j++) {
98  // Rule #2: We don't want to accept replacements that require low feerate junk to be
99  // mined first. Ideally we'd keep track of the ancestor feerates and make the decision
100  // based on that, but for now requiring all new inputs to be confirmed works.
101  //
102  // Note that if you relax this to make RBF a little more useful, this may break the
103  // CalculateMempoolAncestors RBF relaxation which subtracts the conflict count/size from the
104  // descendant limit.
105  if (!parents_of_conflicts.count(tx.vin[j].prevout.hash)) {
106  // Rather than check the UTXO set - potentially expensive - it's cheaper to just check
107  // if the new input refers to a tx that's in the mempool.
108  if (pool.exists(GenTxid::Txid(tx.vin[j].prevout.hash))) {
109  return strprintf("replacement %s adds unconfirmed input, idx %d",
110  tx.GetHash().ToString(), j);
111  }
112  }
113  }
114  return std::nullopt;
115 }
116 
117 std::optional<std::string> EntriesAndTxidsDisjoint(const CTxMemPool::setEntries& ancestors,
118  const std::set<Txid>& direct_conflicts,
119  const uint256& txid)
120 {
121  for (CTxMemPool::txiter ancestorIt : ancestors) {
122  const Txid& hashAncestor = ancestorIt->GetTx().GetHash();
123  if (direct_conflicts.count(hashAncestor)) {
124  return strprintf("%s spends conflicting transaction %s",
125  txid.ToString(),
126  hashAncestor.ToString());
127  }
128  }
129  return std::nullopt;
130 }
131 
132 std::optional<std::string> PaysMoreThanConflicts(const CTxMemPool::setEntries& iters_conflicting,
133  CFeeRate replacement_feerate,
134  const uint256& txid)
135 {
136  for (const auto& mi : iters_conflicting) {
137  // Don't allow the replacement to reduce the feerate of the mempool.
138  //
139  // We usually don't want to accept replacements with lower feerates than what they replaced
140  // as that would lower the feerate of the next block. Requiring that the feerate always be
141  // increased is also an easy-to-reason about way to prevent DoS attacks via replacements.
142  //
143  // We only consider the feerates of transactions being directly replaced, not their indirect
144  // descendants. While that does mean high feerate children are ignored when deciding whether
145  // or not to replace, we do require the replacement to pay more overall fees too, mitigating
146  // most cases.
147  CFeeRate original_feerate(mi->GetModifiedFee(), mi->GetTxSize());
148  if (replacement_feerate <= original_feerate) {
149  return strprintf("rejecting replacement %s; new feerate %s <= old feerate %s",
150  txid.ToString(),
151  replacement_feerate.ToString(),
152  original_feerate.ToString());
153  }
154  }
155  return std::nullopt;
156 }
157 
158 std::optional<std::string> PaysForRBF(CAmount original_fees,
159  CAmount replacement_fees,
160  size_t replacement_vsize,
161  CFeeRate relay_fee,
162  const uint256& txid)
163 {
164  // Rule #3: The replacement fees must be greater than or equal to fees of the
165  // transactions it replaces, otherwise the bandwidth used by those conflicting transactions
166  // would not be paid for.
167  if (replacement_fees < original_fees) {
168  return strprintf("rejecting replacement %s, less fees than conflicting txs; %s < %s",
169  txid.ToString(), FormatMoney(replacement_fees), FormatMoney(original_fees));
170  }
171 
172  // Rule #4: The new transaction must pay for its own bandwidth. Otherwise, we have a DoS
173  // vector where attackers can cause a transaction to be replaced (and relayed) repeatedly by
174  // increasing the fee by tiny amounts.
175  CAmount additional_fees = replacement_fees - original_fees;
176  if (additional_fees < relay_fee.GetFee(replacement_vsize)) {
177  return strprintf("rejecting replacement %s, not enough additional fees to relay; %s < %s",
178  txid.ToString(),
179  FormatMoney(additional_fees),
180  FormatMoney(relay_fee.GetFee(replacement_vsize)));
181  }
182  return std::nullopt;
183 }
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:12
#define Assert(val)
Identity function.
Definition: check.h:77
Fee rate in satoshis per kilovirtualbyte: CAmount / kvB.
Definition: feerate.h:33
std::string ToString(const FeeEstimateMode &fee_estimate_mode=FeeEstimateMode::BTC_KVB) const
Definition: feerate.cpp:39
CAmount GetFee(uint32_t num_bytes) const
Return the fee in satoshis for the given vsize in vbytes.
Definition: feerate.cpp:23
The basic transaction that is broadcasted on the network and contained in blocks.
Definition: transaction.h:296
const Txid & GetHash() const LIFETIMEBOUND
Definition: transaction.h:343
const std::vector< CTxIn > vin
Definition: transaction.h:306
An input of a transaction.
Definition: transaction.h:67
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
Definition: txmempool.h:300
setEntries AssumeCalculateMemPoolAncestors(std::string_view calling_fn_name, const CTxMemPoolEntry &entry, const Limits &limits, bool fSearchForParents=true) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Same as CalculateMemPoolAncestors, but always returns a (non-optional) setEntries.
Definition: txmempool.cpp:269
RecursiveMutex cs
This mutex needs to be locked when accessing mapTx or other members that are guarded by it.
Definition: txmempool.h:388
std::set< txiter, CompareIteratorByHash > setEntries
Definition: txmempool.h:394
indexed_transaction_set::nth_index< 0 >::type::const_iterator txiter
Definition: txmempool.h:391
bool exists(const GenTxid &gtxid) const
Definition: txmempool.h:674
void CalculateDescendants(txiter it, setEntries &setDescendants) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Populate setDescendants with all in-mempool descendants of hash.
Definition: txmempool.cpp:535
const CTxMemPoolEntry * GetEntry(const Txid &txid) const LIFETIMEBOUND EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:836
static GenTxid Txid(const uint256 &hash)
Definition: transaction.h:434
std::string ToString() const
Definition: uint256.cpp:55
std::string ToString() const
256-bit opaque blob.
Definition: uint256.h:106
std::string FormatMoney(const CAmount n)
Money parsing/formatting utilities.
Definition: moneystr.cpp:16
std::optional< std::string > PaysMoreThanConflicts(const CTxMemPool::setEntries &iters_conflicting, CFeeRate replacement_feerate, const uint256 &txid)
Check that the feerate of the replacement transaction(s) is higher than the feerate of each of the tr...
Definition: rbf.cpp:132
std::optional< std::string > HasNoNewUnconfirmed(const CTransaction &tx, const CTxMemPool &pool, const CTxMemPool::setEntries &iters_conflicting)
The replacement transaction may only include an unconfirmed input if that input was included in one o...
Definition: rbf.cpp:85
std::optional< std::string > PaysForRBF(CAmount original_fees, CAmount replacement_fees, size_t replacement_vsize, CFeeRate relay_fee, const uint256 &txid)
The replacement transaction must pay more fees than the original transactions.
Definition: rbf.cpp:158
RBFTransactionState IsRBFOptInEmptyMempool(const CTransaction &tx)
Definition: rbf.cpp:51
std::optional< std::string > EntriesAndTxidsDisjoint(const CTxMemPool::setEntries &ancestors, const std::set< Txid > &direct_conflicts, const uint256 &txid)
Check the intersection between two sets of transactions (a set of mempool entries and a set of txids)...
Definition: rbf.cpp:117
RBFTransactionState IsRBFOptIn(const CTransaction &tx, const CTxMemPool &pool)
Determine whether an unconfirmed transaction is signaling opt-in to RBF according to BIP 125 This inv...
Definition: rbf.cpp:22
std::optional< std::string > GetEntriesForConflicts(const CTransaction &tx, CTxMemPool &pool, const CTxMemPool::setEntries &iters_conflicting, CTxMemPool::setEntries &all_conflicts)
Get all descendants of iters_conflicting.
Definition: rbf.cpp:57
RBFTransactionState
The rbf state of unconfirmed transactions.
Definition: rbf.h:27
@ UNKNOWN
Unconfirmed tx that does not signal rbf and is not in the mempool.
@ FINAL
Neither this tx nor a mempool ancestor signals rbf.
@ REPLACEABLE_BIP125
Either this tx or a mempool ancestor signals rbf.
static constexpr uint32_t MAX_REPLACEMENT_CANDIDATES
Maximum number of transactions that can be replaced by RBF (Rule #5).
Definition: rbf.h:24
static constexpr MemPoolLimits NoLimits()
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1162
bool SignalsOptInRBF(const CTransaction &tx)
Check whether the sequence numbers on this transaction are signaling opt-in to replace-by-fee,...
Definition: rbf.cpp:9
AssertLockHeld(pool.cs)