22 std::vector<CTxDestination> addresses;
33 addresses.emplace_back(dest);
37 std::set<CScript> output_scripts;
38 for (
const auto& address : addresses) {
40 if (
wallet.IsMine(output_script)) {
41 output_scripts.
insert(output_script);
45 if (output_scripts.empty()) {
51 if (!params[1].isNull())
52 min_depth = params[1].getInt<
int>();
54 const bool include_immature_coinbase{params[2].isNull() ? false : params[2].get_bool()};
58 for (
const std::pair<const uint256, CWalletTx>& wtx_pair :
wallet.mapWallet) {
60 int depth{
wallet.GetTxDepthInMainChain(wtx)};
64 || (
wallet.IsTxImmatureCoinBase(wtx) && !include_immature_coinbase))
69 for (
const CTxOut& txout : wtx.
tx->vout) {
83 "\nReturns the total amount received by the given address in transactions with at least minconf confirmations.\n",
93 "\nThe amount from transactions with at least 1 confirmation\n"
95 "\nThe amount including unconfirmed transactions, zero confirmations\n"
97 "\nThe amount with at least 6 confirmations\n"
99 "\nThe amount with at least 6 confirmations including immature coinbase outputs\n"
101 "\nAs a JSON-RPC call\n"
111 pwallet->BlockUntilSyncedToCurrentChain();
113 LOCK(pwallet->cs_wallet);
124 "\nReturns the total amount received by addresses with <label> in transactions with at least [minconf] confirmations.\n",
134 "\nAmount received by the default label with at least 1 confirmation\n"
136 "\nAmount received at the tabby label including unconfirmed amounts with zero confirmations\n"
138 "\nThe amount with at least 6 confirmations\n"
140 "\nThe amount with at least 6 confirmations including immature coinbase outputs\n"
142 "\nAs a JSON-RPC call\n"
152 pwallet->BlockUntilSyncedToCurrentChain();
154 LOCK(pwallet->cs_wallet);
165 "\nReturns the total available balance.\n"
166 "The available balance is what the wallet considers currently spendable, and is\n"
167 "thus affected by options which limit spendability such as -spendzeroconfchange.\n",
171 {
"include_watchonly",
RPCArg::Type::BOOL,
RPCArg::DefaultHint{
"true for watch-only wallets, otherwise false"},
"Also include balance in watch-only addresses (see 'importaddress')"},
172 {
"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."},
178 "\nThe total amount in the wallet with 0 or more confirmations\n"
180 "\nThe total amount in the wallet with at least 6 confirmations\n"
182 "\nAs a JSON-RPC call\n"
192 pwallet->BlockUntilSyncedToCurrentChain();
194 LOCK(pwallet->cs_wallet);
196 const UniValue& dummy_value = request.params[0];
202 if (!request.params[1].isNull()) {
203 min_depth = request.params[1].getInt<
int>();
210 const auto bal =
GetBalance(*pwallet, min_depth, avoid_reuse);
212 return ValueFromAmount(bal.m_mine_trusted + (include_watchonly ? bal.m_watchonly_trusted : 0));
220 "DEPRECATED\nIdentical to getbalances().mine.untrusted_pending\n",
231 pwallet->BlockUntilSyncedToCurrentChain();
233 LOCK(pwallet->cs_wallet);
243 "\nUpdates list of temporarily unspendable outputs.\n"
244 "Temporarily lock (unlock=false) or unlock (unlock=true) specified transaction outputs.\n"
245 "If no transaction outputs are specified when unlocking then all current locked transaction outputs are unlocked.\n"
246 "A locked transaction output will not be chosen by automatic coin selection, when spending bitcoins.\n"
247 "Manually selected coins are automatically unlocked.\n"
248 "Locks are stored in memory only, unless persistent=true, in which case they will be written to the\n"
249 "wallet database and loaded on node start. Unwritten (persistent=false) locks are always cleared\n"
250 "(by virtue of process exit) when a node stops or fails. Unlocking will clear both persistent and not.\n"
251 "Also see the listunspent call\n",
264 {
"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."},
270 "\nList the unspent transactions\n"
272 "\nLock an unspent transaction\n"
273 +
HelpExampleCli(
"lockunspent",
"false \"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":1}]\"") +
274 "\nList the locked transactions\n"
276 "\nUnlock the transaction again\n"
277 +
HelpExampleCli(
"lockunspent",
"true \"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":1}]\"") +
278 "\nLock the transaction persistently in the wallet database\n"
279 +
HelpExampleCli(
"lockunspent",
"false \"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":1}]\" true") +
280 "\nAs a JSON-RPC call\n"
281 +
HelpExampleRpc(
"lockunspent",
"false, \"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":1}]\"")
290 pwallet->BlockUntilSyncedToCurrentChain();
292 LOCK(pwallet->cs_wallet);
294 bool fUnlock = request.params[0].get_bool();
296 const bool persistent{request.params[2].isNull() ? false : request.params[2].get_bool()};
298 if (request.params[1].isNull()) {
300 if (!pwallet->UnlockAllCoins())
310 std::vector<COutPoint> outputs;
311 outputs.reserve(output_params.
size());
313 for (
unsigned int idx = 0; idx < output_params.
size(); idx++) {
330 const auto it = pwallet->mapWallet.find(outpt.
hash);
331 if (it == pwallet->mapWallet.end()) {
337 if (outpt.
n >= trans.
tx->vout.size()) {
341 if (pwallet->IsSpent(outpt)) {
345 const bool is_locked = pwallet->IsLockedCoin(outpt);
347 if (fUnlock && !is_locked) {
351 if (!fUnlock && is_locked && !persistent) {
355 outputs.push_back(outpt);
358 std::unique_ptr<WalletBatch> batch =
nullptr;
360 if (fUnlock || persistent) batch = std::make_unique<WalletBatch>(pwallet->GetDatabase());
379 "\nReturns list of temporarily unspendable outputs.\n"
380 "See the lockunspent call to lock and unlock transactions for spending.\n",
393 "\nList the unspent transactions\n"
395 "\nLock an unspent transaction\n"
396 +
HelpExampleCli(
"lockunspent",
"false \"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":1}]\"") +
397 "\nList the locked transactions\n"
399 "\nUnlock the transaction again\n"
400 +
HelpExampleCli(
"lockunspent",
"true \"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":1}]\"") +
401 "\nAs a JSON-RPC call\n"
409 LOCK(pwallet->cs_wallet);
411 std::vector<COutPoint> vOutpts;
412 pwallet->ListLockedCoins(vOutpts);
419 o.
pushKV(
"txid", outpt.hash.GetHex());
420 o.
pushKV(
"vout", (
int)outpt.n);
433 "Returns an object with all balances in " +
CURRENCY_UNIT +
".\n",
441 {
RPCResult::Type::STR_AMOUNT,
"untrusted_pending",
"untrusted pending balance (outputs created by others that are in the mempool)"},
443 {
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)"},
445 {
RPCResult::Type::OBJ,
"watchonly",
true,
"watchonly balances (not present if wallet does not watch anything)",
448 {
RPCResult::Type::STR_AMOUNT,
"untrusted_pending",
"untrusted pending balance (outputs created by others that are in the mempool)"},
464 wallet.BlockUntilSyncedToCurrentChain();
473 balances_mine.pushKV(
"untrusted_pending",
ValueFromAmount(bal.m_mine_untrusted_pending));
474 balances_mine.pushKV(
"immature",
ValueFromAmount(bal.m_mine_immature));
479 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));
481 balances.pushKV(
"mine", balances_mine);
483 auto spk_man =
wallet.GetLegacyScriptPubKeyMan();
484 if (spk_man && spk_man->HaveWatchOnly()) {
486 balances_watchonly.pushKV(
"trusted",
ValueFromAmount(bal.m_watchonly_trusted));
487 balances_watchonly.pushKV(
"untrusted_pending",
ValueFromAmount(bal.m_watchonly_untrusted_pending));
488 balances_watchonly.pushKV(
"immature",
ValueFromAmount(bal.m_watchonly_immature));
489 balances.pushKV(
"watchonly", balances_watchonly);
500 "\nReturns array of unspent transaction outputs\n"
501 "with between minconf and maxconf (inclusive) confirmations.\n"
502 "Optionally filter to only include txouts paid to specified addresses.\n",
512 "See description of \"safe\" attribute below."},
535 {
RPCResult::Type::NUM,
"ancestorcount",
true,
"The number of in-mempool ancestor transactions, including this one (if transaction is in the mempool)"},
536 {
RPCResult::Type::NUM,
"ancestorsize",
true,
"The virtual transaction size of in-mempool ancestors, including this one (if transaction is in the mempool)"},
537 {
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)"},
539 {
RPCResult::Type::STR,
"witnessScript",
true,
"witnessScript if the scriptPubKey is P2WSH or P2SH-P2WSH"},
541 {
RPCResult::Type::BOOL,
"solvable",
"Whether we know how to spend this output, ignoring the lack of keys"},
542 {
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)"},
543 {
RPCResult::Type::STR,
"desc",
true,
"(only when solvable) A descriptor for spending this output"},
544 {
RPCResult::Type::ARR,
"parent_descs",
false,
"List of parent descriptors for the scriptPubKey of this coin.", {
547 {
RPCResult::Type::BOOL,
"safe",
"Whether this output is considered safe to spend. Unconfirmed transactions\n"
548 "from outside keys and unconfirmed replacement transactions are considered unsafe\n"
549 "and are not eligible for spending by fundrawtransaction and sendtoaddress."},
557 +
HelpExampleCli(
"listunspent",
"6 9999999 '[]' true '{ \"minimumAmount\": 0.005 }'")
558 +
HelpExampleRpc(
"listunspent",
"6, 9999999, [] , true, { \"minimumAmount\": 0.005 } ")
566 if (!request.params[0].isNull()) {
567 nMinDepth = request.params[0].getInt<
int>();
570 int nMaxDepth = 9999999;
571 if (!request.params[1].isNull()) {
572 nMaxDepth = request.params[1].getInt<
int>();
575 std::set<CTxDestination> destinations;
576 if (!request.params[2].isNull()) {
578 for (
unsigned int idx = 0; idx < inputs.
size(); idx++) {
579 const UniValue& input = inputs[idx];
584 if (!destinations.insert(dest).second) {
590 bool include_unsafe =
true;
591 if (!request.params[3].isNull()) {
592 include_unsafe = request.params[3].get_bool();
598 if (!request.params[4].isNull()) {
611 if (options.
exists(
"minimumAmount"))
614 if (options.
exists(
"maximumAmount"))
617 if (options.
exists(
"minimumSumAmount"))
620 if (options.
exists(
"maximumCount"))
623 if (options.
exists(
"include_immature_coinbase")) {
630 pwallet->BlockUntilSyncedToCurrentChain();
633 std::vector<COutput> vecOutputs;
640 LOCK(pwallet->cs_wallet);
644 LOCK(pwallet->cs_wallet);
648 for (
const COutput& out : vecOutputs) {
650 const CScript& scriptPubKey = out.txout.scriptPubKey;
652 bool reused = avoid_reuse && pwallet->IsSpentKey(scriptPubKey);
654 if (destinations.size() && (!fValidAddress || !destinations.count(address)))
658 entry.
pushKV(
"txid", out.outpoint.hash.GetHex());
659 entry.
pushKV(
"vout", (
int)out.outpoint.n);
664 const auto* address_book_entry = pwallet->FindAddressBookEntry(address);
665 if (address_book_entry) {
666 entry.
pushKV(
"label", address_book_entry->GetLabel());
669 std::unique_ptr<SigningProvider> provider = pwallet->GetSolvingProvider(scriptPubKey);
674 if (provider->GetCScript(hash, redeemScript)) {
685 if (provider->GetCScript(
id, witnessScript)) {
694 if (provider->GetCScript(
id, witnessScript)) {
703 entry.
pushKV(
"confirmations", out.depth);
705 size_t ancestor_count, descendant_count, ancestor_size;
707 pwallet->chain().getTransactionAncestry(out.outpoint.hash, ancestor_count, descendant_count, &ancestor_size, &ancestor_fees);
708 if (ancestor_count) {
709 entry.
pushKV(
"ancestorcount", uint64_t(ancestor_count));
710 entry.
pushKV(
"ancestorsize", uint64_t(ancestor_size));
711 entry.
pushKV(
"ancestorfees", uint64_t(ancestor_fees));
714 entry.
pushKV(
"spendable", out.spendable);
715 entry.
pushKV(
"solvable", out.solvable);
717 std::unique_ptr<SigningProvider> provider = pwallet->GetSolvingProvider(scriptPubKey);
720 entry.
pushKV(
"desc", descriptor->ToString());
724 if (avoid_reuse) entry.
pushKV(
"reused", reused);
725 entry.
pushKV(
"safe", out.safe);
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 (see script.h)
An output of a transaction.
void push_back(UniValue val)
const std::string & get_str() 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)
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)
std::unique_ptr< Descriptor > InferDescriptor(const CScript &script, const SigningProvider &provider)
Find a descriptor for the specified script, using information from provider where possible.
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.
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()
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)
uint256 ParseHashO(const UniValue &o, std::string strKey)
const std::string EXAMPLE_ADDRESS[2]
Example bech32 addresses for the RPCExamples help documentation.
void RPCTypeCheckObj(const UniValue &o, const std::map< std::string, UniValueType > &typesExpected, bool fAllowNull, bool fStrict)
bool ExtractDestination(const CScript &scriptPubKey, CTxDestination &addressRet)
Parse a standard scriptPubKey for the destination address.
bool IsValidDestination(const CTxDestination &dest)
Check whether a CTxDestination is a CNoDestination.
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
std::variant< CNoDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, WitnessUnknown > CTxDestination
A txout script template with a specific destination.
@ 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)
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(...)
const UniValue & find_value(const UniValue &obj, const std::string &name)
std::string HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.