23 int confirms =
wallet.GetTxDepthInMainChain(wtx);
24 entry.pushKV(
"confirmations", confirms);
26 entry.pushKV(
"generated",
true);
29 entry.pushKV(
"blockhash", conf->confirmed_block_hash.GetHex());
30 entry.pushKV(
"blockheight", conf->confirmed_block_height);
31 entry.pushKV(
"blockindex", conf->position_in_block);
34 entry.pushKV(
"blocktime", block_time);
38 entry.pushKV(
"txid", wtx.GetHash().GetHex());
39 entry.pushKV(
"wtxid", wtx.GetWitnessHash().GetHex());
41 for (
const Txid& conflict :
wallet.GetTxConflicts(wtx))
43 entry.pushKV(
"walletconflicts", std::move(conflicts));
45 for (
const Txid& mempool_conflict : wtx.mempool_conflicts)
47 entry.pushKV(
"mempoolconflicts", std::move(mempool_conflicts));
48 entry.pushKV(
"time", wtx.GetTxTime());
49 entry.pushKV(
"timereceived", int64_t{wtx.nTimeReceived});
52 std::string rbfStatus =
"no";
56 rbfStatus =
"unknown";
60 entry.pushKV(
"bip125-replaceable", rbfStatus);
62 for (
const std::pair<const std::string, std::string>& item : wtx.mapValue)
63 entry.pushKV(item.first, item.second);
69 int nConf{std::numeric_limits<int>::max()};
79 if (!params[0].isNull())
80 nMinDepth = params[0].getInt<
int>();
83 bool fIncludeEmpty =
false;
84 if (!params[1].isNull())
85 fIncludeEmpty = params[1].get_bool();
93 std::optional<CTxDestination> filtered_address{std::nullopt};
94 if (!by_label && !params[3].isNull() && !params[3].get_str().empty()) {
102 std::map<CTxDestination, tallyitem> mapTally;
103 for (
const auto& [
_, wtx] :
wallet.mapWallet) {
105 int nDepth =
wallet.GetTxDepthInMainChain(wtx);
106 if (nDepth < nMinDepth)
110 if ((wtx.IsCoinBase() && (nDepth < 1))
111 || (
wallet.IsTxImmatureCoinBase(wtx) && !include_immature_coinbase)) {
115 for (
const CTxOut& txout : wtx.tx->vout) {
120 if (filtered_address && !(filtered_address == address)) {
125 if (!(mine & filter))
131 item.
txids.push_back(wtx.GetHash());
139 std::map<std::string, tallyitem> label_tally;
141 const auto& func = [&](
const CTxDestination& address,
const std::string& label,
bool is_change,
const std::optional<AddressPurpose>& purpose) {
142 if (is_change)
return;
144 auto it = mapTally.find(address);
145 if (it == mapTally.end() && !fIncludeEmpty)
149 int nConf = std::numeric_limits<int>::max();
150 bool fIsWatchonly =
false;
151 if (it != mapTally.end()) {
152 nAmount = (*it).second.nAmount;
153 nConf = (*it).second.nConf;
154 fIsWatchonly = (*it).second.fIsWatchonly;
164 if (fIsWatchonly) obj.
pushKV(
"involvesWatchonly",
true);
167 obj.
pushKV(
"confirmations", (nConf == std::numeric_limits<int>::max() ? 0 : nConf));
168 obj.
pushKV(
"label", label);
170 if (it != mapTally.end()) {
171 for (
const Txid& _item : (*it).second.txids) {
175 obj.
pushKV(
"txids", std::move(transactions));
176 ret.push_back(std::move(obj));
180 if (filtered_address) {
181 const auto& entry =
wallet.FindAddressBookEntry(*filtered_address,
false);
182 if (entry) func(*filtered_address, entry->GetLabel(), entry->IsChange(), entry->purpose);
185 wallet.ForEachAddrBookEntry(func);
189 for (
const auto& entry : label_tally) {
190 CAmount nAmount = entry.second.nAmount;
191 int nConf = entry.second.nConf;
193 if (entry.second.fIsWatchonly)
194 obj.
pushKV(
"involvesWatchonly",
true);
196 obj.
pushKV(
"confirmations", (nConf == std::numeric_limits<int>::max() ? 0 : nConf));
197 obj.
pushKV(
"label", entry.first);
198 ret.push_back(std::move(obj));
208 "listreceivedbyaddress",
209 "List balances by receiving address.\n",
222 {
RPCResult::Type::BOOL,
"involvesWatchonly",
true,
"Only returns true if imported addresses were involved in transaction"},
225 {
RPCResult::Type::NUM,
"confirmations",
"The number of confirmations of the most recent transaction included"},
226 {
RPCResult::Type::STR,
"label",
"The label of the receiving address. The default label is \"\""},
237 +
HelpExampleCli(
"listreceivedbyaddress",
"6 true true \"\" true")
248 pwallet->BlockUntilSyncedToCurrentChain();
250 const bool include_immature_coinbase{request.params[4].isNull() ? false : request.params[4].get_bool()};
252 LOCK(pwallet->cs_wallet);
254 return ListReceived(*pwallet, request.params,
false, include_immature_coinbase);
262 "listreceivedbylabel",
263 "List received transactions by label.\n",
275 {
RPCResult::Type::BOOL,
"involvesWatchonly",
true,
"Only returns true if imported addresses were involved in transaction"},
277 {
RPCResult::Type::NUM,
"confirmations",
"The number of confirmations of the most recent transaction included"},
278 {
RPCResult::Type::STR,
"label",
"The label of the receiving address. The default label is \"\""},
294 pwallet->BlockUntilSyncedToCurrentChain();
296 const bool include_immature_coinbase{request.params[3].isNull() ? false : request.params[3].get_bool()};
298 LOCK(pwallet->cs_wallet);
300 return ListReceived(*pwallet, request.params,
true, include_immature_coinbase);
325 Vec&
ret,
const isminefilter& filter_ismine,
const std::optional<std::string>& filter_label,
326 bool include_change =
false)
330 std::list<COutputEntry> listReceived;
331 std::list<COutputEntry> listSent;
338 if (!filter_label.has_value())
344 entry.
pushKV(
"involvesWatchonly",
true);
347 entry.
pushKV(
"category",
"send");
349 const auto* address_book_entry =
wallet.FindAddressBookEntry(
s.destination);
350 if (address_book_entry) {
351 entry.
pushKV(
"label", address_book_entry->GetLabel());
358 ret.push_back(std::move(entry));
363 if (listReceived.size() > 0 &&
wallet.GetTxDepthInMainChain(wtx) >= nMinDepth) {
367 const auto* address_book_entry =
wallet.FindAddressBookEntry(r.destination);
368 if (address_book_entry) {
369 label = address_book_entry->GetLabel();
371 if (filter_label.has_value() && label != filter_label.value()) {
376 entry.
pushKV(
"involvesWatchonly",
true);
382 if (
wallet.GetTxDepthInMainChain(wtx) < 1)
383 entry.
pushKV(
"category",
"orphan");
384 else if (
wallet.IsTxImmatureCoinBase(wtx))
385 entry.
pushKV(
"category",
"immature");
387 entry.
pushKV(
"category",
"generate");
391 entry.
pushKV(
"category",
"receive");
394 if (address_book_entry) {
395 entry.
pushKV(
"label", label);
397 entry.
pushKV(
"vout", r.vout);
401 ret.push_back(std::move(entry));
409 return{{
RPCResult::Type::NUM,
"confirmations",
"The number of confirmations for the transaction. Negative confirmations means the\n"
410 "transaction conflicted that many blocks ago."},
411 {
RPCResult::Type::BOOL,
"generated",
true,
"Only present if the transaction's only input is a coinbase one."},
412 {
RPCResult::Type::BOOL,
"trusted",
true,
"Whether we consider the transaction to be trusted and safe to spend from.\n"
413 "Only present when the transaction has 0 confirmations (or negative confirmations, if conflicted)."},
416 {
RPCResult::Type::NUM,
"blockindex",
true,
"The index of the transaction in the block that includes it."},
420 {
RPCResult::Type::ARR,
"walletconflicts",
"Confirmed transactions that have been detected by the wallet to conflict with this transaction.",
424 {
RPCResult::Type::STR_HEX,
"replaced_by_txid",
true,
"Only if 'category' is 'send'. The txid if this tx was replaced."},
425 {
RPCResult::Type::STR_HEX,
"replaces_txid",
true,
"Only if 'category' is 'send'. The txid if this tx replaces another."},
426 {
RPCResult::Type::ARR,
"mempoolconflicts",
"Transactions in the mempool that directly conflict with either this transaction or an ancestor transaction",
433 {
RPCResult::Type::STR,
"comment",
true,
"If a comment is associated with the transaction, only present if not empty."},
434 {
RPCResult::Type::STR,
"bip125-replaceable",
"(\"yes|no|unknown\") Whether this transaction signals BIP125 replaceability or has an unconfirmed ancestor signaling BIP125 replaceability.\n"
435 "May be unknown for unconfirmed transactions not in the mempool because their unconfirmed ancestors are unknown."},
436 {
RPCResult::Type::ARR,
"parent_descs",
true,
"Only if 'category' is 'received'. List of parent descriptors for the output script of this coin.", {
446 "If a label name is provided, this will return only incoming transactions paying to addresses with the specified label.\n"
447 "\nReturns up to 'count' most recent transactions skipping the first 'from' transactions.\n",
450 "with the specified label, or \"*\" to disable filtering and return all transactions."},
453 {
"include_watchonly",
RPCArg::Type::BOOL,
RPCArg::DefaultHint{
"true for watch-only wallets, otherwise false"},
"Include transactions to watch-only addresses (see 'importaddress')"},
460 {
RPCResult::Type::BOOL,
"involvesWatchonly",
true,
"Only returns true if imported addresses were involved in transaction."},
461 {
RPCResult::Type::STR,
"address",
true,
"The bitcoin address of the transaction (not returned if the output does not have an address, e.g. OP_RETURN null data)."},
463 "\"send\" Transactions sent.\n"
464 "\"receive\" Non-coinbase transactions received.\n"
465 "\"generate\" Coinbase transactions received with more than 100 confirmations.\n"
466 "\"immature\" Coinbase transactions received with 100 or fewer confirmations.\n"
467 "\"orphan\" Orphaned coinbase transactions received."},
469 "for all other categories"},
473 "'send' category of transactions."},
477 {
RPCResult::Type::BOOL,
"abandoned",
"'true' if the transaction has been abandoned (inputs are respendable)."},
482 "\nList the most recent 10 transactions in the systems\n"
484 "\nList transactions 100 to 120\n"
486 "\nAs a JSON-RPC call\n"
496 pwallet->BlockUntilSyncedToCurrentChain();
498 std::optional<std::string> filter_label;
499 if (!request.params[0].isNull() && request.params[0].get_str() !=
"*") {
501 if (filter_label.value().empty()) {
506 if (!request.params[1].isNull())
507 nCount = request.params[1].getInt<
int>();
509 if (!request.params[2].isNull())
510 nFrom = request.params[2].getInt<
int>();
522 std::vector<UniValue>
ret;
524 LOCK(pwallet->cs_wallet);
529 for (CWallet::TxItems::const_reverse_iterator it = txOrdered.rbegin(); it != txOrdered.rend(); ++it)
533 if ((
int)
ret.size() >= (nCount+nFrom))
break;
539 if (nFrom > (
int)
ret.size())
541 if ((nFrom + nCount) > (
int)
ret.size())
542 nCount =
ret.size() - nFrom;
544 auto txs_rev_it{std::make_move_iterator(
ret.rend())};
546 result.push_backV(txs_rev_it - nFrom - nCount, txs_rev_it - nFrom);
556 "Get all transactions in blocks since block [blockhash], or all transactions if omitted.\n"
557 "If \"blockhash\" is no longer a part of the main chain, transactions from the fork point onward are included.\n"
558 "Additionally, if include_removed is set, transactions affecting the wallet which were removed are returned in the \"removed\" array.\n",
561 {
"target_confirmations",
RPCArg::Type::NUM,
RPCArg::Default{1},
"Return the nth block hash from the main chain. e.g. 1 would mean the best block hash. Note: this is not used as a filter, but only affects [lastblock] in the return value"},
562 {
"include_watchonly",
RPCArg::Type::BOOL,
RPCArg::DefaultHint{
"true for watch-only wallets, otherwise false"},
"Include transactions to watch-only addresses (see 'importaddress')"},
564 "(not guaranteed to work on pruned nodes)"},
575 {
RPCResult::Type::BOOL,
"involvesWatchonly",
true,
"Only returns true if imported addresses were involved in transaction."},
576 {
RPCResult::Type::STR,
"address",
true,
"The bitcoin address of the transaction (not returned if the output does not have an address, e.g. OP_RETURN null data)."},
578 "\"send\" Transactions sent.\n"
579 "\"receive\" Non-coinbase transactions received.\n"
580 "\"generate\" Coinbase transactions received with more than 100 confirmations.\n"
581 "\"immature\" Coinbase transactions received with 100 or fewer confirmations.\n"
582 "\"orphan\" Orphaned coinbase transactions received."},
584 "for all other categories"},
587 "'send' category of transactions."},
591 {
RPCResult::Type::BOOL,
"abandoned",
"'true' if the transaction has been abandoned (inputs are respendable)."},
595 {
RPCResult::Type::ARR,
"removed",
true,
"<structure is the same as \"transactions\" above, only present if include_removed=true>\n"
596 "Note: transactions that were re-added in the active chain will appear as-is in this array, and may thus have a positive confirmation count."
598 {
RPCResult::Type::STR_HEX,
"lastblock",
"The hash of the block (target_confirmations-1) from the best block on the main chain, or the genesis hash if the referenced block does not exist yet. This is typically used to feed back into listsinceblock the next time you call it. So you would generally use a target_confirmations of say 6, so you will be continually re-notified of transactions until they've reached 6 confirmations plus any new ones"},
603 +
HelpExampleCli(
"listsinceblock",
"\"000000000000000bacf66f7497b7dc45ef753ee9a7d38571037cdb1a57f663ad\" 6")
604 +
HelpExampleRpc(
"listsinceblock",
"\"000000000000000bacf66f7497b7dc45ef753ee9a7d38571037cdb1a57f663ad\", 6")
614 wallet.BlockUntilSyncedToCurrentChain();
618 std::optional<int> height;
619 std::optional<int> altheight;
620 int target_confirms = 1;
624 if (!request.params[0].isNull() && !request.params[0].get_str().empty()) {
625 blockId =
ParseHashV(request.params[0],
"blockhash");
633 if (!request.params[1].isNull()) {
634 target_confirms = request.params[1].getInt<
int>();
636 if (target_confirms < 1) {
645 bool include_removed = (request.params[3].isNull() || request.params[3].get_bool());
646 bool include_change = (!request.params[4].isNull() && request.params[4].get_bool());
649 std::optional<std::string> filter_label;
650 if (!request.params[5].isNull()) filter_label.emplace(
LabelFromValue(request.params[5]));
652 int depth = height ?
wallet.GetLastBlockHeight() + 1 - *height : -1;
656 for (
const auto& [
_, tx] :
wallet.mapWallet) {
658 if (depth == -1 || abs(
wallet.GetTxDepthInMainChain(tx)) < depth) {
666 while (include_removed && altheight && *altheight > *height) {
672 auto it =
wallet.mapWallet.find(tx->GetHash());
673 if (it !=
wallet.mapWallet.end()) {
684 target_confirms = std::min(target_confirms,
wallet.GetLastBlockHeight() + 1);
688 ret.pushKV(
"transactions", std::move(transactions));
689 if (include_removed)
ret.pushKV(
"removed", std::move(removed));
690 ret.pushKV(
"lastblock", lastblock.
GetHex());
701 "Get detailed information about in-wallet transaction <txid>\n",
705 "Whether to include watch-only addresses in balance calculation and details[]"},
707 "Whether to include a `decoded` field containing the decoded transaction (equivalent to RPC decoderawtransaction)"},
714 "'send' category of transactions."},
722 {
RPCResult::Type::BOOL,
"involvesWatchonly",
true,
"Only returns true if imported addresses were involved in transaction."},
725 "\"send\" Transactions sent.\n"
726 "\"receive\" Non-coinbase transactions received.\n"
727 "\"generate\" Coinbase transactions received with more than 100 confirmations.\n"
728 "\"immature\" Coinbase transactions received with 100 or fewer confirmations.\n"
729 "\"orphan\" Orphaned coinbase transactions received."},
734 "'send' category of transactions."},
735 {
RPCResult::Type::BOOL,
"abandoned",
"'true' if the transaction has been abandoned (inputs are respendable)."},
736 {
RPCResult::Type::ARR,
"parent_descs",
true,
"Only if 'category' is 'received'. List of parent descriptors for the output script of this coin.", {
742 {
RPCResult::Type::OBJ,
"decoded",
true,
"The decoded transaction (only present when `verbose` is passed)",
744 {
RPCResult::Type::ELISION,
"",
"Equivalent to the RPC decoderawtransaction method, or the RPC getrawtransaction method when `verbose` is passed."},
750 HelpExampleCli(
"gettransaction",
"\"1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d\"")
751 +
HelpExampleCli(
"gettransaction",
"\"1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d\" true")
752 +
HelpExampleCli(
"gettransaction",
"\"1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d\" false true")
753 +
HelpExampleRpc(
"gettransaction",
"\"1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d\"")
762 pwallet->BlockUntilSyncedToCurrentChain();
764 LOCK(pwallet->cs_wallet);
774 bool verbose = request.params[2].isNull() ? false : request.params[2].get_bool();
777 auto it = pwallet->mapWallet.find(hash);
778 if (it == pwallet->mapWallet.end()) {
785 CAmount nNet = nCredit - nDebit;
796 entry.
pushKV(
"details", std::move(details));
803 entry.
pushKV(
"decoded", std::move(decoded));
815 "abandontransaction",
816 "Mark in-wallet transaction <txid> as abandoned\n"
817 "This will mark this transaction and all its in-wallet descendants as abandoned which will allow\n"
818 "for their inputs to be respent. It can be used to replace \"stuck\" or evicted transactions.\n"
819 "It only works on transactions which are not included in a block and are not currently in the mempool.\n"
820 "It has no effect on transactions which are already abandoned.\n",
826 HelpExampleCli(
"abandontransaction",
"\"1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d\"")
827 +
HelpExampleRpc(
"abandontransaction",
"\"1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d\"")
836 pwallet->BlockUntilSyncedToCurrentChain();
838 LOCK(pwallet->cs_wallet);
842 if (!pwallet->mapWallet.count(hash)) {
845 if (!pwallet->AbandonTransaction(hash)) {
858 "Rescan the local blockchain for wallet related transactions.\n"
859 "Note: Use \"getwalletinfo\" to query the scanning progress.\n"
860 "The rescan is significantly faster if block filters are available\n"
861 "(using startup option \"-blockfilterindex=1\").\n",
869 {
RPCResult::Type::NUM,
"start_height",
"The block height where the rescan started (the requested height or 0)"},
870 {
RPCResult::Type::NUM,
"stop_height",
"The height of the last rescanned block. May be null in rare cases if there was a reorg and the call didn't scan any blocks because they were already scanned in the background."},
885 wallet.BlockUntilSyncedToCurrentChain();
892 int start_height = 0;
893 std::optional<int> stop_height;
896 LOCK(pwallet->m_relock_mutex);
898 LOCK(pwallet->cs_wallet);
900 int tip_height = pwallet->GetLastBlockHeight();
902 if (!request.params[0].isNull()) {
903 start_height = request.params[0].getInt<
int>();
904 if (start_height < 0 || start_height > tip_height) {
909 if (!request.params[1].isNull()) {
910 stop_height = request.params[1].getInt<
int>();
911 if (*stop_height < 0 || *stop_height > tip_height) {
913 }
else if (*stop_height < start_height) {
919 if (!pwallet->chain().hasBlocks(pwallet->GetLastBlockHash(), start_height, stop_height)) {
920 if (pwallet->chain().havePruned() && pwallet->chain().getPruneHeight() >= start_height) {
921 throw JSONRPCError(
RPC_MISC_ERROR,
"Can't rescan beyond pruned data. Use RPC call getblockchaininfo to determine your pruned height.");
923 if (pwallet->chain().hasAssumedValidChain()) {
924 throw JSONRPCError(
RPC_MISC_ERROR,
"Failed to rescan unavailable blocks likely due to an in-progress assumeutxo background sync. Check logs or getchainstates RPC for assumeutxo background sync progress and try again later.");
926 throw JSONRPCError(
RPC_MISC_ERROR,
"Failed to rescan unavailable blocks, potentially caused by data corruption. If the issue persists you may want to reindex (see -reindex option).");
929 CHECK_NONFATAL(pwallet->chain().findAncestorByHeight(pwallet->GetLastBlockHash(), start_height,
FoundBlock().hash(start_block)));
933 pwallet->ScanForWalletTransactions(start_block, start_height, stop_height, reserver,
true,
false);
944 response.
pushKV(
"start_height", start_height);
954 "Stops current wallet rescan triggered by an RPC call, e.g. by a rescanblockchain call.\n"
955 "Note: Use \"getwalletinfo\" to query the scanning progress.\n",
959 "\nImport a private key\n"
961 "\nAbort the running wallet rescan\n"
963 "\nAs a JSON-RPC call\n"
971 if (!pwallet->IsScanning() || pwallet->IsAbortingRescan())
return false;
972 pwallet->AbortRescan();
bool ExtractDestination(const CScript &scriptPubKey, CTxDestination &addressRet)
Parse a scriptPubKey for the destination.
bool IsValidDestination(const CTxDestination &dest)
Check whether a CTxDestination corresponds to one with an address.
std::variant< CNoDestination, PubKeyDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, PayToAnchor, WitnessUnknown > CTxDestination
A txout script categorized into standard templates.
int64_t CAmount
Amount in satoshis (Can be negative)
#define CHECK_NONFATAL(condition)
Identity function.
std::vector< CTransactionRef > vtx
An output of a transaction.
void push_back(UniValue val)
void pushKV(std::string key, UniValue val)
std::string GetHex() const
Interface giving clients (wallet processes, maybe other analysis tools in the future) ability to acce...
virtual RBFTransactionState isRBFOptIn(const CTransaction &tx)=0
Check if transaction is RBF opt in.
virtual bool findBlock(const uint256 &hash, const FoundBlock &block={})=0
Return whether node has the block and optionally return block metadata or contents.
Helper for findBlock to selectively return pieces of block data.
std::string GetHex() const
static transaction_identifier FromUint256(const uint256 &id)
A CWallet maintains a set of transactions and balances, and provides the ability to create new transa...
std::multimap< int64_t, CWalletTx * > TxItems
A transaction with a bunch of additional info that only the owner cares about.
RAII object to check and reserve a wallet rescan.
bool reserve(bool with_passphrase=false)
std::string EncodeHexTx(const CTransaction &tx)
void TxToUniv(const CTransaction &tx, const uint256 &block_hash, UniValue &entry, bool include_hex=true, const CTxUndo *txundo=nullptr, TxVerbosity verbosity=TxVerbosity::SHOW_DETAILS)
UniValue ValueFromAmount(const CAmount amount)
const std::string CURRENCY_UNIT
bool IsValidDestinationString(const std::string &str, const CChainParams ¶ms)
CTxDestination DecodeDestination(const std::string &str, std::string &error_msg, std::vector< int > *error_locations)
std::string EncodeDestination(const CTxDestination &dest)
std::shared_ptr< CWallet > GetWalletForJSONRPCRequest(const JSONRPCRequest &request)
Figures out what wallet, if any, to use for a JSONRPCRequest.
RPCHelpMan listreceivedbyaddress()
static std::vector< RPCResult > TransactionDescriptionString()
bool CachedTxIsTrusted(const CWallet &wallet, const CWalletTx &wtx, std::set< Txid > &trusted_parents)
static const RPCResult RESULT_LAST_PROCESSED_BLOCK
void EnsureWalletIsUnlocked(const CWallet &wallet)
bool CachedTxIsFromMe(const CWallet &wallet, const CWalletTx &wtx, const isminefilter &filter)
CAmount CachedTxGetDebit(const CWallet &wallet, const CWalletTx &wtx, const isminefilter &filter)
filter decides which addresses will count towards the debit
void CachedTxGetAmounts(const CWallet &wallet, const CWalletTx &wtx, std::list< COutputEntry > &listReceived, std::list< COutputEntry > &listSent, CAmount &nFee, const isminefilter &filter, bool include_change)
void PushParentDescriptors(const CWallet &wallet, const CScript &script_pubkey, UniValue &entry)
Fetch parent descriptors of this scriptPubKey.
std::underlying_type_t< isminetype > isminefilter
used for bitflags of isminetype
CAmount CachedTxGetCredit(const CWallet &wallet, const CWalletTx &wtx, const isminefilter &filter)
RPCHelpMan abandontransaction()
RPCHelpMan listtransactions()
RPCHelpMan listsinceblock()
std::string LabelFromValue(const UniValue &value)
void AppendLastProcessedBlock(UniValue &entry, const CWallet &wallet)
static void ListTransactions(const CWallet &wallet, const CWalletTx &wtx, int nMinDepth, bool fLong, Vec &ret, const isminefilter &filter_ismine, const std::optional< std::string > &filter_label, bool include_change=false) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet)
List transactions based on the given criteria.
static UniValue ListReceived(const CWallet &wallet, const UniValue ¶ms, const bool by_label, const bool include_immature_coinbase) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet)
bool ParseIncludeWatchonly(const UniValue &include_watchonly, const CWallet &wallet)
Used by RPC commands that have an include_watchonly parameter.
RPCHelpMan gettransaction()
RPCHelpMan rescanblockchain()
static void WalletTxToJSON(const CWallet &wallet, const CWalletTx &wtx, UniValue &entry) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet)
RPCHelpMan listreceivedbylabel()
static void MaybePushAddress(UniValue &entry, const CTxDestination &dest)
RBFTransactionState
The rbf state of unconfirmed transactions.
@ UNKNOWN
Unconfirmed tx that does not signal rbf and is not in the mempool.
@ REPLACEABLE_BIP125
Either this tx or a mempool ancestor signals rbf.
std::shared_ptr< const CTransaction > CTransactionRef
UniValue JSONRPCError(int code, const std::string &message)
@ RPC_MISC_ERROR
General application defined errors.
@ RPC_INVALID_PARAMETER
Invalid, missing or duplicate parameter.
@ RPC_WALLET_ERROR
Wallet errors.
@ RPC_INVALID_ADDRESS_OR_KEY
Invalid address or key.
std::string HelpExampleCli(const std::string &methodname, const std::string &args)
std::string HelpExampleRpc(const std::string &methodname, const std::string &args)
const std::string UNIX_EPOCH_TIME
String used to describe UNIX epoch time in documentation, factored out to a constant for consistency.
const std::string EXAMPLE_ADDRESS[2]
Example bech32 addresses for the RPCExamples help documentation.
uint256 ParseHashV(const UniValue &v, std::string_view name)
Utilities: convert hex-encoded Values (throws error if not hex).
@ STR_HEX
Special type that is a STR with only hex chars.
std::string DefaultHint
Hint for default value.
@ OMITTED
Optional argument for which the default value is omitted from help text for one of two reasons:
@ ELISION
Special type to denote elision (...)
@ NUM_TIME
Special numeric to denote unix epoch time.
@ STR_HEX
Special string with only hex chars.
@ STR_AMOUNT
Special string to represent a floating point amount.
std::optional< int > last_scanned_height
enum wallet::CWallet::ScanResult::@19 status
State of transaction confirmed in a block.
std::vector< Txid > txids
#define EXCLUSIVE_LOCKS_REQUIRED(...)
consteval auto _(util::TranslatedLiteral str)
V Cat(V v1, V &&v2)
Concatenate two vectors, moving elements.