1// Copyright (c) 2017-present 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 <wallet/feebumper.h>
6
7#include <coins.h>
8#include <common/system.h>
9#include <consensus/validation.h>
10#include <interfaces/chain.h>
11#include <policy/policy.h>
12#include <util/moneystr.h>
13#include <util/rbf.h>
14#include <util/translation.h>
15#include <wallet/coincontrol.h>
16#include <wallet/fees.h>
17#include <wallet/receive.h>
18#include <wallet/spend.h>
19#include <wallet/wallet.h>
20
21namespace wallet {
22//! Check whether transaction has descendant in wallet or mempool, or has been
23//! mined, or conflicts with a mined transaction. Return a feebumper::Result.
24static feebumper::Result PreconditionChecks(const CWallet& wallet, const CWalletTx& wtx, bool require_mine, std::vector<bilingual_str>& errors) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet)
25{
26    if (wallet.HasWalletSpend(wtx.GetTx())) {
27        errors.emplace_back(Untranslated("Transaction has descendants in the wallet"));
28        return feebumper::Result::INVALID_PARAMETER;
29    }
30
31    {
32        if (wallet.chain().hasDescendantsInMempool(wtx.GetHash())) {
33            errors.emplace_back(Untranslated("Transaction has descendants in the mempool"));
34            return feebumper::Result::INVALID_PARAMETER;
35        }
36    }
37
38    if (wallet.GetTxDepthInMainChain(wtx) != 0) {
39        errors.emplace_back(Untranslated("Transaction has been mined, or is conflicted with a mined transaction"));
40        return feebumper::Result::WALLET_ERROR;
41    }
42
43    if (wtx.m_replaced_by_txid) {
44        errors.push_back(Untranslated(strprintf("Cannot bump transaction %s which was already bumped by transaction %s", wtx.GetHash().ToString(), wtx.m_replaced_by_txid->ToString())));
45        return feebumper::Result::WALLET_ERROR;
46    }
47
48    if (require_mine) {
49        // check that original tx consists entirely of our inputs
50        // if not, we can't bump the fee, because the wallet has no way of knowing the value of the other inputs (thus the fee)
51        if (!AllInputsMine(wallet, *wtx.GetTx())) {
52            errors.emplace_back(Untranslated("Transaction contains inputs that don't belong to this wallet"));
53            return feebumper::Result::WALLET_ERROR;
54        }
55    }
56
57    return feebumper::Result::OK;
58}
59
60//! Check if the user provided a valid feeRate
61static feebumper::Result CheckFeeRate(const CWallet& wallet, const CMutableTransaction& mtx, const CFeeRate& newFeerate, const int64_t maxTxSize, CAmount old_fee, std::vector<bilingual_str>& errors)
62{
63    // check that fee rate is higher than mempool's minimum fee
64    // (no point in bumping fee if we know that the new tx won't be accepted to the mempool)
65    // This may occur if fallbackfee is too low, or, perhaps,
66    // in a rare situation where the mempool minimum fee increased significantly since the fee estimation just a
67    // moment earlier. In this case, we report an error to the user, who may adjust the fee.
68    CFeeRate minMempoolFeeRate = wallet.chain().mempoolMinFee();
69
70    if (newFeerate.GetFeePerK() < minMempoolFeeRate.GetFeePerK()) {
71        errors.push_back(Untranslated(
72            strprintf("New fee rate (%s) is lower than the minimum fee rate (%s) to get into the mempool -- ",
73            FormatMoney(newFeerate.GetFeePerK()),
74            FormatMoney(minMempoolFeeRate.GetFeePerK()))));
75        return feebumper::Result::WALLET_ERROR;
76    }
77
78    std::vector<COutPoint> reused_inputs;
79    reused_inputs.reserve(mtx.vin.size());
80    for (const CTxIn& txin : mtx.vin) {
81        reused_inputs.push_back(txin.prevout);
82    }
83
84    const std::optional<CAmount> combined_bump_fee = wallet.chain().calculateCombinedBumpFee(reused_inputs, newFeerate);
85    if (!combined_bump_fee.has_value()) {
86        errors.push_back(Untranslated(strprintf("Failed to calculate bump fees, because unconfirmed UTXOs depend on an enormous cluster of unconfirmed transactions.")));
87        return feebumper::Result::WALLET_ERROR;
88    }
89    CAmount new_total_fee = newFeerate.GetFee(maxTxSize) + combined_bump_fee.value();
90
91    CFeeRate incrementalRelayFee = wallet.chain().relayIncrementalFee();
92
93    // Min total fee is old fee + relay fee
94    CAmount minTotalFee = old_fee + incrementalRelayFee.GetFee(maxTxSize);
95
96    if (new_total_fee < minTotalFee) {
97        errors.push_back(Untranslated(strprintf("Insufficient total fee %s, must be at least %s (oldFee %s + incrementalFee %s)",
98            FormatMoney(new_total_fee), FormatMoney(minTotalFee), FormatMoney(old_fee), FormatMoney(incrementalRelayFee.GetFee(maxTxSize)))));
99        return feebumper::Result::INVALID_PARAMETER;
100    }
101
102    CAmount requiredFee = GetRequiredFee(wallet, maxTxSize);
103    if (new_total_fee < requiredFee) {
104        errors.push_back(Untranslated(strprintf("Insufficient total fee (cannot be less than required fee %s)",
105            FormatMoney(requiredFee))));
106        return feebumper::Result::INVALID_PARAMETER;
107    }
108
109    // Check that in all cases the new fee doesn't violate maxTxFee
110    const CAmount max_tx_fee = wallet.m_default_max_tx_fee;
111    if (new_total_fee > max_tx_fee) {
112        errors.push_back(Untranslated(strprintf("Specified or calculated fee %s is too high (cannot be higher than -maxtxfee %s)",
113            FormatMoney(new_total_fee), FormatMoney(max_tx_fee))));
114        return feebumper::Result::WALLET_ERROR;
115    }
116
117    return feebumper::Result::OK;
118}
119
120static CFeeRate EstimateFeeRate(const CWallet& wallet, const CWalletTx& wtx, const CAmount old_fee, const CCoinControl& coin_control)
121{
122    // Get the fee rate of the original transaction. This is calculated from
123    // the tx fee/vsize, so it may have been rounded down. Add 1 satoshi to the
124    // result.
125    int64_t txSize = GetVirtualTransactionSize(*(wtx.GetTx()));
126    CFeeRate feerate(old_fee, txSize);
127    feerate += CFeeRate(1);
128
129    // The node has a configurable incremental relay fee. Increment the fee by
130    // the minimum of that and the wallet's conservative
131    // WALLET_INCREMENTAL_RELAY_FEE value to future proof against changes to
132    // network wide policy for incremental relay fee that our node may not be
133    // aware of. This ensures we're over the required relay fee rate
134    // (Rule 4).  The replacement tx will be at least as large as the
135    // original tx, so the total fee will be greater (Rule 3)
136    CFeeRate node_incremental_relay_fee = wallet.chain().relayIncrementalFee();
137    CFeeRate wallet_incremental_relay_fee = CFeeRate(WALLET_INCREMENTAL_RELAY_FEE);
138    feerate += std::max(node_incremental_relay_fee, wallet_incremental_relay_fee);
139
140    // Fee rate must also be at least the wallet's GetMinimumFeeRate
141    CFeeRate min_feerate(GetMinimumFeeRate(wallet, coin_control).fee_rate);
142
143    // Set the required fee rate for the replacement transaction in coin control.
144    return std::max(feerate, min_feerate);
145}
146
147namespace feebumper {
148
149bool TransactionCanBeBumped(const CWallet& wallet, const Txid& txid)
150{
151    LOCK(wallet.cs_wallet);
152    const CWalletTx* wtx = wallet.GetWalletTx(txid);
153    if (wtx == nullptr) return false;
154
155    std::vector<bilingual_str> errors_dummy;
156    feebumper::Result res = PreconditionChecks(wallet, *wtx, /* require_mine=*/ true, errors_dummy);
157    return res == feebumper::Result::OK;
158}
159
160Result CreateRateBumpTransaction(CWallet& wallet, const Txid& txid, const CCoinControl& coin_control, std::vector<bilingual_str>& errors,
161                                 CAmount& old_fee, CAmount& new_fee, CMutableTransaction& mtx, bool require_mine, const std::vector<CTxOut>& outputs, std::optional<uint32_t> original_change_index)
162{
163    // For now, cannot specify both new outputs to use and an output index to send change
164    if (!outputs.empty() && original_change_index.has_value()) {
165        errors.emplace_back(Untranslated("The options 'outputs' and 'original_change_index' are incompatible. You can only either specify a new set of outputs, or designate a change output to be recycled."));
166        return Result::INVALID_PARAMETER;
167    }
168
169    // We are going to modify coin control later, copy to reuse
170    CCoinControl new_coin_control(coin_control);
171
172    LOCK(wallet.cs_wallet);
173    errors.clear();
174    auto it = wallet.mapWallet.find(txid);
175    if (it == wallet.mapWallet.end()) {
176        errors.emplace_back(Untranslated("Invalid or non-wallet transaction id"));
177        return Result::INVALID_ADDRESS_OR_KEY;
178    }
179    const CWalletTx& wtx = it->second;
180    const CTransactionRef& tx = wtx.GetTx();
181
182    // Make sure that original_change_index is valid
183    if (original_change_index.has_value() && original_change_index.value() >= tx->vout.size()) {
184        errors.emplace_back(Untranslated("Change position is out of range"));
185        return Result::INVALID_PARAMETER;
186    }
187
188    // Retrieve all of the UTXOs and add them to coin control
189    // While we're here, calculate the input amount
190    std::map<COutPoint, Coin> coins;
191    CAmount input_value = 0;
192    std::vector<CTxOut> spent_outputs;
193    for (const CTxIn& txin : tx->vin) {
194        coins[txin.prevout]; // Create empty map entry keyed by prevout.
195    }
196    wallet.chain().findCoins(coins);
197    for (const CTxIn& txin : tx->vin) {
198        const Coin& coin = coins.at(txin.prevout);
199        if (coin.out.IsNull()) {
200            errors.emplace_back(Untranslated(strprintf("%s:%u is already spent", txin.prevout.hash.GetHex(), txin.prevout.n)));
201            return Result::MISC_ERROR;
202        }
203        PreselectedInput& preset_txin = new_coin_control.Select(txin.prevout);
204        if (!wallet.IsMine(txin.prevout)) {
205            preset_txin.SetTxOut(coin.out);
206        }
207        input_value += coin.out.nValue;
208        spent_outputs.push_back(coin.out);
209    }
210
211    // Figure out if we need to compute the input weight, and do so if necessary
212    PrecomputedTransactionData txdata;
213    txdata.Init(*tx, std::move(spent_outputs), /* force=*/ true);
214    for (unsigned int i = 0; i < tx->vin.size(); ++i) {
215        const CTxIn& txin = tx->vin.at(i);
216        const Coin& coin = coins.at(txin.prevout);
217
218        if (new_coin_control.IsExternalSelected(txin.prevout)) {
219            // For external inputs, we estimate the size using the size of this input
220            int64_t input_weight = GetTransactionInputWeight(txin);
221            // Because signatures can have different sizes, we need to figure out all of the
222            // signature sizes and replace them with the max sized signature.
223            // In order to do this, we verify the script with a special SignatureChecker which
224            // will observe the signatures verified and record their sizes.
225            SignatureWeights weights;
226            TransactionSignatureChecker tx_checker(tx.get(), i, coin.out.nValue, txdata, MissingDataBehavior::FAIL);
227            SignatureWeightChecker size_checker(weights, tx_checker);
228            VerifyScript(txin.scriptSig, coin.out.scriptPubKey, &txin.scriptWitness, STANDARD_SCRIPT_VERIFY_FLAGS, size_checker);
229            // Add the difference between max and current to input_weight so that it represents the largest the input could be
230            input_weight += weights.GetWeightDiffToMax();
231            new_coin_control.SetInputWeight(txin.prevout, input_weight);
232        }
233    }
234
235    Result result = PreconditionChecks(wallet, wtx, require_mine, errors);
236    if (result != Result::OK) {
237        return result;
238    }
239
240    // Calculate the old output amount.
241    CAmount output_value = 0;
242    for (const auto& old_output : tx->vout) {
243        output_value += old_output.nValue;
244    }
245
246    old_fee = input_value - output_value;
247
248    // Fill in recipients (and preserve a single change key if there
249    // is one). If outputs vector is non-empty, replace original
250    // outputs with its contents, otherwise use original outputs.