highperfocused/bitcoin
1
0
Fork 0
mirror of https://github.com/bitcoin/bitcoin.git synced 2025-10-11 12:03:04 +02:00
Code Issues Packages Projects Releases Wiki Activity

whitespace fixups after move and scripted-diff

Browse Source
This commit is contained in:
glozow
2021-09-01 09:54:04 +01:00
parent fa47622e8d
commit 32748da0f4
3 changed files with 44 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
src/policy/rbf.cpp
View File

@@ -57,14 +57,13 @@ std::optional<std::string> GetEntriesForConflicts(const CTransaction& tx,
uint64_t nConflictingCount = 0; uint64_t nConflictingCount = 0;
for (const auto& mi : iters_conflicting) { for (const auto& mi : iters_conflicting) {
nConflictingCount += mi->GetCountWithDescendants(); nConflictingCount += mi->GetCountWithDescendants();
// This potentially overestimates the number of actual descendants // This potentially overestimates the number of actual descendants but we just want to be
// but we just want to be conservative to avoid doing too much // conservative to avoid doing too much work.
// work.
if (nConflictingCount > MAX_BIP125_REPLACEMENT_CANDIDATES) { if (nConflictingCount > MAX_BIP125_REPLACEMENT_CANDIDATES) {
return strprintf("rejecting replacement %s; too many potential replacements (%d > %d)\n", return strprintf("rejecting replacement %s; too many potential replacements (%d > %d)\n",
txid.ToString(), txid.ToString(),
nConflictingCount, nConflictingCount,
MAX_BIP125_REPLACEMENT_CANDIDATES); MAX_BIP125_REPLACEMENT_CANDIDATES);
} }
} }
// If not too many to replace, then calculate the set of // If not too many to replace, then calculate the set of
@@ -82,28 +81,22 @@ std::optional<std::string> HasNoNewUnconfirmed(const CTransaction& tx,
AssertLockHeld(pool.cs); AssertLockHeld(pool.cs);
std::set<uint256> parents_of_conflicts; std::set<uint256> parents_of_conflicts;
for (const auto& mi : iters_conflicting) { for (const auto& mi : iters_conflicting) {
for (const CTxIn &txin : mi->GetTx().vin) for (const CTxIn &txin : mi->GetTx().vin) {
{
parents_of_conflicts.insert(txin.prevout.hash); parents_of_conflicts.insert(txin.prevout.hash);
} }
} }
for (unsigned int j = 0; j < tx.vin.size(); j++) for (unsigned int j = 0; j < tx.vin.size(); j++) {
{ // We don't want to accept replacements that require low feerate junk to be mined first.
// We don't want to accept replacements that require low // Ideally we'd keep track of the ancestor feerates and make the decision based on that, but
// feerate junk to be mined first. Ideally we'd keep track of // for now requiring all new inputs to be confirmed works.
// the ancestor feerates and make the decision based on that,
// but for now requiring all new inputs to be confirmed works.
// //
// Note that if you relax this to make RBF a little more useful, // Note that if you relax this to make RBF a little more useful, this may break the
// this may break the CalculateMempoolAncestors RBF relaxation, // CalculateMempoolAncestors RBF relaxation, above. See the comment above the first
// above. See the comment above the first CalculateMempoolAncestors // CalculateMempoolAncestors call for more info.
// call for more info. if (!parents_of_conflicts.count(tx.vin[j].prevout.hash)) {
if (!parents_of_conflicts.count(tx.vin[j].prevout.hash)) // Rather than check the UTXO set - potentially expensive - it's cheaper to just check
{ // if the new input refers to a tx that's in the mempool.
// Rather than check the UTXO set - potentially expensive -
// it's cheaper to just check if the new input refers to a
// tx that's in the mempool.
if (pool.exists(tx.vin[j].prevout.hash)) { if (pool.exists(tx.vin[j].prevout.hash)) {
return strprintf("replacement %s adds unconfirmed input, idx %d", return strprintf("replacement %s adds unconfirmed input, idx %d",
tx.GetHash().ToString(), j); tx.GetHash().ToString(), j);
@@ -117,11 +110,9 @@ std::optional<std::string> EntriesAndTxidsDisjoint(const CTxMemPool::setEntries&
const std::set<uint256>& direct_conflicts, const std::set<uint256>& direct_conflicts,
const uint256& txid) const uint256& txid)
{ {
for (CTxMemPool::txiter ancestorIt : ancestors) for (CTxMemPool::txiter ancestorIt : ancestors) {
{
const uint256 &hashAncestor = ancestorIt->GetTx().GetHash(); const uint256 &hashAncestor = ancestorIt->GetTx().GetHash();
if (direct_conflicts.count(hashAncestor)) if (direct_conflicts.count(hashAncestor)) {
{
return strprintf("%s spends conflicting transaction %s", return strprintf("%s spends conflicting transaction %s",
txid.ToString(), txid.ToString(),
hashAncestor.ToString()); hashAncestor.ToString());
@@ -135,23 +126,18 @@ std::optional<std::string> PaysMoreThanConflicts(const CTxMemPool::setEntries& i
const uint256& txid) const uint256& txid)
{ {
for (const auto& mi : iters_conflicting) { for (const auto& mi : iters_conflicting) {
// Don't allow the replacement to reduce the feerate of the // Don't allow the replacement to reduce the feerate of the mempool.
// mempool.
// //
// We usually don't want to accept replacements with lower // We usually don't want to accept replacements with lower feerates than what they replaced
// feerates than what they replaced as that would lower the // as that would lower the feerate of the next block. Requiring that the feerate always be
// feerate of the next block. Requiring that the feerate always // increased is also an easy-to-reason about way to prevent DoS attacks via replacements.
// be increased is also an easy-to-reason about way to prevent
// DoS attacks via replacements.
// //
// We only consider the feerates of transactions being directly // We only consider the feerates of transactions being directly replaced, not their indirect
// replaced, not their indirect descendants. While that does // descendants. While that does mean high feerate children are ignored when deciding whether
// mean high feerate children are ignored when deciding whether // or not to replace, we do require the replacement to pay more overall fees too, mitigating
// or not to replace, we do require the replacement to pay more // most cases.
// overall fees too, mitigating most cases.
CFeeRate original_feerate(mi->GetModifiedFee(), mi->GetTxSize()); CFeeRate original_feerate(mi->GetModifiedFee(), mi->GetTxSize());
if (replacement_feerate <= original_feerate) if (replacement_feerate <= original_feerate) {
{
return strprintf("rejecting replacement %s; new feerate %s <= old feerate %s", return strprintf("rejecting replacement %s; new feerate %s <= old feerate %s",
txid.ToString(), txid.ToString(),
replacement_feerate.ToString(), replacement_feerate.ToString(),
@@ -169,8 +155,7 @@ std::optional<std::string> PaysForRBF(CAmount original_fees,
// The replacement must pay greater fees than the transactions it // The replacement must pay greater fees than the transactions it
// replaces - if we did the bandwidth used by those conflicting // replaces - if we did the bandwidth used by those conflicting
// transactions would not be paid for. // transactions would not be paid for.
if (replacement_fees < original_fees) if (replacement_fees < original_fees) {
{
return strprintf("rejecting replacement %s, less fees than conflicting txs; %s < %s", return strprintf("rejecting replacement %s, less fees than conflicting txs; %s < %s",
txid.ToString(), FormatMoney(replacement_fees), FormatMoney(original_fees)); txid.ToString(), FormatMoney(replacement_fees), FormatMoney(original_fees));
} }
@@ -178,8 +163,7 @@ std::optional<std::string> PaysForRBF(CAmount original_fees,
// Finally in addition to paying more fees than the conflicts the // Finally in addition to paying more fees than the conflicts the
// new transaction must pay for its own bandwidth. // new transaction must pay for its own bandwidth.
CAmount additional_fees = replacement_fees - original_fees; CAmount additional_fees = replacement_fees - original_fees;
if (additional_fees < ::incrementalRelayFee.GetFee(replacement_vsize)) if (additional_fees < ::incrementalRelayFee.GetFee(replacement_vsize)) {
{
return strprintf("rejecting replacement %s, not enough additional fees to relay; %s < %s", return strprintf("rejecting replacement %s, not enough additional fees to relay; %s < %s",
txid.ToString(), txid.ToString(),
FormatMoney(additional_fees), FormatMoney(additional_fees),

18
src/policy/rbf.h
View File

@@ -39,8 +39,8 @@ RBFTransactionState IsRBFOptInEmptyMempool(const CTransaction& tx);
* transactions to be replaced and their descendant transactions which will be evicted from the * transactions to be replaced and their descendant transactions which will be evicted from the
* mempool must not exceed a total of 100 transactions." Quit as early as possible. There cannot be * mempool must not exceed a total of 100 transactions." Quit as early as possible. There cannot be
* more than MAX_BIP125_REPLACEMENT_CANDIDATES potential entries. * more than MAX_BIP125_REPLACEMENT_CANDIDATES potential entries.
* @param[in] iters_conflicting The set of iterators to mempool entries. * @param[in] iters_conflicting The set of iterators to mempool entries.
* @param[out] all_conflicts Populated with all the mempool entries that would be replaced, * @param[out] all_conflicts Populated with all the mempool entries that would be replaced,
* which includes descendants of iters_conflicting. Not cleared at * which includes descendants of iters_conflicting. Not cleared at
* the start; any existing mempool entries will remain in the set. * the start; any existing mempool entries will remain in the set.
* @returns an error message if Rule #5 is broken, otherwise a std::nullopt. * @returns an error message if Rule #5 is broken, otherwise a std::nullopt.
@@ -59,11 +59,11 @@ std::optional<std::string> HasNoNewUnconfirmed(const CTransaction& tx, const CTx
/** Check the intersection between two sets of transactions (a set of mempool entries and a set of /** Check the intersection between two sets of transactions (a set of mempool entries and a set of
* txids) to make sure they are disjoint. * txids) to make sure they are disjoint.
* @param[in] ancestors Set of mempool entries corresponding to ancestors of the * @param[in] ancestors Set of mempool entries corresponding to ancestors of the
* replacement transactions. * replacement transactions.
* @param[in] direct_conflicts Set of txids corresponding to the mempool conflicts * @param[in] direct_conflicts Set of txids corresponding to the mempool conflicts
* (candidates to be replaced). * (candidates to be replaced).
* @param[in] txid Transaction ID, included in the error message if violation occurs. * @param[in] txid Transaction ID, included in the error message if violation occurs.
* @returns error message if the sets intersect, std::nullopt if they are disjoint. * @returns error message if the sets intersect, std::nullopt if they are disjoint.
*/ */
std::optional<std::string> EntriesAndTxidsDisjoint(const CTxMemPool::setEntries& ancestors, std::optional<std::string> EntriesAndTxidsDisjoint(const CTxMemPool::setEntries& ancestors,
@@ -81,9 +81,9 @@ std::optional<std::string> PaysMoreThanConflicts(const CTxMemPool::setEntries& i
/** Enforce BIP125 Rule #3 "The replacement transaction pays an absolute fee of at least the sum /** Enforce BIP125 Rule #3 "The replacement transaction pays an absolute fee of at least the sum
* paid by the original transactions." Enforce BIP125 Rule #4 "The replacement transaction must also * paid by the original transactions." Enforce BIP125 Rule #4 "The replacement transaction must also
* pay for its own bandwidth at or above the rate set by the node's minimum relay fee setting." * pay for its own bandwidth at or above the rate set by the node's minimum relay fee setting."
* @param[in] original_fees Total modified fees of original transaction(s). * @param[in] original_fees Total modified fees of original transaction(s).
* @param[in] replacement_fees Total modified fees of replacement transaction(s). * @param[in] replacement_fees Total modified fees of replacement transaction(s).
* @param[in] replacement_vsize Total virtual size of replacement transaction(s). * @param[in] replacement_vsize Total virtual size of replacement transaction(s).
* @param[in] txid Transaction ID, included in the error message if violation occurs. * @param[in] txid Transaction ID, included in the error message if violation occurs.
* @returns error string if fees are insufficient, otherwise std::nullopt. * @returns error string if fees are insufficient, otherwise std::nullopt.
*/ */

14
src/util/rbf.h
View File

@@ -11,15 +11,13 @@ class CTransaction;
static const uint32_t MAX_BIP125_RBF_SEQUENCE = 0xfffffffd; static const uint32_t MAX_BIP125_RBF_SEQUENCE = 0xfffffffd;
/** Check whether the sequence numbers on this transaction are signaling /** Check whether the sequence numbers on this transaction are signaling opt-in to replace-by-fee,
* opt-in to replace-by-fee, according to BIP 125. * according to BIP 125. Allow opt-out of transaction replacement by setting nSequence >
* Allow opt-out of transaction replacement by setting * MAX_BIP125_RBF_SEQUENCE (SEQUENCE_FINAL-2) on all inputs.
* nSequence > MAX_BIP125_RBF_SEQUENCE (SEQUENCE_FINAL-2) on all inputs.
* *
* SEQUENCE_FINAL-1 is picked to still allow use of nLockTime by * SEQUENCE_FINAL-1 is picked to still allow use of nLockTime by non-replaceable transactions. All
* non-replaceable transactions. All inputs rather than just one * inputs rather than just one is for the sake of multi-party protocols, where we don't want a single
* is for the sake of multi-party protocols, where we don't * party to be able to disable replacement. */
* want a single party to be able to disable replacement. */
bool SignalsOptInRBF(const CTransaction &tx); bool SignalsOptInRBF(const CTransaction &tx);
#endif // BITCOIN_UTIL_RBF_H #endif // BITCOIN_UTIL_RBF_H