5#include <bitcoin-build-config.h>
24 "\nReturns a new Bitcoin address for receiving payments.\n"
25 "If 'label' is specified, it is added to the address book \n"
26 "so payments received with the address will be associated with 'label'.\n",
28 {
"label",
RPCArg::Type::STR,
RPCArg::Default{
""},
"The label name for the address to be linked to. It can also be set to the empty string \"\" to represent the default label. The label does not need to exist, it will be created if there is no label by the given name."},
29 {
"address_type",
RPCArg::Type::STR,
RPCArg::DefaultHint{
"set by -addresstype"},
"The address type to use. Options are \"legacy\", \"p2sh-segwit\", \"bech32\", and \"bech32m\"."},
43 LOCK(pwallet->cs_wallet);
45 if (!pwallet->CanGetAddresses()) {
52 OutputType output_type = pwallet->m_default_address_type;
53 if (!request.params[1].isNull()) {
54 std::optional<OutputType> parsed =
ParseOutputType(request.params[1].get_str());
58 output_type = parsed.value();
61 auto op_dest = pwallet->GetNewDestination(output_type, label);
74 "\nReturns a new Bitcoin address, for receiving change.\n"
75 "This is for use with raw transactions, NOT normal use.\n",
77 {
"address_type",
RPCArg::Type::STR,
RPCArg::DefaultHint{
"set by -changetype"},
"The address type to use. Options are \"legacy\", \"p2sh-segwit\", \"bech32\", and \"bech32m\"."},
91 LOCK(pwallet->cs_wallet);
93 if (!pwallet->CanGetAddresses(
true)) {
97 OutputType output_type = pwallet->m_default_change_type.value_or(pwallet->m_default_address_type);
98 if (!request.params[0].isNull()) {
99 std::optional<OutputType> parsed =
ParseOutputType(request.params[0].get_str());
103 output_type = parsed.value();
106 auto op_dest = pwallet->GetNewChangeDestination(output_type);
119 "\nSets the label associated with the given address.\n",
134 LOCK(pwallet->cs_wallet);
143 if (pwallet->IsMine(dest)) {
157 "\nLists groups of addresses which have had their common ownership\n"
158 "made public by common use as inputs or as the resulting change\n"
159 "in past transactions\n",
186 pwallet->BlockUntilSyncedToCurrentChain();
188 LOCK(pwallet->cs_wallet);
200 const auto* address_book_entry = pwallet->FindAddressBookEntry(address);
201 if (address_book_entry) {
202 addressInfo.
push_back(address_book_entry->GetLabel());
205 jsonGrouping.
push_back(std::move(addressInfo));
207 jsonGroupings.
push_back(std::move(jsonGrouping));
209 return jsonGroupings;
217 "Refills each descriptor keypool in the wallet up to the specified number of new keys.\n"
218 "By default, descriptor wallets have 4 active ranged descriptors (\"legacy\", \"p2sh-segwit\", \"bech32\", and \"bech32m\"), each with " +
util::ToString(
DEFAULT_KEYPOOL_SIZE) +
" entries.\n" +
233 LOCK(pwallet->cs_wallet);
236 unsigned int kpSize = 0;
237 if (!request.params[0].isNull()) {
238 if (request.params[0].getInt<
int>() < 0)
240 kpSize = (
unsigned int)request.params[0].getInt<
int>();
244 pwallet->TopUpKeyPool(kpSize);
246 if (pwallet->GetKeyPoolSize() < kpSize) {
264 std::vector<std::vector<unsigned char>> solutions_data;
275 UniValue wallet_detail = std::visit(*
this, embedded);
276 subobj.
pushKVs(std::move(wallet_detail));
280 if (subobj.
exists(
"pubkey")) obj.
pushKV(
"pubkey", subobj[
"pubkey"]);
281 obj.
pushKV(
"embedded", std::move(subobj));
284 obj.
pushKV(
"sigsrequired", solutions_data[0][0]);
286 for (
size_t i = 1; i < solutions_data.size() - 1; ++i) {
287 CPubKey key(solutions_data[i].begin(), solutions_data[i].end());
290 obj.
pushKV(
"pubkeys", std::move(pubkeys));
356 std::unique_ptr<SigningProvider> provider =
nullptr;
366 "\nReturn information about the given bitcoin address.\n"
367 "Some of the information will only be present if the address is in the active wallet.\n",
378 {
RPCResult::Type::BOOL,
"solvable",
"If we know how to spend coins sent to this address, ignoring the possible lack of private keys."},
379 {
RPCResult::Type::STR,
"desc",
true,
"A descriptor for spending coins sent to this address (only when solvable)."},
380 {
RPCResult::Type::STR,
"parent_desc",
true,
"The descriptor used to derive this address if this is a descriptor wallet"},
386 {
RPCResult::Type::STR,
"script",
true,
"The output script type. Only if isscript is true and the redeemscript is known. Possible\n"
387 "types: nonstandard, pubkey, pubkeyhash, scripthash, multisig, nulldata, witness_v0_keyhash,\n"
388 "witness_v0_scripthash, witness_unknown."},
390 {
RPCResult::Type::ARR,
"pubkeys",
true,
"Array of pubkeys associated with the known redeemscript (only if script is multisig).",
394 {
RPCResult::Type::NUM,
"sigsrequired",
true,
"The number of signatures required to spend multisig output (only if script is multisig)."},
395 {
RPCResult::Type::STR_HEX,
"pubkey",
true,
"The hex value of the raw public key for single-key addresses (possibly embedded in P2SH or P2WSH)."},
396 {
RPCResult::Type::OBJ,
"embedded",
true,
"Information about the address embedded in P2SH or P2WSH, if relevant and known.",
398 {
RPCResult::Type::ELISION,
"",
"Includes all getaddressinfo output fields for the embedded address, excluding metadata (timestamp, hdkeypath, hdseedid)\n"
399 "and relation to the wallet (ismine, iswatchonly)."},
406 {
RPCResult::Type::ARR,
"labels",
"Array of labels associated with the address. Currently limited to one label but returned\n"
407 "as an array to keep the API stable if multiple labels are enabled in the future.",
422 LOCK(pwallet->cs_wallet);
424 std::string error_msg;
430 if (error_msg.empty()) error_msg =
"Invalid address";
438 ret.pushKV(
"address", currentAddress);
441 ret.pushKV(
"scriptPubKey",
HexStr(scriptPubKey));
443 std::unique_ptr<SigningProvider> provider = pwallet->GetSolvingProvider(scriptPubKey);
450 bool solvable = inferred->IsSolvable();
451 ret.pushKV(
"solvable", solvable);
453 ret.pushKV(
"desc", inferred->ToString());
456 ret.pushKV(
"solvable",
false);
459 const auto& spk_mans = pwallet->GetScriptPubKeyMans(scriptPubKey);
462 if (spk_mans.size()) spk_man = *spk_mans.begin();
466 std::string desc_str;
468 ret.pushKV(
"parent_desc", desc_str);
480 if (
const std::unique_ptr<CKeyMetadata> meta = spk_man->GetMetadata(dest)) {
481 ret.pushKV(
"timestamp", meta->nCreateTime);
482 if (meta->has_key_origin) {
486 ret.pushKV(
"hdseedid", meta->hd_seed_id.GetHex());
487 ret.pushKV(
"hdmasterfingerprint",
HexStr(meta->key_origin.fingerprint));
498 const auto* address_book_entry = pwallet->FindAddressBookEntry(dest);
499 if (address_book_entry) {
500 labels.
push_back(address_book_entry->GetLabel());
502 ret.pushKV(
"labels", std::move(labels));
512 "\nReturns the list of addresses assigned the specified label.\n",
521 {
RPCResult::Type::STR,
"purpose",
"Purpose of address (\"send\" for sending address, \"receive\" for receiving address)"},
534 LOCK(pwallet->cs_wallet);
540 std::set<std::string> addresses;
541 pwallet->ForEachAddrBookEntry([&](
const CTxDestination& _dest,
const std::string& _label,
bool _is_change,
const std::optional<AddressPurpose>& _purpose) {
542 if (_is_change)
return;
543 if (_label == label) {
548 bool unique = addresses.emplace(address).second;
556 ret.pushKVEnd(address, std::move(value));
572 "\nReturns the list of all labels, or labels that are assigned to addresses with a specific purpose.\n",
583 "\nList all labels\n"
585 "\nList labels that have receiving addresses\n"
587 "\nList labels that have sending addresses\n"
589 "\nAs a JSON-RPC call\n"
597 LOCK(pwallet->cs_wallet);
599 std::optional<AddressPurpose> purpose;
600 if (!request.params[0].isNull()) {
601 std::string purpose_str = request.params[0].get_str();
602 if (!purpose_str.empty()) {
611 std::set<std::string> label_set = pwallet->ListAddrBookLabels(purpose);
614 for (
const std::string&
name : label_set) {
624#ifdef ENABLE_EXTERNAL_SIGNER
628 "walletdisplayaddress",
629 "Display address on an external signer for verification.",
659 result.
pushKV(
"address", request.params[0].get_str());
CScriptID ToScriptID(const ScriptHash &script_hash)
bool ExtractDestination(const CScript &scriptPubKey, CTxDestination &addressRet)
Parse a scriptPubKey for the destination.
bool IsValidDestination(const CTxDestination &dest)
Check whether a CTxDestination corresponds to one with an address.
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
CKeyID ToKeyID(const PKHash &key_hash)
std::variant< CNoDestination, PubKeyDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, PayToAnchor, WitnessUnknown > CTxDestination
A txout script categorized into standard templates.
std::string WriteHDKeypath(const std::vector< uint32_t > &keypath, bool apostrophe)
Write HD keypaths as strings.
#define CHECK_NONFATAL(condition)
Identity function.
A reference to a CKey: the Hash160 of its serialized public key.
An encapsulated public key.
bool IsCompressed() const
Check whether this is a compressed public key.
A hasher class for RIPEMD-160.
CRIPEMD160 & Write(const unsigned char *data, size_t len)
void Finalize(unsigned char hash[OUTPUT_SIZE])
Serialized script, used inside transaction inputs and outputs.
A reference to a CScript: the Hash160 of its serialization.
An interface to be implemented by keystores that support signing.
virtual bool GetCScript(const CScriptID &scriptid, CScript &script) const
virtual bool GetPubKey(const CKeyID &address, CPubKey &pubkey) const
void push_back(UniValue val)
void pushKVs(UniValue obj)
bool exists(const std::string &key) const
void pushKV(std::string key, UniValue val)
constexpr unsigned char * begin()
A CWallet maintains a set of transactions and balances, and provides the ability to create new transa...
RecursiveMutex cs_wallet
Main wallet lock.
util::Result< void > DisplayAddress(const CTxDestination &dest) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Display address on an external signer.
UniValue operator()(const PayToAnchor &id) const
UniValue operator()(const PKHash &pkhash) const
UniValue operator()(const WitnessV0ScriptHash &id) const
UniValue operator()(const WitnessV1Taproot &id) const
const SigningProvider *const provider
UniValue operator()(const WitnessV0KeyHash &id) const
UniValue operator()(const WitnessUnknown &id) const
DescribeWalletAddressVisitor(const SigningProvider *_provider)
void ProcessSubScript(const CScript &subscript, UniValue &obj) const
UniValue operator()(const CNoDestination &dest) const
UniValue operator()(const ScriptHash &scripthash) const
UniValue operator()(const PubKeyDestination &dest) const
bool GetDescriptorString(std::string &out, const bool priv) const
UniValue ValueFromAmount(const CAmount amount)
const std::string CURRENCY_UNIT
std::string HexStr(const std::span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
CTxDestination DecodeDestination(const std::string &str, std::string &error_msg, std::vector< int > *error_locations)
std::string EncodeDestination(const CTxDestination &dest)
bilingual_str ErrorString(const Result< T > &result)
std::string ToString(const T &t)
Locale-independent version of std::to_string.
std::shared_ptr< CWallet > GetWalletForJSONRPCRequest(const JSONRPCRequest &request)
Figures out what wallet, if any, to use for a JSONRPCRequest.
RPCHelpMan keypoolrefill()
bool ScriptIsChange(const CWallet &wallet, const CScript &script)
void EnsureWalletIsUnlocked(const CWallet &wallet)
const std::string HELP_REQUIRING_PASSPHRASE
RPCHelpMan walletdisplayaddress()
RPCHelpMan listaddressgroupings()
static const unsigned int DEFAULT_KEYPOOL_SIZE
Default for -keypool.
std::string LabelFromValue(const UniValue &value)
isminetype
IsMine() return codes, which depend on ScriptPubKeyMan implementation.
static UniValue DescribeWalletAddress(const CWallet &wallet, const CTxDestination &dest)
std::string PurposeToString(AddressPurpose p)
RPCHelpMan getrawchangeaddress()
RPCHelpMan getaddressinfo()
std::map< CTxDestination, CAmount > GetAddressBalances(const CWallet &wallet)
RPCHelpMan getaddressesbylabel()
std::optional< AddressPurpose > PurposeFromString(std::string_view s)
RPCHelpMan getnewaddress()
std::set< std::set< CTxDestination > > GetAddressGroupings(const CWallet &wallet)
std::optional< OutputType > ParseOutputType(const std::string &type)
UniValue JSONRPCError(int code, const std::string &message)
@ RPC_WALLET_INVALID_LABEL_NAME
Invalid label name.
@ RPC_MISC_ERROR
General application defined errors.
@ RPC_INVALID_PARAMETER
Invalid, missing or duplicate parameter.
@ RPC_WALLET_ERROR
Wallet errors.
@ RPC_WALLET_KEYPOOL_RAN_OUT
Keypool ran out, call keypoolrefill first.
@ RPC_INVALID_ADDRESS_OR_KEY
Invalid address or key.
std::string HelpExampleCli(const std::string &methodname, const std::string &args)
std::string HelpExampleRpc(const std::string &methodname, const std::string &args)
const std::string UNIX_EPOCH_TIME
String used to describe UNIX epoch time in documentation, factored out to a constant for consistency.
const std::string EXAMPLE_ADDRESS[2]
Example bech32 addresses for the RPCExamples help documentation.
UniValue DescribeAddress(const CTxDestination &dest)
std::unique_ptr< Descriptor > InferDescriptor(const CScript &script, const SigningProvider &provider)
Find a descriptor for the specified script, using information from provider where possible.
TxoutType Solver(const CScript &scriptPubKey, std::vector< std::vector< unsigned char > > &vSolutionsRet)
Parse a scriptPubKey and identify script type for standard scripts.
std::string GetTxnOutputType(TxoutType t)
Get the name of a TxoutType as a string.
std::string DefaultHint
Hint for default value.
@ OMITTED
Optional argument for which the default value is omitted from help text for one of two reasons:
@ ELISION
Special type to denote elision (...)
@ NUM_TIME
Special numeric to denote unix epoch time.
@ ARR_FIXED
Special array that has a fixed number of entries.
@ OBJ_DYN
Special dictionary with keys that are not literals.
@ STR_HEX
Special string with only hex chars.
@ STR_AMOUNT
Special string to represent a floating point amount.
CTxDestination subtype to encode any future Witness version.