LCOV - code coverage report
Current view: top level - src/wallet - spend.cpp (source / functions) Hit Total Coverage
Test: fuzz_coverage.info Lines: 15 735 2.0 %
Date: 2023-10-05 12:38:51 Functions: 8 49 16.3 %
Branches: 11 1363 0.8 %

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

Generated by: LCOV version 1.14