Differential D5316 Diff 16484 src/wallet/rpcwallet.cpp

Changeset View

Standalone View

src/wallet/rpcwallet.cpp

Show First 20 Lines • Show All 224 Lines • ▼ Show 20 Lines	static UniValue getnewaddress(const Config &config,
pwallet->LearnRelatedScripts(newKey, output_type);		pwallet->LearnRelatedScripts(newKey, output_type);
CTxDestination dest = GetDestinationForKey(newKey, output_type);		CTxDestination dest = GetDestinationForKey(newKey, output_type);

pwallet->SetAddressBook(dest, label, "receive");		pwallet->SetAddressBook(dest, label, "receive");

return EncodeDestination(dest, config);		return EncodeDestination(dest, config);
}		}

static CTxDestination GetLabelDestination(CWallet *const pwallet,
const std::string &label,
bool bForceNew = false)
EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
CTxDestination dest;
if (!pwallet->GetLabelDestination(dest, label, bForceNew)) {
throw JSONRPCError(
RPC_WALLET_KEYPOOL_RAN_OUT,
"Error: Keypool ran out, please call keypoolrefill first");
}

return dest;
}

static UniValue getaccountaddress(const Config &config,
const JSONRPCRequest &request) {
std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
CWallet *const pwallet = wallet.get();

if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
return NullUniValue;
}

if (!IsDeprecatedRPCEnabled(gArgs, "accounts")) {
if (request.fHelp) {
throw std::runtime_error(
"getaccountaddress (Deprecated, will be removed in v0.21. To "
"use this command, start bitcoind with "
"-deprecatedrpc=accounts)");
}
throw JSONRPCError(
RPC_METHOD_DEPRECATED,
"getaccountaddress is deprecated and will be removed in v0.21. To "
"use this command, start bitcoind with -deprecatedrpc=accounts.");
}

if (request.fHelp \|\| request.params.size() != 1) {
throw std::runtime_error(
"getaccountaddress \"account\"\n"
"\n\nDEPRECATED. Returns the current Bitcoin address for receiving"
"payments to this account.\n"
"\nArguments:\n"
"1. \"account\" (string, required) The account for the "
"address. It can also be set to the empty string \"\" to represent "
"the default account. The account does not need to exist, it will "
"be created and a new address created if there is no account by "
"the given name.\n"
"\nResult:\n"
"\"address\" (string) The account bitcoin address\n"
"\nExamples:\n" +
HelpExampleCli("getaccountaddress", "") +
HelpExampleCli("getaccountaddress", "\"\"") +
HelpExampleCli("getaccountaddress", "\"myaccount\"") +
HelpExampleRpc("getaccountaddress", "\"myaccount\""));
}
auto locked_chain = pwallet->chain().lock();
LOCK(pwallet->cs_wallet);

// Parse the account first so we don't generate a key if there's an error
std::string account = LabelFromValue(request.params[0]);

UniValue ret(UniValue::VSTR);

ret = EncodeDestination(GetLabelDestination(pwallet, account), config);
return ret;
}

static UniValue getrawchangeaddress(const Config &config,		static UniValue getrawchangeaddress(const Config &config,
const JSONRPCRequest &request) {		const JSONRPCRequest &request) {
std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);		std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
CWallet *const pwallet = wallet.get();		CWallet *const pwallet = wallet.get();

if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {		if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
return NullUniValue;		return NullUniValue;
}		}
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines
static UniValue setlabel(const Config &config, const JSONRPCRequest &request) {		static UniValue setlabel(const Config &config, const JSONRPCRequest &request) {
std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);		std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
CWallet *const pwallet = wallet.get();		CWallet *const pwallet = wallet.get();

if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {		if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
return NullUniValue;		return NullUniValue;
}		}

if (!IsDeprecatedRPCEnabled(gArgs, "accounts") &&
request.strMethod == "setaccount") {
if (request.fHelp) {
throw std::runtime_error(
"setaccount (Deprecated, will be removed in v0.21. To use this "
"command, start bitcoind with -deprecatedrpc=accounts)");
}
throw JSONRPCError(
RPC_METHOD_DEPRECATED,
"setaccount is deprecated and will be removed in v0.21. To use "
"this command, start bitcoind with -deprecatedrpc=accounts.");
}

if (request.fHelp \|\| request.params.size() != 2) {		if (request.fHelp \|\| request.params.size() != 2) {
throw std::runtime_error(		throw std::runtime_error(
"setlabel \"address\" \"label\"\n"		"setlabel \"address\" \"label\"\n"
"\nSets the label associated with the given address.\n"		"\nSets the label associated with the given address.\n"
"\nArguments:\n"		"\nArguments:\n"
"1. \"address\" (string, required) The bitcoin address to "		"1. \"address\" (string, required) The bitcoin address to "
"be associated with a label.\n"		"be associated with a label.\n"
"2. \"label\" (string, required) The label to assign to "		"2. \"label\" (string, required) The label to assign to "
Show All 14 Lines	if (!IsValidDestination(dest)) {
"Invalid Bitcoin address");		"Invalid Bitcoin address");
}		}

std::string old_label = pwallet->mapAddressBook[dest].name;		std::string old_label = pwallet->mapAddressBook[dest].name;
std::string label = LabelFromValue(request.params[1]);		std::string label = LabelFromValue(request.params[1]);

if (IsMine(*pwallet, dest)) {		if (IsMine(*pwallet, dest)) {
pwallet->SetAddressBook(dest, label, "receive");		pwallet->SetAddressBook(dest, label, "receive");
if (request.strMethod == "setaccount" && old_label != label &&
dest == GetLabelDestination(pwallet, old_label)) {
// for setaccount, call GetLabelDestination so a new receive address
// is created for the old account
GetLabelDestination(pwallet, old_label, true);
}
} else {		} else {
pwallet->SetAddressBook(dest, label, "send");		pwallet->SetAddressBook(dest, label, "send");
}		}

// Detect when there are no addresses using this label.		// Detect when there are no addresses using this label.
// If so, delete the account record for it. Labels, unlike addresses, can be		// If so, delete the account record for it. Labels, unlike addresses, can be
// deleted, and if we wouldn't do this, the record would stick around		// deleted, and if we wouldn't do this, the record would stick around
// forever.		// forever.
bool found_address = false;		bool found_address = false;
for (const std::pair<const CTxDestination, CAddressBookData> &item :		for (const std::pair<const CTxDestination, CAddressBookData> &item :
pwallet->mapAddressBook) {		pwallet->mapAddressBook) {
if (item.second.name == label) {		if (item.second.name == label) {
found_address = true;		found_address = true;
break;		break;
}		}
}		}
if (!found_address) {		if (!found_address) {
pwallet->DeleteLabel(old_label);		pwallet->DeleteLabel(old_label);
}		}

return NullUniValue;		return NullUniValue;
}		}

static UniValue getaccount(const Config &config,
const JSONRPCRequest &request) {
std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
CWallet *const pwallet = wallet.get();

if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
return NullUniValue;
}

if (!IsDeprecatedRPCEnabled(gArgs, "accounts")) {
if (request.fHelp) {
throw std::runtime_error(
"getaccount (Deprecated, will be removed in v0.21. To use this "
"command, start bitcoind with -deprecatedrpc=accounts)");
}
throw JSONRPCError(
RPC_METHOD_DEPRECATED,
"getaccount is deprecated and will be removed in v0.21. To use "
"this command, start bitcoind with -deprecatedrpc=accounts.");
}

if (request.fHelp \|\| request.params.size() != 1) {
throw std::runtime_error(
"getaccount \"address\"\n"
"\nDEPRECATED. Returns the account associated with the given "
"address.\n"
"\nArguments:\n"
"1. \"address\" (string, required) The bitcoin address for "
"account lookup.\n"
"\nResult:\n"
"\"accountname\" (string) the account address\n"
"\nExamples:\n" +
HelpExampleCli("getaccount",
"\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\"") +
HelpExampleRpc("getaccount",
"\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\""));
}

auto locked_chain = pwallet->chain().lock();
LOCK(pwallet->cs_wallet);

CTxDestination dest =
DecodeDestination(request.params[0].get_str(), config.GetChainParams());
if (!IsValidDestination(dest)) {
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
"Invalid Bitcoin address");
}

std::string strAccount;
std::map<CTxDestination, CAddressBookData>::iterator mi =
pwallet->mapAddressBook.find(dest);
if (mi != pwallet->mapAddressBook.end() && !(*mi).second.name.empty()) {
strAccount = (*mi).second.name;
}

return strAccount;
}

static UniValue getaddressesbyaccount(const Config &config,
const JSONRPCRequest &request) {
std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
CWallet *const pwallet = wallet.get();

if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
return NullUniValue;
}

if (!IsDeprecatedRPCEnabled(gArgs, "accounts")) {
if (request.fHelp) {
throw std::runtime_error(
"getaddressbyaccount (Deprecated, will be removed in v0.21. To "
"use this command, start bitcoind with "
"-deprecatedrpc=accounts)");
}
throw JSONRPCError(RPC_METHOD_DEPRECATED,
"getaddressesbyaccount is deprecated and will be "
"removed in v0.21. To use this command, start "
"bitcoind with -deprecatedrpc=accounts.");
}

if (request.fHelp \|\| request.params.size() != 1) {
throw std::runtime_error(
"getaddressesbyaccount \"account\"\n"
"\nDEPRECATED. Returns the list of addresses for the given "
"account.\n"
"\nArguments:\n"
"1. \"account\" (string, required) The account name.\n"
"\nResult:\n"
"[ (json array of string)\n"
" \"address\" (string) a bitcoin address associated with "
"the given account\n"
" ,...\n"
"]\n"
"\nExamples:\n" +
HelpExampleCli("getaddressesbyaccount", "\"tabby\"") +
HelpExampleRpc("getaddressesbyaccount", "\"tabby\""));
}

auto locked_chain = pwallet->chain().lock();
LOCK(pwallet->cs_wallet);

std::string strAccount = LabelFromValue(request.params[0]);

// Find all addresses that have the given account
UniValue ret(UniValue::VARR);
for (const std::pair<const CTxDestination, CAddressBookData> &item :
pwallet->mapAddressBook) {
const CTxDestination &dest = item.first;
const std::string &strName = item.second.name;
if (strName == strAccount) {
ret.push_back(EncodeDestination(dest, config));
}
}

return ret;
}

static CTransactionRef SendMoney(interfaces::Chain::Lock &locked_chain,		static CTransactionRef SendMoney(interfaces::Chain::Lock &locked_chain,
CWallet *const pwallet,		CWallet *const pwallet,
const CTxDestination &address, Amount nValue,		const CTxDestination &address, Amount nValue,
bool fSubtractFeeFromAmount,		bool fSubtractFeeFromAmount,
mapValue_t mapValue, std::string fromAccount) {		mapValue_t mapValue) {
Amount curBalance = pwallet->GetBalance();		Amount curBalance = pwallet->GetBalance();

// Check amount		// Check amount
if (nValue <= Amount::zero()) {		if (nValue <= Amount::zero()) {
throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid amount");		throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid amount");
}		}

if (nValue > curBalance) {		if (nValue > curBalance) {
Show All 27 Lines	if (!pwallet->CreateTransaction(locked_chain, vecSend, tx, reservekey,
strError = strprintf("Error: This transaction requires a "		strError = strprintf("Error: This transaction requires a "
"transaction fee of at least %s",		"transaction fee of at least %s",
FormatMoney(nFeeRequired));		FormatMoney(nFeeRequired));
}		}
throw JSONRPCError(RPC_WALLET_ERROR, strError);		throw JSONRPCError(RPC_WALLET_ERROR, strError);
}		}
CValidationState state;		CValidationState state;
if (!pwallet->CommitTransaction(tx, std::move(mapValue), {} /* orderForm */,		if (!pwallet->CommitTransaction(tx, std::move(mapValue), {} /* orderForm */,
std::move(fromAccount), reservekey,		"" /* account */, reservekey,
g_connman.get(), state)) {		g_connman.get(), state)) {
strError =		strError =
strprintf("Error: The transaction was rejected! Reason given: %s",		strprintf("Error: The transaction was rejected! Reason given: %s",
FormatStateMessage(state));		FormatStateMessage(state));
throw JSONRPCError(RPC_WALLET_ERROR, strError);		throw JSONRPCError(RPC_WALLET_ERROR, strError);
}		}
return tx;		return tx;
}		}
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Lines	static UniValue sendtoaddress(const Config &config,

bool fSubtractFeeFromAmount = false;		bool fSubtractFeeFromAmount = false;
if (!request.params[4].isNull()) {		if (!request.params[4].isNull()) {
fSubtractFeeFromAmount = request.params[4].get_bool();		fSubtractFeeFromAmount = request.params[4].get_bool();
}		}

EnsureWalletIsUnlocked(pwallet);		EnsureWalletIsUnlocked(pwallet);

CTransactionRef tx =		CTransactionRef tx = SendMoney(*locked_chain, pwallet, dest, nAmount,
SendMoney(*locked_chain, pwallet, dest, nAmount, fSubtractFeeFromAmount,		fSubtractFeeFromAmount, std::move(mapValue));
std::move(mapValue), {} /* fromAccount */);
return tx->GetId().GetHex();		return tx->GetId().GetHex();
}		}

static UniValue listaddressgroupings(const Config &config,		static UniValue listaddressgroupings(const Config &config,
const JSONRPCRequest &request) {		const JSONRPCRequest &request) {
std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);		std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
CWallet *const pwallet = wallet.get();		CWallet *const pwallet = wallet.get();

▲ Show 20 Lines • Show All 230 Lines • ▼ Show 20 Lines	static UniValue getreceivedbylabel(const Config &config,
const JSONRPCRequest &request) {		const JSONRPCRequest &request) {
std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);		std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
CWallet *const pwallet = wallet.get();		CWallet *const pwallet = wallet.get();

if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {		if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
return NullUniValue;		return NullUniValue;
}		}

if (!IsDeprecatedRPCEnabled(gArgs, "accounts") &&
request.strMethod == "getreceivedbyaccount") {
if (request.fHelp) {
throw std::runtime_error(
"getreceivedbyaccount (Deprecated, will be removed in v0.21. "
"To use this command, start bitcoind with "
"-deprecatedrpc=accounts)");
}
throw JSONRPCError(RPC_METHOD_DEPRECATED,
"getreceivedbyaccount is deprecated and will be "
"removed in v0.21. To use this command, start "
"bitcoind with -deprecatedrpc=accounts.");
}

if (request.fHelp \|\| request.params.size() < 1 \|\|		if (request.fHelp \|\| request.params.size() < 1 \|\|
request.params.size() > 2) {		request.params.size() > 2) {
throw std::runtime_error(		throw std::runtime_error(
"getreceivedbylabel \"label\" ( minconf )\n"		"getreceivedbylabel \"label\" ( minconf )\n"
"\nReturns the total amount received by addresses with <label> in "		"\nReturns the total amount received by addresses with <label> in "
"transactions with at least [minconf] confirmations.\n"		"transactions with at least [minconf] confirmations.\n"
"\nArguments:\n"		"\nArguments:\n"
"1. \"label\" (string, required) The selected label, may be "		"1. \"label\" (string, required) The selected label, may be "
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines	static UniValue getbalance(const Config &config,
CWallet *const pwallet = wallet.get();		CWallet *const pwallet = wallet.get();

if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {		if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
return NullUniValue;		return NullUniValue;
}		}

if (request.fHelp \|\| (request.params.size() > 3)) {		if (request.fHelp \|\| (request.params.size() > 3)) {
throw std::runtime_error(		throw std::runtime_error(
(IsDeprecatedRPCEnabled(gArgs, "accounts")
? std::string(
"getbalance ( \"account\" minconf include_watchonly )\n"
"\nIf account is not specified, returns the server's "
"total available balance.\n"
"The available balance is what the wallet considers "
"currently spendable,\nand is thus affected by options "
"which limit spendability such as "
"-spendzeroconfchange.\n"
"If account is specified (DEPRECATED), returns the "
"balance in the account.\n"
"Note that the account \"\" is not the same as leaving "
"the parameter out.\nThe server total may be different "
"to the balance in the default "
"\"\" account.\n"
"\nArguments:\n"
"1. \"account\" (string, optional) DEPRECATED. "
"This argument will be removed in v0.21. \n"
" To use this deprecated argument, "
"start bitcoind with -deprecatedrpc=accounts. The "
"account string may be given as a\n"
" specific account name to find the "
"balance associated with wallet keys in\n"
" a named account, or as the empty "
"string (\"\") to find the balance\n"
" associated with wallet keys not "
"in any named account, or as \"*\" to find\n"
" the balance associated with all "
"wallet keys regardless of account.\n"
" When this option is specified, it "
"calculates the balance in a different\n"
" way than when it is not "
"specified, and which can count spends twice when\n"
" there are conflicting pending "
"transactions temporarily resulting in low\n"
" or even negative balances.\n"
" In general, account balance "
"calculation is not considered reliable and\n"
" has resulted in confusing "
"outcomes, so it is recommended to avoid passing\n"
" this argument.\n"
"2. minconf (numeric, optional) Only include "
"transactions confirmed at least this many times. \n"
" The default is 1 if an account is "
"provided or 0 if no account is provided\n")
: std::string(
"getbalance ( \"dummy\" minconf include_watchonly )\n"		"getbalance ( \"dummy\" minconf include_watchonly )\n"
"\nReturns the total available balance.\n"		"\nReturns the total available balance.\n"
"The available balance is what the wallet considers "		"The available balance is what the wallet considers "
"currently spendable, and is\n"		"currently spendable, and is\n"
"thus affected by options which limit spendability such "		"thus affected by options which limit spendability such "
"as -spendzeroconfchange.\n"		"as -spendzeroconfchange.\n"
"\nArguments:\n"		"\nArguments:\n"
"1. (dummy) (string, optional) Remains for "		"1. (dummy) (string, optional) Remains for "
"backward compatibility. Must be excluded or set to "		"backward compatibility. Must be excluded or set to "
"\"*\".\n"		"\"*\".\n"
"2. minconf (numeric, optional, default=0) "		"2. minconf (numeric, optional, default=0) "
"Only include transactions confirmed at least this many "		"Only include transactions confirmed at least this many "
"times.\n")) +		"times.\n"
"3. include_watchonly (bool, optional, default=false) Also include "		"3. include_watchonly (bool, optional, default=false) Also include "
"balance in watch-only addresses (see 'importaddress')\n"		"balance in watch-only addresses (see 'importaddress')\n"
"\nResult:\n"		"\nResult:\n"
"amount (numeric) The total amount in " +		"amount (numeric) The total amount in " +
CURRENCY_UNIT +		CURRENCY_UNIT +
" received for this account.\n"		" received for this wallet.\n"
"\nExamples:\n"		"\nExamples:\n"
"\nThe total amount in the wallet with 1 or more confirmations\n" +		"\nThe total amount in the wallet with 1 or more confirmations\n" +
HelpExampleCli("getbalance", "") +		HelpExampleCli("getbalance", "") +
"\nThe total amount in the wallet at least 6 blocks confirmed\n" +		"\nThe total amount in the wallet at least 6 blocks confirmed\n" +
HelpExampleCli("getbalance", "\"*\" 6") + "\nAs a json rpc call\n" +		HelpExampleCli("getbalance", "\"*\" 6") + "\nAs a json rpc call\n" +
HelpExampleRpc("getbalance", "\"*\", 6"));		HelpExampleRpc("getbalance", "\"*\", 6"));
}		}

// Make sure the results are valid at least up to the most recent block		// Make sure the results are valid at least up to the most recent block
// the user could have gotten from another RPC command prior to now		// the user could have gotten from another RPC command prior to now
pwallet->BlockUntilSyncedToCurrentChain();		pwallet->BlockUntilSyncedToCurrentChain();

auto locked_chain = pwallet->chain().lock();		auto locked_chain = pwallet->chain().lock();
LOCK(pwallet->cs_wallet);		LOCK(pwallet->cs_wallet);

const UniValue &account_value = request.params[0];		const UniValue &dummy_value = request.params[0];
		if (!dummy_value.isNull() && dummy_value.get_str() != "*") {
		throw JSONRPCError(
		RPC_METHOD_DEPRECATED,
		"dummy first argument must be excluded or set to \"*\".");
		}

int min_depth = 0;		int min_depth = 0;
if (IsDeprecatedRPCEnabled(gArgs, "accounts") && !account_value.isNull()) {
// Default min_depth to 1 when an account is provided.
min_depth = 1;
}
if (!request.params[1].isNull()) {		if (!request.params[1].isNull()) {
min_depth = request.params[1].get_int();		min_depth = request.params[1].get_int();
}		}

isminefilter filter = ISMINE_SPENDABLE;		isminefilter filter = ISMINE_SPENDABLE;
if (!request.params[2].isNull() && request.params[2].get_bool()) {		if (!request.params[2].isNull() && request.params[2].get_bool()) {
filter = filter \| ISMINE_WATCH_ONLY;		filter = filter \| ISMINE_WATCH_ONLY;
}		}

if (!account_value.isNull()) {
const std::string &account_param = account_value.get_str();
const std::string *account =
account_param != "*" ? &account_param : nullptr;

if (!IsDeprecatedRPCEnabled(gArgs, "accounts") &&
account_param != "*") {
throw JSONRPCError(
RPC_METHOD_DEPRECATED,
"dummy first argument must be excluded or set to \"*\".");
} else if (IsDeprecatedRPCEnabled(gArgs, "accounts")) {
return ValueFromAmount(
pwallet->GetLegacyBalance(filter, min_depth, account));
}
}

return ValueFromAmount(pwallet->GetBalance(filter, min_depth));		return ValueFromAmount(pwallet->GetBalance(filter, min_depth));
}		}

static UniValue getunconfirmedbalance(const Config &config,		static UniValue getunconfirmedbalance(const Config &config,
const JSONRPCRequest &request) {		const JSONRPCRequest &request) {
std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);		std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
CWallet *const pwallet = wallet.get();		CWallet *const pwallet = wallet.get();

Show All 12 Lines	static UniValue getunconfirmedbalance(const Config &config,
pwallet->BlockUntilSyncedToCurrentChain();		pwallet->BlockUntilSyncedToCurrentChain();

auto locked_chain = pwallet->chain().lock();		auto locked_chain = pwallet->chain().lock();
LOCK(pwallet->cs_wallet);		LOCK(pwallet->cs_wallet);

return ValueFromAmount(pwallet->GetUnconfirmedBalance());		return ValueFromAmount(pwallet->GetUnconfirmedBalance());
}		}

static UniValue movecmd(const Config &config, const JSONRPCRequest &request) {
std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
CWallet *const pwallet = wallet.get();

if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
return NullUniValue;
}

if (!IsDeprecatedRPCEnabled(gArgs, "accounts")) {
if (request.fHelp) {
throw std::runtime_error(
"move (Deprecated, will be removed in v0.21. To use this "
"command, start bitcoind with -deprecatedrpc=accounts)");
}
throw JSONRPCError(
RPC_METHOD_DEPRECATED,
"move is deprecated and will be removed in v0.21. To use this "
"command, start bitcoind with -deprecatedrpc=accounts.");
}

if (request.fHelp \|\| request.params.size() < 3 \|\|
request.params.size() > 5) {
throw std::runtime_error(
"move \"fromaccount\" \"toaccount\" amount ( minconf \"comment\" "
")\n"
"\nDEPRECATED. Move a specified amount from one account in your "
"wallet to another.\n"
"\nArguments:\n"
"1. \"fromaccount\" (string, required) The name of the account "
"to move funds from. May be the default account using \"\".\n"
"2. \"toaccount\" (string, required) The name of the account "
"to move funds to. May be the default account using \"\".\n"
"3. amount (numeric) Quantity of " +
CURRENCY_UNIT +
" to move between accounts.\n"
"4. (dummy) (numeric, optional) Ignored. Remains for "
"backward compatibility.\n"
"5. \"comment\" (string, optional) An optional comment, "
"stored in the wallet only.\n"
"\nResult:\n"
"true\|false (boolean) true if successful.\n"
"\nExamples:\n"
"\nMove 0.01 " +
CURRENCY_UNIT +
" from the default account to the account named tabby\n" +
HelpExampleCli("move", "\"\" \"tabby\" 0.01") + "\nMove 0.01 " +
CURRENCY_UNIT +
" timotei to akiko with a comment and funds have 6 "
"confirmations\n" +
HelpExampleCli("move",
"\"timotei\" \"akiko\" 0.01 6 \"happy birthday!\"") +
"\nAs a json rpc call\n" +
HelpExampleRpc(
"move",
"\"timotei\", \"akiko\", 0.01, 6, \"happy birthday!\""));
}

auto locked_chain = pwallet->chain().lock();
LOCK(pwallet->cs_wallet);

std::string strFrom = LabelFromValue(request.params[0]);
std::string strTo = LabelFromValue(request.params[1]);
Amount nAmount = AmountFromValue(request.params[2]);
if (nAmount <= Amount::zero()) {
throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount for send");
}
if (!request.params[3].isNull()) {
// Unused parameter, used to be nMinDepth, keep type-checking it though.
(void)request.params[3].get_int();
}

std::string strComment;
if (!request.params[4].isNull()) {
strComment = request.params[4].get_str();
}

if (!pwallet->AccountMove(strFrom, strTo, nAmount, strComment)) {
throw JSONRPCError(RPC_DATABASE_ERROR, "database error");
}

return true;
}

static UniValue sendfrom(const Config &config, const JSONRPCRequest &request) {
std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
CWallet *const pwallet = wallet.get();

if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
return NullUniValue;
}

if (!IsDeprecatedRPCEnabled(gArgs, "accounts")) {
if (request.fHelp) {
throw std::runtime_error(
"sendfrom (Deprecated, will be removed in V0.21. To use this "
"command, start bitcoind with -deprecatedrpc=accounts)");
}
throw JSONRPCError(
RPC_METHOD_DEPRECATED,
"sendfrom is deprecated and will be removed in V0.21. To use this "
"command, start bitcoind with -deprecatedrpc=accounts.");
}

if (request.fHelp \|\| request.params.size() < 3 \|\|
request.params.size() > 6) {
throw std::runtime_error(
"sendfrom \"fromaccount\" \"toaddress\" amount ( minconf "
"\"comment\" \"comment_to\" )\n"
"\nDEPRECATED (use sendtoaddress). Sent an amount from an account "
"to a bitcoin address." +
HelpRequiringPassphrase(pwallet) +
"\n"
"\nArguments:\n"
"1. \"fromaccount\" (string, required) The name of the "
"account to send funds from. May be the default account using "
"\"\".\n"
" Specifying an account does not influence "
"coin selection, but it does associate the newly created\n"
" transaction with the account, so the "
"account's balance computation and transaction history can "
"reflect\n"
" the spend.\n"
"2. \"toaddress\" (string, required) The bitcoin address "
"to send funds to.\n"
"3. amount (numeric or string, required) The amount "
"in " +
CURRENCY_UNIT +
" (transaction fee is added on top).\n"
"4. minconf (numeric, optional, default=1) Only use "
"funds with at least this many confirmations.\n"
"5. \"comment\" (string, optional) A comment used to "
"store what the transaction is for. \n"
" This is not part of the "
"transaction, just kept in your wallet.\n"
"6. \"comment_to\" (string, optional) An optional comment "
"to store the name of the person or organization \n"
" to which you're sending the "
"transaction. This is not part of the transaction, \n"
" it is just kept in your "
"wallet.\n"
"\nResult:\n"
"\"txid\" (string) The transaction id.\n"
"\nExamples:\n"
"\nSend 0.01 " +
CURRENCY_UNIT +
" from the default account to the address, must have at least 1 "
"confirmation\n" +
HelpExampleCli("sendfrom",
"\"\" \"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\" 0.01") +
"\nSend 0.01 from the tabby account to the given address, funds "
"must have at least 6 confirmations\n" +
HelpExampleCli("sendfrom",
"\"tabby\" \"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\" "
"0.01 6 \"donation\" \"seans outpost\"") +
"\nAs a json rpc call\n" +
HelpExampleRpc("sendfrom",
"\"tabby\", \"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\", "
"0.01, 6, \"donation\", \"seans outpost\""));
}

// Make sure the results are valid at least up to the most recent block
// the user could have gotten from another RPC command prior to now
pwallet->BlockUntilSyncedToCurrentChain();

auto locked_chain = pwallet->chain().lock();
LOCK(pwallet->cs_wallet);

std::string label = LabelFromValue(request.params[0]);
CTxDestination dest =
DecodeDestination(request.params[1].get_str(), config.GetChainParams());
if (!IsValidDestination(dest)) {
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
"Invalid Bitcoin address");
}
Amount nAmount = AmountFromValue(request.params[2]);
if (nAmount <= Amount::zero()) {
throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount for send");
}

int nMinDepth = 1;
if (!request.params[3].isNull()) {
nMinDepth = request.params[3].get_int();
}

mapValue_t mapValue;
if (!request.params[4].isNull() && !request.params[4].get_str().empty()) {
mapValue["comment"] = request.params[4].get_str();
}

if (!request.params[5].isNull() && !request.params[5].get_str().empty()) {
mapValue["to"] = request.params[5].get_str();
}

EnsureWalletIsUnlocked(pwallet);

// Check funds
Amount nBalance =
pwallet->GetLegacyBalance(ISMINE_SPENDABLE, nMinDepth, &label);
if (nAmount > nBalance) {
throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS,
"Account has insufficient funds");
}

CTransactionRef tx = SendMoney(*locked_chain, pwallet, dest, nAmount, false,
std::move(mapValue), std::move(label));
return tx->GetId().GetHex();
}

static UniValue sendmany(const Config &config, const JSONRPCRequest &request) {		static UniValue sendmany(const Config &config, const JSONRPCRequest &request) {
std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);		std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
CWallet *const pwallet = wallet.get();		CWallet *const pwallet = wallet.get();

if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {		if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
return NullUniValue;		return NullUniValue;
}		}

std::string help_text;		if (request.fHelp \|\| request.params.size() < 2 \|\| request.params.size() > 8)
		FabienUnsubmitted Not Done Inline Actions Not 8 Fabien: Not 8
if (!IsDeprecatedRPCEnabled(gArgs, "accounts")) {		throw std::runtime_error(
help_text =		"sendmany {\"address\":amount,...} ( minconf \"comment\" "
		FabienUnsubmitted Not Done Inline Actions The dummy element is missing (and was also previously, despite the detailed doc has it. Is this a backport missing or an oversight from another backport ?). Fabien: The dummy element is missing (and was also previously, despite the detailed doc has it. Is this…
		nakihitoAuthorUnsubmitted Done Inline Actions https://reviews.bitcoinabc.org/D4370#change-4q6XVS3POqj5 https://github.com/bitcoin/bitcoin/pull/12953/files#diff-df7d84ff2f53fcb2a0dc15a3a51e55ceR1089-R1132 https://github.com/bitcoin/bitcoin/pull/14023/files?file-filters%5B%5D=.cpp#diff-df7d84ff2f53fcb2a0dc15a3a51e55ceL1124-L1169 The dummy element has always been missing, even on Core. nakihito: https://reviews.bitcoinabc.org/D4370#change-4q6XVS3POqj5 https://github.
		FabienUnsubmitted Not Done Inline Actions Thanks for digging into this. Please add it to the diff, there is no reason for not fixing a known mistake and it seems appropriated to do it here since it's account/label related. Fabien: Thanks for digging into this. Please add it to the diff, there is no reason for not fixing a…
"sendmany \"fromaccount\" {\"address\":amount,...} ( minconf "		"[\"address\",...] )\n"
"\"comment\" [\"address\",...] )\n"
"\nSend multiple times. Amounts are double-precision floating "		"\nSend multiple times. Amounts are double-precision floating "
"point numbers.\n"		"point numbers.\n" +
"Note that the \"fromaccount\" argument has been removed in V0.20. "
"To use this RPC with a \"fromaccount\" argument, restart\n"
"bitcoind with -deprecatedrpc=accounts\n" +
HelpRequiringPassphrase(pwallet) +		HelpRequiringPassphrase(pwallet) +
"\n"		"\n"
"\nArguments:\n"		"\nArguments:\n"
"1. \"dummy\" (string, required) Must be set to \"\" "		"1. \"dummy\" (string, required) Must be set to \"\" "
"for backwards compatibility.\n"		"for backwards compatibility.\n"
"2. \"amounts\" (string, required) A json object with "		"2. \"amounts\" (string, required) A json object with "
"addresses and amounts\n"		"addresses and amounts\n"
" {\n"		" {\n"
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines	if (request.fHelp \|\| request.params.size() < 2 \|\| request.params.size() > 8)
"1 \"\" "		"1 \"\" "
"\"[\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\\\","		"\"[\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\\\","
"\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\"]\"") +		"\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\"]\"") +
"\nAs a json rpc call\n" +		"\nAs a json rpc call\n" +
HelpExampleRpc("sendmany",		HelpExampleRpc("sendmany",
"\"\", "		"\"\", "
"\"{\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\\\":0.01,"		"\"{\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\\\":0.01,"
"\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\":0.02}\","		"\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\":0.02}\","
" 6, \"testing\"");		" 6, \"testing\""));
} else {
help_text =
"sendmany \"\" \"fromaccount\" {\"address\":amount,...} ( "
"minconf \"comment\" [\"address\",...])\n"
"\nSend multiple times. Amounts are double-precision floating "
"point numbers." +
HelpRequiringPassphrase(pwallet) +
"\n"
"\nArguments:\n"
"1. \"fromaccount\" (string, required) DEPRECATED. The "
"account to send the funds from. Should be \"\" for the default "
"account\n"
"2. \"amounts\" (string, required) A json object with "
"addresses and amounts\n"
" {\n"
" \"address\":amount (numeric or string) The bitcoin "
"address is the key, the numeric amount (can be string) in " +
CURRENCY_UNIT +
" is the value\n"
" ,...\n"
" }\n"
"3. minconf (numeric, optional, default=1) Only "
"use the balance confirmed at least this many times.\n"
"4. \"comment\" (string, optional) A comment\n"
"5. subtractfeefrom (array, optional) A json array with "
"addresses.\n"
" The fee will be equally deducted from "
"the amount of each selected address.\n"
" Those recipients will receive less "
"bitcoins than you enter in their corresponding amount field.\n"
" If no addresses are specified here, "
"the sender pays the fee.\n"
" [\n"
" \"address\" (string) Subtract fee from this "
"address\n"
" ,...\n"
" ]\n"
"\nResult:\n"
"\"txid\" (string) The transaction id for the "
"send. Only 1 transaction is created regardless of \n"
" the number of addresses.\n"
"\nExamples:\n"
"\nSend two amounts to two different addresses:\n" +
HelpExampleCli("sendmany",
"\"\" "
"\"{\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\\\":0.01,"
"\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\":0.02}"
"\"") +
"\nSend two amounts to two different addresses setting the "
"confirmation and comment:\n" +
HelpExampleCli("sendmany",
"\"\" "
"\"{\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\\\":0.01,"
"\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\":0.02}\" "
"6 \"testing\"") +
"\nSend two amounts to two different addresses, subtract fee from "
"amount:\n" +
HelpExampleCli("sendmany",
"\"\" "
"\"{\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\\\":0.01,"
"\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\":0.02}\" "
"1 \"\" "
"\"[\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\\\","
"\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\"]\"") +
"\nAs a json rpc call\n" +
HelpExampleRpc("sendmany",
"\"\", "
"\"{\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\\\":0.01,"
"\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\":0.02}\","
" 6, \"testing\"");
}

if (request.fHelp \|\| request.params.size() < 2 \|\|
request.params.size() > 5) {
throw std::runtime_error(help_text);
}

// Make sure the results are valid at least up to the most recent block		// Make sure the results are valid at least up to the most recent block
// the user could have gotten from another RPC command prior to now		// the user could have gotten from another RPC command prior to now
pwallet->BlockUntilSyncedToCurrentChain();		pwallet->BlockUntilSyncedToCurrentChain();

auto locked_chain = pwallet->chain().lock();		auto locked_chain = pwallet->chain().lock();
LOCK(pwallet->cs_wallet);		LOCK(pwallet->cs_wallet);

if (pwallet->GetBroadcastTransactions() && !g_connman) {		if (pwallet->GetBroadcastTransactions() && !g_connman) {
throw JSONRPCError(		throw JSONRPCError(
RPC_CLIENT_P2P_DISABLED,		RPC_CLIENT_P2P_DISABLED,
"Error: Peer-to-peer functionality missing or disabled");		"Error: Peer-to-peer functionality missing or disabled");
}		}

if (!IsDeprecatedRPCEnabled(gArgs, "accounts") &&		if (!request.params[0].isNull() && !request.params[0].get_str().empty()) {
!request.params[0].get_str().empty()) {
throw JSONRPCError(RPC_INVALID_PARAMETER,		throw JSONRPCError(RPC_INVALID_PARAMETER,
"Dummy value must be set to \"\"");		"Dummy value must be set to \"\"");
}		}
std::string strAccount = LabelFromValue(request.params[0]);
UniValue sendTo = request.params[1].get_obj();		UniValue sendTo = request.params[1].get_obj();
int nMinDepth = 1;		int nMinDepth = 1;
if (!request.params[2].isNull()) {		if (!request.params[2].isNull()) {
nMinDepth = request.params[2].get_int();		nMinDepth = request.params[2].get_int();
}		}

mapValue_t mapValue;		mapValue_t mapValue;
if (!request.params[3].isNull() && !request.params[3].get_str().empty()) {		if (!request.params[3].isNull() && !request.params[3].get_str().empty()) {
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines	for (const std::string &name_ : keys) {

CRecipient recipient = {scriptPubKey, nAmount, fSubtractFeeFromAmount};		CRecipient recipient = {scriptPubKey, nAmount, fSubtractFeeFromAmount};
vecSend.push_back(recipient);		vecSend.push_back(recipient);
}		}

EnsureWalletIsUnlocked(pwallet);		EnsureWalletIsUnlocked(pwallet);

// Check funds		// Check funds
if (IsDeprecatedRPCEnabled(gArgs, "accounts") &&		if (totalAmount >
totalAmount > pwallet->GetLegacyBalance(ISMINE_SPENDABLE, nMinDepth,		pwallet->GetLegacyBalance(ISMINE_SPENDABLE, nMinDepth, nullptr)) {
&strAccount)) {
throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS,
"Account has insufficient funds");
} else if (!IsDeprecatedRPCEnabled(gArgs, "accounts") &&
totalAmount > pwallet->GetLegacyBalance(ISMINE_SPENDABLE,
nMinDepth, nullptr)) {
throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS,		throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS,
"Wallet has insufficient funds");		"Wallet has insufficient funds");
}		}

// Shuffle recipient list		// Shuffle recipient list
std::shuffle(vecSend.begin(), vecSend.end(), FastRandomContext());		std::shuffle(vecSend.begin(), vecSend.end(), FastRandomContext());

// Send		// Send
CReserveKey keyChange(pwallet);		CReserveKey keyChange(pwallet);
Amount nFeeRequired = Amount::zero();		Amount nFeeRequired = Amount::zero();
int nChangePosRet = -1;		int nChangePosRet = -1;
std::string strFailReason;		std::string strFailReason;
CTransactionRef tx;		CTransactionRef tx;
CCoinControl coinControl;		CCoinControl coinControl;
bool fCreated = pwallet->CreateTransaction(		bool fCreated = pwallet->CreateTransaction(
*locked_chain, vecSend, tx, keyChange, nFeeRequired, nChangePosRet,		*locked_chain, vecSend, tx, keyChange, nFeeRequired, nChangePosRet,
strFailReason, coinControl);		strFailReason, coinControl);
if (!fCreated) {		if (!fCreated) {
throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, strFailReason);		throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, strFailReason);
}		}
CValidationState state;		CValidationState state;
if (!pwallet->CommitTransaction(tx, std::move(mapValue), {} /* orderForm */,		if (!pwallet->CommitTransaction(tx, std::move(mapValue), {} /* orderForm */,
std::move(strAccount), keyChange,		"" /* account */, keyChange,
g_connman.get(), state)) {		g_connman.get(), state)) {
strFailReason = strprintf("Transaction commit failed:: %s",		strFailReason = strprintf("Transaction commit failed:: %s",
FormatStateMessage(state));		FormatStateMessage(state));
throw JSONRPCError(RPC_WALLET_ERROR, strFailReason);		throw JSONRPCError(RPC_WALLET_ERROR, strFailReason);
}		}

return tx->GetId().GetHex();		return tx->GetId().GetHex();
}		}
▲ Show 20 Lines • Show All 218 Lines • ▼ Show 20 Lines	for (auto item_it = start; item_it != end; ++item_it) {
_item.nConf = std::min(_item.nConf, nConf);		_item.nConf = std::min(_item.nConf, nConf);
_item.fIsWatchonly = fIsWatchonly;		_item.fIsWatchonly = fIsWatchonly;
} else {		} else {
UniValue obj(UniValue::VOBJ);		UniValue obj(UniValue::VOBJ);
if (fIsWatchonly) {		if (fIsWatchonly) {
obj.pushKV("involvesWatchonly", true);		obj.pushKV("involvesWatchonly", true);
}		}
obj.pushKV("address", EncodeDestination(address, config));		obj.pushKV("address", EncodeDestination(address, config));
obj.pushKV("account", label);
obj.pushKV("amount", ValueFromAmount(nAmount));		obj.pushKV("amount", ValueFromAmount(nAmount));
obj.pushKV("confirmations",		obj.pushKV("confirmations",
(nConf == std::numeric_limits<int>::max() ? 0 : nConf));		(nConf == std::numeric_limits<int>::max() ? 0 : nConf));
obj.pushKV("label", label);		obj.pushKV("label", label);
UniValue transactions(UniValue::VARR);		UniValue transactions(UniValue::VARR);
if (it != mapTally.end()) {		if (it != mapTally.end()) {
for (const uint256 &_item : (*it).second.txids) {		for (const uint256 &_item : (*it).second.txids) {
transactions.push_back(_item.GetHex());		transactions.push_back(_item.GetHex());
}		}
}		}
obj.pushKV("txids", transactions);		obj.pushKV("txids", transactions);
ret.push_back(obj);		ret.push_back(obj);
}		}
}		}

if (by_label) {		if (by_label) {
for (const auto &entry : label_tally) {		for (const auto &entry : label_tally) {
Amount nAmount = entry.second.nAmount;		Amount nAmount = entry.second.nAmount;
int nConf = entry.second.nConf;		int nConf = entry.second.nConf;
UniValue obj(UniValue::VOBJ);		UniValue obj(UniValue::VOBJ);
if (entry.second.fIsWatchonly) {		if (entry.second.fIsWatchonly) {
obj.pushKV("involvesWatchonly", true);		obj.pushKV("involvesWatchonly", true);
}		}
obj.pushKV("account", entry.first);
obj.pushKV("amount", ValueFromAmount(nAmount));		obj.pushKV("amount", ValueFromAmount(nAmount));
obj.pushKV("confirmations",		obj.pushKV("confirmations",
(nConf == std::numeric_limits<int>::max() ? 0 : nConf));		(nConf == std::numeric_limits<int>::max() ? 0 : nConf));
obj.pushKV("label", entry.first);		obj.pushKV("label", entry.first);
ret.push_back(obj);		ret.push_back(obj);
}		}
}		}

Show All 25 Lines	if (request.fHelp \|\| request.params.size() > 4) {
"information on this address.\n"		"information on this address.\n"
"\nResult:\n"		"\nResult:\n"
"[\n"		"[\n"
" {\n"		" {\n"
" \"involvesWatchonly\" : true, (bool) Only returned if "		" \"involvesWatchonly\" : true, (bool) Only returned if "
"imported addresses were involved in transaction\n"		"imported addresses were involved in transaction\n"
" \"address\" : \"receivingaddress\", (string) The receiving "		" \"address\" : \"receivingaddress\", (string) The receiving "
"address\n"		"address\n"
" \"account\" : \"accountname\", (string) DEPRECATED. "
"Backwards compatible alias for label.\n \"\".\n"
" \"amount\" : x.xxx, (numeric) The total "		" \"amount\" : x.xxx, (numeric) The total "
"amount in " +		"amount in " +
CURRENCY_UNIT +		CURRENCY_UNIT +
" received by the address\n"		" received by the address\n"
" \"confirmations\" : n, (numeric) The number of "		" \"confirmations\" : n, (numeric) The number of "
"confirmations of the most recent transaction included\n"		"confirmations of the most recent transaction included\n"
" \"label\" : \"label\", (string) The label of "		" \"label\" : \"label\", (string) The label of "
"the receiving address. The default label is \"\".\n"		"the receiving address. The default label is \"\".\n"
Show All 29 Lines	static UniValue listreceivedbylabel(const Config &config,
const JSONRPCRequest &request) {		const JSONRPCRequest &request) {
std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);		std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
CWallet *const pwallet = wallet.get();		CWallet *const pwallet = wallet.get();

if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {		if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
return NullUniValue;		return NullUniValue;
}		}

if (!IsDeprecatedRPCEnabled(gArgs, "accounts") &&
request.strMethod == "listreceivedbyaccount") {
if (request.fHelp) {
throw std::runtime_error(
"listreceivedbyaccount (Deprecated, will be removed in v0.21. "
"To use this command, start bitcoind with "
"-deprecatedrpc=accounts)");
}
throw JSONRPCError(RPC_METHOD_DEPRECATED,
"listreceivedbyaccount is deprecated and will be "
"removed in v0.21. To use this command, start "
"bitcoind with -deprecatedrpc=accounts.");
}

if (request.fHelp \|\| request.params.size() > 3) {		if (request.fHelp \|\| request.params.size() > 3) {
throw std::runtime_error(		throw std::runtime_error(
"listreceivedbylabel ( minconf include_empty include_watchonly)\n"		"listreceivedbylabel ( minconf include_empty include_watchonly)\n"
"\nList received transactions by label.\n"		"\nList received transactions by label.\n"
"\nArguments:\n"		"\nArguments:\n"
"1. minconf (numeric, optional, default=1) The minimum "		"1. minconf (numeric, optional, default=1) The minimum "
"number of confirmations before payments are included.\n"		"number of confirmations before payments are included.\n"
"2. include_empty (bool, optional, default=false) Whether to "		"2. include_empty (bool, optional, default=false) Whether to "
"include labels that haven't received any payments.\n"		"include labels that haven't received any payments.\n"
"3. include_watchonly (bool, optional, default=false) Whether to "		"3. include_watchonly (bool, optional, default=false) Whether to "
"include watch-only addresses (see 'importaddress').\n"		"include watch-only addresses (see 'importaddress').\n"

"\nResult:\n"		"\nResult:\n"
"[\n"		"[\n"
" {\n"		" {\n"
" \"involvesWatchonly\" : true, (bool) Only returned if "		" \"involvesWatchonly\" : true, (bool) Only returned if "
"imported addresses were involved in transaction\n"		"imported addresses were involved in transaction\n"
" \"account\" : \"accountname\", (string) DEPRECATED. "
"Backwards compatible alias for label.\n"
" \"amount\" : x.xxx, (numeric) The total amount "		" \"amount\" : x.xxx, (numeric) The total amount "
"received by addresses with this label\n"		"received by addresses with this label\n"
" \"confirmations\" : n, (numeric) The number of "		" \"confirmations\" : n, (numeric) The number of "
"confirmations of the most recent transaction included\n"		"confirmations of the most recent transaction included\n"
" \"label\" : \"label\" (string) The label of the "		" \"label\" : \"label\" (string) The label of the "
"receiving address. The default label is \"\".\n"		"receiving address. The default label is \"\".\n"
" }\n"		" }\n"
" ,...\n"		" ,...\n"
Show All 21 Lines	static void MaybePushAddress(UniValue &entry, const CTxDestination &dest) {
}		}
}		}

/**		/**
* List transactions based on the given criteria.		* List transactions based on the given criteria.
*		*
* @param pwallet The wallet.		* @param pwallet The wallet.
* @param wtx The wallet transaction.		* @param wtx The wallet transaction.
* @param strAccount The account, if any, or "*" for all.
* @param nMinDepth The minimum confirmation depth.		* @param nMinDepth The minimum confirmation depth.
* @param fLong Whether to include the JSON version of the transaction.		* @param fLong Whether to include the JSON version of the transaction.
* @param ret The UniValue into which the result is stored.		* @param ret The UniValue into which the result is stored.
* @param filter The "is mine" filter bool.		* @param filter The "is mine" filter bool.
*/		*/
static void ListTransactions(interfaces::Chain::Lock &locked_chain,		static void ListTransactions(interfaces::Chain::Lock &locked_chain,
CWallet *const pwallet, const CWalletTx &wtx,		CWallet *const pwallet, const CWalletTx &wtx,
const std::string &strAccount, int nMinDepth,		int nMinDepth, bool fLong, UniValue &ret,
bool fLong, UniValue &ret,
const isminefilter &filter) {		const isminefilter &filter) {
		FabienUnsubmitted Not Done Inline Actions There is a missing `EXCLUSIVE_LOCKS_REQUIRED`, is there a missing backport ? Fabien: There is a missing `EXCLUSIVE_LOCKS_REQUIRED`, is there a missing backport ?
		nakihitoAuthorUnsubmitted Done Inline Actions https://github.com/bitcoin/bitcoin/pull/13083/files but it does not affect this change. nakihito: https://github.com/bitcoin/bitcoin/pull/13083/files but it does not affect this change.
		nakihitoAuthorUnsubmitted Done Inline Actions Should've been added in D4094. nakihito: Should've been added in D4094.
		FabienUnsubmitted Not Done Inline Actions OK, agreed it's out of scope. Fabien: OK, agreed it's out of scope.
		jasonbcoxUnsubmitted Not Done Inline Actions Please be sure to follow up on this before this diff is closed out, lest it be forgotten. jasonbcox: Please be sure to follow up on this before this diff is closed out, lest it be forgotten.
		nakihitoAuthorUnsubmitted Done Inline Actions Removed here: D5078. nakihito: Removed here: D5078.
Amount nFee;		Amount nFee;
std::string strSentAccount;		std::string dummy_account;
std::list<COutputEntry> listReceived;		std::list<COutputEntry> listReceived;
std::list<COutputEntry> listSent;		std::list<COutputEntry> listSent;

wtx.GetAmounts(listReceived, listSent, nFee, strSentAccount, filter);		wtx.GetAmounts(listReceived, listSent, nFee, dummy_account, filter);

bool fAllAccounts = (strAccount == std::string("*"));
bool involvesWatchonly = wtx.IsFromMe(ISMINE_WATCH_ONLY);		bool involvesWatchonly = wtx.IsFromMe(ISMINE_WATCH_ONLY);

// Sent		// Sent
if ((!listSent.empty() \|\| nFee != Amount::zero()) &&		if (!listSent.empty() \|\| nFee != Amount::zero()) {
(fAllAccounts \|\| strAccount == strSentAccount)) {
for (const COutputEntry &s : listSent) {		for (const COutputEntry &s : listSent) {
UniValue entry(UniValue::VOBJ);		UniValue entry(UniValue::VOBJ);
if (involvesWatchonly \|\|		if (involvesWatchonly \|\|
(::IsMine(*pwallet, s.destination) & ISMINE_WATCH_ONLY)) {		(::IsMine(*pwallet, s.destination) & ISMINE_WATCH_ONLY)) {
entry.pushKV("involvesWatchonly", true);		entry.pushKV("involvesWatchonly", true);
}		}
if (IsDeprecatedRPCEnabled(gArgs, "accounts")) {
entry.pushKV("account", strSentAccount);
}
MaybePushAddress(entry, s.destination);		MaybePushAddress(entry, s.destination);
entry.pushKV("category", "send");		entry.pushKV("category", "send");
entry.pushKV("amount", ValueFromAmount(-s.amount));		entry.pushKV("amount", ValueFromAmount(-s.amount));
if (pwallet->mapAddressBook.count(s.destination)) {		if (pwallet->mapAddressBook.count(s.destination)) {
entry.pushKV("label",		entry.pushKV("label",
pwallet->mapAddressBook[s.destination].name);		pwallet->mapAddressBook[s.destination].name);
}		}
entry.pushKV("vout", s.vout);		entry.pushKV("vout", s.vout);
entry.pushKV("fee", ValueFromAmount(-1 * nFee));		entry.pushKV("fee", ValueFromAmount(-1 * nFee));
if (fLong) {		if (fLong) {
WalletTxToJSON(pwallet->chain(), locked_chain, wtx, entry);		WalletTxToJSON(pwallet->chain(), locked_chain, wtx, entry);
}		}
entry.pushKV("abandoned", wtx.isAbandoned());		entry.pushKV("abandoned", wtx.isAbandoned());
ret.push_back(entry);		ret.push_back(entry);
}		}
}		}

// Received		// Received
if (listReceived.size() > 0 &&		if (listReceived.size() > 0 &&
wtx.GetDepthInMainChain(locked_chain) >= nMinDepth) {		wtx.GetDepthInMainChain(locked_chain) >= nMinDepth) {
for (const COutputEntry &r : listReceived) {		for (const COutputEntry &r : listReceived) {
std::string account;		std::string label;
if (pwallet->mapAddressBook.count(r.destination)) {		if (pwallet->mapAddressBook.count(r.destination)) {
account = pwallet->mapAddressBook[r.destination].name;		label = pwallet->mapAddressBook[r.destination].name;
}		}
if (fAllAccounts \|\| (account == strAccount)) {
UniValue entry(UniValue::VOBJ);		UniValue entry(UniValue::VOBJ);
if (involvesWatchonly \|\|		if (involvesWatchonly \|\|
(::IsMine(*pwallet, r.destination) & ISMINE_WATCH_ONLY)) {		(::IsMine(*pwallet, r.destination) & ISMINE_WATCH_ONLY)) {
entry.pushKV("involvesWatchonly", true);		entry.pushKV("involvesWatchonly", true);
}		}
if (IsDeprecatedRPCEnabled(gArgs, "accounts")) {
entry.pushKV("account", account);
}
MaybePushAddress(entry, r.destination);		MaybePushAddress(entry, r.destination);
if (wtx.IsCoinBase()) {		if (wtx.IsCoinBase()) {
if (wtx.GetDepthInMainChain(locked_chain) < 1) {		if (wtx.GetDepthInMainChain(locked_chain) < 1) {
entry.pushKV("category", "orphan");		entry.pushKV("category", "orphan");
} else if (wtx.IsImmatureCoinBase(locked_chain)) {		} else if (wtx.IsImmatureCoinBase(locked_chain)) {
entry.pushKV("category", "immature");		entry.pushKV("category", "immature");
} else {		} else {
entry.pushKV("category", "generate");		entry.pushKV("category", "generate");
}		}
} else {		} else {
entry.pushKV("category", "receive");		entry.pushKV("category", "receive");
}		}
entry.pushKV("amount", ValueFromAmount(r.amount));		entry.pushKV("amount", ValueFromAmount(r.amount));
if (pwallet->mapAddressBook.count(r.destination)) {		if (pwallet->mapAddressBook.count(r.destination)) {
entry.pushKV("label", account);		entry.pushKV("label", label);
}		}
entry.pushKV("vout", r.vout);		entry.pushKV("vout", r.vout);
if (fLong) {		if (fLong) {
WalletTxToJSON(pwallet->chain(), locked_chain, wtx, entry);		WalletTxToJSON(pwallet->chain(), locked_chain, wtx, entry);
}		}
ret.push_back(entry);		ret.push_back(entry);
}		}
}		}
}		}
}

static void AcentryToJSON(const CAccountingEntry &acentry,
const std::string &strAccount, UniValue &ret) {
bool fAllAccounts = (strAccount == std::string("*"));

if (fAllAccounts \|\| acentry.strAccount == strAccount) {
UniValue entry(UniValue::VOBJ);
entry.pushKV("account", acentry.strAccount);
entry.pushKV("category", "move");
entry.pushKV("time", acentry.nTime);
entry.pushKV("amount", ValueFromAmount(acentry.nCreditDebit));
if (IsDeprecatedRPCEnabled(gArgs, "accounts")) {
entry.pushKV("otheraccount", acentry.strOtherAccount);
}
entry.pushKV("comment", acentry.strComment);
ret.push_back(entry);
}
}

UniValue listtransactions(const Config &config, const JSONRPCRequest &request) {		UniValue listtransactions(const Config &config, const JSONRPCRequest &request) {
std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);		std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
CWallet *const pwallet = wallet.get();		CWallet *const pwallet = wallet.get();

if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {		if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
return NullUniValue;		return NullUniValue;
}		}

std::string help_text{};		if (request.fHelp \|\| request.params.size() > 4) {
if (!IsDeprecatedRPCEnabled(gArgs, "accounts")) {		throw std::runtime_error(
help_text =
"listtransactions ( \"dummy\" count skip include_watchonly)\n"		"listtransactions ( \"dummy\" count skip include_watchonly)\n"
"\nReturns up to 'count' most recent transactions skipping the "		"\nReturns up to 'count' most recent transactions skipping the "
"first 'from' transactions for account 'account'.\n"		"first 'from' transactions.\n"
"Note that the \"account\" argument and \"otheraccount\" return "
"value have been removed in V0.20. To use this RPC with an "
"\"account\" argument, restart\n"
"bitcoind with -deprecatedrpc=accounts\n"
"\nArguments:\n"		"\nArguments:\n"
"1. \"dummy\" (string, optional) If set, should be \"*\" for "		"1. \"dummy\" (string, optional) If set, should be \"*\" for "
"backwards compatibility.\n"		"backwards compatibility.\n"
"2. count (numeric, optional, default=10) The number of "		"2. count (numeric, optional, default=10) The number of "
"transactions to return\n"		"transactions to return\n"
"3. skip (numeric, optional, default=0) The number of "		"3. skip (numeric, optional, default=0) The number of "
"transactions to skip\n"		"transactions to skip\n"
"4. include_watchonly (bool, optional, default=false) Include "		"4. include_watchonly (bool, optional, default=false) Include "
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines	if (request.fHelp \|\| request.params.size() > 4) {
"]\n"		"]\n"

"\nExamples:\n"		"\nExamples:\n"
"\nList the most recent 10 transactions in the systems\n" +		"\nList the most recent 10 transactions in the systems\n" +
HelpExampleCli("listtransactions", "") +		HelpExampleCli("listtransactions", "") +
"\nList transactions 100 to 120\n" +		"\nList transactions 100 to 120\n" +
HelpExampleCli("listtransactions", "\"*\" 20 100") +		HelpExampleCli("listtransactions", "\"*\" 20 100") +
"\nAs a json rpc call\n" +		"\nAs a json rpc call\n" +
HelpExampleRpc("listtransactions", "\"*\", 20, 100");		HelpExampleRpc("listtransactions", "\"*\", 20, 100"));
} else {
help_text =
"listtransactions ( \"account\" count skip include_watchonly)\n"
"\nReturns up to 'count' most recent transactions skipping the "
"first 'from' transactions for account 'account'.\n"
"\nArguments:\n"
"1. \"account\" (string, optional) DEPRECATED. This argument "
"will be removed in V0.21. The account name. Should be \"*\".\n"
"2. count (numeric, optional, default=10) The number of "
"transactions to return\n"
"3. skip (numeric, optional, default=0) The number of "
"transactions to skip\n"
"4. include_watchonly (bool, optional, default=false) Include "
"transactions to watch-only addresses (see 'importaddress')\n"
"\nResult:\n"
"[\n"
" {\n"
" \"account\":\"accountname\", (string) DEPRECATED. This "
"field will be removed in V0.21. The account name associated with "
"the transaction. \n"
" It will be \"\" "
"for the default account.\n"
" \"address\":\"address\", (string) The bitcoin address of "
"the transaction. Not present for \n"
" move transactions "
"(category = move).\n"
" \"category\":\"send\|receive\|move\", (string) The transaction "
"category. 'move' is a local (off blockchain)\n"
" transaction "
"between accounts, and not associated with an address,\n"
" transaction id or "
"block. 'send' and 'receive' transactions are \n"
" associated with "
"an address, transaction id and block details\n"
" \"amount\": x.xxx, (numeric) The amount in " +
CURRENCY_UNIT +
". This is negative for the 'send' category, and for the\n"
" 'move' category for "
"moves outbound. It is positive for the 'receive' category,\n"
" and for the 'move' "
"category for inbound funds.\n"
" \"label\": \"label\", (string) A comment for the "
"address/transaction, if any\n"
" \"vout\": n, (numeric) the vout value\n"
" \"fee\": x.xxx, (numeric) The amount of the fee "
"in " +
CURRENCY_UNIT +
". This is negative and only available for the \n"
" 'send' category of "
"transactions.\n"
" \"confirmations\": n, (numeric) The number of "
"confirmations for the transaction. Available for 'send' and \n"
" 'receive' category of "
"transactions. Negative confirmations indicate the\n"
" transaction conflicts "
"with the block chain\n"
" \"trusted\": xxx, (bool) Whether we consider the "
"outputs of this unconfirmed transaction safe to spend.\n"
" \"blockhash\": \"hashvalue\", (string) The block hash "
"containing the transaction. Available for 'send' and 'receive'\n"
" category of "
"transactions.\n"
" \"blockindex\": n, (numeric) The index of the "
"transaction in the block that includes it. Available for 'send' "
"and 'receive'\n"
" category of "
"transactions.\n"
" \"blocktime\": xxx, (numeric) The block time in "
"seconds since epoch (1 Jan 1970 GMT).\n"
" \"txid\": \"transactionid\", (string) The transaction id. "
"Available for 'send' and 'receive' category of transactions.\n"
" \"time\": xxx, (numeric) The transaction time in "
"seconds since epoch (midnight Jan 1 1970 GMT).\n"
" \"timereceived\": xxx, (numeric) The time received in "
"seconds since epoch (midnight Jan 1 1970 GMT). Available \n"
" for 'send' and "
"'receive' category of transactions.\n"
" \"comment\": \"...\", (string) If a comment is "
"associated with the transaction.\n"
" \"otheraccount\": \"accountname\", (string) DEPRECATED. This "
"field will be removed in V0.21. For the 'move' category of "
"transactions, the account the funds came \n"
" from (for receiving "
"funds, positive amounts), or went to (for sending funds,\n"
" negative amounts).\n"
" \"abandoned\": xxx (bool) 'true' if the transaction "
"has been abandoned (inputs are respendable). Only available for "
"the \n"
" 'send' category of "
"transactions.\n"
" }\n"
"]\n"

"\nExamples:\n"
"\nList the most recent 10 transactions in the systems\n" +
HelpExampleCli("listtransactions", "") +
"\nList transactions 100 to 120\n" +
HelpExampleCli("listtransactions", "\"*\" 20 100") +
"\nAs a json rpc call\n" +
HelpExampleRpc("listtransactions", "\"*\", 20, 100");
}
if (request.fHelp \|\| request.params.size() > 4) {
throw std::runtime_error(help_text);
}		}

// Make sure the results are valid at least up to the most recent block		// Make sure the results are valid at least up to the most recent block
// the user could have gotten from another RPC command prior to now		// the user could have gotten from another RPC command prior to now
pwallet->BlockUntilSyncedToCurrentChain();		pwallet->BlockUntilSyncedToCurrentChain();

auto locked_chain = pwallet->chain().lock();		auto locked_chain = pwallet->chain().lock();
LOCK(pwallet->cs_wallet);		LOCK(pwallet->cs_wallet);

std::string strAccount = "*";		if (!request.params[0].isNull() && request.params[0].get_str() != "*") {
if (!request.params[0].isNull()) {
strAccount = request.params[0].get_str();
if (!IsDeprecatedRPCEnabled(gArgs, "accounts") && strAccount != "*") {
throw JSONRPCError(RPC_INVALID_PARAMETER,		throw JSONRPCError(RPC_INVALID_PARAMETER,
"Dummy value must be set to \"*\"");		"Dummy value must be set to \"*\"");
}		}
}
int nCount = 10;		int nCount = 10;
if (!request.params[1].isNull()) {		if (!request.params[1].isNull()) {
nCount = request.params[1].get_int();		nCount = request.params[1].get_int();
}		}

int nFrom = 0;		int nFrom = 0;
if (!request.params[2].isNull()) {		if (!request.params[2].isNull()) {
nFrom = request.params[2].get_int();		nFrom = request.params[2].get_int();
Show All 14 Lines	UniValue listtransactions(const Config &config, const JSONRPCRequest &request) {

const CWallet::TxItems &txOrdered = pwallet->wtxOrdered;		const CWallet::TxItems &txOrdered = pwallet->wtxOrdered;

// iterate backwards until we have nCount items to return:		// iterate backwards until we have nCount items to return:
for (CWallet::TxItems::const_reverse_iterator it = txOrdered.rbegin();		for (CWallet::TxItems::const_reverse_iterator it = txOrdered.rbegin();
it != txOrdered.rend(); ++it) {		it != txOrdered.rend(); ++it) {
CWalletTx const pwtx = (it).second.first;		CWalletTx const pwtx = (it).second.first;
if (pwtx != nullptr) {		if (pwtx != nullptr) {
ListTransactions(locked_chain, pwallet, pwtx, strAccount, 0, true,		ListTransactions(locked_chain, pwallet, pwtx, 0, true, ret,
ret, filter);		filter);
}
if (IsDeprecatedRPCEnabled(gArgs, "accounts")) {
CAccountingEntry const pacentry = (it).second.second;
if (pacentry != nullptr) {
AcentryToJSON(*pacentry, strAccount, ret);
}
}		}

if ((int)ret.size() >= (nCount + nFrom)) {		if ((int)ret.size() >= (nCount + nFrom)) {
break;		break;
}		}
}		}

// ret is newest to oldest		// ret is newest to oldest
Show All 24 Lines	UniValue listtransactions(const Config &config, const JSONRPCRequest &request) {

ret.clear();		ret.clear();
ret.setArray();		ret.setArray();
ret.push_backV(arrTmp);		ret.push_backV(arrTmp);

return ret;		return ret;
}		}

static UniValue listaccounts(const Config &config,
const JSONRPCRequest &request) {
std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
CWallet *const pwallet = wallet.get();

if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
return NullUniValue;
}

if (!IsDeprecatedRPCEnabled(gArgs, "accounts")) {
if (request.fHelp) {
throw std::runtime_error(
"listaccounts (Deprecated, will be removed in v0.21. To use "
"this command, start bitcoind with -deprecatedrpc=accounts)");
}
throw JSONRPCError(
RPC_METHOD_DEPRECATED,
"listaccounts is deprecated and will be removed in v0.21. To use "
"this command, start bitcoind with -deprecatedrpc=accounts.");
}

if (request.fHelp \|\| request.params.size() > 2) {
throw std::runtime_error(
"listaccounts ( minconf include_watchonly)\n"
"\nDEPRECATED. Returns Object that has account names as keys, "
"account balances as values.\n"
"\nArguments:\n"
"1. minconf (numeric, optional, default=1) Only "
"include transactions with at least this many confirmations\n"
"2. include_watchonly (bool, optional, default=false) Include "
"balances in watch-only addresses (see 'importaddress')\n"
"\nResult:\n"
"{ (json object where keys are account names, "
"and values are numeric balances\n"
" \"account\": x.xxx, (numeric) The property name is the account "
"name, and the value is the total balance for the account.\n"
" ...\n"
"}\n"
"\nExamples:\n"
"\nList account balances where there at least 1 confirmation\n" +
HelpExampleCli("listaccounts", "") +
"\nList account balances including zero confirmation "
"transactions\n" +
HelpExampleCli("listaccounts", "0") +
"\nList account balances for 6 or more confirmations\n" +
HelpExampleCli("listaccounts", "6") + "\nAs json rpc call\n" +
HelpExampleRpc("listaccounts", "6"));
}

// Make sure the results are valid at least up to the most recent block
// the user could have gotten from another RPC command prior to now
pwallet->BlockUntilSyncedToCurrentChain();

auto locked_chain = pwallet->chain().lock();
LOCK(pwallet->cs_wallet);

int nMinDepth = 1;
if (!request.params[0].isNull()) {
nMinDepth = request.params[0].get_int();
}

isminefilter includeWatchonly = ISMINE_SPENDABLE;
if (!request.params[1].isNull() && request.params[1].get_bool()) {
includeWatchonly = includeWatchonly \| ISMINE_WATCH_ONLY;
}

std::map<std::string, Amount> mapAccountBalances;
for (const std::pair<const CTxDestination, CAddressBookData> &entry :
pwallet->mapAddressBook) {
// This address belongs to me
if (IsMine(*pwallet, entry.first) & includeWatchonly) {
mapAccountBalances[entry.second.name] = Amount::zero();
}
}

for (const std::pair<const TxId, CWalletTx> &pairWtx : pwallet->mapWallet) {
const CWalletTx &wtx = pairWtx.second;
Amount nFee;
std::string strSentAccount;
std::list<COutputEntry> listReceived;
std::list<COutputEntry> listSent;
int nDepth = wtx.GetDepthInMainChain(*locked_chain);
if (wtx.IsImmatureCoinBase(*locked_chain) \|\| nDepth < 0) {
continue;
}
wtx.GetAmounts(listReceived, listSent, nFee, strSentAccount,
includeWatchonly);
mapAccountBalances[strSentAccount] -= nFee;
for (const COutputEntry &s : listSent) {
mapAccountBalances[strSentAccount] -= s.amount;
}
if (nDepth >= nMinDepth) {
for (const COutputEntry &r : listReceived) {
if (pwallet->mapAddressBook.count(r.destination)) {
mapAccountBalances[pwallet->mapAddressBook[r.destination]
.name] += r.amount;
} else {
mapAccountBalances[""] += r.amount;
}
}
}
}

const std::list<CAccountingEntry> &acentries = pwallet->laccentries;
for (const CAccountingEntry &entry : acentries) {
mapAccountBalances[entry.strAccount] += entry.nCreditDebit;
}

UniValue ret(UniValue::VOBJ);
for (const std::pair<const std::string, Amount> &accountBalance :
mapAccountBalances) {
ret.pushKV(accountBalance.first,
ValueFromAmount(accountBalance.second));
}
return ret;
}

static UniValue listsinceblock(const Config &config,		static UniValue listsinceblock(const Config &config,
const JSONRPCRequest &request) {		const JSONRPCRequest &request) {
std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);		std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
CWallet *const pwallet = wallet.get();		CWallet *const pwallet = wallet.get();

if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {		if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
return NullUniValue;		return NullUniValue;
}		}
Show All 22 Lines	if (request.fHelp \|\| request.params.size() > 4) {
"4. include_removed: (bool, optional, default=true) Show "		"4. include_removed: (bool, optional, default=true) Show "
"transactions that were removed due to a reorg in the \"removed\" "		"transactions that were removed due to a reorg in the \"removed\" "
"array\n"		"array\n"
" (not "		" (not "
"guaranteed to work on pruned nodes)\n"		"guaranteed to work on pruned nodes)\n"
"\nResult:\n"		"\nResult:\n"
"{\n"		"{\n"
" \"transactions\": [\n"		" \"transactions\": [\n"
" \"account\":\"accountname\", (string) DEPRECATED. This "
"field will be removed in V0.21. To see this deprecated field, "
"start bitcoind with -deprecatedrpc=accounts. The "
"account name associated with the transaction. Will be \"\" for "
"the default account.\n"
" \"address\":\"address\", (string) The bitcoin address of "		" \"address\":\"address\", (string) The bitcoin address of "
"the transaction. Not present for move transactions (category = "		"the transaction. Not present for move transactions (category = "
"move).\n"		"move).\n"
" \"category\":\"send\|receive\", (string) The transaction "		" \"category\":\"send\|receive\", (string) The transaction "
"category. 'send' has negative amounts, 'receive' has positive "		"category. 'send' has negative amounts, 'receive' has positive "
"amounts.\n"		"amounts.\n"
" \"amount\": x.xxx, (numeric) The amount in " +		" \"amount\": x.xxx, (numeric) The amount in " +
CURRENCY_UNIT +		CURRENCY_UNIT +
▲ Show 20 Lines • Show All 111 Lines • ▼ Show 20 Lines	static UniValue listsinceblock(const Config &config,
int depth = pindex ? (1 + chainActive.Height() - pindex->nHeight) : -1;		int depth = pindex ? (1 + chainActive.Height() - pindex->nHeight) : -1;

UniValue transactions(UniValue::VARR);		UniValue transactions(UniValue::VARR);

for (const std::pair<const TxId, CWalletTx> &pairWtx : pwallet->mapWallet) {		for (const std::pair<const TxId, CWalletTx> &pairWtx : pwallet->mapWallet) {
CWalletTx tx = pairWtx.second;		CWalletTx tx = pairWtx.second;

if (depth == -1 \|\| tx.GetDepthInMainChain(*locked_chain) < depth) {		if (depth == -1 \|\| tx.GetDepthInMainChain(*locked_chain) < depth) {
ListTransactions(locked_chain, pwallet, tx, "", 0, true,		ListTransactions(*locked_chain, pwallet, tx, 0, true, transactions,
transactions, filter);		filter);
}		}
}		}

const Consensus::Params &params = config.GetChainParams().GetConsensus();		const Consensus::Params &params = config.GetChainParams().GetConsensus();

// when a reorg'd block is requested, we also list any relevant transactions		// when a reorg'd block is requested, we also list any relevant transactions
// in the blocks of the chain that was detached		// in the blocks of the chain that was detached
UniValue removed(UniValue::VARR);		UniValue removed(UniValue::VARR);
while (include_removed && paltindex && paltindex != pindex) {		while (include_removed && paltindex && paltindex != pindex) {
CBlock block;		CBlock block;
if (!ReadBlockFromDisk(block, paltindex, params)) {		if (!ReadBlockFromDisk(block, paltindex, params)) {
throw JSONRPCError(RPC_INTERNAL_ERROR,		throw JSONRPCError(RPC_INTERNAL_ERROR,
"Can't read block from disk");		"Can't read block from disk");
}		}
for (const CTransactionRef &tx : block.vtx) {		for (const CTransactionRef &tx : block.vtx) {
auto it = pwallet->mapWallet.find(tx->GetId());		auto it = pwallet->mapWallet.find(tx->GetId());
if (it != pwallet->mapWallet.end()) {		if (it != pwallet->mapWallet.end()) {
// We want all transactions regardless of confirmation count to		// We want all transactions regardless of confirmation count to
// appear here, even negative confirmation ones, hence the big		// appear here, even negative confirmation ones, hence the big
// negative.		// negative.
ListTransactions(locked_chain, pwallet, it->second, "",		ListTransactions(*locked_chain, pwallet, it->second, -100000000,
-100000000, true, removed, filter);		true, removed, filter);
}		}
}		}
paltindex = paltindex->pprev;		paltindex = paltindex->pprev;
}		}

CBlockIndex *pblockLast =		CBlockIndex *pblockLast =
chainActive[chainActive.Height() + 1 - target_confirms];		chainActive[chainActive.Height() + 1 - target_confirms];
uint256 lastblock = pblockLast ? pblockLast->GetBlockHash() : uint256();		uint256 lastblock = pblockLast ? pblockLast->GetBlockHash() : uint256();
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines	if (request.fHelp \|\| request.params.size() < 1 \|\|
"seconds since epoch (1 Jan 1970 GMT)\n"		"seconds since epoch (1 Jan 1970 GMT)\n"
" \"bip125-replaceable\": \"yes\|no\|unknown\", (string) Whether "		" \"bip125-replaceable\": \"yes\|no\|unknown\", (string) Whether "
"this transaction could be replaced due to BIP125 "		"this transaction could be replaced due to BIP125 "
"(replace-by-fee);\n"		"(replace-by-fee);\n"
" may be unknown "		" may be unknown "
"for unconfirmed transactions not in the mempool\n"		"for unconfirmed transactions not in the mempool\n"
" \"details\" : [\n"		" \"details\" : [\n"
" {\n"		" {\n"
" \"account\" : \"accountname\", (string) DEPRECATED. "
"This field will be removed in a V0.21. To see this deprecated "
"field, start bitcoind with -deprecatedrpc=accounts. The account "
"name involved in the transaction, can be \"\" for the default "
"account.\n"
" \"address\" : \"address\", (string) The bitcoin "		" \"address\" : \"address\", (string) The bitcoin "
"address involved in the transaction\n"		"address involved in the transaction\n"
" \"category\" : \"send\|receive\", (string) The category, "		" \"category\" : \"send\|receive\", (string) The category, "
"either 'send' or 'receive'\n"		"either 'send' or 'receive'\n"
" \"amount\" : x.xxx, (numeric) The amount "		" \"amount\" : x.xxx, (numeric) The amount "
"in " +		"in " +
CURRENCY_UNIT +		CURRENCY_UNIT +
"\n"		"\n"
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines	static UniValue gettransaction(const Config &config,
entry.pushKV("amount", ValueFromAmount(nNet - nFee));		entry.pushKV("amount", ValueFromAmount(nNet - nFee));
if (wtx.IsFromMe(filter)) {		if (wtx.IsFromMe(filter)) {
entry.pushKV("fee", ValueFromAmount(nFee));		entry.pushKV("fee", ValueFromAmount(nFee));
}		}

WalletTxToJSON(pwallet->chain(), *locked_chain, wtx, entry);		WalletTxToJSON(pwallet->chain(), *locked_chain, wtx, entry);

UniValue details(UniValue::VARR);		UniValue details(UniValue::VARR);
ListTransactions(locked_chain, pwallet, wtx, "", 0, false, details,		ListTransactions(*locked_chain, pwallet, wtx, 0, false, details, filter);
filter);
entry.pushKV("details", details);		entry.pushKV("details", details);

std::string strHex = EncodeHexTx(*wtx.tx, RPCSerializationFlags());		std::string strHex = EncodeHexTx(*wtx.tx, RPCSerializationFlags());
entry.pushKV("hex", strHex);		entry.pushKV("hex", strHex);

return entry;		return entry;
}		}

▲ Show 20 Lines • Show All 1,139 Lines • ▼ Show 20 Lines	if (request.fHelp \|\| request.params.size() > 5) {
"\nResult\n"		"\nResult\n"
"[ (array of json object)\n"		"[ (array of json object)\n"
" {\n"		" {\n"
" \"txid\" : \"txid\", (string) the transaction id \n"		" \"txid\" : \"txid\", (string) the transaction id \n"
" \"vout\" : n, (numeric) the vout value\n"		" \"vout\" : n, (numeric) the vout value\n"
" \"address\" : \"address\", (string) the bitcoin address\n"		" \"address\" : \"address\", (string) the bitcoin address\n"
" \"label\" : \"label\", (string) The associated label, "		" \"label\" : \"label\", (string) The associated label, "
"or \"\" for the default label\n"		"or \"\" for the default label\n"
" \"account\" : \"account\", (string) DEPRECATED. This field "
"will be removed in v0.21. To see this deprecated field, start "
"bitcoind with -deprecatedrpc=accounts. The associated account, or "
"\"\" for the default account\n"
" \"scriptPubKey\" : \"key\", (string) the script key\n"		" \"scriptPubKey\" : \"key\", (string) the script key\n"
" \"amount\" : x.xxx, (numeric) the transaction output "		" \"amount\" : x.xxx, (numeric) the transaction output "
"amount in " +		"amount in " +
CURRENCY_UNIT +		CURRENCY_UNIT +
"\n"		"\n"
" \"confirmations\" : n, (numeric) The number of "		" \"confirmations\" : n, (numeric) The number of "
"confirmations\n"		"confirmations\n"
" \"redeemScript\" : n (string) The redeemScript if "		" \"redeemScript\" : n (string) The redeemScript if "
▲ Show 20 Lines • Show All 127 Lines • ▼ Show 20 Lines	for (const COutput &out : vecOutputs) {
entry.pushKV("vout", out.i);		entry.pushKV("vout", out.i);

if (fValidAddress) {		if (fValidAddress) {
entry.pushKV("address", EncodeDestination(address, config));		entry.pushKV("address", EncodeDestination(address, config));

auto i = pwallet->mapAddressBook.find(address);		auto i = pwallet->mapAddressBook.find(address);
if (i != pwallet->mapAddressBook.end()) {		if (i != pwallet->mapAddressBook.end()) {
entry.pushKV("label", i->second.name);		entry.pushKV("label", i->second.name);
if (IsDeprecatedRPCEnabled(gArgs, "accounts")) {
entry.pushKV("account", i->second.name);
}
}		}

if (scriptPubKey.IsPayToScriptHash()) {		if (scriptPubKey.IsPayToScriptHash()) {
const CScriptID &hash = boost::get<CScriptID>(address);		const CScriptID &hash = boost::get<CScriptID>(address);
CScript redeemScript;		CScript redeemScript;
if (pwallet->GetCScript(hash, redeemScript)) {		if (pwallet->GetCScript(hash, redeemScript)) {
entry.pushKV("redeemScript", HexStr(redeemScript.begin(),		entry.pushKV("redeemScript", HexStr(redeemScript.begin(),
redeemScript.end()));		redeemScript.end()));
▲ Show 20 Lines • Show All 660 Lines • ▼ Show 20 Lines	if (request.fHelp \|\| request.params.size() != 1) {
" \"pubkey\" : \"publickeyhex\", (string, optional) The hex "		" \"pubkey\" : \"publickeyhex\", (string, optional) The hex "
"value of the raw public key, for single-key addresses (possibly "		"value of the raw public key, for single-key addresses (possibly "
"embedded in P2SH or P2WSH)\n"		"embedded in P2SH or P2WSH)\n"
" \"embedded\" : {...}, (object, optional) Information "		" \"embedded\" : {...}, (object, optional) Information "
"about the address embedded in P2SH or P2WSH, if relevant and "		"about the address embedded in P2SH or P2WSH, if relevant and "
"known. It includes all getaddressinfo output fields for the "		"known. It includes all getaddressinfo output fields for the "
"embedded address, excluding metadata (\"timestamp\", "		"embedded address, excluding metadata (\"timestamp\", "
"\"hdkeypath\", \"hdseedid\") and relation to the wallet "		"\"hdkeypath\", \"hdseedid\") and relation to the wallet "
"(\"ismine\", \"iswatchonly\", \"account\").\n"		"(\"ismine\", \"iswatchonly\").\n"
" \"iscompressed\" : true\|false, (boolean) If the address is "		" \"iscompressed\" : true\|false, (boolean) If the address is "
"compressed\n"		"compressed\n"
" \"label\" : \"label\" (string) The label associated "		" \"label\" : \"label\" (string) The label associated "
"with the address, \"\" is the default account\n"		"with the address, \"\" is the default label\n"
" \"account\" : \"account\" (string) DEPRECATED. This "
"field will be removed in V0.21. To see this deprecated field, "
"start bitcoind with -deprecatedrpc=accounts. The account "
"associated with the address, \"\" is the default account\n"
" \"timestamp\" : timestamp, (number, optional) The creation "		" \"timestamp\" : timestamp, (number, optional) The creation "
"time of the key if available in seconds since epoch (Jan 1 1970 "		"time of the key if available in seconds since epoch (Jan 1 1970 "
"GMT)\n"		"GMT)\n"
" \"hdkeypath\" : \"keypath\" (string, optional) The HD "		" \"hdkeypath\" : \"keypath\" (string, optional) The HD "
"keypath if the key is HD and available\n"		"keypath if the key is HD and available\n"
" \"hdseedid\" : \"<hash160>\" (string, optional) The "		" \"hdseedid\" : \"<hash160>\" (string, optional) The "
"Hash160 of the HD seed\n"		"Hash160 of the HD seed\n"
" \"hdmasterkeyid\" : \"<hash160>\" (string, optional) alias for "		" \"hdmasterkeyid\" : \"<hash160>\" (string, optional) alias for "
Show All 37 Lines	UniValue getaddressinfo(const Config &config, const JSONRPCRequest &request) {

isminetype mine = IsMine(*pwallet, dest);		isminetype mine = IsMine(*pwallet, dest);
ret.pushKV("ismine", bool(mine & ISMINE_SPENDABLE));		ret.pushKV("ismine", bool(mine & ISMINE_SPENDABLE));
ret.pushKV("iswatchonly", bool(mine & ISMINE_WATCH_ONLY));		ret.pushKV("iswatchonly", bool(mine & ISMINE_WATCH_ONLY));
UniValue detail = DescribeWalletAddress(pwallet, dest);		UniValue detail = DescribeWalletAddress(pwallet, dest);
ret.pushKVs(detail);		ret.pushKVs(detail);
if (pwallet->mapAddressBook.count(dest)) {		if (pwallet->mapAddressBook.count(dest)) {
ret.pushKV("label", pwallet->mapAddressBook[dest].name);		ret.pushKV("label", pwallet->mapAddressBook[dest].name);
if (IsDeprecatedRPCEnabled(gArgs, "accounts")) {
ret.pushKV("account", pwallet->mapAddressBook[dest].name);
}
}		}
ret.pushKV("ischange", pwallet->IsChange(scriptPubKey));		ret.pushKV("ischange", pwallet->IsChange(scriptPubKey));
const CKeyMetadata *meta = nullptr;		const CKeyMetadata *meta = nullptr;
CKeyID key_id = GetKeyForDestination(*pwallet, dest);		CKeyID key_id = GetKeyForDestination(*pwallet, dest);
if (!key_id.IsNull()) {		if (!key_id.IsNull()) {
auto it = pwallet->mapKeyMetadata.find(key_id);		auto it = pwallet->mapKeyMetadata.find(key_id);
if (it != pwallet->mapKeyMetadata.end()) {		if (it != pwallet->mapKeyMetadata.end()) {
meta = &it->second;		meta = &it->second;
▲ Show 20 Lines • Show All 566 Lines • ▼ Show 20 Lines	static UniValue walletcreatefundedpsbt(const Config &config,
result.pushKV("changepos", change_position);		result.pushKV("changepos", change_position);
return result;		return result;
}		}

// clang-format off		// clang-format off
static const ContextFreeRPCCommand commands[] = {		static const ContextFreeRPCCommand commands[] = {
// category name actor (function) argNames		// category name actor (function) argNames
// ------------------- ------------------------ ---------------------- ----------		// ------------------- ------------------------ ---------------------- ----------
{ "rawtransactions", "fundrawtransaction", fundrawtransaction, {"hexstring","options"} },		{ "generating", "generate", generate, {"nblocks","maxtries"} },
{ "wallet", "walletprocesspsbt", walletprocesspsbt, {"psbt","sign","sighashtype","bip32derivs"} },
{ "wallet", "walletcreatefundedpsbt", walletcreatefundedpsbt, {"inputs","outputs","locktime","options","bip32derivs"} },
{ "hidden", "resendwallettransactions", resendwallettransactions, {} },		{ "hidden", "resendwallettransactions", resendwallettransactions, {} },
		{ "rawtransactions", "fundrawtransaction", fundrawtransaction, {"hexstring","options"} },
{ "wallet", "abandontransaction", abandontransaction, {"txid"} },		{ "wallet", "abandontransaction", abandontransaction, {"txid"} },
{ "wallet", "addmultisigaddress", addmultisigaddress, {"nrequired","keys","label\|account"} },		{ "wallet", "addmultisigaddress", addmultisigaddress, {"nrequired","keys","label"} },
{ "wallet", "backupwallet", backupwallet, {"destination"} },		{ "wallet", "backupwallet", backupwallet, {"destination"} },
{ "wallet", "createwallet", createwallet, {"wallet_name", "disable_private_keys", "blank"} },		{ "wallet", "createwallet", createwallet, {"wallet_name", "disable_private_keys", "blank"} },
{ "wallet", "encryptwallet", encryptwallet, {"passphrase"} },		{ "wallet", "encryptwallet", encryptwallet, {"passphrase"} },
		{ "wallet", "getaddressesbylabel", getaddressesbylabel, {"label"} },
{ "wallet", "getaddressinfo", getaddressinfo, {"address"} },		{ "wallet", "getaddressinfo", getaddressinfo, {"address"} },
{ "wallet", "getbalance", getbalance, {"account\|dummy","minconf","include_watchonly"} },		{ "wallet", "getbalance", getbalance, {"dummy","minconf","include_watchonly"} },
{ "wallet", "getnewaddress", getnewaddress, {"label\|account", "address_type"} },		{ "wallet", "getnewaddress", getnewaddress, {"label", "address_type"} },
{ "wallet", "getrawchangeaddress", getrawchangeaddress, {"address_type"} },		{ "wallet", "getrawchangeaddress", getrawchangeaddress, {"address_type"} },
{ "wallet", "getreceivedbyaddress", getreceivedbyaddress, {"address","minconf"} },		{ "wallet", "getreceivedbyaddress", getreceivedbyaddress, {"address","minconf"} },
		{ "wallet", "getreceivedbylabel", getreceivedbylabel, {"label","minconf"} },
{ "wallet", "gettransaction", gettransaction, {"txid","include_watchonly"} },		{ "wallet", "gettransaction", gettransaction, {"txid","include_watchonly"} },
{ "wallet", "getunconfirmedbalance", getunconfirmedbalance, {} },		{ "wallet", "getunconfirmedbalance", getunconfirmedbalance, {} },
{ "wallet", "getwalletinfo", getwalletinfo, {} },		{ "wallet", "getwalletinfo", getwalletinfo, {} },
{ "wallet", "keypoolrefill", keypoolrefill, {"newsize"} },		{ "wallet", "keypoolrefill", keypoolrefill, {"newsize"} },
{ "wallet", "listaddressgroupings", listaddressgroupings, {} },		{ "wallet", "listaddressgroupings", listaddressgroupings, {} },
		{ "wallet", "listlabels", listlabels, {"purpose"} },
{ "wallet", "listlockunspent", listlockunspent, {} },		{ "wallet", "listlockunspent", listlockunspent, {} },
{ "wallet", "listreceivedbyaddress", listreceivedbyaddress, {"minconf","include_empty","include_watchonly","address_filter"} },		{ "wallet", "listreceivedbyaddress", listreceivedbyaddress, {"minconf","include_empty","include_watchonly","address_filter"} },
		{ "wallet", "listreceivedbylabel", listreceivedbylabel, {"minconf","include_empty","include_watchonly"} },
{ "wallet", "listsinceblock", listsinceblock, {"blockhash","target_confirmations","include_watchonly","include_removed"} },		{ "wallet", "listsinceblock", listsinceblock, {"blockhash","target_confirmations","include_watchonly","include_removed"} },
{ "wallet", "listtransactions", listtransactions, {"account\|dummy","count","skip","include_watchonly"} },		{ "wallet", "listtransactions", listtransactions, {"dummy","count","skip","include_watchonly"} },
{ "wallet", "listunspent", listunspent, {"minconf","maxconf","addresses","include_unsafe","query_options"} },		{ "wallet", "listunspent", listunspent, {"minconf","maxconf","addresses","include_unsafe","query_options"} },
{ "wallet", "listwallets", listwallets, {} },		{ "wallet", "listwallets", listwallets, {} },
{ "wallet", "loadwallet", loadwallet, {"filename"} },		{ "wallet", "loadwallet", loadwallet, {"filename"} },
{ "wallet", "lockunspent", lockunspent, {"unlock","transactions"} },		{ "wallet", "lockunspent", lockunspent, {"unlock","transactions"} },
{ "wallet", "rescanblockchain", rescanblockchain, {"start_height", "stop_height"} },		{ "wallet", "rescanblockchain", rescanblockchain, {"start_height", "stop_height"} },
{ "wallet", "sethdseed", sethdseed, {"newkeypool","seed"} },		{ "wallet", "sendmany", sendmany, {"dummy","amounts","minconf","comment","subtractfeefrom"} },
{ "wallet", "sendmany", sendmany, {"fromaccount\|dummy","amounts","minconf","comment","subtractfeefrom"} },
{ "wallet", "sendtoaddress", sendtoaddress, {"address","amount","comment","comment_to","subtractfeefromamount"} },		{ "wallet", "sendtoaddress", sendtoaddress, {"address","amount","comment","comment_to","subtractfeefromamount"} },
		{ "wallet", "sethdseed", sethdseed, {"newkeypool","seed"} },
		{ "wallet", "setlabel", setlabel, {"address","label"} },
{ "wallet", "settxfee", settxfee, {"amount"} },		{ "wallet", "settxfee", settxfee, {"amount"} },
{ "wallet", "signmessage", signmessage, {"address","message"} },		{ "wallet", "signmessage", signmessage, {"address","message"} },
{ "wallet", "signrawtransactionwithwallet", signrawtransactionwithwallet, {"hextring","prevtxs","sighashtype"} },		{ "wallet", "signrawtransactionwithwallet", signrawtransactionwithwallet, {"hextring","prevtxs","sighashtype"} },
{ "wallet", "unloadwallet", unloadwallet, {"wallet_name"} },		{ "wallet", "unloadwallet", unloadwallet, {"wallet_name"} },
		{ "wallet", "walletcreatefundedpsbt", walletcreatefundedpsbt, {"inputs","outputs","locktime","options","bip32derivs"} },
{ "wallet", "walletlock", walletlock, {} },		{ "wallet", "walletlock", walletlock, {} },
{ "wallet", "walletpassphrasechange", walletpassphrasechange, {"oldpassphrase","newpassphrase"} },
{ "wallet", "walletpassphrase", walletpassphrase, {"passphrase","timeout"} },		{ "wallet", "walletpassphrase", walletpassphrase, {"passphrase","timeout"} },
		{ "wallet", "walletpassphrasechange", walletpassphrasechange, {"oldpassphrase","newpassphrase"} },
/** Account functions (deprecated) */		{ "wallet", "walletprocesspsbt", walletprocesspsbt, {"psbt","sign","sighashtype","bip32derivs"} },
{ "wallet", "getaccountaddress", getaccountaddress, {"account"} },
{ "wallet", "getaccount", getaccount, {"address"} },
{ "wallet", "getaddressesbyaccount", getaddressesbyaccount, {"account"} },
{ "wallet", "getreceivedbyaccount", getreceivedbylabel, {"account","minconf"} },
{ "wallet", "listaccounts", listaccounts, {"minconf","include_watchonly"} },
{ "wallet", "listreceivedbyaccount", listreceivedbylabel, {"minconf","include_empty","include_watchonly"} },
{ "wallet", "setaccount", setlabel, {"address","account"} },
{ "wallet", "sendfrom", sendfrom, {"fromaccount","toaddress","amount","minconf","comment","comment_to"} },
{ "wallet", "move", movecmd, {"fromaccount","toaccount","amount","minconf","comment"} },

/** Label functions (to replace non-balance account functions) */
{ "wallet", "getaddressesbylabel", getaddressesbylabel, {"label"} },
{ "wallet", "getreceivedbylabel", getreceivedbylabel, {"label","minconf"} },
{ "wallet", "listlabels", listlabels, {"purpose"} },
{ "wallet", "listreceivedbylabel", listreceivedbylabel, {"minconf","include_empty","include_watchonly"} },
{ "wallet", "setlabel", setlabel, {"address","label"} },

{ "generating", "generate", generate, {"nblocks","maxtries"} },
};		};
// clang-format on		// clang-format on

void RegisterWalletRPCCommands(CRPCTable &t) {		void RegisterWalletRPCCommands(CRPCTable &t) {
for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {		for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {
t.appendCommand(commands[vcidx].name, &commands[vcidx]);		t.appendCommand(commands[vcidx].name, &commands[vcidx]);
}		}
}		}