Branch data Line data Source code
1 : : // Copyright (c) 2021-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 <algorithm>
6 : : #include <common/args.h>
7 : : #include <common/messages.h>
8 : : #include <common/system.h>
9 : : #include <consensus/amount.h>
10 : : #include <consensus/validation.h>
11 : : #include <interfaces/chain.h>
12 : : #include <node/types.h>
13 : : #include <numeric>
14 : : #include <policy/policy.h>
15 : : #include <primitives/transaction.h>
16 : : #include <script/script.h>
17 : : #include <script/signingprovider.h>
18 : : #include <script/solver.h>
19 : : #include <util/check.h>
20 : : #include <util/moneystr.h>
21 : : #include <util/rbf.h>
22 : : #include <util/trace.h>
23 : : #include <util/translation.h>
24 : : #include <wallet/coincontrol.h>
25 : : #include <wallet/fees.h>
26 : : #include <wallet/receive.h>
27 : : #include <wallet/spend.h>
28 : : #include <wallet/transaction.h>
29 : : #include <wallet/wallet.h>
30 : :
31 : : #include <cmath>
32 : :
33 : : using common::StringForFeeReason;
34 : : using common::TransactionErrorString;
35 : : using interfaces::FoundBlock;
36 : : using node::TransactionError;
37 : :
38 : : TRACEPOINT_SEMAPHORE(coin_selection, selected_coins);
39 : : TRACEPOINT_SEMAPHORE(coin_selection, normal_create_tx_internal);
40 : : TRACEPOINT_SEMAPHORE(coin_selection, attempting_aps_create_tx);
41 : : TRACEPOINT_SEMAPHORE(coin_selection, aps_create_tx_internal);
42 : :
43 : : namespace wallet {
44 : : static constexpr size_t OUTPUT_GROUP_MAX_ENTRIES{100};
45 : :
46 : : /** Whether the descriptor represents, directly or not, a witness program. */
47 : 212384 : static bool IsSegwit(const Descriptor& desc) {
48 [ + + ]: 212384 : if (const auto typ = desc.GetOutputType()) return *typ != OutputType::LEGACY;
49 : : return false;
50 : : }
51 : :
52 : : /** Whether to assume ECDSA signatures' will be high-r. */
53 : 200833 : static bool UseMaxSig(const std::optional<CTxIn>& txin, const CCoinControl* coin_control) {
54 : : // Use max sig if watch only inputs were used or if this particular input is an external input
55 : : // to ensure a sufficient fee is attained for the requested feerate.
56 [ + + + + : 200833 : return coin_control && (coin_control->fAllowWatchOnly || (txin && coin_control->IsExternalSelected(txin->prevout)));
+ + + + ]
57 : : }
58 : :
59 : : /** Get the size of an input (in witness units) once it's signed.
60 : : *
61 : : * @param desc The output script descriptor of the coin spent by this input.
62 : : * @param txin Optionally the txin to estimate the size of. Used to determine the size of ECDSA signatures.
63 : : * @param coin_control Information about the context to determine the size of ECDSA signatures.
64 : : * @param tx_is_segwit Whether the transaction has at least a single input spending a segwit coin.
65 : : * @param can_grind_r Whether the signer will be able to grind the R of the signature.
66 : : */
67 : 200847 : static std::optional<int64_t> MaxInputWeight(const Descriptor& desc, const std::optional<CTxIn>& txin,
68 : : const CCoinControl* coin_control, const bool tx_is_segwit,
69 : : const bool can_grind_r) {
70 [ + + + + : 201553 : if (const auto sat_weight = desc.MaxSatisfactionWeight(!can_grind_r || UseMaxSig(txin, coin_control))) {
+ + ]
71 [ + - ]: 200844 : if (const auto elems_count = desc.MaxSatisfactionElems()) {
72 : 200844 : const bool is_segwit = IsSegwit(desc);
73 : : // Account for the size of the scriptsig and the number of elements on the witness stack. Note
74 : : // that if any input in the transaction is spending a witness program, we need to specify the
75 : : // witness stack size for every input regardless of whether it is segwit itself.
76 : : // NOTE: this also works in case of mixed scriptsig-and-witness such as in p2sh-wrapped segwit v0
77 : : // outputs. In this case the size of the scriptsig length will always be one (since the redeemScript
78 : : // is always a push of the witness program in this case, which is smaller than 253 bytes).
79 [ + + + + ]: 200844 : const int64_t scriptsig_len = is_segwit ? 1 : GetSizeOfCompactSize(*sat_weight / WITNESS_SCALE_FACTOR);
80 [ - + + + ]: 200844 : const int64_t witstack_len = is_segwit ? GetSizeOfCompactSize(*elems_count) : (tx_is_segwit ? 1 : 0);
81 : : // previous txid + previous vout + sequence + scriptsig len + witstack size + scriptsig or witness
82 : : // NOTE: sat_weight already accounts for the witness discount accordingly.
83 : 200844 : return (32 + 4 + 4 + scriptsig_len) * WITNESS_SCALE_FACTOR + witstack_len + *sat_weight;
84 : : }
85 : : }
86 : :
87 : 3 : return {};
88 : : }
89 : :
90 : 296138 : int CalculateMaximumSignedInputSize(const CTxOut& txout, const COutPoint outpoint, const SigningProvider* provider, bool can_grind_r, const CCoinControl* coin_control)
91 : : {
92 [ + + ]: 296138 : if (!provider) return -1;
93 : :
94 [ + - ]: 186071 : if (const auto desc = InferDescriptor(txout.scriptPubKey, *provider)) {
95 [ + - + + ]: 372142 : if (const auto weight = MaxInputWeight(*desc, {}, coin_control, true, can_grind_r)) {
96 [ + - ]: 186068 : return static_cast<int>(GetVirtualTransactionSize(*weight, 0, 0));
97 : : }
98 : 186068 : }
99 : :
100 : 3 : return -1;
101 : : }
102 : :
103 : 122246 : int CalculateMaximumSignedInputSize(const CTxOut& txout, const CWallet* wallet, const CCoinControl* coin_control)
104 : : {
105 : 122246 : const std::unique_ptr<SigningProvider> provider = wallet->GetSolvingProvider(txout.scriptPubKey);
106 [ + - + - ]: 244492 : return CalculateMaximumSignedInputSize(txout, COutPoint(), provider.get(), wallet->CanGrindR(), coin_control);
107 : 122246 : }
108 : :
109 : : /** Infer a descriptor for the given output script. */
110 : 26316 : static std::unique_ptr<Descriptor> GetDescriptor(const CWallet* wallet, const CCoinControl* coin_control,
111 : : const CScript script_pubkey)
112 : : {
113 : 26316 : MultiSigningProvider providers;
114 [ + - + + ]: 52576 : for (const auto spkman: wallet->GetScriptPubKeyMans(script_pubkey)) {
115 [ + - + - ]: 26260 : providers.AddProvider(spkman->GetSolvingProvider(script_pubkey));
116 : 0 : }
117 [ + + ]: 26316 : if (coin_control) {
118 [ + - + - : 23717 : providers.AddProvider(std::make_unique<FlatSigningProvider>(coin_control->m_external_provider));
- + ]
119 : : }
120 [ + - ]: 26316 : return InferDescriptor(script_pubkey, providers);
121 : 26316 : }
122 : :
123 : : /** Infer the maximum size of this input after it will be signed. */
124 : 16279 : static std::optional<int64_t> GetSignedTxinWeight(const CWallet* wallet, const CCoinControl* coin_control,
125 : : const CTxIn& txin, const CTxOut& txo, const bool tx_is_segwit,
126 : : const bool can_grind_r)
127 : : {
128 : : // If weight was provided, use that.
129 : 16279 : std::optional<int64_t> weight;
130 [ + + + + ]: 16279 : if (coin_control && (weight = coin_control->GetInputWeight(txin.prevout))) {
131 : 1503 : return weight.value();
132 : : }
133 : :
134 : : // Otherwise, use the maximum satisfaction size provided by the descriptor.
135 [ + - ]: 14776 : std::unique_ptr<Descriptor> desc{GetDescriptor(wallet, coin_control, txo.scriptPubKey)};
136 [ + - + - : 29552 : if (desc) return MaxInputWeight(*desc, {txin}, coin_control, tx_is_segwit, can_grind_r);
+ - ]
137 : :
138 : 0 : return {};
139 : 14776 : }
140 : :
141 : : // txouts needs to be in the order of tx.vin
142 : 3399 : TxSize CalculateMaximumSignedTxSize(const CTransaction &tx, const CWallet *wallet, const std::vector<CTxOut>& txouts, const CCoinControl* coin_control)
143 : : {
144 : : // version + nLockTime + input count + output count
145 [ + + + + ]: 3403 : int64_t weight = (4 + 4 + GetSizeOfCompactSize(tx.vin.size()) + GetSizeOfCompactSize(tx.vout.size())) * WITNESS_SCALE_FACTOR;
146 : : // Whether any input spends a witness program. Necessary to run before the next loop over the
147 : : // inputs in order to accurately compute the compactSize length for the witness data per input.
148 : 3399 : bool is_segwit = std::any_of(txouts.begin(), txouts.end(), [&](const CTxOut& txo) {
149 [ + - ]: 11540 : std::unique_ptr<Descriptor> desc{GetDescriptor(wallet, coin_control, txo.scriptPubKey)};
150 [ + - + - ]: 11540 : if (desc) return IsSegwit(*desc);
151 : : return false;
152 : 11540 : });
153 : : // Segwit marker and flag
154 [ + + ]: 3399 : if (is_segwit) weight += 2;
155 : :
156 : : // Add the size of the transaction outputs.
157 [ + + ]: 46562 : for (const auto& txo : tx.vout) weight += GetSerializeSize(txo) * WITNESS_SCALE_FACTOR;
158 : :
159 : : // Add the size of the transaction inputs as if they were signed.
160 [ + + ]: 19678 : for (uint32_t i = 0; i < txouts.size(); i++) {
161 : 16279 : const auto txin_weight = GetSignedTxinWeight(wallet, coin_control, tx.vin[i], txouts[i], is_segwit, wallet->CanGrindR());
162 [ - + ]: 16279 : if (!txin_weight) return TxSize{-1, -1};
163 [ - + ]: 16279 : assert(*txin_weight > -1);
164 : 16279 : weight += *txin_weight;
165 : : }
166 : :
167 : : // It's ok to use 0 as the number of sigops since we never create any pathological transaction.
168 : 3399 : return TxSize{GetVirtualTransactionSize(weight, 0, 0), weight};
169 : : }
170 : :
171 : 3399 : TxSize CalculateMaximumSignedTxSize(const CTransaction &tx, const CWallet *wallet, const CCoinControl* coin_control)
172 : : {
173 : 3399 : std::vector<CTxOut> txouts;
174 : : // Look up the inputs. The inputs are either in the wallet, or in coin_control.
175 [ + + ]: 19678 : for (const CTxIn& input : tx.vin) {
176 [ + - ]: 16279 : const auto mi = wallet->mapWallet.find(input.prevout.hash);
177 : : // Can not estimate size without knowing the input details
178 [ + + ]: 16279 : if (mi != wallet->mapWallet.end()) {
179 [ - + ]: 16243 : assert(input.prevout.n < mi->second.tx->vout.size());
180 [ + - + - ]: 16243 : txouts.emplace_back(mi->second.tx->vout.at(input.prevout.n));
181 [ + - ]: 36 : } else if (coin_control) {
182 [ + - ]: 36 : const auto& txout{coin_control->GetExternalOutput(input.prevout)};
183 [ - + ]: 36 : if (!txout) return TxSize{-1, -1};
184 [ + - ]: 36 : txouts.emplace_back(*txout);
185 : 36 : } else {
186 : 0 : return TxSize{-1, -1};
187 : : }
188 : : }
189 [ + - ]: 3399 : return CalculateMaximumSignedTxSize(tx, wallet, txouts, coin_control);
190 : 3399 : }
191 : :
192 : 1469 : size_t CoinsResult::Size() const
193 : : {
194 : 1469 : size_t size{0};
195 [ + + ]: 3740 : for (const auto& it : coins) {
196 : 2271 : size += it.second.size();
197 : : }
198 : 1469 : return size;
199 : : }
200 : :
201 : 2658 : std::vector<COutput> CoinsResult::All() const
202 : : {
203 : 2658 : std::vector<COutput> all;
204 [ + - ]: 2658 : all.reserve(coins.size());
205 [ + + ]: 5415 : for (const auto& it : coins) {
206 [ + - ]: 2757 : all.insert(all.end(), it.second.begin(), it.second.end());
207 : : }
208 : 2658 : return all;
209 : 0 : }
210 : :
211 : 709 : void CoinsResult::Clear() {
212 : 709 : coins.clear();
213 : 709 : }
214 : :
215 : 4 : void CoinsResult::Erase(const std::unordered_set<COutPoint, SaltedOutpointHasher>& coins_to_remove)
216 : : {
217 [ + + ]: 8 : for (auto& [type, vec] : coins) {
218 : 4 : auto remove_it = std::remove_if(vec.begin(), vec.end(), [&](const COutput& coin) {
219 : : // remove it if it's on the set
220 [ + + ]: 17 : if (coins_to_remove.count(coin.outpoint) == 0) return false;
221 : :
222 : : // update cached amounts
223 : 5 : total_amount -= coin.txout.nValue;
224 [ + - ]: 5 : if (coin.HasEffectiveValue()) total_effective_amount = *total_effective_amount - coin.GetEffectiveValue();
225 : : return true;
226 : : });
227 : 4 : vec.erase(remove_it, vec.end());
228 : : }
229 : 4 : }
230 : :
231 : 20 : void CoinsResult::Shuffle(FastRandomContext& rng_fast)
232 : : {
233 [ + + ]: 56 : for (auto& it : coins) {
234 : 36 : std::shuffle(it.second.begin(), it.second.end(), rng_fast);
235 : : }
236 : 20 : }
237 : :
238 : 290194 : void CoinsResult::Add(OutputType type, const COutput& out)
239 : : {
240 : 290194 : coins[type].emplace_back(out);
241 : 290194 : total_amount += out.txout.nValue;
242 [ + + ]: 290194 : if (out.HasEffectiveValue()) {
243 [ + - ]: 510578 : total_effective_amount = total_effective_amount.has_value() ?
244 : 510578 : *total_effective_amount + out.GetEffectiveValue() : out.GetEffectiveValue();
245 : : }
246 : 290194 : }
247 : :
248 : 173873 : static OutputType GetOutputType(TxoutType type, bool is_from_p2sh)
249 : : {
250 [ + + + + ]: 173873 : switch (type) {
251 : : case TxoutType::WITNESS_V1_TAPROOT:
252 : : return OutputType::BECH32M;
253 : 125959 : case TxoutType::WITNESS_V0_KEYHASH:
254 : 125959 : case TxoutType::WITNESS_V0_SCRIPTHASH:
255 [ + + ]: 125959 : if (is_from_p2sh) return OutputType::P2SH_SEGWIT;
256 : 116138 : else return OutputType::BECH32;
257 : 43977 : case TxoutType::SCRIPTHASH:
258 : 43977 : case TxoutType::PUBKEYHASH:
259 : 43977 : return OutputType::LEGACY;
260 : 33 : default:
261 : 33 : return OutputType::UNKNOWN;
262 : : }
263 : : }
264 : :
265 : : // Fetch and validate the coin control selected inputs.
266 : : // Coins could be internal (from the wallet) or external.
267 : 447 : util::Result<PreSelectedInputs> FetchSelectedInputs(const CWallet& wallet, const CCoinControl& coin_control,
268 : : const CoinSelectionParams& coin_selection_params)
269 : : {
270 [ + - ]: 447 : PreSelectedInputs result;
271 [ + - ]: 447 : const bool can_grind_r = wallet.CanGrindR();
272 [ + - + - ]: 447 : std::map<COutPoint, CAmount> map_of_bump_fees = wallet.chain().calculateIndividualBumpFees(coin_control.ListSelected(), coin_selection_params.m_effective_feerate);
273 [ + - + + ]: 6069 : for (const COutPoint& outpoint : coin_control.ListSelected()) {
274 [ + - + + ]: 5625 : int64_t input_bytes = coin_control.GetInputWeight(outpoint).value_or(-1);
275 [ + - ]: 2503 : if (input_bytes != -1) {
276 [ + - ]: 2503 : input_bytes = GetVirtualTransactionSize(input_bytes, 0, 0);
277 : : }
278 : 5625 : CTxOut txout;
279 [ + - + + ]: 5625 : if (auto ptr_wtx = wallet.GetWalletTx(outpoint.hash)) {
280 : : // Clearly invalid input, fail
281 [ - + ]: 5585 : if (ptr_wtx->tx->vout.size() <= outpoint.n) {
282 [ # # # # ]: 0 : return util::Error{strprintf(_("Invalid pre-selected input %s"), outpoint.ToString())};
283 : : }
284 [ + - ]: 5585 : txout = ptr_wtx->tx->vout.at(outpoint.n);
285 [ + + ]: 5585 : if (input_bytes == -1) {
286 [ + - ]: 3107 : input_bytes = CalculateMaximumSignedInputSize(txout, &wallet, &coin_control);
287 : : }
288 : : } else {
289 : : // The input is external. We did not find the tx in mapWallet.
290 [ + - ]: 40 : const auto out{coin_control.GetExternalOutput(outpoint)};
291 [ - + ]: 40 : if (!out) {
292 [ # # # # ]: 0 : return util::Error{strprintf(_("Not found pre-selected input %s"), outpoint.ToString())};
293 : : }
294 : :
295 : 40 : txout = *out;
296 : 40 : }
297 : :
298 [ + + ]: 3147 : if (input_bytes == -1) {
299 [ + - ]: 19 : input_bytes = CalculateMaximumSignedInputSize(txout, outpoint, &coin_control.m_external_provider, can_grind_r, &coin_control);
300 : : }
301 : :
302 [ + + ]: 19 : if (input_bytes == -1) {
303 [ + - + - ]: 9 : return util::Error{strprintf(_("Not solvable pre-selected input %s"), outpoint.ToString())}; // Not solvable, can't estimate size for fee
304 : : }
305 : :
306 : : /* Set some defaults for depth, spendable, solvable, safe, time, and from_me as these don't matter for preset inputs since no selection is being done. */
307 [ + - ]: 5622 : COutput output(outpoint, txout, /*depth=*/ 0, input_bytes, /*spendable=*/ true, /*solvable=*/ true, /*safe=*/ true, /*time=*/ 0, /*from_me=*/ false, coin_selection_params.m_effective_feerate);
308 [ + - ]: 5622 : output.ApplyBumpFee(map_of_bump_fees.at(output.outpoint));
309 [ + - ]: 5622 : result.Insert(output, coin_selection_params.m_subtract_fee_outputs);
310 : 5625 : }
311 : 444 : return result;
312 : 447 : }
313 : :
314 : 3685 : CoinsResult AvailableCoins(const CWallet& wallet,
315 : : const CCoinControl* coinControl,
316 : : std::optional<CFeeRate> feerate,
317 : : const CoinFilterParams& params)
318 : : {
319 : 3685 : AssertLockHeld(wallet.cs_wallet);
320 : :
321 [ + - ]: 3685 : CoinsResult result;
322 : : // Either the WALLET_FLAG_AVOID_REUSE flag is not set (in which case we always allow), or we default to avoiding, and only in the case where
323 : : // a coin control object is provided, and has the avoid address reuse flag set to false, do we allow already used addresses
324 [ + - + + : 3685 : bool allow_used_addresses = !wallet.IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE) || (coinControl && !coinControl->m_avoid_address_reuse);
+ - + + ]
325 [ + + ]: 3651 : const int min_depth = {coinControl ? coinControl->m_min_depth : DEFAULT_MIN_DEPTH};
326 : 7361 : const int max_depth = {coinControl ? coinControl->m_max_depth : DEFAULT_MAX_DEPTH};
327 [ + + ]: 3676 : const bool only_safe = {coinControl ? !coinControl->m_include_unsafe_inputs : true};
328 [ + - ]: 3685 : const bool can_grind_r = wallet.CanGrindR();
329 : 3685 : std::vector<COutPoint> outpoints;
330 : :
331 : 3685 : std::set<uint256> trusted_parents;
332 [ + + ]: 656445 : for (const auto& entry : wallet.mapWallet)
333 : : {
334 : 652760 : const uint256& txid = entry.first;
335 : 652760 : const CWalletTx& wtx = entry.second;
336 : :
337 [ + - + + : 652760 : if (wallet.IsTxImmatureCoinBase(wtx) && !params.include_immature_coinbase)
+ + ]
338 : 219351 : continue;
339 : :
340 [ + - ]: 433409 : int nDepth = wallet.GetTxDepthInMainChain(wtx);
341 [ + + ]: 433409 : if (nDepth < 0)
342 : 4125 : continue;
343 : :
344 : : // We should not consider coins which aren't at least in our mempool
345 : : // It's possible for these to be conflicted via ancestors which we may never be able to detect
346 [ + + + - : 429284 : if (nDepth == 0 && !wtx.InMempool())
+ + ]
347 : 4591 : continue;
348 : :
349 [ + - ]: 424693 : bool safeTx = CachedTxIsTrusted(wallet, wtx, trusted_parents);
350 : :
351 : : // We should not consider coins from transactions that are replacing
352 : : // other transactions.
353 : : //
354 : : // Example: There is a transaction A which is replaced by bumpfee
355 : : // transaction B. In this case, we want to prevent creation of
356 : : // a transaction B' which spends an output of B.
357 : : //
358 : : // Reason: If transaction A were initially confirmed, transactions B
359 : : // and B' would no longer be valid, so the user would have to create
360 : : // a new transaction C to replace B'. However, in the case of a
361 : : // one-block reorg, transactions B' and C might BOTH be accepted,
362 : : // when the user only wanted one of them. Specifically, there could
363 : : // be a 1-block reorg away from the chain where transactions A and C
364 : : // were accepted to another chain where B, B', and C were all
365 : : // accepted.
366 [ + + + - : 495025 : if (nDepth == 0 && wtx.mapValue.count("replaces_txid")) {
+ + + + ]
367 : 145 : safeTx = false;
368 : : }
369 : :
370 : : // Similarly, we should not consider coins from transactions that
371 : : // have been replaced. In the example above, we would want to prevent
372 : : // creation of a transaction A' spending an output of A, because if
373 : : // transaction B were initially confirmed, conflicting with A and
374 : : // A', we wouldn't want to the user to create a transaction D
375 : : // intending to replace A', but potentially resulting in a scenario
376 : : // where A, A', and D could all be accepted (instead of just B and
377 : : // D, or just A and A' like the user would want).
378 [ + + + - : 495025 : if (nDepth == 0 && wtx.mapValue.count("replaced_by_txid")) {
+ + + + ]
379 : 1 : safeTx = false;
380 : : }
381 : :
382 [ + + ]: 424693 : if (only_safe && !safeTx) {
383 : 1985 : continue;
384 : : }
385 : :
386 [ + + ]: 422708 : if (nDepth < min_depth || nDepth > max_depth) {
387 : 3945 : continue;
388 : : }
389 : :
390 [ + - ]: 418763 : bool tx_from_me = CachedTxIsFromMe(wallet, wtx, ISMINE_ALL);
391 : :
392 [ + + ]: 1560606 : for (unsigned int i = 0; i < wtx.tx->vout.size(); i++) {
393 [ + + ]: 1141843 : const CTxOut& output = wtx.tx->vout[i];
394 [ + + ]: 1141843 : const COutPoint outpoint(Txid::FromUint256(txid), i);
395 : :
396 [ + + - + ]: 1141843 : if (output.nValue < params.min_amount || output.nValue > params.max_amount)
397 : 153250 : continue;
398 : :
399 : : // Skip manually selected coins (the caller can fetch them directly)
400 [ + + + - : 988593 : if (coinControl && coinControl->HasSelected() && coinControl->IsSelected(outpoint))
+ + + - +
+ ]
401 : 4006 : continue;
402 : :
403 [ + - + + : 984587 : if (wallet.IsLockedCoin(outpoint) && params.skip_locked)
+ + ]
404 : 372 : continue;
405 : :
406 [ + - + + ]: 984215 : if (wallet.IsSpent(outpoint))
407 : 461594 : continue;
408 : :
409 [ + - ]: 522621 : isminetype mine = wallet.IsMine(output);
410 : :
411 [ + + ]: 522621 : if (mine == ISMINE_NO) {
412 : 348748 : continue;
413 : : }
414 : :
415 [ + + + - : 173873 : if (!allow_used_addresses && wallet.IsSpentKey(output.scriptPubKey)) {
+ - ]
416 : 0 : continue;
417 : : }
418 : :
419 [ + - ]: 173873 : std::unique_ptr<SigningProvider> provider = wallet.GetSolvingProvider(output.scriptPubKey);
420 : :
421 [ + - ]: 173873 : int input_bytes = CalculateMaximumSignedInputSize(output, COutPoint(), provider.get(), can_grind_r, coinControl);
422 : : // Because CalculateMaximumSignedInputSize infers a solvable descriptor to get the satisfaction size,
423 : : // it is safe to assume that this input is solvable if input_bytes is greater than -1.
424 : 173873 : bool solvable = input_bytes > -1;
425 [ - + - - : 173873 : bool spendable = ((mine & ISMINE_SPENDABLE) != ISMINE_NO) || (((mine & ISMINE_WATCH_ONLY) != ISMINE_NO) && (coinControl && coinControl->fAllowWatchOnly && solvable));
- - - - -
- ]
426 : :
427 : : // Filter by spendable outputs only
428 [ # # ]: 0 : if (!spendable && params.only_spendable) continue;
429 : :
430 : : // Obtain script type
431 : 173873 : std::vector<std::vector<uint8_t>> script_solutions;
432 [ + - ]: 173873 : TxoutType type = Solver(output.scriptPubKey, script_solutions);
433 : :
434 : : // If the output is P2SH and solvable, we want to know if it is
435 : : // a P2SH (legacy) or one of P2SH-P2WPKH, P2SH-P2WSH (P2SH-Segwit). We can determine
436 : : // this from the redeemScript. If the output is not solvable, it will be classified
437 : : // as a P2SH (legacy), since we have no way of knowing otherwise without the redeemScript
438 : 173873 : bool is_from_p2sh{false};
439 [ + + ]: 173873 : if (type == TxoutType::SCRIPTHASH && solvable) {
440 : 9838 : CScript script;
441 [ + - - + ]: 9838 : if (!provider->GetCScript(CScriptID(uint160(script_solutions[0])), script)) continue;
442 [ + - ]: 9838 : type = Solver(script, script_solutions);
443 : 9838 : is_from_p2sh = true;
444 : 9838 : }
445 : :
446 [ + - ]: 173873 : result.Add(GetOutputType(type, is_from_p2sh),
447 [ + - + - ]: 173873 : COutput(outpoint, output, nDepth, input_bytes, spendable, solvable, safeTx, wtx.GetTxTime(), tx_from_me, feerate));
448 : :
449 [ + - ]: 173873 : outpoints.push_back(outpoint);
450 : :
451 : : // Checks the sum amount of all UTXO's.
452 [ - + ]: 173873 : if (params.min_sum_amount != MAX_MONEY) {
453 [ # # ]: 0 : if (result.GetTotalAmount() >= params.min_sum_amount) {
454 : : return result;
455 : : }
456 : : }
457 : :
458 : : // Checks the maximum number of UTXO's.
459 [ - + - - : 173873 : if (params.max_count > 0 && result.Size() >= params.max_count) {
- - ]
460 : : return result;
461 : : }
462 : 173873 : }
463 : : }
464 : :
465 [ + + ]: 3685 : if (feerate.has_value()) {
466 [ + - ]: 3310 : std::map<COutPoint, CAmount> map_of_bump_fees = wallet.chain().calculateIndividualBumpFees(outpoints, feerate.value());
467 : :
468 [ + + ]: 8390 : for (auto& [_, outputs] : result.coins) {
469 [ + + ]: 144048 : for (auto& output : outputs) {
470 [ + - ]: 138968 : output.ApplyBumpFee(map_of_bump_fees.at(output.outpoint));
471 : : }
472 : : }
473 : 3310 : }
474 : :
475 : : return result;
476 : 3685 : }
477 : :
478 : 365 : CoinsResult AvailableCoinsListUnspent(const CWallet& wallet, const CCoinControl* coinControl, CoinFilterParams params)
479 : : {
480 : 365 : params.only_spendable = false;
481 : 365 : return AvailableCoins(wallet, coinControl, /*feerate=*/ std::nullopt, params);
482 : : }
483 : :
484 : 5 : const CTxOut& FindNonChangeParentOutput(const CWallet& wallet, const COutPoint& outpoint)
485 : : {
486 : 5 : AssertLockHeld(wallet.cs_wallet);
487 : 5 : const CWalletTx* wtx{Assert(wallet.GetWalletTx(outpoint.hash))};
488 : :
489 : 5 : const CTransaction* ptx = wtx->tx.get();
490 : 5 : int n = outpoint.n;
491 [ + - + - ]: 7 : while (OutputIsChange(wallet, ptx->vout[n]) && ptx->vin.size() > 0) {
492 : 7 : const COutPoint& prevout = ptx->vin[0].prevout;
493 : 7 : const CWalletTx* it = wallet.GetWalletTx(prevout.hash);
494 [ + - + - : 9 : if (!it || it->tx->vout.size() <= prevout.n ||
+ + ]
495 : 2 : !wallet.IsMine(it->tx->vout[prevout.n])) {
496 : : break;
497 : : }
498 : 2 : ptx = it->tx.get();
499 : 2 : n = prevout.n;
500 : : }
501 : 5 : return ptx->vout[n];
502 : : }
503 : :
504 : 3 : std::map<CTxDestination, std::vector<COutput>> ListCoins(const CWallet& wallet)
505 : : {
506 : 3 : AssertLockHeld(wallet.cs_wallet);
507 : :
508 [ + - ]: 3 : std::map<CTxDestination, std::vector<COutput>> result;
509 : :
510 [ + - ]: 3 : CCoinControl coin_control;
511 : : // Include watch-only for LegacyScriptPubKeyMan wallets without private keys
512 [ + - - + : 3 : coin_control.fAllowWatchOnly = wallet.GetLegacyScriptPubKeyMan() && wallet.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS);
- - - - ]
513 : 3 : CoinFilterParams coins_params;
514 : 3 : coins_params.only_spendable = false;
515 : 3 : coins_params.skip_locked = false;
516 [ + - + - : 8 : for (const COutput& coin : AvailableCoins(wallet, &coin_control, /*feerate=*/std::nullopt, coins_params).All()) {
+ + ]
517 : 5 : CTxDestination address;
518 [ - + - - : 5 : if ((coin.spendable || (wallet.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) && coin.solvable))) {
- - - - ]
519 [ + - + - : 5 : if (!ExtractDestination(FindNonChangeParentOutput(wallet, coin.outpoint).scriptPubKey, address)) {
+ - ]
520 : : // For backwards compatibility, we convert P2PK output scripts into PKHash destinations
521 [ - + ]: 5 : if (auto pk_dest = std::get_if<PubKeyDestination>(&address)) {
522 [ + - ]: 5 : address = PKHash(pk_dest->GetPubKey());
523 : : } else {
524 : 0 : continue;
525 : : }
526 : : }
527 [ + - + - ]: 5 : result[address].emplace_back(coin);
528 : : }
529 : 8 : }
530 : 3 : return result;
531 : 3 : }
532 : :
533 : 6477 : FilteredOutputGroups GroupOutputs(const CWallet& wallet,
534 : : const CoinsResult& coins,
535 : : const CoinSelectionParams& coin_sel_params,
536 : : const std::vector<SelectionFilter>& filters,
537 : : std::vector<OutputGroup>& ret_discarded_groups)
538 : : {
539 [ + + ]: 6477 : FilteredOutputGroups filtered_groups;
540 : :
541 [ + + ]: 6477 : if (!coin_sel_params.m_avoid_partial_spends) {
542 : : // Allowing partial spends means no grouping. Each COutput gets its own OutputGroup
543 [ + + ]: 10722 : for (const auto& [type, outputs] : coins.coins) {
544 [ + + ]: 522570 : for (const COutput& output : outputs) {
545 : : // Get mempool info
546 : 516852 : size_t ancestors, descendants;
547 [ + - ]: 516852 : wallet.chain().getTransactionAncestry(output.outpoint.hash, ancestors, descendants);
548 : :
549 : : // Create a new group per output and add it to the all groups vector
550 [ + - ]: 516852 : OutputGroup group(coin_sel_params);
551 [ + - + - ]: 516852 : group.Insert(std::make_shared<COutput>(output), ancestors, descendants);
552 : :
553 : : // Each filter maps to a different set of groups
554 : 516852 : bool accepted = false;
555 [ + + ]: 1839515 : for (const auto& sel_filter : filters) {
556 : 1322663 : const auto& filter = sel_filter.filter;
557 [ + - + + ]: 1322663 : if (!group.EligibleForSpending(filter)) continue;
558 [ + - + - ]: 1265998 : filtered_groups[filter].Push(group, type, /*insert_positive=*/true, /*insert_mixed=*/true);
559 : : accepted = true;
560 : : }
561 [ + + + - ]: 516852 : if (!accepted) ret_discarded_groups.emplace_back(group);
562 : 516852 : }
563 : : }
564 : : return filtered_groups;
565 : : }
566 : :
567 : : // We want to combine COutputs that have the same scriptPubKey into single OutputGroups
568 : : // except when there are more than OUTPUT_GROUP_MAX_ENTRIES COutputs grouped in an OutputGroup.
569 : : // To do this, we maintain a map where the key is the scriptPubKey and the value is a vector of OutputGroups.
570 : : // For each COutput, we check if the scriptPubKey is in the map, and if it is, the COutput is added
571 : : // to the last OutputGroup in the vector for the scriptPubKey. When the last OutputGroup has
572 : : // OUTPUT_GROUP_MAX_ENTRIES COutputs, a new OutputGroup is added to the end of the vector.
573 : 1473 : typedef std::map<std::pair<CScript, OutputType>, std::vector<OutputGroup>> ScriptPubKeyToOutgroup;
574 : 121619 : const auto& insert_output = [&](
575 : : const std::shared_ptr<COutput>& output, OutputType type, size_t ancestors, size_t descendants,
576 : : ScriptPubKeyToOutgroup& groups_map) {
577 [ + - ]: 120146 : std::vector<OutputGroup>& groups = groups_map[std::make_pair(output->txout.scriptPubKey,type)];
578 : :
579 [ + + ]: 120146 : if (groups.size() == 0) {
580 : : // No OutputGroups for this scriptPubKey yet, add one
581 : 76330 : groups.emplace_back(coin_sel_params);
582 : : }
583 : :
584 : : // Get the last OutputGroup in the vector so that we can add the COutput to it
585 : : // A pointer is used here so that group can be reassigned later if it is full.
586 : 120146 : OutputGroup* group = &groups.back();
587 : :
588 : : // Check if this OutputGroup is full. We limit to OUTPUT_GROUP_MAX_ENTRIES when using -avoidpartialspends
589 : : // to avoid surprising users with very high fees.
590 [ + + ]: 120146 : if (group->m_outputs.size() >= OUTPUT_GROUP_MAX_ENTRIES) {
591 : : // The last output group is full, add a new group to the vector and use that group for the insertion
592 : 228 : groups.emplace_back(coin_sel_params);
593 : 228 : group = &groups.back();
594 : : }
595 : :
596 : 120146 : group->Insert(output, ancestors, descendants);
597 : 120146 : };
598 : :
599 : 1473 : ScriptPubKeyToOutgroup spk_to_groups_map;
600 : 1473 : ScriptPubKeyToOutgroup spk_to_positive_groups_map;
601 [ + + ]: 3748 : for (const auto& [type, outs] : coins.coins) {
602 [ + + ]: 62357 : for (const COutput& output : outs) {
603 : 60082 : size_t ancestors, descendants;
604 [ + - ]: 60082 : wallet.chain().getTransactionAncestry(output.outpoint.hash, ancestors, descendants);
605 : :
606 [ + - ]: 60082 : const auto& shared_output = std::make_shared<COutput>(output);
607 : : // Filter for positive only before adding the output
608 [ + + ]: 60082 : if (output.GetEffectiveValue() > 0) {
609 [ + - ]: 60064 : insert_output(shared_output, type, ancestors, descendants, spk_to_positive_groups_map);
610 : : }
611 : :
612 : : // 'All' groups
613 [ + - ]: 60082 : insert_output(shared_output, type, ancestors, descendants, spk_to_groups_map);
614 : 60082 : }
615 : : }
616 : :
617 : : // Now we go through the entire maps and pull out the OutputGroups
618 : 4419 : const auto& push_output_groups = [&](const ScriptPubKeyToOutgroup& groups_map, bool positive_only) {
619 [ + + ]: 79276 : for (const auto& [script, groups] : groups_map) {
620 : : // Go through the vector backwards. This allows for the first item we deal with being the partial group.
621 [ + + ]: 152888 : for (auto group_it = groups.rbegin(); group_it != groups.rend(); group_it++) {
622 : 76558 : const OutputGroup& group = *group_it;
623 : :
624 : : // Each filter maps to a different set of groups
625 : 76558 : bool accepted = false;
626 [ + + ]: 535746 : for (const auto& sel_filter : filters) {
627 : 459188 : const auto& filter = sel_filter.filter;
628 [ + + ]: 459188 : if (!group.EligibleForSpending(filter)) continue;
629 : :
630 : : // Don't include partial groups if there are full groups too and we don't want partial groups
631 [ + + + + : 355066 : if (group_it == groups.rbegin() && groups.size() > 1 && !filter.m_include_partial_groups) {
+ + ]
632 : 124 : continue;
633 : : }
634 : :
635 : 354942 : OutputType type = script.second;
636 : : // Either insert the group into the positive-only groups or the mixed ones.
637 : 354942 : filtered_groups[filter].Push(group, type, positive_only, /*insert_mixed=*/!positive_only);
638 : 354942 : accepted = true;
639 : : }
640 [ + + ]: 76558 : if (!accepted) ret_discarded_groups.emplace_back(group);
641 : : }
642 : : }
643 : 4419 : };
644 : :
645 [ + - ]: 1473 : push_output_groups(spk_to_groups_map, /*positive_only=*/ false);
646 [ + - ]: 1473 : push_output_groups(spk_to_positive_groups_map, /*positive_only=*/ true);
647 : :
648 : 1473 : return filtered_groups;
649 : 1473 : }
650 : :
651 : 3427 : FilteredOutputGroups GroupOutputs(const CWallet& wallet,
652 : : const CoinsResult& coins,
653 : : const CoinSelectionParams& params,
654 : : const std::vector<SelectionFilter>& filters)
655 : : {
656 : 3427 : std::vector<OutputGroup> unused;
657 [ + - ]: 6854 : return GroupOutputs(wallet, coins, params, filters, unused);
658 : 3427 : }
659 : :
660 : : // Returns true if the result contains an error and the message is not empty
661 : 11334 : static bool HasErrorMsg(const util::Result<SelectionResult>& res) { return !util::ErrorString(res).empty(); }
662 : :
663 : 3495 : util::Result<SelectionResult> AttemptSelection(interfaces::Chain& chain, const CAmount& nTargetValue, OutputGroupTypeMap& groups,
664 : : const CoinSelectionParams& coin_selection_params, bool allow_mixed_output_types)
665 : : {
666 : : // Run coin selection on each OutputType and compute the Waste Metric
667 : 3495 : std::vector<SelectionResult> results;
668 [ + - + + ]: 8400 : for (auto& [type, group] : groups.groups_by_type) {
669 [ + - ]: 4957 : auto result{ChooseSelectionResult(chain, nTargetValue, group, coin_selection_params)};
670 : : // If any specific error message appears here, then something particularly wrong happened.
671 [ + - + + ]: 4957 : if (HasErrorMsg(result)) return result; // So let's return the specific error.
672 : : // Append the favorable result.
673 [ + + + - ]: 4905 : if (result) results.push_back(*result);
674 : 4905 : }
675 : : // If we have at least one solution for funding the transaction without mixing, choose the minimum one according to waste metric
676 : : // and return the result
677 [ + + + - : 6416 : if (results.size() > 0) return *std::min_element(results.begin(), results.end());
+ - ]
678 : :
679 : : // If we can't fund the transaction from any individual OutputType, run coin selection one last time
680 : : // over all available coins, which would allow mixing.
681 : : // If TypesCount() <= 1, there is nothing to mix.
682 [ + + + + ]: 470 : if (allow_mixed_output_types && groups.TypesCount() > 1) {
683 [ + - ]: 68 : return ChooseSelectionResult(chain, nTargetValue, groups.all_groups, coin_selection_params);
684 : : }
685 : : // Either mixing is not allowed and we couldn't find a solution from any single OutputType, or mixing was allowed and we still couldn't
686 : : // find a solution using all available coins
687 : 804 : return util::Error();
688 : 3495 : };
689 : :
690 : 5025 : util::Result<SelectionResult> ChooseSelectionResult(interfaces::Chain& chain, const CAmount& nTargetValue, Groups& groups, const CoinSelectionParams& coin_selection_params)
691 : : {
692 : : // Vector of results. We will choose the best one based on waste.
693 : 5025 : std::vector<SelectionResult> results;
694 : 5025 : std::vector<util::Result<SelectionResult>> errors;
695 : 10946 : auto append_error = [&] (util::Result<SelectionResult>&& result) {
696 : : // If any specific error message appears here, then something different from a simple "no selection found" happened.
697 : : // Let's save it, so it can be retrieved to the user if no other selection algorithm succeeded.
698 [ + + ]: 5921 : if (HasErrorMsg(result)) {
699 : 91 : errors.emplace_back(std::move(result));
700 : : }
701 : 10946 : };
702 : :
703 : : // Maximum allowed weight for selected coins.
704 [ + + ]: 5025 : int max_transaction_weight = coin_selection_params.m_max_tx_weight.value_or(MAX_STANDARD_TX_WEIGHT);
705 : 5025 : int tx_weight_no_input = coin_selection_params.tx_noinputs_size * WITNESS_SCALE_FACTOR;
706 : 5025 : int max_selection_weight = max_transaction_weight - tx_weight_no_input;
707 [ + + ]: 5025 : if (max_selection_weight <= 0) {
708 [ + - ]: 36 : return util::Error{_("Maximum transaction weight is less than transaction weight without inputs")};
709 : : }
710 : :
711 : : // SFFO frequently causes issues in the context of changeless input sets: skip BnB when SFFO is active
712 [ + + ]: 5013 : if (!coin_selection_params.m_subtract_fee_outputs) {
713 [ + - + + ]: 3541 : if (auto bnb_result{SelectCoinsBnB(groups.positive_group, nTargetValue, coin_selection_params.m_cost_of_change, max_selection_weight)}) {
714 [ + - ]: 116 : results.push_back(*bnb_result);
715 [ + - ]: 6966 : } else append_error(std::move(bnb_result));
716 : : }
717 : :
718 : : // Deduct change weight because remaining Coin Selection algorithms can create change output
719 : 5013 : int change_outputs_weight = coin_selection_params.change_output_size * WITNESS_SCALE_FACTOR;
720 : 5013 : max_selection_weight -= change_outputs_weight;
721 [ + + + - ]: 5013 : if (max_selection_weight < 0 && results.empty()) {
722 [ + - ]: 18 : return util::Error{_("Maximum transaction weight is too low, can not accommodate change output")};
723 : : }
724 : :
725 : : // The knapsack solver has some legacy behavior where it will spend dust outputs. We retain this behavior, so don't filter for positive only here.
726 [ + - + + ]: 5007 : if (auto knapsack_result{KnapsackSolver(groups.mixed_group, nTargetValue, coin_selection_params.m_min_change_target, coin_selection_params.rng_fast, max_selection_weight)}) {
727 [ + - ]: 3970 : results.push_back(*knapsack_result);
728 [ + - ]: 1037 : } else append_error(std::move(knapsack_result));
729 : :
730 [ + + ]: 5007 : if (coin_selection_params.m_effective_feerate > CFeeRate{3 * coin_selection_params.m_long_term_feerate}) { // Minimize input set for feerates of at least 3×LTFRE (default: 30 ṩ/vB+)
731 [ + - + + ]: 842 : if (auto cg_result{CoinGrinder(groups.positive_group, nTargetValue, coin_selection_params.m_min_change_target, max_selection_weight)}) {
732 [ + - ]: 470 : cg_result->RecalculateWaste(coin_selection_params.min_viable_change, coin_selection_params.m_cost_of_change, coin_selection_params.m_change_fee);
733 [ + - ]: 470 : results.push_back(*cg_result);
734 : : } else {
735 [ + - ]: 372 : append_error(std::move(cg_result));
736 : 842 : }
737 : : }
738 : :
739 [ + - + + ]: 5007 : if (auto srd_result{SelectCoinsSRD(groups.positive_group, nTargetValue, coin_selection_params.m_change_fee, coin_selection_params.rng_fast, max_selection_weight)}) {
740 [ + - ]: 3920 : results.push_back(*srd_result);
741 [ + - ]: 1087 : } else append_error(std::move(srd_result));
742 : :
743 [ + + ]: 5007 : if (results.empty()) {
744 : : // No solution found, retrieve the first explicit error (if any).
745 : : // future: add 'severity level' to errors so the worst one can be retrieved instead of the first one.
746 [ + + ]: 2040 : return errors.empty() ? util::Error() : std::move(errors.front());
747 : : }
748 : :
749 : : // If the chosen input set has unconfirmed inputs, check for synergies from overlapping ancestry
750 [ + + ]: 12446 : for (auto& result : results) {
751 : 8476 : std::vector<COutPoint> outpoints;
752 [ + - + - ]: 8476 : std::set<std::shared_ptr<COutput>> coins = result.GetInputSet();
753 : 8476 : CAmount summed_bump_fees = 0;
754 [ + + ]: 165514 : for (auto& coin : coins) {
755 [ + + ]: 157038 : if (coin->depth > 0) continue; // Bump fees only exist for unconfirmed inputs
756 [ + - ]: 1706 : outpoints.push_back(coin->outpoint);
757 : 1706 : summed_bump_fees += coin->ancestor_bump_fees;
758 : : }
759 [ + - ]: 8476 : std::optional<CAmount> combined_bump_fee = chain.calculateCombinedBumpFee(outpoints, coin_selection_params.m_effective_feerate);
760 [ - + ]: 8476 : if (!combined_bump_fee.has_value()) {
761 [ # # ]: 0 : return util::Error{_("Failed to calculate bump fees, because unconfirmed UTXOs depend on enormous cluster of unconfirmed transactions.")};
762 : : }
763 [ + + ]: 8476 : CAmount bump_fee_overestimate = summed_bump_fees - combined_bump_fee.value();
764 [ + + ]: 8476 : if (bump_fee_overestimate) {
765 [ + - ]: 11 : result.SetBumpFeeDiscount(bump_fee_overestimate);
766 : : }
767 [ + - ]: 8476 : result.RecalculateWaste(coin_selection_params.min_viable_change, coin_selection_params.m_cost_of_change, coin_selection_params.m_change_fee);
768 : 8476 : }
769 : :
770 : : // Choose the result with the least waste
771 : : // If the waste is the same, choose the one which spends more inputs.
772 [ + - + - ]: 7940 : return *std::min_element(results.begin(), results.end());
773 : 5025 : }
774 : :
775 : 3425 : util::Result<SelectionResult> SelectCoins(const CWallet& wallet, CoinsResult& available_coins, const PreSelectedInputs& pre_set_inputs,
776 : : const CAmount& nTargetValue, const CCoinControl& coin_control,
777 : : const CoinSelectionParams& coin_selection_params)
778 : : {
779 : : // Deduct preset inputs amount from the search target
780 : 3425 : CAmount selection_target = nTargetValue - pre_set_inputs.total_amount;
781 : :
782 : : // Return if automatic coin selection is disabled, and we don't cover the selection target
783 [ + + + + ]: 3425 : if (!coin_control.m_allow_other_inputs && selection_target > 0) {
784 : 24 : return util::Error{_("The preselected coins total amount does not cover the transaction target. "
785 : 12 : "Please allow other inputs to be automatically selected or include more coins manually")};
786 : : }
787 : :
788 : : // Return if we can cover the target only with the preset inputs
789 [ + + ]: 3413 : if (selection_target <= 0) {
790 [ + - ]: 349 : SelectionResult result(nTargetValue, SelectionAlgorithm::MANUAL);
791 [ + - ]: 349 : result.AddInputs(pre_set_inputs.coins, coin_selection_params.m_subtract_fee_outputs);
792 [ + - ]: 349 : result.RecalculateWaste(coin_selection_params.min_viable_change, coin_selection_params.m_cost_of_change, coin_selection_params.m_change_fee);
793 : 349 : return result;
794 : 349 : }
795 : :
796 : : // Return early if we cannot cover the target with the wallet's UTXO.
797 : : // We use the total effective value if we are not subtracting fee from outputs and 'available_coins' contains the data.
798 [ + + ]: 3064 : CAmount available_coins_total_amount = coin_selection_params.m_subtract_fee_outputs ? available_coins.GetTotalAmount() :
799 [ + - ]: 2444 : (available_coins.GetEffectiveTotalAmount().has_value() ? *available_coins.GetEffectiveTotalAmount() : 0);
800 [ + + ]: 3064 : if (selection_target > available_coins_total_amount) {
801 : 28 : return util::Error(); // Insufficient funds
802 : : }
803 : :
804 : : // Start wallet Coin Selection procedure
805 : 3050 : auto op_selection_result = AutomaticCoinSelection(wallet, available_coins, selection_target, coin_selection_params);
806 [ + + ]: 3050 : if (!op_selection_result) return op_selection_result;
807 : :
808 : : // If needed, add preset inputs to the automatic coin selection result
809 [ + + ]: 3039 : if (!pre_set_inputs.coins.empty()) {
810 [ + - ]: 80 : SelectionResult preselected(pre_set_inputs.total_amount, SelectionAlgorithm::MANUAL);
811 [ + - ]: 80 : preselected.AddInputs(pre_set_inputs.coins, coin_selection_params.m_subtract_fee_outputs);
812 [ + - ]: 80 : op_selection_result->Merge(preselected);
813 : 80 : op_selection_result->RecalculateWaste(coin_selection_params.min_viable_change,
814 : 80 : coin_selection_params.m_cost_of_change,
815 [ + - ]: 80 : coin_selection_params.m_change_fee);
816 : :
817 : : // Verify we haven't exceeded the maximum allowed weight
818 [ + + ]: 80 : int max_inputs_weight = coin_selection_params.m_max_tx_weight.value_or(MAX_STANDARD_TX_WEIGHT) - (coin_selection_params.tx_noinputs_size * WITNESS_SCALE_FACTOR);
819 [ + + ]: 80 : if (op_selection_result->GetWeight() > max_inputs_weight) {
820 [ + - ]: 4 : return util::Error{_("The combination of the pre-selected inputs and the wallet automatic inputs selection exceeds the transaction maximum weight. "
821 : 2 : "Please try sending a smaller amount or manually consolidating your wallet's UTXOs")};
822 : : }
823 : 80 : }
824 : 3037 : return op_selection_result;
825 : 3050 : }
826 : :
827 : 3050 : util::Result<SelectionResult> AutomaticCoinSelection(const CWallet& wallet, CoinsResult& available_coins, const CAmount& value_to_select, const CoinSelectionParams& coin_selection_params)
828 : : {
829 : 3050 : unsigned int limit_ancestor_count = 0;
830 : 3050 : unsigned int limit_descendant_count = 0;
831 : 3050 : wallet.chain().getPackageLimits(limit_ancestor_count, limit_descendant_count);
832 [ - + ]: 3050 : const size_t max_ancestors = (size_t)std::max<int64_t>(1, limit_ancestor_count);
833 [ - + ]: 3050 : const size_t max_descendants = (size_t)std::max<int64_t>(1, limit_descendant_count);
834 [ + - ]: 3050 : const bool fRejectLongChains = gArgs.GetBoolArg("-walletrejectlongchains", DEFAULT_WALLET_REJECT_LONG_CHAINS);
835 : :
836 : : // Cases where we have 101+ outputs all pointing to the same destination may result in
837 : : // privacy leaks as they will potentially be deterministically sorted. We solve that by
838 : : // explicitly shuffling the outputs before processing
839 [ + + + + ]: 3050 : if (coin_selection_params.m_avoid_partial_spends && available_coins.Size() > OUTPUT_GROUP_MAX_ENTRIES) {
840 : 20 : available_coins.Shuffle(coin_selection_params.rng_fast);
841 : : }
842 : :
843 : : // Coin Selection attempts to select inputs from a pool of eligible UTXOs to fund the
844 : : // transaction at a target feerate. If an attempt fails, more attempts may be made using a more
845 : : // permissive CoinEligibilityFilter.
846 : 3050 : {
847 : : // Place coins eligibility filters on a scope increasing order.
848 : 3050 : std::vector<SelectionFilter> ordered_filters{
849 : : // If possible, fund the transaction with confirmed UTXOs only. Prefer at least six
850 : : // confirmations on outputs received from other wallets and only spend confirmed change.
851 : : {CoinEligibilityFilter(1, 6, 0), /*allow_mixed_output_types=*/false},
852 : : {CoinEligibilityFilter(1, 1, 0)},
853 : 3050 : };
854 : : // Fall back to using zero confirmation change (but with as few ancestors in the mempool as
855 : : // possible) if we cannot fund the transaction otherwise.
856 [ + + ]: 3050 : if (wallet.m_spend_zero_conf_change) {
857 [ + - ]: 3048 : ordered_filters.push_back({CoinEligibilityFilter(0, 1, 2)});
858 [ + + + + : 9102 : ordered_filters.push_back({CoinEligibilityFilter(0, 1, std::min(size_t{4}, max_ancestors/3), std::min(size_t{4}, max_descendants/3))});
+ - ]
859 [ + - ]: 3048 : ordered_filters.push_back({CoinEligibilityFilter(0, 1, max_ancestors/2, max_descendants/2)});
860 : : // If partial groups are allowed, relax the requirement of spending OutputGroups (groups
861 : : // of UTXOs sent to the same address, which are obviously controlled by a single wallet)
862 : : // in their entirety.
863 [ + - ]: 3048 : ordered_filters.push_back({CoinEligibilityFilter(0, 1, max_ancestors-1, max_descendants-1, /*include_partial=*/true)});
864 : : // Try with unsafe inputs if they are allowed. This may spend unconfirmed outputs
865 : : // received from other wallets.
866 [ + + ]: 3048 : if (coin_selection_params.m_include_unsafe_inputs) {
867 [ + - ]: 7 : ordered_filters.push_back({CoinEligibilityFilter(/*conf_mine=*/0, /*conf_theirs*/0, max_ancestors-1, max_descendants-1, /*include_partial=*/true)});
868 : : }
869 : : // Try with unlimited ancestors/descendants. The transaction will still need to meet
870 : : // mempool ancestor/descendant policy to be accepted to mempool and broadcasted, but
871 : : // OutputGroups use heuristics that may overestimate ancestor/descendant counts.
872 [ + + ]: 3048 : if (!fRejectLongChains) {
873 [ + - ]: 58 : ordered_filters.push_back({CoinEligibilityFilter(0, 1, std::numeric_limits<uint64_t>::max(),
874 : : std::numeric_limits<uint64_t>::max(),
875 : : /*include_partial=*/true)});
876 : : }
877 : : }
878 : :
879 : : // Group outputs and map them by coin eligibility filter
880 : 3050 : std::vector<OutputGroup> discarded_groups;
881 [ + - ]: 3050 : FilteredOutputGroups filtered_groups = GroupOutputs(wallet, available_coins, coin_selection_params, ordered_filters, discarded_groups);
882 : :
883 : : // Check if we still have enough balance after applying filters (some coins might be discarded)
884 : 3050 : CAmount total_discarded = 0;
885 : 3050 : CAmount total_unconf_long_chain = 0;
886 [ + + ]: 3080 : for (const auto& group : discarded_groups) {
887 [ + - ]: 30 : total_discarded += group.GetSelectionAmount();
888 [ + + + + : 30 : if (group.m_ancestors >= max_ancestors || group.m_descendants >= max_descendants) total_unconf_long_chain += group.GetSelectionAmount();
+ - ]
889 : : }
890 : :
891 [ + + ]: 3050 : if (CAmount total_amount = available_coins.GetTotalAmount() - total_discarded < value_to_select) {
892 : : // Special case, too-long-mempool cluster.
893 [ + + ]: 2 : if (total_amount + total_unconf_long_chain > value_to_select) {
894 [ + - ]: 3 : return util::Error{_("Unconfirmed UTXOs are available, but spending them creates a chain of transactions that will be rejected by the mempool")};
895 : : }
896 : 2 : return util::Error{}; // General "Insufficient Funds"
897 : : }
898 : :
899 : : // Walk-through the filters until the solution gets found.
900 : : // If no solution is found, return the first detailed error (if any).
901 : : // future: add "error level" so the worst one can be picked instead.
902 : 3048 : std::vector<util::Result<SelectionResult>> res_detailed_errors;
903 [ + + ]: 5193 : for (const auto& select_filter : ordered_filters) {
904 : 5184 : auto it = filtered_groups.find(select_filter.filter);
905 [ + + ]: 5184 : if (it == filtered_groups.end()) continue;
906 : 6990 : if (auto res{AttemptSelection(wallet.chain(), value_to_select, it->second,
907 [ + - + + ]: 3495 : coin_selection_params, select_filter.allow_mixed_output_types)}) {
908 : 3039 : return res; // result found
909 : : } else {
910 : : // If any specific error message appears here, then something particularly wrong might have happened.
911 : : // Save the error and continue the selection process. So if no solutions gets found, we can return
912 : : // the detailed error to the upper layers.
913 [ + - + + : 456 : if (HasErrorMsg(res)) res_detailed_errors.emplace_back(std::move(res));
+ - ]
914 : 3495 : }
915 : : }
916 : :
917 : : // Return right away if we have a detailed error
918 [ + - ]: 9 : if (!res_detailed_errors.empty()) return std::move(res_detailed_errors.front());
919 : :
920 : :
921 : : // General "Insufficient Funds"
922 : 0 : return util::Error{};
923 : 6098 : }
924 : : }
925 : :
926 : 2590 : static bool IsCurrentForAntiFeeSniping(interfaces::Chain& chain, const uint256& block_hash)
927 : : {
928 [ + - ]: 2590 : if (chain.isInitialBlockDownload()) {
929 : : return false;
930 : : }
931 : 2590 : constexpr int64_t MAX_ANTI_FEE_SNIPING_TIP_AGE = 8 * 60 * 60; // in seconds
932 : 2590 : int64_t block_time;
933 : 2590 : CHECK_NONFATAL(chain.findBlock(block_hash, FoundBlock().time(block_time)));
934 [ + + ]: 2590 : if (block_time < (GetTime() - MAX_ANTI_FEE_SNIPING_TIP_AGE)) {
935 : 8 : return false;
936 : : }
937 : : return true;
938 : : }
939 : :
940 : : /**
941 : : * Set a height-based locktime for new transactions (uses the height of the
942 : : * current chain tip unless we are not synced with the current chain
943 : : */
944 : 2590 : static void DiscourageFeeSniping(CMutableTransaction& tx, FastRandomContext& rng_fast,
945 : : interfaces::Chain& chain, const uint256& block_hash, int block_height)
946 : : {
947 : : // All inputs must be added by now
948 [ - + ]: 2590 : assert(!tx.vin.empty());
949 : : // Discourage fee sniping.
950 : : //
951 : : // For a large miner the value of the transactions in the best block and
952 : : // the mempool can exceed the cost of deliberately attempting to mine two
953 : : // blocks to orphan the current best block. By setting nLockTime such that
954 : : // only the next block can include the transaction, we discourage this
955 : : // practice as the height restricted and limited blocksize gives miners
956 : : // considering fee sniping fewer options for pulling off this attack.
957 : : //
958 : : // A simple way to think about this is from the wallet's point of view we
959 : : // always want the blockchain to move forward. By setting nLockTime this
960 : : // way we're basically making the statement that we only want this
961 : : // transaction to appear in the next block; we don't want to potentially
962 : : // encourage reorgs by allowing transactions to appear at lower heights
963 : : // than the next block in forks of the best chain.
964 : : //
965 : : // Of course, the subsidy is high enough, and transaction volume low
966 : : // enough, that fee sniping isn't a problem yet, but by implementing a fix
967 : : // now we ensure code won't be written that makes assumptions about
968 : : // nLockTime that preclude a fix later.
969 [ + + ]: 2590 : if (IsCurrentForAntiFeeSniping(chain, block_hash)) {
970 : 2582 : tx.nLockTime = block_height;
971 : :
972 : : // Secondly occasionally randomly pick a nLockTime even further back, so
973 : : // that transactions that are delayed after signing for whatever reason,
974 : : // e.g. high-latency mix networks and some CoinJoin implementations, have
975 : : // better privacy.
976 [ + + ]: 5164 : if (rng_fast.randrange(10) == 0) {
977 [ - + ]: 558 : tx.nLockTime = std::max(0, int(tx.nLockTime) - int(rng_fast.randrange(100)));
978 : : }
979 : : } else {
980 : : // If our chain is lagging behind, we can't discourage fee sniping nor help
981 : : // the privacy of high-latency transactions. To avoid leaking a potentially
982 : : // unique "nLockTime fingerprint", set nLockTime to a constant.
983 : 8 : tx.nLockTime = 0;
984 : : }
985 : : // Sanity check all values
986 [ - + ]: 2590 : assert(tx.nLockTime < LOCKTIME_THRESHOLD); // Type must be block height
987 [ - + ]: 2590 : assert(tx.nLockTime <= uint64_t(block_height));
988 [ + + ]: 11139 : for (const auto& in : tx.vin) {
989 : : // Can not be FINAL for locktime to work
990 [ - + ]: 8549 : assert(in.nSequence != CTxIn::SEQUENCE_FINAL);
991 : : // May be MAX NONFINAL to disable both BIP68 and BIP125
992 [ + + ]: 8549 : if (in.nSequence == CTxIn::MAX_SEQUENCE_NONFINAL) continue;
993 : : // May be MAX BIP125 to disable BIP68 and enable BIP125
994 [ + - ]: 8342 : if (in.nSequence == MAX_BIP125_RBF_SEQUENCE) continue;
995 : : // The wallet does not support any other sequence-use right now.
996 : 0 : assert(false);
997 : : }
998 : 2590 : }
999 : :
1000 : 39869 : size_t GetSerializeSizeForRecipient(const CRecipient& recipient)
1001 : : {
1002 [ + - ]: 39869 : return ::GetSerializeSize(CTxOut(recipient.nAmount, GetScriptForDestination(recipient.dest)));
1003 : : }
1004 : :
1005 : 39869 : bool IsDust(const CRecipient& recipient, const CFeeRate& dustRelayFee)
1006 : : {
1007 [ + - + - ]: 39869 : return ::IsDust(CTxOut(recipient.nAmount, GetScriptForDestination(recipient.dest)), dustRelayFee);
1008 : : }
1009 : :
1010 : 3347 : static util::Result<CreatedTransactionResult> CreateTransactionInternal(
1011 : : CWallet& wallet,
1012 : : const std::vector<CRecipient>& vecSend,
1013 : : std::optional<unsigned int> change_pos,
1014 : : const CCoinControl& coin_control,
1015 : : bool sign) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet)
1016 : : {
1017 : 3347 : AssertLockHeld(wallet.cs_wallet);
1018 : :
1019 : 3347 : FastRandomContext rng_fast;
1020 [ + - ]: 3347 : CMutableTransaction txNew; // The resulting transaction that we make
1021 : :
1022 [ + + ]: 3347 : if (coin_control.m_version) {
1023 : 743 : txNew.version = coin_control.m_version.value();
1024 : : }
1025 : :
1026 [ + + ]: 3347 : CoinSelectionParams coin_selection_params{rng_fast}; // Parameters for coin selection, init with dummy
1027 : 3347 : coin_selection_params.m_avoid_partial_spends = coin_control.m_avoid_partial_spends;
1028 : 3347 : coin_selection_params.m_include_unsafe_inputs = coin_control.m_include_unsafe_inputs;
1029 [ + + + - ]: 3356 : coin_selection_params.m_max_tx_weight = coin_control.m_max_tx_weight.value_or(MAX_STANDARD_TX_WEIGHT);
1030 : 3347 : int minimum_tx_weight = MIN_STANDARD_TX_NONWITNESS_SIZE * WITNESS_SCALE_FACTOR;
1031 [ + - + + : 3347 : if (coin_selection_params.m_max_tx_weight.value() < minimum_tx_weight || coin_selection_params.m_max_tx_weight.value() > MAX_STANDARD_TX_WEIGHT) {
+ + ]
1032 [ + - ]: 9 : return util::Error{strprintf(_("Maximum transaction weight must be between %d and %d"), minimum_tx_weight, MAX_STANDARD_TX_WEIGHT)};
1033 : : }
1034 : : // Set the long term feerate estimate to the wallet's consolidate feerate
1035 : 3344 : coin_selection_params.m_long_term_feerate = wallet.m_consolidate_feerate;
1036 : : // Static vsize overhead + outputs vsize. 4 nVersion, 4 nLocktime, 1 input count, 1 witness overhead (dummy, flag, stack size)
1037 [ + + ]: 3344 : coin_selection_params.tx_noinputs_size = 10 + GetSizeOfCompactSize(vecSend.size()); // bytes for output count
1038 : :
1039 : 3344 : CAmount recipients_sum = 0;
1040 [ + + + - ]: 3344 : const OutputType change_type = wallet.TransactionChangeType(coin_control.m_change_type ? *coin_control.m_change_type : wallet.m_default_change_type, vecSend);
1041 : 3344 : ReserveDestination reservedest(&wallet, change_type);
1042 : 3344 : unsigned int outputs_to_subtract_fee_from = 0; // The number of outputs which we are subtracting the fee from
1043 [ + + ]: 43213 : for (const auto& recipient : vecSend) {
1044 [ + - + - : 39869 : if (IsDust(recipient, wallet.chain().relayDustFee())) {
- + ]
1045 [ # # ]: 0 : return util::Error{_("Transaction amount too small")};
1046 : : }
1047 : :
1048 : : // Include the fee cost for outputs.
1049 [ + - ]: 39869 : coin_selection_params.tx_noinputs_size += GetSerializeSizeForRecipient(recipient);
1050 : 39869 : recipients_sum += recipient.nAmount;
1051 : :
1052 [ + + ]: 39869 : if (recipient.fSubtractFeeFromAmount) {
1053 : 638 : outputs_to_subtract_fee_from++;
1054 : 638 : coin_selection_params.m_subtract_fee_outputs = true;
1055 : : }
1056 : : }
1057 : :
1058 : : // Create change script that will be used if we need change
1059 : 3344 : CScript scriptChange;
1060 [ + - ]: 3344 : bilingual_str error; // possible error str
1061 : :
1062 : : // coin control: send change to custom address
1063 [ + - ]: 3344 : if (!std::get_if<CNoDestination>(&coin_control.destChange)) {
1064 [ + - ]: 3344 : scriptChange = GetScriptForDestination(coin_control.destChange);
1065 : : } else { // no coin control: send change to newly generated address
1066 : : // Note: We use a new key here to keep it from being obvious which side is the change.
1067 : : // The drawback is that by not reusing a previous key, the change may be lost if a
1068 : : // backup is restored, if the backup doesn't have the new private key for the change.
1069 : : // If we reused the old key, it would be possible to add code to look for and
1070 : : // rediscover unknown transactions that were written with keys of ours to recover
1071 : : // post-backup change.
1072 : :
1073 : : // Reserve a new key pair from key pool. If it fails, provide a dummy
1074 : : // destination in case we don't need change.
1075 : 1672 : CTxDestination dest;
1076 [ + - ]: 1672 : auto op_dest = reservedest.GetReservedDestination(true);
1077 [ + + ]: 1672 : if (!op_dest) {
1078 [ + - + - : 84 : error = _("Transaction needs a change address, but we can't generate it.") + Untranslated(" ") + util::ErrorString(op_dest);
+ - + - ]
1079 : : } else {
1080 [ + - ]: 1658 : dest = *op_dest;
1081 [ + - ]: 3316 : scriptChange = GetScriptForDestination(dest);
1082 : : }
1083 : : // A valid destination implies a change script (and
1084 : : // vice-versa). An empty change script will abort later, if the
1085 : : // change keypool ran out, but change is required.
1086 [ + - + + : 1986 : CHECK_NONFATAL(IsValidDestination(dest) != scriptChange.empty());
+ - ]
1087 : 1672 : }
1088 [ + - ]: 3344 : CTxOut change_prototype_txout(0, scriptChange);
1089 : 3344 : coin_selection_params.change_output_size = GetSerializeSize(change_prototype_txout);
1090 : :
1091 : : // Get size of spending the change output
1092 [ + - ]: 3344 : int change_spend_size = CalculateMaximumSignedInputSize(change_prototype_txout, &wallet, /*coin_control=*/nullptr);
1093 : : // If the wallet doesn't know how to sign change output, assume p2sh-p2wpkh
1094 : : // as lower-bound to allow BnB to do it's thing
1095 [ + + ]: 3344 : if (change_spend_size == -1) {
1096 : 24 : coin_selection_params.change_spend_size = DUMMY_NESTED_P2WPKH_INPUT_SIZE;
1097 : : } else {
1098 : 3320 : coin_selection_params.change_spend_size = change_spend_size;
1099 : : }
1100 : :
1101 : : // Set discard feerate
1102 [ + - ]: 3344 : coin_selection_params.m_discard_feerate = GetDiscardRate(wallet);
1103 : :
1104 : : // Get the fee rate to use effective values in coin selection
1105 : 3344 : FeeCalculation feeCalc;
1106 [ + - ]: 3344 : coin_selection_params.m_effective_feerate = GetMinimumFeeRate(wallet, coin_control, &feeCalc);
1107 : : // Do not, ever, assume that it's fine to change the fee rate if the user has explicitly
1108 : : // provided one
1109 [ + + + + ]: 3344 : if (coin_control.m_feerate && coin_selection_params.m_effective_feerate > *coin_control.m_feerate) {
1110 [ + - + - : 63 : return util::Error{strprintf(_("Fee rate (%s) is lower than the minimum fee rate setting (%s)"), coin_control.m_feerate->ToString(FeeEstimateMode::SAT_VB), coin_selection_params.m_effective_feerate.ToString(FeeEstimateMode::SAT_VB))};
+ - ]
1111 : : }
1112 [ + + + + ]: 3323 : if (feeCalc.reason == FeeReason::FALLBACK && !wallet.m_allow_fallback_fee) {
1113 : : // eventually allow a fallback fee
1114 [ + - ]: 9 : return util::Error{strprintf(_("Fee estimation failed. Fallbackfee is disabled. Wait a few blocks or enable %s."), "-fallbackfee")};
1115 : : }
1116 : :
1117 : : // Calculate the cost of change
1118 : : // Cost of change is the cost of creating the change output + cost of spending the change output in the future.
1119 : : // For creating the change output now, we use the effective feerate.
1120 : : // For spending the change output in the future, we use the discard feerate for now.
1121 : : // So cost of change = (change output size * effective feerate) + (size of spending change output * discard feerate)
1122 [ + - ]: 3320 : coin_selection_params.m_change_fee = coin_selection_params.m_effective_feerate.GetFee(coin_selection_params.change_output_size);
1123 [ + - ]: 3320 : coin_selection_params.m_cost_of_change = coin_selection_params.m_discard_feerate.GetFee(coin_selection_params.change_spend_size) + coin_selection_params.m_change_fee;
1124 : :
1125 [ + - ]: 3320 : coin_selection_params.m_min_change_target = GenerateChangeTarget(std::floor(recipients_sum / vecSend.size()), coin_selection_params.m_change_fee, rng_fast);
1126 : :
1127 : : // The smallest change amount should be:
1128 : : // 1. at least equal to dust threshold
1129 : : // 2. at least 1 sat greater than fees to spend it at m_discard_feerate
1130 [ + - ]: 3320 : const auto dust = GetDustThreshold(change_prototype_txout, coin_selection_params.m_discard_feerate);
1131 [ + - ]: 3320 : const auto change_spend_fee = coin_selection_params.m_discard_feerate.GetFee(coin_selection_params.change_spend_size);
1132 [ + + ]: 3320 : coin_selection_params.min_viable_change = std::max(change_spend_fee + 1, dust);
1133 : :
1134 : : // Include the fees for things that aren't inputs, excluding the change output
1135 [ + + + - ]: 3320 : const CAmount not_input_fees = coin_selection_params.m_effective_feerate.GetFee(coin_selection_params.m_subtract_fee_outputs ? 0 : coin_selection_params.tx_noinputs_size);
1136 : 3320 : CAmount selection_target = recipients_sum + not_input_fees;
1137 : :
1138 : : // This can only happen if feerate is 0, and requested destinations are value of 0 (e.g. OP_RETURN)
1139 : : // and no pre-selected inputs. This will result in 0-input transaction, which is consensus-invalid anyways
1140 [ + + + - : 3320 : if (selection_target == 0 && !coin_control.HasSelected()) {
- + ]
1141 [ + - ]: 3 : return util::Error{_("Transaction requires one destination of non-0 value, a non-0 feerate, or a pre-selected input")};
1142 : : }
1143 : :
1144 : : // Fetch manually selected coins
1145 [ + - ]: 3319 : PreSelectedInputs preset_inputs;
1146 [ + - + + ]: 3319 : if (coin_control.HasSelected()) {
1147 [ + - ]: 446 : auto res_fetch_inputs = FetchSelectedInputs(wallet, coin_control, coin_selection_params);
1148 [ + + + - ]: 452 : if (!res_fetch_inputs) return util::Error{util::ErrorString(res_fetch_inputs)};
1149 [ + - ]: 443 : preset_inputs = *res_fetch_inputs;
1150 : 446 : }
1151 : :
1152 : : // Fetch wallet available coins if "other inputs" are
1153 : : // allowed (coins automatically selected by the wallet)
1154 [ + + ]: 3316 : CoinsResult available_coins;
1155 [ + + ]: 3316 : if (coin_control.m_allow_other_inputs) {
1156 [ + - ]: 6460 : available_coins = AvailableCoins(wallet, &coin_control, coin_selection_params.m_effective_feerate);
1157 : : }
1158 : :
1159 : : // Choose coins to use
1160 [ + - ]: 3316 : auto select_coins_res = SelectCoins(wallet, available_coins, preset_inputs, /*nTargetValue=*/selection_target, coin_control, coin_selection_params);
1161 [ + + ]: 3316 : if (!select_coins_res) {
1162 : : // 'SelectCoins' either returns a specific error message or, if empty, means a general "Insufficient funds".
1163 [ + - ]: 37 : const bilingual_str& err = util::ErrorString(select_coins_res);
1164 [ + + + - : 111 : return util::Error{err.empty() ?_("Insufficient funds") : err};
+ - ]
1165 : 37 : }
1166 : 3279 : const SelectionResult& result = *select_coins_res;
1167 : : TRACEPOINT(coin_selection, selected_coins,
1168 : : wallet.GetName().c_str(),
1169 : : GetAlgorithmName(result.GetAlgo()).c_str(),
1170 : : result.GetTarget(),
1171 : : result.GetWaste(),
1172 : 3279 : result.GetSelectedValue());
1173 : :
1174 : : // vouts to the payees
1175 [ + - ]: 3279 : txNew.vout.reserve(vecSend.size() + 1); // + 1 because of possible later insert
1176 [ + + ]: 43078 : for (const auto& recipient : vecSend)
1177 : : {
1178 [ + - + - ]: 79598 : txNew.vout.emplace_back(recipient.nAmount, GetScriptForDestination(recipient.dest));
1179 : : }
1180 [ + - ]: 3279 : const CAmount change_amount = result.GetChange(coin_selection_params.min_viable_change, coin_selection_params.m_change_fee);
1181 [ + + ]: 3279 : if (change_amount > 0) {
1182 [ + - ]: 3209 : CTxOut newTxOut(change_amount, scriptChange);
1183 [ + + ]: 3209 : if (!change_pos) {
1184 : : // Insert change txn at random position:
1185 : 3141 : change_pos = rng_fast.randrange(txNew.vout.size() + 1);
1186 [ - + ]: 68 : } else if ((unsigned int)*change_pos > txNew.vout.size()) {
1187 [ # # ]: 0 : return util::Error{_("Transaction change output index out of range")};
1188 : : }
1189 [ + - ]: 3209 : txNew.vout.insert(txNew.vout.begin() + *change_pos, newTxOut);
1190 : 3209 : } else {
1191 [ + + ]: 70 : change_pos = std::nullopt;
1192 : : }
1193 : :
1194 : : // Shuffle selected coins and fill in final vin
1195 [ + - ]: 3279 : std::vector<std::shared_ptr<COutput>> selected_coins = result.GetShuffledInputVector();
1196 : :
1197 [ + - + + : 3279 : if (coin_control.HasSelected() && coin_control.HasSelectedOrder()) {
+ + ]
1198 : : // When there are preselected inputs, we need to move them to be the first UTXOs
1199 : : // and have them be in the order selected. We can use stable_sort for this, where we
1200 : : // compare with the positions stored in coin_control. The COutputs that have positions
1201 : : // will be placed before those that don't, and those positions will be in order.
1202 [ + - ]: 424 : std::stable_sort(selected_coins.begin(), selected_coins.end(),
1203 : 15282 : [&coin_control](const std::shared_ptr<COutput>& a, const std::shared_ptr<COutput>& b) {
1204 : 15282 : auto a_pos = coin_control.GetSelectionPos(a->outpoint);
1205 : 15282 : auto b_pos = coin_control.GetSelectionPos(b->outpoint);
1206 [ + + + + ]: 15282 : if (a_pos.has_value() && b_pos.has_value()) {
1207 : 14764 : return a_pos.value() < b_pos.value();
1208 [ + + + - ]: 518 : } else if (a_pos.has_value() && !b_pos.has_value()) {
1209 : 79 : return true;
1210 : : } else {
1211 : : return false;
1212 : : }
1213 : : });
1214 : : }
1215 : :
1216 : : // The sequence number is set to non-maxint so that DiscourageFeeSniping
1217 : : // works.
1218 : : //
1219 : : // BIP125 defines opt-in RBF as any nSequence < maxint-1, so
1220 : : // we use the highest possible value in that range (maxint-2)
1221 : : // to avoid conflicting with other possible uses of nSequence,
1222 : : // and in the spirit of "smallest possible change from prior
1223 : : // behavior."
1224 : 3279 : bool use_anti_fee_sniping = true;
1225 [ + + + + ]: 6558 : const uint32_t default_sequence{coin_control.m_signal_bip125_rbf.value_or(wallet.m_signal_rbf) ? MAX_BIP125_RBF_SEQUENCE : CTxIn::MAX_SEQUENCE_NONFINAL};
1226 [ + - ]: 3279 : txNew.vin.reserve(selected_coins.size());
1227 [ + + ]: 17052 : for (const auto& coin : selected_coins) {
1228 [ + - ]: 13773 : std::optional<uint32_t> sequence = coin_control.GetSequence(coin->outpoint);
1229 [ + + ]: 13773 : if (sequence) {
1230 : : // If an input has a preset sequence, we can't do anti-fee-sniping
1231 : 1753 : use_anti_fee_sniping = false;
1232 : : }
1233 [ + + + - ]: 15526 : txNew.vin.emplace_back(coin->outpoint, CScript{}, sequence.value_or(default_sequence));
1234 : :
1235 [ + - ]: 13773 : auto scripts = coin_control.GetScripts(coin->outpoint);
1236 [ + + ]: 13773 : if (scripts.first) {
1237 : 1753 : txNew.vin.back().scriptSig = *scripts.first;
1238 : : }
1239 [ + + ]: 13773 : if (scripts.second) {
1240 [ + - ]: 13773 : txNew.vin.back().scriptWitness = *scripts.second;
1241 : : }
1242 : 13773 : }
1243 [ + + ]: 3279 : if (coin_control.m_locktime) {
1244 : 689 : txNew.nLockTime = coin_control.m_locktime.value();
1245 : : // If we have a locktime set, we can't use anti-fee-sniping
1246 : 689 : use_anti_fee_sniping = false;
1247 : : }
1248 [ + - ]: 3279 : if (use_anti_fee_sniping) {
1249 [ + - ]: 2590 : DiscourageFeeSniping(txNew, rng_fast, wallet.chain(), wallet.GetLastBlockHash(), wallet.GetLastBlockHeight());
1250 : : }
1251 : :
1252 : : // Calculate the transaction fee
1253 [ + - + - ]: 3279 : TxSize tx_sizes = CalculateMaximumSignedTxSize(CTransaction(txNew), &wallet, &coin_control);
1254 : 3279 : int nBytes = tx_sizes.vsize;
1255 [ - + ]: 3279 : if (nBytes == -1) {
1256 [ # # ]: 0 : return util::Error{_("Missing solving data for estimating transaction size")};
1257 : : }
1258 [ + - + - ]: 3279 : CAmount fee_needed = coin_selection_params.m_effective_feerate.GetFee(nBytes) + result.GetTotalBumpFees();
1259 : 3279 : const CAmount output_value = CalculateOutputValue(txNew);
1260 : 3279 : Assume(recipients_sum + change_amount == output_value);
1261 [ + - ]: 3279 : CAmount current_fee = result.GetSelectedValue() - output_value;
1262 : :
1263 : : // Sanity check that the fee cannot be negative as that means we have more output value than input value
1264 [ - + ]: 3279 : if (current_fee < 0) {
1265 [ # # # # ]: 0 : return util::Error{Untranslated(STR_INTERNAL_BUG("Fee paid < 0"))};
1266 : : }
1267 : :
1268 : : // If there is a change output and we overpay the fees then increase the change to match the fee needed
1269 [ + + + + ]: 3279 : if (change_pos && fee_needed < current_fee) {
1270 [ + - ]: 988 : auto& change = txNew.vout.at(*change_pos);
1271 : 988 : change.nValue += current_fee - fee_needed;
1272 [ + - ]: 988 : current_fee = result.GetSelectedValue() - CalculateOutputValue(txNew);
1273 [ - + ]: 988 : if (fee_needed != current_fee) {
1274 [ # # # # ]: 0 : return util::Error{Untranslated(STR_INTERNAL_BUG("Change adjustment: Fee needed != fee paid"))};
1275 : : }
1276 : : }
1277 : :
1278 : : // Reduce output values for subtractFeeFromAmount
1279 [ + + ]: 3279 : if (coin_selection_params.m_subtract_fee_outputs) {
1280 : 628 : CAmount to_reduce = fee_needed - current_fee;
1281 : 628 : unsigned int i = 0;
1282 : 628 : bool fFirst = true;
1283 [ + + ]: 1267 : for (const auto& recipient : vecSend)
1284 : : {
1285 [ + + + + ]: 640 : if (change_pos && i == *change_pos) {
1286 : 300 : ++i;
1287 : : }
1288 [ + + ]: 640 : CTxOut& txout = txNew.vout[i];
1289 : :
1290 [ + + ]: 640 : if (recipient.fSubtractFeeFromAmount)
1291 : : {
1292 : 636 : txout.nValue -= to_reduce / outputs_to_subtract_fee_from; // Subtract fee equally from each selected recipient
1293 : :
1294 [ + + ]: 636 : if (fFirst) // first receiver pays the remainder not divisible by output count
1295 : : {
1296 : 628 : fFirst = false;
1297 : 628 : txout.nValue -= to_reduce % outputs_to_subtract_fee_from;
1298 : : }
1299 : :
1300 : : // Error if this output is reduced to be below dust
1301 [ + - + - : 636 : if (IsDust(txout, wallet.chain().relayDustFee())) {
+ + ]
1302 [ + - ]: 1 : if (txout.nValue < 0) {
1303 [ + - ]: 3 : return util::Error{_("The transaction amount is too small to pay the fee")};
1304 : : } else {
1305 [ # # ]: 0 : return util::Error{_("The transaction amount is too small to send after the fee has been deducted")};
1306 : : }
1307 : : }
1308 : : }
1309 : 639 : ++i;
1310 : : }
1311 [ + - ]: 627 : current_fee = result.GetSelectedValue() - CalculateOutputValue(txNew);
1312 [ - + ]: 627 : if (fee_needed != current_fee) {
1313 [ # # # # ]: 0 : return util::Error{Untranslated(STR_INTERNAL_BUG("SFFO: Fee needed != fee paid"))};
1314 : : }
1315 : : }
1316 : :
1317 : : // fee_needed should now always be less than or equal to the current fees that we pay.
1318 : : // If it is not, it is a bug.
1319 [ - + ]: 3278 : if (fee_needed > current_fee) {
1320 [ # # # # ]: 0 : return util::Error{Untranslated(STR_INTERNAL_BUG("Fee needed > fee paid"))};
1321 : : }
1322 : :
1323 : : // Give up if change keypool ran out and change is required
1324 [ + + + + : 3908 : if (scriptChange.empty() && change_pos) {
+ + ]
1325 [ + - ]: 6 : return util::Error{error};
1326 : : }
1327 : :
1328 [ + + + - : 3276 : if (sign && !wallet.SignTransaction(txNew)) {
+ - ]
1329 [ # # ]: 0 : return util::Error{_("Signing transaction failed")};
1330 : : }
1331 : :
1332 : : // Return the constructed transaction data.
1333 [ + - ]: 3276 : CTransactionRef tx = MakeTransactionRef(std::move(txNew));
1334 : :
1335 : : // Limit size
1336 [ + + - + ]: 3276 : if ((sign && GetTransactionWeight(*tx) > MAX_STANDARD_TX_WEIGHT) ||
1337 [ + + ]: 896 : (!sign && tx_sizes.weight > MAX_STANDARD_TX_WEIGHT))
1338 : : {
1339 [ + - ]: 6 : return util::Error{_("Transaction too large")};
1340 : : }
1341 : :
1342 [ + + ]: 3274 : if (current_fee > wallet.m_default_max_tx_fee) {
1343 [ + - ]: 57 : return util::Error{TransactionErrorString(TransactionError::MAX_FEE_EXCEEDED)};
1344 : : }
1345 : :
1346 [ + - + - : 3255 : if (gArgs.GetBoolArg("-walletrejectlongchains", DEFAULT_WALLET_REJECT_LONG_CHAINS)) {
+ + ]
1347 : : // Lastly, ensure this tx will pass the mempool's chain limits
1348 [ + - ]: 3193 : auto result = wallet.chain().checkChainLimits(tx);
1349 [ + + ]: 3193 : if (!result) {
1350 [ + - ]: 3 : return util::Error{util::ErrorString(result)};
1351 : : }
1352 : 3193 : }
1353 : :
1354 : : // Before we return success, we assume any change key will be used to prevent
1355 : : // accidental reuse.
1356 [ + - ]: 3254 : reservedest.KeepDestination();
1357 : :
1358 [ + - + - : 3254 : wallet.WalletLogPrintf("Coin Selection: Algorithm:%s, Waste Metric Score:%d\n", GetAlgorithmName(result.GetAlgo()), result.GetWaste());
+ - ]
1359 [ + - ]: 3254 : wallet.WalletLogPrintf("Fee Calculation: Fee:%d Bytes:%u Tgt:%d (requested %d) Reason:\"%s\" Decay %.5f: Estimation: (%g - %g) %.2f%% %.1f/(%.1f %d mem %.1f out) Fail: (%g - %g) %.2f%% %.1f/(%.1f %d mem %.1f out)\n",
1360 : 0 : current_fee, nBytes, feeCalc.returnedTarget, feeCalc.desiredTarget, StringForFeeReason(feeCalc.reason), feeCalc.est.decay,
1361 : : feeCalc.est.pass.start, feeCalc.est.pass.end,
1362 [ + - ]: 3254 : (feeCalc.est.pass.totalConfirmed + feeCalc.est.pass.inMempool + feeCalc.est.pass.leftMempool) > 0.0 ? 100 * feeCalc.est.pass.withinTarget / (feeCalc.est.pass.totalConfirmed + feeCalc.est.pass.inMempool + feeCalc.est.pass.leftMempool) : 0.0,
1363 : : feeCalc.est.pass.withinTarget, feeCalc.est.pass.totalConfirmed, feeCalc.est.pass.inMempool, feeCalc.est.pass.leftMempool,
1364 : : feeCalc.est.fail.start, feeCalc.est.fail.end,
1365 [ + + + + ]: 3254 : (feeCalc.est.fail.totalConfirmed + feeCalc.est.fail.inMempool + feeCalc.est.fail.leftMempool) > 0.0 ? 100 * feeCalc.est.fail.withinTarget / (feeCalc.est.fail.totalConfirmed + feeCalc.est.fail.inMempool + feeCalc.est.fail.leftMempool) : 0.0,
1366 : : feeCalc.est.fail.withinTarget, feeCalc.est.fail.totalConfirmed, feeCalc.est.fail.inMempool, feeCalc.est.fail.leftMempool);
1367 [ + - - + : 9762 : return CreatedTransactionResult(tx, current_fee, change_pos, feeCalc);
+ - ]
1368 : 23293 : }
1369 : :
1370 : 1748 : util::Result<CreatedTransactionResult> CreateTransaction(
1371 : : CWallet& wallet,
1372 : : const std::vector<CRecipient>& vecSend,
1373 : : std::optional<unsigned int> change_pos,
1374 : : const CCoinControl& coin_control,
1375 : : bool sign)
1376 : : {
1377 [ - + ]: 1748 : if (vecSend.empty()) {
1378 : 0 : return util::Error{_("Transaction must have at least one recipient")};
1379 : : }
1380 : :
1381 [ - + - + : 8469 : if (std::any_of(vecSend.cbegin(), vecSend.cend(), [](const auto& recipient){ return recipient.nAmount < 0; })) {
- + - + -
+ - + - +
- + ]
1382 : 0 : return util::Error{_("Transaction amounts must not be negative")};
1383 : : }
1384 : :
1385 : 1748 : LOCK(wallet.cs_wallet);
1386 : :
1387 [ + - ]: 1748 : auto res = CreateTransactionInternal(wallet, vecSend, change_pos, coin_control, sign);
1388 : : TRACEPOINT(coin_selection, normal_create_tx_internal,
1389 : : wallet.GetName().c_str(),
1390 : : bool(res),
1391 : : res ? res->fee : 0,
1392 : 1748 : res && res->change_pos.has_value() ? int32_t(*res->change_pos) : -1);
1393 [ + + ]: 1748 : if (!res) return res;
1394 : 1659 : const auto& txr_ungrouped = *res;
1395 : : // try with avoidpartialspends unless it's enabled already
1396 [ + + + - : 1659 : if (txr_ungrouped.fee > 0 /* 0 means non-functional fee rate estimation */ && wallet.m_max_aps_fee > -1 && !coin_control.m_avoid_partial_spends) {
+ + ]
1397 : 1599 : TRACEPOINT(coin_selection, attempting_aps_create_tx, wallet.GetName().c_str());
1398 [ + - ]: 1599 : CCoinControl tmp_cc = coin_control;
1399 : 1599 : tmp_cc.m_avoid_partial_spends = true;
1400 : :
1401 : : // Reuse the change destination from the first creation attempt to avoid skipping BIP44 indexes
1402 [ + + ]: 1599 : if (txr_ungrouped.change_pos) {
1403 [ + - ]: 1564 : ExtractDestination(txr_ungrouped.tx->vout[*txr_ungrouped.change_pos].scriptPubKey, tmp_cc.destChange);
1404 : : }
1405 : :
1406 [ + - ]: 1599 : auto txr_grouped = CreateTransactionInternal(wallet, vecSend, change_pos, tmp_cc, sign);
1407 : : // if fee of this alternative one is within the range of the max fee, we use this one
1408 [ + + ]: 3194 : const bool use_aps{txr_grouped.has_value() ? (txr_grouped->fee <= txr_ungrouped.fee + wallet.m_max_aps_fee) : false};
1409 : : TRACEPOINT(coin_selection, aps_create_tx_internal,
1410 : : wallet.GetName().c_str(),
1411 : : use_aps,
1412 : : txr_grouped.has_value(),
1413 : : txr_grouped.has_value() ? txr_grouped->fee : 0,
1414 : 1599 : txr_grouped.has_value() && txr_grouped->change_pos.has_value() ? int32_t(*txr_grouped->change_pos) : -1);
1415 [ + + ]: 1599 : if (txr_grouped) {
1416 : 3190 : wallet.WalletLogPrintf("Fee non-grouped = %lld, grouped = %lld, using %s\n",
1417 [ + + + - ]: 1855 : txr_ungrouped.fee, txr_grouped->fee, use_aps ? "grouped" : "non-grouped");
1418 [ + + ]: 1595 : if (use_aps) return txr_grouped;
1419 : : }
1420 : 1599 : }
1421 : 324 : return res;
1422 [ + - ]: 3496 : }
1423 : :
1424 : 419 : util::Result<CreatedTransactionResult> FundTransaction(CWallet& wallet, const CMutableTransaction& tx, const std::vector<CRecipient>& vecSend, std::optional<unsigned int> change_pos, bool lockUnspents, CCoinControl coinControl)
1425 : : {
1426 : : // We want to make sure tx.vout is not used now that we are passing outputs as a vector of recipients.
1427 : : // This sets us up to remove tx completely in a future PR in favor of passing the inputs directly.
1428 [ - + ]: 419 : assert(tx.vout.empty());
1429 : :
1430 : : // Set the user desired locktime
1431 : 419 : coinControl.m_locktime = tx.nLockTime;
1432 : :
1433 : : // Set the user desired version
1434 : 419 : coinControl.m_version = tx.version;
1435 : :
1436 : : // Acquire the locks to prevent races to the new locked unspents between the
1437 : : // CreateTransaction call and LockCoin calls (when lockUnspents is true).
1438 : 419 : LOCK(wallet.cs_wallet);
1439 : :
1440 : : // Fetch specified UTXOs from the UTXO set to get the scriptPubKeys and values of the outputs being selected
1441 : : // and to match with the given solving_data. Only used for non-wallet outputs.
1442 : 419 : std::map<COutPoint, Coin> coins;
1443 [ + + ]: 3082 : for (const CTxIn& txin : tx.vin) {
1444 [ + - ]: 2663 : coins[txin.prevout]; // Create empty map entry keyed by prevout.
1445 : : }
1446 [ + - ]: 419 : wallet.chain().findCoins(coins);
1447 : :
1448 [ + + ]: 3081 : for (const CTxIn& txin : tx.vin) {
1449 : 2663 : const auto& outPoint = txin.prevout;
1450 [ + - ]: 2663 : PreselectedInput& preset_txin = coinControl.Select(outPoint);
1451 [ + - + + ]: 2663 : if (!wallet.IsMine(outPoint)) {
1452 [ + - + + ]: 24 : if (coins[outPoint].out.IsNull()) {
1453 [ + - ]: 3 : return util::Error{_("Unable to find UTXO for external input")};
1454 : : }
1455 : :
1456 : : // The input was not in the wallet, but is in the UTXO set, so select as external
1457 [ + - + - ]: 23 : preset_txin.SetTxOut(coins[outPoint].out);
1458 : : }
1459 [ + - ]: 2662 : preset_txin.SetSequence(txin.nSequence);
1460 [ + - ]: 2662 : preset_txin.SetScriptSig(txin.scriptSig);
1461 [ + - ]: 2662 : preset_txin.SetScriptWitness(txin.scriptWitness);
1462 : : }
1463 : :
1464 [ + - ]: 418 : auto res = CreateTransaction(wallet, vecSend, change_pos, coinControl, false);
1465 [ + + ]: 418 : if (!res) {
1466 : 68 : return res;
1467 : : }
1468 : :
1469 [ + + ]: 350 : if (lockUnspents) {
1470 [ + + ]: 8 : for (const CTxIn& txin : res->tx->vin) {
1471 [ + - ]: 4 : wallet.LockCoin(txin.prevout);
1472 : : }
1473 : : }
1474 : :
1475 : 350 : return res;
1476 [ + - ]: 1256 : }
1477 : : } // namespace wallet
|
