251        case TxoutType::WITNESS_V0_KEYHASH:
252        case TxoutType::WITNESS_V0_SCRIPTHASH:
253            if (is_from_p2sh) return OutputType::P2SH_SEGWIT;
254            else return OutputType::BECH32;
255        case TxoutType::SCRIPTHASH:
256        case TxoutType::PUBKEYHASH:
257            return OutputType::LEGACY;
258        default:
259            return OutputType::UNKNOWN;
260    }
261}
262
263// Fetch and validate the coin control selected inputs.
264// Coins could be internal (from the wallet) or external.
265util::Result<CoinsResult> FetchSelectedInputs(const CWallet& wallet, const CCoinControl& coin_control,
266                                            const CoinSelectionParams& coin_selection_params)
267{
268    CoinsResult result;
269    const bool can_grind_r = wallet.CanGrindR();
270    std::map<COutPoint, CAmount> map_of_bump_fees = wallet.chain().calculateIndividualBumpFees(coin_control.ListSelected(), coin_selection_params.m_effective_feerate);
271    for (const COutPoint& outpoint : coin_control.ListSelected()) {
272        int64_t input_bytes = coin_control.GetInputWeight(outpoint).value_or(-1);
273        if (input_bytes != -1) {
274            input_bytes = GetVirtualTransactionSize(input_bytes, 0, 0);
275        }
276        CTxOut txout;
277        if (auto txo = wallet.GetTXO(outpoint)) {
278            txout = txo->GetTxOut();
279            if (input_bytes == -1) {
280                input_bytes = CalculateMaximumSignedInputSize(txout, &wallet, &coin_control);
281            }
282            const CWalletTx& parent_tx = txo->GetWalletTx();
283            if (wallet.GetTxDepthInMainChain(parent_tx) == 0) {
284                if (parent_tx.GetTx()->version == TRUC_VERSION && coin_control.m_version != TRUC_VERSION) {
285                    return util::Error{strprintf(_("Can't spend unconfirmed version 3 pre-selected input with a version %d tx"), coin_control.m_version)};
286                } else if (coin_control.m_version == TRUC_VERSION && parent_tx.GetTx()->version != TRUC_VERSION) {
287                    return util::Error{strprintf(_("Can't spend unconfirmed version %d pre-selected input with a version 3 tx"), parent_tx.GetTx()->version)};
288                }
289            }
290        } else {
291            // The input is external. We did not find the tx in mapWallet.
292            const auto out{coin_control.GetExternalOutput(outpoint)};
293            if (!out) {
294                return util::Error{strprintf(_("Not found pre-selected input %s"), outpoint.ToString())};
295            }
296
297            txout = *out;
298        }
299
300        if (input_bytes == -1) {
301            input_bytes = CalculateMaximumSignedInputSize(txout, outpoint, &coin_control.m_external_provider, can_grind_r, &coin_control);
302        }
303
304        if (input_bytes == -1) {
305            return util::Error{strprintf(_("Not solvable pre-selected input %s"), outpoint.ToString())}; // Not solvable, can't estimate size for fee
306        }
307
308        /* Set some defaults for depth, solvable, safe, time, and from_me as these don't matter for preset inputs since no selection is being done. */
309        COutput output(outpoint, txout, /*depth=*/0, input_bytes, /*solvable=*/true, /*safe=*/true, /*time=*/0, /*from_me=*/false, coin_selection_params.m_effective_feerate);
310        output.ApplyBumpFee(map_of_bump_fees.at(output.outpoint));
311        result.Add(OutputType::UNKNOWN, output);
312    }
313    return result;
314}
315
316CoinsResult AvailableCoins(const CWallet& wallet,
317                           const CCoinControl* coinControl,
318                           std::optional<CFeeRate> feerate,
319                           const CoinFilterParams& params)
320{
321    AssertLockHeld(wallet.cs_wallet);
322
323    CoinsResult result;
324    // track unconfirmed truc outputs separately if we are tracking trucness
325    std::vector<std::pair<OutputType, COutput>> unconfirmed_truc_coins;
326    std::unordered_map<Txid, CAmount, SaltedTxidHasher> truc_txid_by_value;
327    // 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
328    // a coin control object is provided, and has the avoid address reuse flag set to false, do we allow already used addresses
329    bool allow_used_addresses = !wallet.IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE) || (coinControl && !coinControl->m_avoid_address_reuse);
330    const int min_depth = {coinControl ? coinControl->m_min_depth : DEFAULT_MIN_DEPTH};
331    const int max_depth = {coinControl ? coinControl->m_max_depth : DEFAULT_MAX_DEPTH};
332    const bool only_safe = {coinControl ? !coinControl->m_include_unsafe_inputs : true};
333    const bool can_grind_r = wallet.CanGrindR();
334    std::vector<COutPoint> outpoints;
335
336    std::set<Txid> trusted_parents;
337    // Cache for whether each tx passes the tx level checks (first bool), and whether the transaction is "safe" (second bool)
338    std::unordered_map<Txid, std::pair<bool, bool>, SaltedTxidHasher> tx_safe_cache;
339    for (const auto& [outpoint, txo] : wallet.GetTXOs()) {
340        const CWalletTx& wtx = txo.GetWalletTx();
341        const CTxOut& output = txo.GetTxOut();
342
343        if (tx_safe_cache.contains(outpoint.hash) && !tx_safe_cache.at(outpoint.hash).first) {
344            continue;
345        }
346
347        int nDepth = wallet.GetTxDepthInMainChain(wtx);
348
349        // Perform tx level checks if we haven't already come across outputs from this tx before.
350        if (!tx_safe_cache.contains(outpoint.hash)) {
351            tx_safe_cache[outpoint.hash] = {false, false};
352
353            if (wallet.IsTxImmatureCoinBase(wtx) && !params.include_immature_coinbase)
354                continue;
355
356            if (nDepth < 0)
357                continue;
358
359            // We should not consider coins which aren't at least in our mempool
360            // It's possible for these to be conflicted via ancestors which we may never be able to detect
361            if (nDepth == 0 && !wtx.InMempool())
362                continue;
363
364            bool safeTx = CachedTxIsTrusted(wallet, wtx, trusted_parents);
365
366            // We should not consider coins from transactions that are replacing
367            // other transactions.
368            //
369            // Example: There is a transaction A which is replaced by bumpfee
370            // transaction B. In this case, we want to prevent creation of
371            // a transaction B' which spends an output of B.
372            //
373            // Reason: If transaction A were initially confirmed, transactions B
374            // and B' would no longer be valid, so the user would have to create
375            // a new transaction C to replace B'. However, in the case of a
376            // one-block reorg, transactions B' and C might BOTH be accepted,
377            // when the user only wanted one of them. Specifically, there could
378            // be a 1-block reorg away from the chain where transactions A and C
379            // were accepted to another chain where B, B', and C were all
380            // accepted.
381            if (nDepth == 0 && wtx.m_replaces_txid) {
382                safeTx = false;
383            }
384
385            // Similarly, we should not consider coins from transactions that
386            // have been replaced. In the example above, we would want to prevent
387            // creation of a transaction A' spending an output of A, because if
388            // transaction B were initially confirmed, conflicting with A and
389            // A', we wouldn't want to the user to create a transaction D
390            // intending to replace A', but potentially resulting in a scenario
391            // where A, A', and D could all be accepted (instead of just B and
392            // D, or just A and A' like the user would want).
393            if (nDepth == 0 && wtx.m_replaced_by_txid) {
394                safeTx = false;
395            }
396
397            if (nDepth == 0 && params.check_version_trucness) {
398                if (coinControl->m_version == TRUC_VERSION) {
399                    if (wtx.GetTx()->version != TRUC_VERSION) continue;
400                    // this unconfirmed v3 transaction already has a child
401                    if (wtx.truc_child_in_mempool.has_value()) continue;
402
403                    // this unconfirmed v3 transaction has a parent: spending would create a third generation
404                    size_t ancestors, unused_cluster_count;
405                    wallet.chain().getTransactionAncestry(wtx.GetTx()->GetHash(), ancestors, unused_cluster_count);
406                    if (ancestors > 1) continue;
407                } else {
408                    if (wtx.GetTx()->version == TRUC_VERSION) continue;
409                }
410            }
411
412            if (only_safe && !safeTx) {
413                continue;
414            }
415
416            if (nDepth < min_depth || nDepth > max_depth) {
417                continue;
418            }
419
420            tx_safe_cache[outpoint.hash] = {true, safeTx};
421        }
422        const auto& [tx_ok, tx_safe] = tx_safe_cache.at(outpoint.hash);
423        if (!Assume(tx_ok)) {
424            continue;
425        }
426
427        if (output.nValue < params.min_amount || output.nValue > params.max_amount)
428            continue;
429
430        // Skip manually selected coins (the caller can fetch them directly)
431        if (coinControl && coinControl->HasSelected() && coinControl->IsSelected(outpoint))
432            continue;
433
434        if (wallet.IsLockedCoin(outpoint) && params.skip_locked)
435            continue;
436
437        if (wallet.IsSpent(outpoint))
438            continue;
439
440        if (!allow_used_addresses && wallet.IsSpentKey(output.scriptPubKey)) {
441            continue;
442        }
443
444        bool tx_from_me = CachedTxIsFromMe(wallet, wtx);
445
446        std::unique_ptr<SigningProvider> provider = wallet.GetSolvingProvider(output.scriptPubKey);
447
448        int input_bytes = CalculateMaximumSignedInputSize(output, COutPoint(), provider.get(), can_grind_r, coinControl);
449        // Because CalculateMaximumSignedInputSize infers a solvable descriptor to get the satisfaction size,
450        // it is safe to assume that this input is solvable if input_bytes is greater than -1.
451        bool solvable = input_bytes > -1;
452
453        // Obtain script type
454        std::vector<std::vector<uint8_t>> script_solutions;
455        TxoutType type = Solver(output.scriptPubKey, script_solutions);
456
457        // If the output is P2SH and solvable, we want to know if it is
458        // a P2SH (legacy) or one of P2SH-P2WPKH, P2SH-P2WSH (P2SH-Segwit). We can determine
459        // this from the redeemScript. If the output is not solvable, it will be classified
460        // as a P2SH (legacy), since we have no way of knowing otherwise without the redeemScript
461        bool is_from_p2sh{false};
462        if (type == TxoutType::SCRIPTHASH && solvable) {
463            CScript script;
464            if (!provider->GetCScript(CScriptID(uint160(script_solutions[0])), script)) continue;
465            type = Solver(script, script_solutions);
466            is_from_p2sh = true;
467        }
468
469        auto available_output_type = GetOutputType(type, is_from_p2sh);
470        auto available_output = COutput(outpoint, output, nDepth, input_bytes, solvable, tx_safe, wtx.GetTxTime(), tx_from_me, feerate);
471        if (wtx.GetTx()->version == TRUC_VERSION && nDepth == 0 && params.check_version_trucness) {
472            unconfirmed_truc_coins.emplace_back(available_output_type, available_output);
473            auto [it, _] = truc_txid_by_value.try_emplace(wtx.GetTx()->GetHash(), 0);
474            it->second += output.nValue;
475        } else {
476            result.Add(available_output_type, available_output);
477        }
478
479        outpoints.push_back(outpoint);
480
481        // Checks the sum amount of all UTXO's.
482        if (params.min_sum_amount != MAX_MONEY) {
483            if (result.GetTotalAmount() >= params.min_sum_amount) {
484                return result;
485            }
486        }
487
488        // Checks the maximum number of UTXO's.
489        if (params.max_count > 0 && result.Size() >= params.max_count) {
490            return result;
491        }
492    }
493
494    // Return all the coins from one TRUC transaction, that have the highest value.
495    // This could be improved in the future by encoding these restrictions in
496    // the coin selection itself so that we don't have to filter out
497    // other unconfirmed TRUC coins beforehand.
498    if (params.check_version_trucness && unconfirmed_truc_coins.size() > 0) {
499        auto highest_value_truc_tx = std::max_element(truc_txid_by_value.begin(), truc_txid_by_value.end(), [](const auto& tx1, const auto& tx2){
500                return tx1.second < tx2.second;