Receiving addresses, change and wallet address metadata

501    if (provider) {
502        auto inferred = InferDescriptor(scriptPubKey, *provider);
503        bool solvable = inferred->IsSolvable();
504        ret.pushKV("solvable", solvable);
505        if (solvable) {
506            ret.pushKV("desc", inferred->ToString());
507        }
508    } else {
509        ret.pushKV("solvable", false);
510    }
511
512    const auto& spk_mans = pwallet->GetScriptPubKeyMans(scriptPubKey);
513    // In most cases there is only one matching ScriptPubKey manager and we can't resolve ambiguity in a better way
514    ScriptPubKeyMan* spk_man{nullptr};
515    if (spk_mans.size()) spk_man = *spk_mans.begin();
516
517    DescriptorScriptPubKeyMan* desc_spk_man = dynamic_cast<DescriptorScriptPubKeyMan*>(spk_man);
518    if (desc_spk_man) {
519        std::string desc_str;
520        if (desc_spk_man->GetDescriptorString(desc_str, /*priv=*/false)) {
521            ret.pushKV("parent_desc", desc_str);
522        }
523    }
524
525    ret.pushKV("iswatchonly", false);
526
527    UniValue detail = DescribeWalletAddress(*pwallet, dest);
528    ret.pushKVs(std::move(detail));
529
530    ret.pushKV("ischange", ScriptIsChange(*pwallet, scriptPubKey));
531
532    if (spk_man) {
533        if (const std::unique_ptr<CKeyMetadata> meta = spk_man->GetMetadata(dest)) {
534            ret.pushKV("timestamp", meta->nCreateTime);
535            if (meta->has_key_origin) {
536                // In legacy wallets hdkeypath has always used an apostrophe for
537                // hardened derivation. Perhaps some external tool depends on that.
538                ret.pushKV("hdkeypath", WriteHDKeypath(meta->key_origin.path, /*apostrophe=*/!desc_spk_man));
539                ret.pushKV("hdseedid", meta->hd_seed_id.GetHex());
540                ret.pushKV("hdmasterfingerprint", HexStr(meta->key_origin.fingerprint));
541            }
542        }
543    }
544
545    // Return a `labels` array containing the label associated with the address,
546    // equivalent to the `label` field above. Currently only one label can be
547    // associated with an address, but we return an array so the API remains
548    // stable if we allow multiple labels to be associated with an address in
549    // the future.
550    UniValue labels(UniValue::VARR);
551    const auto* address_book_entry = pwallet->FindAddressBookEntry(dest);
552    if (address_book_entry) {
553        labels.push_back(address_book_entry->GetLabel());
554    }
555    ret.pushKV("labels", std::move(labels));
556
557    return ret;
558},
559    };
560}
561
562RPCMethod getaddressesbylabel()
563{
564    return RPCMethod{
565        "getaddressesbylabel",
566        "Returns the list of addresses assigned the specified label.\n",
567                {
568                    {"label", RPCArg::Type::STR, RPCArg::Optional::NO, "The label."},
569                },
570                RPCResult{
571                    RPCResult::Type::OBJ_DYN, "", "json object with addresses as keys",
572                    {
573                        {RPCResult::Type::OBJ, "address", "json object with information about address",
574                        {
575                            {RPCResult::Type::STR, "purpose", "Purpose of address (\"send\" for sending address, \"receive\" for receiving address)"},
576                        }},
577                    }
578                },
579                RPCExamples{
580                    HelpExampleCli("getaddressesbylabel", "\"tabby\"")
581            + HelpExampleRpc("getaddressesbylabel", "\"tabby\"")
582                },
583        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
584{
585    const std::shared_ptr<const CWallet> pwallet = GetWalletForJSONRPCRequest(request);
586    if (!pwallet) return UniValue::VNULL;
587
588    LOCK(pwallet->cs_wallet);
589
590    const std::string label{LabelFromValue(request.params[0])};
591
592    // Find all addresses that have the given label
593    UniValue ret(UniValue::VOBJ);
594    std::set<std::string> addresses;
595    pwallet->ForEachAddrBookEntry([&](const CTxDestination& _dest, const std::string& _label, bool _is_change, const std::optional<AddressPurpose>& _purpose) {
596        if (_is_change) return;
597        if (_label == label) {
598            std::string address = EncodeDestination(_dest);
599            // CWallet::m_address_book is not expected to contain duplicate
600            // address strings, but build a separate set as a precaution just in
601            // case it does.
602            bool unique = addresses.emplace(address).second;
603            CHECK_NONFATAL(unique);
604            // UniValue::pushKV checks if the key exists in O(N)
605            // and since duplicate addresses are unexpected (checked with
606            // std::set in O(log(N))), UniValue::pushKVEnd is used instead,
607            // which currently is O(1).
608            UniValue value(UniValue::VOBJ);
609            value.pushKV("purpose", _purpose ? PurposeToString(*_purpose) : "unknown");
610            ret.pushKVEnd(address, std::move(value));
611        }
612    });
613
614    if (ret.empty()) {
615        throw JSONRPCError(RPC_WALLET_INVALID_LABEL_NAME, std::string("No addresses with label " + label));
616    }
617
618    return ret;
619},
620    };
621}
622
623RPCMethod listlabels()
624{
625    return RPCMethod{
626        "listlabels",
627        "Returns the list of all labels, or labels that are assigned to addresses with a specific purpose.\n",
628                {
629                    {"purpose", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "Address purpose to list labels for ('send','receive'). An empty string is the same as not providing this argument."},
630                },
631                RPCResult{
632                    RPCResult::Type::ARR, "", "",
633                    {
634                        {RPCResult::Type::STR, "label", "Label name"},
635                    }
636                },
637                RPCExamples{
638            "\nList all labels\n"
639            + HelpExampleCli("listlabels", "") +
640            "\nList labels that have receiving addresses\n"
641            + HelpExampleCli("listlabels", "receive") +
642            "\nList labels that have sending addresses\n"
643            + HelpExampleCli("listlabels", "send") +
644            "\nAs a JSON-RPC call\n"
645            + HelpExampleRpc("listlabels", R"("receive")")
646                },
647        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
648{
649    const std::shared_ptr<const CWallet> pwallet = GetWalletForJSONRPCRequest(request);
650    if (!pwallet) return UniValue::VNULL;
651
652    LOCK(pwallet->cs_wallet);
653
654    std::optional<AddressPurpose> purpose;
655    if (!request.params[0].isNull()) {
656        std::string purpose_str = request.params[0].get_str();
657        if (!purpose_str.empty()) {
658            purpose = PurposeFromString(purpose_str);
659            if (!purpose) {
660                throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid 'purpose' argument, must be a known purpose string, typically 'send', or 'receive'.");
661            }
662        }
663    }
664
665    // Add to a set to sort by label name, then insert into Univalue array
666    std::set<std::string> label_set = pwallet->ListAddrBookLabels(purpose);
667
668    UniValue ret(UniValue::VARR);
669    for (const std::string& name : label_set) {
670        ret.push_back(name);
671    }
672
673    return ret;
674},
675    };
676}
677
678
679#ifdef ENABLE_EXTERNAL_SIGNER
680RPCMethod walletdisplayaddress()
681{
682    return RPCMethod{
683        "walletdisplayaddress",
684        "Display address on an external signer for verification.",
685        {
686            {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "bitcoin address to display"},
687        },
688        RPCResult{
689            RPCResult::Type::OBJ,"","",
690            {
691                {RPCResult::Type::STR, "address", "The address as confirmed by the signer"},
692            }
693        },
694        RPCExamples{""},
695        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
696        {
697            std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
698            if (!wallet) return UniValue::VNULL;
699            CWallet* const pwallet = wallet.get();
700
701            LOCK(pwallet->cs_wallet);
702
703            CTxDestination dest = DecodeDestination(request.params[0].get_str());
704
705            // Make sure the destination is valid
706            if (!IsValidDestination(dest)) {
707                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address");
708            }
709
710            util::Result<void> res = pwallet->DisplayAddress(dest);
711            if (!res) throw JSONRPCError(RPC_MISC_ERROR, util::ErrorString(res).original);
712
713            UniValue result(UniValue::VOBJ);
714            result.pushKV("address", request.params[0].get_str());
715            return result;
716        }
717    };
718}
719#endif // ENABLE_EXTERNAL_SIGNER
720} // namespace wallet
721