Branch data Line data Source code
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 : :
22 : : #include <compare>
23 : :
24 : 814 : RBFTransactionState IsRBFOptIn(const CTransaction& tx, const CTxMemPool& pool)
25 : : {
26 : 814 : AssertLockHeld(pool.cs);
27 : :
28 : : // First check the transaction itself.
29 [ + + ]: 814 : if (SignalsOptInRBF(tx)) {
30 : : return RBFTransactionState::REPLACEABLE_BIP125;
31 : : }
32 : :
33 : : // If this transaction is not in our mempool, then we can't be sure
34 : : // we will know about all its inputs.
35 [ + + ]: 611 : if (!pool.exists(tx.GetHash())) {
36 : : return RBFTransactionState::UNKNOWN;
37 : : }
38 : :
39 : : // If all the inputs have nSequence >= maxint-1, it still might be
40 : : // signaled for RBF if any unconfirmed parents have signaled.
41 : 341 : const auto& entry{*Assert(pool.GetEntry(tx.GetHash()))};
42 : 341 : auto ancestors{pool.AssumeCalculateMemPoolAncestors(__func__, entry, CTxMemPool::Limits::NoLimits(),
43 : 341 : /*fSearchForParents=*/false)};
44 : :
45 [ + + ]: 412 : for (CTxMemPool::txiter it : ancestors) {
46 [ + - + + ]: 97 : if (SignalsOptInRBF(it->GetTx())) {
47 : : return RBFTransactionState::REPLACEABLE_BIP125;
48 : : }
49 : : }
50 : : return RBFTransactionState::FINAL;
51 : 341 : }
52 : :
53 : 0 : RBFTransactionState IsRBFOptInEmptyMempool(const CTransaction& tx)
54 : : {
55 : : // If we don't have a local mempool we can only check the transaction itself.
56 [ # # ]: 0 : return SignalsOptInRBF(tx) ? RBFTransactionState::REPLACEABLE_BIP125 : RBFTransactionState::UNKNOWN;
57 : : }
58 : :
59 : 81887 : std::optional<std::string> GetEntriesForConflicts(const CTransaction& tx,
60 : : CTxMemPool& pool,
61 : : const CTxMemPool::setEntries& iters_conflicting,
62 : : CTxMemPool::setEntries& all_conflicts)
63 : : {
64 : 81887 : AssertLockHeld(pool.cs);
65 : 81887 : uint64_t nConflictingCount = 0;
66 [ + + ]: 182587 : for (const auto& mi : iters_conflicting) {
67 [ - + ]: 100700 : nConflictingCount += mi->GetCountWithDescendants();
68 : : // Rule #5: don't consider replacing more than MAX_REPLACEMENT_CANDIDATES
69 : : // entries from the mempool. This potentially overestimates the number of actual
70 : : // descendants (i.e. if multiple conflicts share a descendant, it will be counted multiple
71 : : // times), but we just want to be conservative to avoid doing too much work.
72 [ - + ]: 100700 : if (nConflictingCount > MAX_REPLACEMENT_CANDIDATES) {
73 : 0 : return strprintf("rejecting replacement %s; too many potential replacements (%d > %d)",
74 [ # # ]: 0 : tx.GetHash().ToString(),
75 : : nConflictingCount,
76 : 0 : MAX_REPLACEMENT_CANDIDATES);
77 : : }
78 : : }
79 : : // Calculate the set of all transactions that would have to be evicted.
80 [ + + ]: 182587 : for (CTxMemPool::txiter it : iters_conflicting) {
81 : 100700 : pool.CalculateDescendants(it, all_conflicts);
82 : : }
83 : 81887 : return std::nullopt;
84 : : }
85 : :
86 : 62737 : std::optional<std::string> HasNoNewUnconfirmed(const CTransaction& tx,
87 : : const CTxMemPool& pool,
88 : : const CTxMemPool::setEntries& iters_conflicting)
89 : : {
90 : 62737 : AssertLockHeld(pool.cs);
91 : 62737 : std::set<Txid> parents_of_conflicts;
92 [ + + ]: 187184 : for (const auto& mi : iters_conflicting) {
93 [ + + ]: 484381 : for (const CTxIn& txin : mi->GetTx().vin) {
94 [ + - ]: 359934 : parents_of_conflicts.insert(txin.prevout.hash);
95 : : }
96 : : }
97 : :
98 [ - + + + ]: 176974 : for (unsigned int j = 0; j < tx.vin.size(); j++) {
99 : : // Rule #2: We don't want to accept replacements that require low feerate junk to be
100 : : // mined first. Ideally we'd keep track of the ancestor feerates and make the decision
101 : : // based on that, but for now requiring all new inputs to be confirmed works.
102 : : //
103 : : // Note that if you relax this to make RBF a little more useful, this may break the
104 : : // CalculateMempoolAncestors RBF relaxation which subtracts the conflict count/size from the
105 : : // descendant limit.
106 [ + + ]: 126376 : if (!parents_of_conflicts.count(tx.vin[j].prevout.hash)) {
107 : : // Rather than check the UTXO set - potentially expensive - it's cheaper to just check
108 : : // if the new input refers to a tx that's in the mempool.
109 [ + - + + ]: 42386 : if (pool.exists(tx.vin[j].prevout.hash)) {
110 : 12139 : return strprintf("replacement %s adds unconfirmed input, idx %d",
111 [ + - + - ]: 36417 : tx.GetHash().ToString(), j);
112 : : }
113 : : }
114 : : }
115 : 50598 : return std::nullopt;
116 : 62737 : }
117 : :
118 : 612084 : std::optional<std::string> EntriesAndTxidsDisjoint(const CTxMemPool::setEntries& ancestors,
119 : : const std::set<Txid>& direct_conflicts,
120 : : const Txid& txid)
121 : : {
122 [ + + ]: 1108268 : for (CTxMemPool::txiter ancestorIt : ancestors) {
123 : 508188 : const Txid& hashAncestor = ancestorIt->GetTx().GetHash();
124 [ + + ]: 508188 : if (direct_conflicts.count(hashAncestor)) {
125 : 24008 : return strprintf("%s spends conflicting transaction %s",
126 [ + - ]: 24008 : txid.ToString(),
127 [ + - ]: 36012 : hashAncestor.ToString());
128 : : }
129 : : }
130 : 600080 : return std::nullopt;
131 : : }
132 : :
133 : 243478 : std::optional<std::string> PaysMoreThanConflicts(const CTxMemPool::setEntries& iters_conflicting,
134 : : CFeeRate replacement_feerate,
135 : : const Txid& txid)
136 : : {
137 [ + + ]: 329026 : for (const auto& mi : iters_conflicting) {
138 : : // Don't allow the replacement to reduce the feerate of the mempool.
139 : : //
140 : : // We usually don't want to accept replacements with lower feerates than what they replaced
141 : : // as that would lower the feerate of the next block. Requiring that the feerate always be
142 : : // increased is also an easy-to-reason about way to prevent DoS attacks via replacements.
143 : : //
144 : : // We only consider the feerates of transactions being directly replaced, not their indirect
145 : : // descendants. While that does mean high feerate children are ignored when deciding whether
146 : : // or not to replace, we do require the replacement to pay more overall fees too, mitigating
147 : : // most cases.
148 : 266289 : CFeeRate original_feerate(mi->GetModifiedFee(), mi->GetTxSize());
149 [ + + ]: 266289 : if (replacement_feerate <= original_feerate) {
150 : 361482 : return strprintf("rejecting replacement %s; new feerate %s <= old feerate %s",
151 [ + - ]: 361482 : txid.ToString(),
152 [ + - ]: 361482 : replacement_feerate.ToString(),
153 : 542223 : original_feerate.ToString());
154 : : }
155 : : }
156 : 62737 : return std::nullopt;
157 : : }
158 : :
159 : 69748 : std::optional<std::string> PaysForRBF(CAmount original_fees,
160 : : CAmount replacement_fees,
161 : : size_t replacement_vsize,
162 : : CFeeRate relay_fee,
163 : : const Txid& txid)
164 : : {
165 : : // Rule #3: The replacement fees must be greater than or equal to fees of the
166 : : // transactions it replaces, otherwise the bandwidth used by those conflicting transactions
167 : : // would not be paid for.
168 [ + + ]: 69748 : if (replacement_fees < original_fees) {
169 : 33621 : return strprintf("rejecting replacement %s, less fees than conflicting txs; %s < %s",
170 [ + - + - ]: 134484 : txid.ToString(), FormatMoney(replacement_fees), FormatMoney(original_fees));
171 : : }
172 : :
173 : : // Rule #4: The new transaction must pay for its own bandwidth. Otherwise, we have a DoS
174 : : // vector where attackers can cause a transaction to be replaced (and relayed) repeatedly by
175 : : // increasing the fee by tiny amounts.
176 : 36127 : CAmount additional_fees = replacement_fees - original_fees;
177 [ + + ]: 36127 : if (additional_fees < relay_fee.GetFee(replacement_vsize)) {
178 : 3800 : return strprintf("rejecting replacement %s, not enough additional fees to relay; %s < %s",
179 [ + - ]: 7600 : txid.ToString(),
180 [ + - ]: 7600 : FormatMoney(additional_fees),
181 : 11400 : FormatMoney(relay_fee.GetFee(replacement_vsize)));
182 : : }
183 : 32327 : return std::nullopt;
184 : : }
185 : :
186 : 9652 : std::optional<std::pair<DiagramCheckError, std::string>> ImprovesFeerateDiagram(CTxMemPool::ChangeSet& changeset)
187 : : {
188 : : // Require that the replacement strictly improves the mempool's feerate diagram.
189 : 9652 : const auto chunk_results{changeset.CalculateChunksForRBF()};
190 : :
191 [ + + ]: 9652 : if (!chunk_results.has_value()) {
192 [ + - ]: 2960 : return std::make_pair(DiagramCheckError::UNCALCULABLE, util::ErrorString(chunk_results).original);
193 : : }
194 : :
195 [ - + - + : 8172 : if (!std::is_gt(CompareChunks(chunk_results.value().second, chunk_results.value().first))) {
+ - + + ]
196 [ + - ]: 7256 : return std::make_pair(DiagramCheckError::FAILURE, "insufficient feerate: does not improve feerate diagram");
197 : : }
198 : 916 : return std::nullopt;
199 : 9652 : }
|
