Wallet balances, unspent outputs and local coin locks

501                            {RPCResult::Type::BOOL, "spendable", "(DEPRECATED) Always true"},
502                            {RPCResult::Type::BOOL, "solvable", "Whether we know how to spend this output, ignoring the lack of keys"},
503                            {RPCResult::Type::BOOL, "reused", /*optional=*/true, "(only present if avoid_reuse is set) Whether this output is reused/dirty (sent to an address that was previously spent from)"},
504                            {RPCResult::Type::STR, "desc", /*optional=*/true, "(only when solvable) A descriptor for spending this output"},
505                            {RPCResult::Type::ARR, "parent_descs", /*optional=*/false, "List of parent descriptors for the output script of this coin.", {
506                                {RPCResult::Type::STR, "desc", "The descriptor string."},
507                            }},
508                            {RPCResult::Type::BOOL, "safe", "Whether this output is considered safe to spend. Unconfirmed transactions\n"
509                                                            "from outside keys and unconfirmed replacement transactions are considered unsafe\n"
510                                                            "and are not eligible for spending by fundrawtransaction and sendtoaddress."},
511                        }},
512                    }
513                },
514                RPCExamples{
515                    HelpExampleCli("listunspent", "")
516            + HelpExampleCli("listunspent", "6 9999999 \"[\\\"" + EXAMPLE_ADDRESS[0] + "\\\",\\\"" + EXAMPLE_ADDRESS[1] + "\\\"]\"")
517            + HelpExampleRpc("listunspent", strprintf(R"(6, 9999999, ["%s","%s"])", EXAMPLE_ADDRESS[0], EXAMPLE_ADDRESS[1]))
518            + HelpExampleCli("listunspent", "6 9999999 '[]' true '{ \"minimumAmount\": 0.005 }'")
519            + HelpExampleRpc("listunspent", "6, 9999999, [] , true, { \"minimumAmount\": 0.005 } ")
520                },
521        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
522{
523    const std::shared_ptr<const CWallet> pwallet = GetWalletForJSONRPCRequest(request);
524    if (!pwallet) return UniValue::VNULL;
525
526    int nMinDepth = 1;
527    if (!request.params[0].isNull()) {
528        nMinDepth = request.params[0].getInt<int>();
529    }
530
531    int nMaxDepth = 9999999;
532    if (!request.params[1].isNull()) {
533        nMaxDepth = request.params[1].getInt<int>();
534    }
535
536    std::set<CTxDestination> destinations;
537    if (!request.params[2].isNull()) {
538        UniValue inputs = request.params[2].get_array();
539        for (unsigned int idx = 0; idx < inputs.size(); idx++) {
540            const UniValue& input = inputs[idx];
541            CTxDestination dest = DecodeDestination(input.get_str());
542            if (!IsValidDestination(dest)) {
543                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Bitcoin address: ") + input.get_str());
544            }
545            if (!destinations.insert(dest).second) {
546                throw JSONRPCError(RPC_INVALID_PARAMETER, std::string("Invalid parameter, duplicated address: ") + input.get_str());
547            }
548        }
549    }
550
551    bool include_unsafe = true;
552    if (!request.params[3].isNull()) {
553        include_unsafe = request.params[3].get_bool();
554    }
555
556    CoinFilterParams filter_coins;
557    filter_coins.min_amount = 0;
558
559    if (!request.params[4].isNull()) {
560        const UniValue& options = request.params[4].get_obj();
561
562        RPCTypeCheckObj(options,
563            {
564                {"minimumAmount", UniValueType()},
565                {"maximumAmount", UniValueType()},
566                {"minimumSumAmount", UniValueType()},
567                {"maximumCount", UniValueType(UniValue::VNUM)},
568                {"include_immature_coinbase", UniValueType(UniValue::VBOOL)}
569            },
570            true, true);
571
572        if (options.exists("minimumAmount"))
573            filter_coins.min_amount = AmountFromValue(options["minimumAmount"]);
574
575        if (options.exists("maximumAmount"))
576            filter_coins.max_amount = AmountFromValue(options["maximumAmount"]);
577
578        if (options.exists("minimumSumAmount"))
579            filter_coins.min_sum_amount = AmountFromValue(options["minimumSumAmount"]);
580
581        if (options.exists("maximumCount"))
582            filter_coins.max_count = options["maximumCount"].getInt<int64_t>();
583
584        if (options.exists("include_immature_coinbase")) {
585            filter_coins.include_immature_coinbase = options["include_immature_coinbase"].get_bool();
586        }
587    }
588
589    // Make sure the results are valid at least up to the most recent block
590    // the user could have gotten from another RPC command prior to now
591    pwallet->BlockUntilSyncedToCurrentChain();
592
593    UniValue results(UniValue::VARR);
594    std::vector<COutput> vecOutputs;
595    {
596        CCoinControl cctl;
597        cctl.m_avoid_address_reuse = false;
598        cctl.m_min_depth = nMinDepth;
599        cctl.m_max_depth = nMaxDepth;
600        cctl.m_include_unsafe_inputs = include_unsafe;
601        filter_coins.check_version_trucness = false;
602        LOCK(pwallet->cs_wallet);
603        vecOutputs = AvailableCoins(*pwallet, &cctl, /*feerate=*/std::nullopt, filter_coins).All();
604    }
605
606    LOCK(pwallet->cs_wallet);
607
608    const bool avoid_reuse = pwallet->IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE);
609
610    for (const COutput& out : vecOutputs) {
611        CTxDestination address;
612        const CScript& scriptPubKey = out.txout.scriptPubKey;
613        bool fValidAddress = ExtractDestination(scriptPubKey, address);
614        bool reused = avoid_reuse && pwallet->IsSpentKey(scriptPubKey);
615
616        if (destinations.size() && (!fValidAddress || !destinations.contains(address)))
617            continue;
618
619        UniValue entry(UniValue::VOBJ);
620        entry.pushKV("txid", out.outpoint.hash.GetHex());
621        entry.pushKV("vout", out.outpoint.n);
622
623        if (fValidAddress) {
624            entry.pushKV("address", EncodeDestination(address));
625
626            const auto* address_book_entry = pwallet->FindAddressBookEntry(address);
627            if (address_book_entry) {
628                entry.pushKV("label", address_book_entry->GetLabel());
629            }
630
631            std::unique_ptr<SigningProvider> provider = pwallet->GetSolvingProvider(scriptPubKey);
632            if (provider) {
633                if (scriptPubKey.IsPayToScriptHash()) {
634                    const CScriptID hash = ToScriptID(std::get<ScriptHash>(address));
635                    CScript redeemScript;
636                    if (provider->GetCScript(hash, redeemScript)) {
637                        entry.pushKV("redeemScript", HexStr(redeemScript));
638                        // Now check if the redeemScript is actually a P2WSH script
639                        CTxDestination witness_destination;
640                        if (redeemScript.IsPayToWitnessScriptHash()) {
641                            bool extracted = ExtractDestination(redeemScript, witness_destination);
642                            CHECK_NONFATAL(extracted);
643                            // Also return the witness script
644                            const WitnessV0ScriptHash& whash = std::get<WitnessV0ScriptHash>(witness_destination);
645                            CScriptID id{RIPEMD160(whash)};
646                            CScript witnessScript;
647                            if (provider->GetCScript(id, witnessScript)) {
648                                entry.pushKV("witnessScript", HexStr(witnessScript));
649                            }
650                        }
651                    }
652                } else if (scriptPubKey.IsPayToWitnessScriptHash()) {
653                    const WitnessV0ScriptHash& whash = std::get<WitnessV0ScriptHash>(address);
654                    CScriptID id{RIPEMD160(whash)};
655                    CScript witnessScript;
656                    if (provider->GetCScript(id, witnessScript)) {
657                        entry.pushKV("witnessScript", HexStr(witnessScript));
658                    }
659                }
660            }
661        }
662
663        entry.pushKV("scriptPubKey", HexStr(scriptPubKey));
664        entry.pushKV("amount", ValueFromAmount(out.txout.nValue));
665        entry.pushKV("confirmations", out.depth);
666        if (!out.depth) {
667            size_t ancestor_count, unused_cluster_count, ancestor_size;
668            CAmount ancestor_fees;
669            pwallet->chain().getTransactionAncestry(out.outpoint.hash, ancestor_count, unused_cluster_count, &ancestor_size, &ancestor_fees);
670            if (ancestor_count) {
671                entry.pushKV("ancestorcount", ancestor_count);
672                entry.pushKV("ancestorsize", ancestor_size);
673                entry.pushKV("ancestorfees", ancestor_fees);
674            }
675        }
676        entry.pushKV("spendable", true); // Any coins we list are always spendable
677        entry.pushKV("solvable", out.solvable);
678        if (out.solvable) {
679            std::unique_ptr<SigningProvider> provider = pwallet->GetSolvingProvider(scriptPubKey);
680            if (provider) {
681                auto descriptor = InferDescriptor(scriptPubKey, *provider);
682                entry.pushKV("desc", descriptor->ToString());
683            }
684        }
685        PushParentDescriptors(*pwallet, scriptPubKey, entry);
686        if (avoid_reuse) entry.pushKV("reused", reused);
687        entry.pushKV("safe", out.safe);
688        results.push_back(std::move(entry));
689    }
690
691    return results;
692},
693    };
694}
695} // namespace wallet
696