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