1 files changed, 92 insertions, 25 deletions
diff --git a/src/wallet/feebumper.cpp b/src/wallet/feebumper.cpp
index 619197a57a..b87231293f 100644
--- a/src/wallet/feebumper.cpp
+++ b/src/wallet/feebumper.cpp
@@ -57,6 +57,86 @@ static feebumper::Result PreconditionChecks(interfaces::Chain::Lock& locked_chai
     return feebumper::Result::OK;
 }
 
+//! Check if the user provided a valid feeRate
+static feebumper::Result CheckFeeRate(const CWallet* wallet, const CWalletTx& wtx, const CFeeRate& newFeerate, const int64_t maxTxSize, std::vector<std::string>& errors) {
+    // check that fee rate is higher than mempool's minimum fee
+    // (no point in bumping fee if we know that the new tx won't be accepted to the mempool)
+    // This may occur if the user set FeeRate, TotalFee or paytxfee too low, if fallbackfee is too low, or, perhaps,
+    // in a rare situation where the mempool minimum fee increased significantly since the fee estimation just a
+    // moment earlier. In this case, we report an error to the user, who may adjust the fee.
+    CFeeRate minMempoolFeeRate = wallet->chain().mempoolMinFee();
+
+    if (newFeerate.GetFeePerK() < minMempoolFeeRate.GetFeePerK()) {
+        errors.push_back(strprintf(
+            "New fee rate (%s) is lower than the minimum fee rate (%s) to get into the mempool -- ",
+            FormatMoney(newFeerate.GetFeePerK()),
+            FormatMoney(minMempoolFeeRate.GetFeePerK())));
+        return feebumper::Result::WALLET_ERROR;
+    }
+
+    CAmount new_total_fee = newFeerate.GetFee(maxTxSize);
+
+    CFeeRate incrementalRelayFee = std::max(wallet->chain().relayIncrementalFee(), CFeeRate(WALLET_INCREMENTAL_RELAY_FEE));
+
+    // Given old total fee and transaction size, calculate the old feeRate
+    CAmount old_fee = wtx.GetDebit(ISMINE_SPENDABLE) - wtx.tx->GetValueOut();
+    const int64_t txSize = GetVirtualTransactionSize(*(wtx.tx));
+    CFeeRate nOldFeeRate(old_fee, txSize);
+    // Min total fee is old fee + relay fee
+    CAmount minTotalFee = nOldFeeRate.GetFee(maxTxSize) + incrementalRelayFee.GetFee(maxTxSize);
+
+    if (new_total_fee < minTotalFee) {
+        errors.push_back(strprintf("Insufficient total fee %s, must be at least %s (oldFee %s + incrementalFee %s)",
+            FormatMoney(new_total_fee), FormatMoney(minTotalFee), FormatMoney(nOldFeeRate.GetFee(maxTxSize)), FormatMoney(incrementalRelayFee.GetFee(maxTxSize))));
+        return feebumper::Result::INVALID_PARAMETER;
+    }
+
+    CAmount requiredFee = GetRequiredFee(*wallet, maxTxSize);
+    if (new_total_fee < requiredFee) {
+        errors.push_back(strprintf("Insufficient total fee (cannot be less than required fee %s)",
+            FormatMoney(requiredFee)));
+        return feebumper::Result::INVALID_PARAMETER;
+    }
+
+    // Check that in all cases the new fee doesn't violate maxTxFee
+    const CAmount max_tx_fee = wallet->m_default_max_tx_fee;
+    if (new_total_fee > max_tx_fee) {
+        errors.push_back(strprintf("Specified or calculated fee %s is too high (cannot be higher than -maxtxfee %s)",
+                            FormatMoney(new_total_fee), FormatMoney(max_tx_fee)));
+        return feebumper::Result::WALLET_ERROR;
+    }
+
+    return feebumper::Result::OK;
+}
+
+static CFeeRate EstimateFeeRate(CWallet* wallet, const CWalletTx& wtx, CCoinControl& coin_control, CAmount& old_fee)
+{
+    // Get the fee rate of the original transaction. This is calculated from
+    // the tx fee/vsize, so it may have been rounded down. Add 1 satoshi to the
+    // result.
+    old_fee = wtx.GetDebit(ISMINE_SPENDABLE) - wtx.tx->GetValueOut();
+    int64_t txSize = GetVirtualTransactionSize(*(wtx.tx));
+    CFeeRate feerate(old_fee, txSize);
+    feerate += CFeeRate(1);
+
+    // The node has a configurable incremental relay fee. Increment the fee by
+    // the minimum of that and the wallet's conservative
+    // WALLET_INCREMENTAL_RELAY_FEE value to future proof against changes to
+    // network wide policy for incremental relay fee that our node may not be
+    // aware of. This ensures we're over the over the required relay fee rate
+    // (BIP 125 rule 4).  The replacement tx will be at least as large as the
+    // original tx, so the total fee will be greater (BIP 125 rule 3)
+    CFeeRate node_incremental_relay_fee = wallet->chain().relayIncrementalFee();
+    CFeeRate wallet_incremental_relay_fee = CFeeRate(WALLET_INCREMENTAL_RELAY_FEE);
+    feerate += std::max(node_incremental_relay_fee, wallet_incremental_relay_fee);
+
+    // Fee rate must also be at least the wallet's GetMinimumFeeRate
+    CFeeRate min_feerate(GetMinimumFeeRate(*wallet, coin_control, /* feeCalc */ nullptr));
+
+    // Set the required fee rate for the replacement transaction in coin control.
+    return std::max(feerate, min_feerate);
+}
+
 namespace feebumper {
 
 bool TransactionCanBeBumped(const CWallet* wallet, const uint256& txid)
@@ -230,31 +310,18 @@ Result CreateRateBumpTransaction(CWallet* wallet, const uint256& txid, const CCo
         }
     }
 
-    // Get the fee rate of the original transaction. This is calculated from
-    // the tx fee/vsize, so it may have been rounded down. Add 1 satoshi to the
-    // result.
-    old_fee = wtx.GetDebit(ISMINE_SPENDABLE) - wtx.tx->GetValueOut();
-    int64_t txSize = GetVirtualTransactionSize(*(wtx.tx));
-    // Feerate of thing we are bumping
-    CFeeRate feerate(old_fee, txSize);
-    feerate += CFeeRate(1);
-
-    // The node has a configurable incremental relay fee. Increment the fee by
-    // the minimum of that and the wallet's conservative
-    // WALLET_INCREMENTAL_RELAY_FEE value to future proof against changes to
-    // network wide policy for incremental relay fee that our node may not be
-    // aware of. This ensures we're over the over the required relay fee rate
-    // (BIP 125 rule 4).  The replacement tx will be at least as large as the
-    // original tx, so the total fee will be greater (BIP 125 rule 3)
-    CFeeRate node_incremental_relay_fee = wallet->chain().relayIncrementalFee();
-    CFeeRate wallet_incremental_relay_fee = CFeeRate(WALLET_INCREMENTAL_RELAY_FEE);
-    feerate += std::max(node_incremental_relay_fee, wallet_incremental_relay_fee);
-
-    // Fee rate must also be at least the wallet's GetMinimumFeeRate
-    CFeeRate min_feerate(GetMinimumFeeRate(*wallet, new_coin_control, /* feeCalc */ nullptr));
-
-    // Set the required fee rate for the replacement transaction in coin control.
-    new_coin_control.m_feerate = std::max(feerate, min_feerate);
+    if (coin_control.m_feerate) {
+        // The user provided a feeRate argument.
+        // We calculate this here to avoid compiler warning on the cs_wallet lock
+        const int64_t maxTxSize = CalculateMaximumSignedTxSize(*wtx.tx, wallet);
+        Result res = CheckFeeRate(wallet, wtx, *(new_coin_control.m_feerate), maxTxSize, errors);
+        if (res != Result::OK) {
+            return res;
+        }
+    } else {
+        // The user did not provide a feeRate argument
+        new_coin_control.m_feerate = EstimateFeeRate(wallet, wtx, new_coin_control, old_fee);
+    }
 
     // Fill in required inputs we are double-spending(all of them)
     // N.B.: bip125 doesn't require all the inputs in the replaced transaction to be