23 std::vector<CTxDestination> addresses;
34 addresses.emplace_back(dest);
38 std::set<CScript> output_scripts;
39 for (
const auto& address : addresses) {
41 if (
wallet.IsMine(output_script)) {
42 output_scripts.
insert(output_script);
46 if (output_scripts.empty()) {
52 if (!params[1].isNull())
53 min_depth = params[1].getInt<
int>();
55 const bool include_immature_coinbase{params[2].isNull() ? false : params[2].get_bool()};
59 for (
const std::pair<const uint256, CWalletTx>& wtx_pair :
wallet.mapWallet) {
61 int depth{
wallet.GetTxDepthInMainChain(wtx)};
65 || (
wallet.IsTxImmatureCoinBase(wtx) && !include_immature_coinbase))
70 for (
const CTxOut& txout : wtx.
tx->vout) {
84 "\nReturns the total amount received by the given address in transactions with at least minconf confirmations.\n",
94 "\nThe amount from transactions with at least 1 confirmation\n"
96 "\nThe amount including unconfirmed transactions, zero confirmations\n"
98 "\nThe amount with at least 6 confirmations\n"
100 "\nThe amount with at least 6 confirmations including immature coinbase outputs\n"
102 "\nAs a JSON-RPC call\n"
112 pwallet->BlockUntilSyncedToCurrentChain();
114 LOCK(pwallet->cs_wallet);
125 "\nReturns the total amount received by addresses with <label> in transactions with at least [minconf] confirmations.\n",
135 "\nAmount received by the default label with at least 1 confirmation\n"
137 "\nAmount received at the tabby label including unconfirmed amounts with zero confirmations\n"
139 "\nThe amount with at least 6 confirmations\n"
141 "\nThe amount with at least 6 confirmations including immature coinbase outputs\n"
143 "\nAs a JSON-RPC call\n"
153 pwallet->BlockUntilSyncedToCurrentChain();
155 LOCK(pwallet->cs_wallet);
166 "\nReturns the total available balance.\n"
167 "The available balance is what the wallet considers currently spendable, and is\n"
168 "thus affected by options which limit spendability such as -spendzeroconfchange.\n",
172 {
"include_watchonly",
RPCArg::Type::BOOL,
RPCArg::DefaultHint{
"true for watch-only wallets, otherwise false"},
"Also include balance in watch-only addresses (see 'importaddress')"},
173 {
"avoid_reuse",
RPCArg::Type::BOOL,
RPCArg::Default{
true},
"(only available if avoid_reuse wallet flag is set) Do not include balance in dirty outputs; addresses are considered dirty if they have previously been used in a transaction."},
179 "\nThe total amount in the wallet with 0 or more confirmations\n"
181 "\nThe total amount in the wallet with at least 6 confirmations\n"
183 "\nAs a JSON-RPC call\n"
193 pwallet->BlockUntilSyncedToCurrentChain();
195 LOCK(pwallet->cs_wallet);
197 const auto dummy_value{
self.MaybeArg<std::string>(0)};
198 if (dummy_value && *dummy_value !=
"*") {
203 if (!request.params[1].isNull()) {
204 min_depth = request.params[1].getInt<
int>();
211 const auto bal =
GetBalance(*pwallet, min_depth, avoid_reuse);
213 return ValueFromAmount(bal.m_mine_trusted + (include_watchonly ? bal.m_watchonly_trusted : 0));
221 "DEPRECATED\nIdentical to getbalances().mine.untrusted_pending\n",
232 pwallet->BlockUntilSyncedToCurrentChain();
234 LOCK(pwallet->cs_wallet);
244 "\nUpdates list of temporarily unspendable outputs.\n"
245 "Temporarily lock (unlock=false) or unlock (unlock=true) specified transaction outputs.\n"
246 "If no transaction outputs are specified when unlocking then all current locked transaction outputs are unlocked.\n"
247 "A locked transaction output will not be chosen by automatic coin selection, when spending bitcoins.\n"
248 "Manually selected coins are automatically unlocked.\n"
249 "Locks are stored in memory only, unless persistent=true, in which case they will be written to the\n"
250 "wallet database and loaded on node start. Unwritten (persistent=false) locks are always cleared\n"
251 "(by virtue of process exit) when a node stops or fails. Unlocking will clear both persistent and not.\n"
252 "Also see the listunspent call\n",
265 {
"persistent",
RPCArg::Type::BOOL,
RPCArg::Default{
false},
"Whether to write/erase this lock in the wallet database, or keep the change in memory only. Ignored for unlocking."},
271 "\nList the unspent transactions\n"
273 "\nLock an unspent transaction\n"
274 +
HelpExampleCli(
"lockunspent",
"false \"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":1}]\"") +
275 "\nList the locked transactions\n"
277 "\nUnlock the transaction again\n"
278 +
HelpExampleCli(
"lockunspent",
"true \"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":1}]\"") +
279 "\nLock the transaction persistently in the wallet database\n"
280 +
HelpExampleCli(
"lockunspent",
"false \"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":1}]\" true") +
281 "\nAs a JSON-RPC call\n"
282 +
HelpExampleRpc(
"lockunspent",
"false, \"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":1}]\"")
291 pwallet->BlockUntilSyncedToCurrentChain();
293 LOCK(pwallet->cs_wallet);
295 bool fUnlock = request.params[0].get_bool();
297 const bool persistent{request.params[2].isNull() ? false : request.params[2].get_bool()};
299 if (request.params[1].isNull()) {
301 if (!pwallet->UnlockAllCoins())
311 std::vector<COutPoint> outputs;
312 outputs.reserve(output_params.
size());
314 for (
unsigned int idx = 0; idx < output_params.
size(); idx++) {
331 const auto it = pwallet->mapWallet.find(outpt.
hash);
332 if (it == pwallet->mapWallet.end()) {
338 if (outpt.
n >= trans.
tx->vout.size()) {
342 if (pwallet->IsSpent(outpt)) {
346 const bool is_locked = pwallet->IsLockedCoin(outpt);
348 if (fUnlock && !is_locked) {
352 if (!fUnlock && is_locked && !persistent) {
356 outputs.push_back(outpt);
359 std::unique_ptr<WalletBatch> batch =
nullptr;
361 if (fUnlock || persistent) batch = std::make_unique<WalletBatch>(pwallet->GetDatabase());
380 "\nReturns list of temporarily unspendable outputs.\n"
381 "See the lockunspent call to lock and unlock transactions for spending.\n",
394 "\nList the unspent transactions\n"
396 "\nLock an unspent transaction\n"
397 +
HelpExampleCli(
"lockunspent",
"false \"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":1}]\"") +
398 "\nList the locked transactions\n"
400 "\nUnlock the transaction again\n"
401 +
HelpExampleCli(
"lockunspent",
"true \"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":1}]\"") +
402 "\nAs a JSON-RPC call\n"
410 LOCK(pwallet->cs_wallet);
412 std::vector<COutPoint> vOutpts;
413 pwallet->ListLockedCoins(vOutpts);
420 o.
pushKV(
"txid", outpt.hash.GetHex());
421 o.
pushKV(
"vout", (
int)outpt.n);
434 "Returns an object with all balances in " +
CURRENCY_UNIT +
".\n",
442 {
RPCResult::Type::STR_AMOUNT,
"untrusted_pending",
"untrusted pending balance (outputs created by others that are in the mempool)"},
444 {
RPCResult::Type::STR_AMOUNT,
"used",
true,
"(only present if avoid_reuse is set) balance from coins sent to addresses that were previously spent from (potentially privacy violating)"},
446 {
RPCResult::Type::OBJ,
"watchonly",
true,
"watchonly balances (not present if wallet does not watch anything)",
449 {
RPCResult::Type::STR_AMOUNT,
"untrusted_pending",
"untrusted pending balance (outputs created by others that are in the mempool)"},
466 wallet.BlockUntilSyncedToCurrentChain();
475 balances_mine.pushKV(
"untrusted_pending",
ValueFromAmount(bal.m_mine_untrusted_pending));
476 balances_mine.pushKV(
"immature",
ValueFromAmount(bal.m_mine_immature));
481 balances_mine.pushKV(
"used",
ValueFromAmount(full_bal.m_mine_trusted + full_bal.m_mine_untrusted_pending - bal.m_mine_trusted - bal.m_mine_untrusted_pending));
483 balances.pushKV(
"mine", balances_mine);
485 auto spk_man =
wallet.GetLegacyScriptPubKeyMan();
486 if (spk_man && spk_man->HaveWatchOnly()) {
488 balances_watchonly.pushKV(
"trusted",
ValueFromAmount(bal.m_watchonly_trusted));
489 balances_watchonly.pushKV(
"untrusted_pending",
ValueFromAmount(bal.m_watchonly_untrusted_pending));
490 balances_watchonly.pushKV(
"immature",
ValueFromAmount(bal.m_watchonly_immature));
491 balances.pushKV(
"watchonly", balances_watchonly);
504 "\nReturns array of unspent transaction outputs\n"
505 "with between minconf and maxconf (inclusive) confirmations.\n"
506 "Optionally filter to only include txouts paid to specified addresses.\n",
516 "See description of \"safe\" attribute below."},
539 {
RPCResult::Type::NUM,
"ancestorcount",
true,
"The number of in-mempool ancestor transactions, including this one (if transaction is in the mempool)"},
540 {
RPCResult::Type::NUM,
"ancestorsize",
true,
"The virtual transaction size of in-mempool ancestors, including this one (if transaction is in the mempool)"},
541 {
RPCResult::Type::STR_AMOUNT,
"ancestorfees",
true,
"The total fees of in-mempool ancestors (including this one) with fee deltas used for mining priority in " +
CURRENCY_ATOM +
" (if transaction is in the mempool)"},
543 {
RPCResult::Type::STR,
"witnessScript",
true,
"witnessScript if the scriptPubKey is P2WSH or P2SH-P2WSH"},
545 {
RPCResult::Type::BOOL,
"solvable",
"Whether we know how to spend this output, ignoring the lack of keys"},
546 {
RPCResult::Type::BOOL,
"reused",
true,
"(only present if avoid_reuse is set) Whether this output is reused/dirty (sent to an address that was previously spent from)"},
547 {
RPCResult::Type::STR,
"desc",
true,
"(only when solvable) A descriptor for spending this output"},
548 {
RPCResult::Type::ARR,
"parent_descs",
false,
"List of parent descriptors for the scriptPubKey of this coin.", {
551 {
RPCResult::Type::BOOL,
"safe",
"Whether this output is considered safe to spend. Unconfirmed transactions\n"
552 "from outside keys and unconfirmed replacement transactions are considered unsafe\n"
553 "and are not eligible for spending by fundrawtransaction and sendtoaddress."},
561 +
HelpExampleCli(
"listunspent",
"6 9999999 '[]' true '{ \"minimumAmount\": 0.005 }'")
562 +
HelpExampleRpc(
"listunspent",
"6, 9999999, [] , true, { \"minimumAmount\": 0.005 } ")
570 if (!request.params[0].isNull()) {
571 nMinDepth = request.params[0].getInt<
int>();
574 int nMaxDepth = 9999999;
575 if (!request.params[1].isNull()) {
576 nMaxDepth = request.params[1].getInt<
int>();
579 std::set<CTxDestination> destinations;
580 if (!request.params[2].isNull()) {
582 for (
unsigned int idx = 0; idx < inputs.
size(); idx++) {
583 const UniValue& input = inputs[idx];
588 if (!destinations.insert(dest).second) {
594 bool include_unsafe =
true;
595 if (!request.params[3].isNull()) {
596 include_unsafe = request.params[3].get_bool();
602 if (!request.params[4].isNull()) {
615 if (options.
exists(
"minimumAmount"))
618 if (options.
exists(
"maximumAmount"))
621 if (options.
exists(
"minimumSumAmount"))
624 if (options.
exists(
"maximumCount"))
627 if (options.
exists(
"include_immature_coinbase")) {
634 pwallet->BlockUntilSyncedToCurrentChain();
637 std::vector<COutput> vecOutputs;
644 LOCK(pwallet->cs_wallet);
648 LOCK(pwallet->cs_wallet);
654 const CScript& scriptPubKey =
out.txout.scriptPubKey;
656 bool reused = avoid_reuse && pwallet->IsSpentKey(scriptPubKey);
658 if (destinations.size() && (!fValidAddress || !destinations.count(address)))
662 entry.
pushKV(
"txid",
out.outpoint.hash.GetHex());
663 entry.
pushKV(
"vout", (
int)
out.outpoint.n);
668 const auto* address_book_entry = pwallet->FindAddressBookEntry(address);
669 if (address_book_entry) {
670 entry.
pushKV(
"label", address_book_entry->GetLabel());
673 std::unique_ptr<SigningProvider> provider = pwallet->GetSolvingProvider(scriptPubKey);
678 if (provider->GetCScript(hash, redeemScript)) {
689 if (provider->GetCScript(
id, witnessScript)) {
698 if (provider->GetCScript(
id, witnessScript)) {
707 entry.
pushKV(
"confirmations",
out.depth);
709 size_t ancestor_count, descendant_count, ancestor_size;
711 pwallet->chain().getTransactionAncestry(
out.outpoint.hash, ancestor_count, descendant_count, &ancestor_size, &ancestor_fees);
712 if (ancestor_count) {
713 entry.
pushKV(
"ancestorcount", uint64_t(ancestor_count));
714 entry.
pushKV(
"ancestorsize", uint64_t(ancestor_size));
715 entry.
pushKV(
"ancestorfees", uint64_t(ancestor_fees));
718 entry.
pushKV(
"spendable",
out.spendable);
721 std::unique_ptr<SigningProvider> provider = pwallet->GetSolvingProvider(scriptPubKey);
724 entry.
pushKV(
"desc", descriptor->ToString());
728 if (avoid_reuse) entry.
pushKV(
"reused", reused);
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.
std::variant< CNoDestination, PubKeyDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, WitnessUnknown > CTxDestination
A txout script categorized into standard templates.
int64_t CAmount
Amount in satoshis (Can be negative)
static CAmount AmountFromValue(const UniValue &value)
#define CHECK_NONFATAL(condition)
Identity function.
An outpoint - a combination of a transaction hash and an index n into its vout.
Serialized script, used inside transaction inputs and outputs.
bool IsPayToScriptHash() const
bool IsPayToWitnessScriptHash() const
A reference to a CScript: the Hash160 of its serialization.
An output of a transaction.
void push_back(UniValue val)
const std::string & get_str() const
const UniValue & find_value(std::string_view key) const
const UniValue & get_obj() const
const UniValue & get_array() const
bool exists(const std::string &key) const
void pushKV(std::string key, UniValue val)
iterator insert(iterator pos, const T &value)
static transaction_identifier FromUint256(const uint256 &id)
bool m_avoid_address_reuse
Forbids inclusion of dirty (previously used) addresses.
int m_min_depth
Minimum chain depth value for coin availability.
int m_max_depth
Maximum chain depth value for coin availability.
bool m_include_unsafe_inputs
If false, only safe inputs will be used.
A CWallet maintains a set of transactions and balances, and provides the ability to create new transa...
A transaction with a bunch of additional info that only the owner cares about.
UniValue ValueFromAmount(const CAmount amount)
const std::string CURRENCY_ATOM
const std::string CURRENCY_UNIT
uint160 RIPEMD160(Span< const unsigned char > data)
Compute the 160-bit RIPEMD-160 hash of an array.
CTxDestination DecodeDestination(const std::string &str, std::string &error_msg, std::vector< int > *error_locations)
std::string EncodeDestination(const CTxDestination &dest)
std::string FormatMoney(const CAmount n)
Money parsing/formatting utilities.
void AppendLastProcessedBlock(UniValue &entry, const CWallet &wallet) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet)
Balance GetBalance(const CWallet &wallet, const int min_depth, bool avoid_reuse)
std::shared_ptr< CWallet > GetWalletForJSONRPCRequest(const JSONRPCRequest &request)
Figures out what wallet, if any, to use for a JSONRPCRequest.
RPCHelpMan listlockunspent()
static const RPCResult RESULT_LAST_PROCESSED_BLOCK
RPCHelpMan getreceivedbyaddress()
void PushParentDescriptors(const CWallet &wallet, const CScript &script_pubkey, UniValue &entry)
Fetch parent descriptors of this scriptPubKey.
std::string LabelFromValue(const UniValue &value)
CoinsResult AvailableCoinsListUnspent(const CWallet &wallet, const CCoinControl *coinControl, CoinFilterParams params)
Wrapper function for AvailableCoins which skips the feerate and CoinFilterParams::only_spendable para...
bool ParseIncludeWatchonly(const UniValue &include_watchonly, const CWallet &wallet)
Used by RPC commands that have an include_watchonly parameter.
RPCHelpMan getreceivedbylabel()
static CAmount GetReceived(const CWallet &wallet, const UniValue ¶ms, bool by_label) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet)
bool GetAvoidReuseFlag(const CWallet &wallet, const UniValue ¶m)
@ WALLET_FLAG_AVOID_REUSE
RPCHelpMan getunconfirmedbalance()
UniValue JSONRPCError(int code, const std::string &message)
@ RPC_METHOD_DEPRECATED
RPC method is deprecated.
@ RPC_INVALID_PARAMETER
Invalid, missing or duplicate parameter.
@ RPC_WALLET_ERROR
Wallet errors.
@ 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 EXAMPLE_ADDRESS[2]
Example bech32 addresses for the RPCExamples help documentation.
uint256 ParseHashO(const UniValue &o, std::string_view strKey)
void RPCTypeCheckObj(const UniValue &o, const std::map< std::string, UniValueType > &typesExpected, bool fAllowNull, bool fStrict)
std::unique_ptr< Descriptor > InferDescriptor(const CScript &script, const SigningProvider &provider)
Find a descriptor for the specified script, using information from provider where possible.
@ STR_HEX
Special type that is a STR with only hex chars.
@ AMOUNT
Special type representing a floating point amount (can be either NUM or STR)
@ OBJ_NAMED_PARAMS
Special type that behaves almost exactly like OBJ, defining an options object with a list of pre-defi...
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:
std::string oneline_description
Should be empty unless it is supposed to override the auto-generated summary line.
@ STR_HEX
Special string with only hex chars.
@ STR_AMOUNT
Special string to represent a floating point amount.
Wrapper for UniValue::VType, which includes typeAny: Used to denote don't care type.
CAmount m_mine_untrusted_pending
Untrusted, but in mempool (pending)
A UTXO under consideration for use in funding a new transaction.
bool include_immature_coinbase
std::vector< COutput > All() const
Concatenate and return all COutputs as one vector.
#define EXCLUSIVE_LOCKS_REQUIRED(...)
std::string HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.