6#include <bitcoin-build-config.h>
28 "You need to rescan the blockchain in order to correctly mark used "
29 "destinations in the past. Until this is done, some destinations may "
30 "be considered unused, even if the opposite is the case."},
36 "Returns an object containing various wallet state info.\n",
50 {
RPCResult::Type::NUM,
"keypoolsize",
"how many new keys are pre-generated (only counts external keys)"},
51 {
RPCResult::Type::NUM,
"keypoolsize_hd_internal",
true,
"how many new keys are pre-generated for internal use (used for change outputs, only appears if the wallet is using this feature, otherwise external keys are used)"},
52 {
RPCResult::Type::NUM_TIME,
"unlocked_until",
true,
"the " +
UNIX_EPOCH_TIME +
" until which the wallet is unlocked for transfers, or 0 if the wallet is locked (only present for passphrase-encrypted wallets)"},
54 {
RPCResult::Type::BOOL,
"private_keys_enabled",
"false if privatekeys are disabled for this wallet (enforced watch-only wallet)"},
55 {
RPCResult::Type::BOOL,
"avoid_reuse",
"whether this wallet tracks clean/dirty coins in terms of reuse"},
56 {
RPCResult::Type::OBJ,
"scanning",
"current scanning details, or false if no scan is in progress",
61 {
RPCResult::Type::BOOL,
"descriptors",
"whether this wallet uses descriptors for output script management"},
62 {
RPCResult::Type::BOOL,
"external_signer",
"whether this wallet is configured to use an external signer such as a hardware wallet"},
63 {
RPCResult::Type::BOOL,
"blank",
"Whether this wallet intentionally does not contain any keys, scripts, or descriptors"},
64 {
RPCResult::Type::NUM_TIME,
"birthtime",
true,
"The start time for blocks scanning. It could be modified by (re)importing any descriptor with an earlier timestamp."},
79 pwallet->BlockUntilSyncedToCurrentChain();
81 LOCK(pwallet->cs_wallet);
85 size_t kpExternalSize = pwallet->KeypoolCountExternalKeys();
87 obj.
pushKV(
"walletname", pwallet->GetName());
88 obj.
pushKV(
"walletversion", pwallet->GetVersion());
89 obj.
pushKV(
"format", pwallet->GetDatabase().Format());
93 obj.
pushKV(
"txcount", (
int)pwallet->mapWallet.size());
94 const auto kp_oldest = pwallet->GetOldestKeyPoolTime();
95 if (kp_oldest.has_value()) {
96 obj.
pushKV(
"keypoololdest", kp_oldest.value());
98 obj.
pushKV(
"keypoolsize", (int64_t)kpExternalSize);
101 obj.
pushKV(
"keypoolsize_hd_internal", (int64_t)(pwallet->GetKeyPoolSize() - kpExternalSize));
103 if (pwallet->IsCrypted()) {
104 obj.
pushKV(
"unlocked_until", pwallet->nRelockTime);
109 if (pwallet->IsScanning()) {
111 scanning.
pushKV(
"duration", Ticks<std::chrono::seconds>(pwallet->ScanningDuration()));
112 scanning.
pushKV(
"progress", pwallet->ScanningProgress());
113 obj.
pushKV(
"scanning", std::move(scanning));
115 obj.
pushKV(
"scanning",
false);
120 if (int64_t birthtime = pwallet->GetBirthTime(); birthtime !=
UNKNOWN_TIME) {
121 obj.
pushKV(
"birthtime", birthtime);
133 "Returns a list of wallets in the wallet directory.\n",
156 wallet.pushKV(
"name", path.utf8string());
161 result.
pushKV(
"wallets", std::move(wallets));
170 "Returns a list of currently loaded wallets.\n"
171 "For full information on the wallet, use \"getwalletinfo\"\n",
202 "Loads a wallet from a wallet file or directory."
203 "\nNote that all wallet command-line options used when starting bitcoind will be"
204 "\napplied to the new wallet.\n",
206 {
"filename",
RPCArg::Type::STR,
RPCArg::Optional::NO,
"The path to the directory of the wallet to be loaded, either absolute or relative to the \"wallets\" directory. The \"wallets\" directory is set by the -walletdir option and defaults to the \"wallets\" folder within the data directory."},
213 {
RPCResult::Type::ARR,
"warnings",
true,
"Warning messages, if any, related to loading the wallet.",
220 "\nLoad wallet from the wallet dir:\n"
223 +
"\nLoad wallet using absolute path (Unix):\n"
226 +
"\nLoad wallet using absolute path (Windows):\n"
227 +
HelpExampleCli(
"loadwallet",
"\"DriveLetter:\\path\\to\\walletname\\\"")
228 +
HelpExampleRpc(
"loadwallet",
"\"DriveLetter:\\path\\to\\walletname\\\"")
233 const std::string
name(request.params[0].get_str());
240 std::vector<bilingual_str> warnings;
241 std::optional<bool> load_on_start = request.params[1].isNull() ? std::nullopt : std::optional<bool>(request.params[1].get_bool());
245 if (std::any_of(context.wallets.begin(), context.wallets.end(), [&
name](
const auto&
wallet) { return wallet->GetName() == name; })) {
250 std::shared_ptr<CWallet>
const wallet =
LoadWallet(context,
name, load_on_start, options, status, error, warnings);
268 flags += (
flags ==
"" ?
"" :
", ") + it.first;
272 "Change the state of the given wallet flag for a wallet.\n",
294 std::string flag_str = request.params[0].get_str();
295 bool value = request.params[1].isNull() || request.params[1].get_bool();
309 if (pwallet->IsWalletFlagSet(flag) == value) {
313 res.pushKV(
"flag_name", flag_str);
314 res.pushKV(
"flag_state", value);
317 pwallet->SetWalletFlag(flag);
319 pwallet->UnsetWalletFlag(flag);
335 "Creates and loads a new wallet.\n",
341 {
"avoid_reuse",
RPCArg::Type::BOOL,
RPCArg::Default{
false},
"Keep track of coin reuse, and treat dirty and clean coins differently with privacy considerations in mind."},
344 {
"external_signer",
RPCArg::Type::BOOL,
RPCArg::Default{
false},
"Use an external signer such as a hardware wallet. Requires -signer to be configured. Wallet creation will fail if keys cannot be fetched. Requires disable_private_keys and descriptors set to true."},
349 {
RPCResult::Type::STR,
"name",
"The wallet name if created successfully. If the wallet was created using a full path, the wallet_name will be the full path."},
350 {
RPCResult::Type::ARR,
"warnings",
true,
"Warning messages, if any, related to creating and loading the wallet.",
359 +
HelpExampleCliNamed(
"createwallet", {{
"wallet_name",
"descriptors"}, {
"avoid_reuse",
true}, {
"descriptors",
true}, {
"load_on_startup",
true}})
360 +
HelpExampleRpcNamed(
"createwallet", {{
"wallet_name",
"descriptors"}, {
"avoid_reuse",
true}, {
"descriptors",
true}, {
"load_on_startup",
true}})
366 if (!request.params[1].isNull() && request.params[1].get_bool()) {
370 if (!request.params[2].isNull() && request.params[2].get_bool()) {
374 passphrase.reserve(100);
375 std::vector<bilingual_str> warnings;
376 if (!request.params[3].isNull()) {
377 passphrase = std::string_view{request.params[3].get_str()};
378 if (passphrase.empty()) {
380 warnings.emplace_back(
Untranslated(
"Empty string given as passphrase, wallet will not be encrypted."));
384 if (!request.params[4].isNull() && request.params[4].get_bool()) {
388 if (!self.
Arg<
bool>(
"descriptors")) {
389 throw JSONRPCError(
RPC_WALLET_ERROR,
"descriptors argument must be set to \"true\"; it is no longer possible to create a legacy wallet.");
391 if (!request.params[7].isNull() && request.params[7].get_bool()) {
392#ifdef ENABLE_EXTERNAL_SIGNER
406 std::optional<bool> load_on_start = request.params[6].isNull() ? std::nullopt : std::optional<bool>(request.params[6].get_bool());
407 const std::shared_ptr<CWallet>
wallet =
CreateWallet(context, request.params[0].get_str(), load_on_start, options, status, error, warnings);
425 "Unloads the wallet referenced by the request endpoint, otherwise unloads the wallet specified in the argument.\n"
426 "Specifying the wallet name on a wallet endpoint is invalid.",
428 {
"wallet_name",
RPCArg::Type::STR,
RPCArg::DefaultHint{
"the wallet name from the RPC endpoint"},
"The name of the wallet to unload. If provided both here and in the RPC endpoint, the two must be identical."},
432 {
RPCResult::Type::ARR,
"warnings",
true,
"Warning messages, if any, related to unloading the wallet.",
443 std::string wallet_name;
445 if (!(request.params[0].isNull() || request.params[0].get_str() == wallet_name)) {
449 wallet_name = request.params[0].get_str();
458 std::vector<bilingual_str> warnings;
468 std::optional<bool> load_on_start{self.
MaybeArg<
bool>(
"load_on_startup")};
488 "Upgrade the wallet. Upgrades to the latest version if no version number is specified.\n"
489 "New keys may be generated and a new wallet backup will need to be made.",
515 if (!request.params[0].isNull()) {
516 version = request.params[0].getInt<
int>();
519 const int previous_version{pwallet->GetVersion()};
520 const bool wallet_upgraded{pwallet->UpgradeWallet(version, error)};
521 const int current_version{pwallet->GetVersion()};
524 if (wallet_upgraded) {
525 if (previous_version == current_version) {
526 result =
"Already at latest version. Wallet version unchanged.";
528 result =
strprintf(
"Wallet upgraded successfully from version %i to version %i.", previous_version, current_version);
533 obj.
pushKV(
"wallet_name", pwallet->GetName());
534 obj.
pushKV(
"previous_version", previous_version);
535 obj.
pushKV(
"current_version", current_version);
536 if (!result.empty()) {
537 obj.
pushKV(
"result", result);
550 "simulaterawtransaction",
551 "Calculate the balance change resulting in the signing and broadcasting of the given transaction(s).\n",
583 if (request.params[1].isObject()) {
584 UniValue options = request.params[1];
591 include_watchonly = options[
"include_watchonly"];
599 const auto& txs = request.params[0].get_array();
601 std::map<COutPoint, CAmount> new_utxos;
602 std::set<COutPoint> spent;
604 for (
size_t i = 0; i < txs.size(); ++i) {
606 if (!
DecodeHexTx(mtx, txs[i].get_str(),
true,
true)) {
611 std::map<COutPoint, Coin> coins;
615 wallet.chain().findCoins(coins);
619 for (
const auto& txin : mtx.
vin) {
620 const auto& outpoint = txin.
prevout;
621 if (spent.count(outpoint)) {
624 if (new_utxos.count(outpoint)) {
625 changes -= new_utxos.at(outpoint);
626 new_utxos.erase(outpoint);
628 if (coins.at(outpoint).IsSpent()) {
631 changes -=
wallet.GetDebit(txin, filter);
633 spent.insert(outpoint);
641 const auto& hash = mtx.
GetHash();
642 for (
size_t i = 0; i < mtx.
vout.size(); ++i) {
643 const auto& txout = mtx.
vout[i];
644 bool is_mine = 0 < (
wallet.IsMine(txout) & filter);
645 changes += new_utxos[
COutPoint(hash, i)] = is_mine ? txout.nValue : 0;
661 "Migrate the wallet to a descriptor wallet.\n"
662 "A new wallet backup will need to be made.\n"
663 "\nThe migration process will create a backup of the wallet before migrating. This backup\n"
664 "file will be named <wallet name>-<timestamp>.legacy.bak and can be found in the directory\n"
665 "for this wallet. In the event of an incorrect migration, the backup can be restored using restorewallet."
666 "\nEncrypted wallets must have the passphrase provided as an argument to this call.\n"
667 "\nThis RPC may take a long time to complete. Increasing the RPC client timeout is recommended.",
669 {
"wallet_name",
RPCArg::Type::STR,
RPCArg::DefaultHint{
"the wallet name from the RPC endpoint"},
"The name of the wallet to migrate. If provided both here and in the RPC endpoint, the two must be identical."},
676 {
RPCResult::Type::STR,
"watchonly_name",
true,
"The name of the migrated wallet containing the watchonly scripts"},
677 {
RPCResult::Type::STR,
"solvables_name",
true,
"The name of the migrated wallet containing solvable but not watched scripts"},
687 std::string wallet_name;
689 if (!(request.params[0].isNull() || request.params[0].get_str() == wallet_name)) {
693 if (request.params[0].isNull()) {
696 wallet_name = request.params[0].get_str();
700 wallet_pass.reserve(100);
701 if (!request.params[1].isNull()) {
702 wallet_pass = std::string_view{request.params[1].get_str()};
712 r.pushKV(
"wallet_name", res->wallet_name);
713 if (res->watchonly_wallet) {
714 r.pushKV(
"watchonly_name", res->watchonly_wallet->GetName());
716 if (res->solvables_wallet) {
717 r.pushKV(
"solvables_name", res->solvables_wallet->GetName());
719 r.pushKV(
"backup_path", res->backup_path.utf8string());
730 "List all BIP 32 HD keys in the wallet and which descriptors use them.\n",
747 {
RPCResult::Type::BOOL,
"active",
"Whether this descriptor is currently used to generate new addresses"},
769 const bool active_only{options.exists(
"active_only") ? options[
"active_only"].get_bool() :
false};
770 const bool priv{options.exists(
"private") ? options[
"private"].get_bool() :
false};
776 std::set<ScriptPubKeyMan*> spkms;
778 spkms =
wallet->GetActiveScriptPubKeyMans();
780 spkms =
wallet->GetAllScriptPubKeyMans();
783 std::map<CExtPubKey, std::set<std::tuple<std::string, bool, bool>>> wallet_xpubs;
784 std::map<CExtPubKey, CExtKey> wallet_xprvs;
785 for (
auto* spkm : spkms) {
788 LOCK(desc_spkm->cs_desc_man);
792 std::set<CPubKey> desc_pubkeys;
793 std::set<CExtPubKey> desc_xpubs;
794 w_desc.
descriptor->GetPubKeys(desc_pubkeys, desc_xpubs);
796 std::string desc_str;
797 bool ok = desc_spkm->GetDescriptorString(desc_str,
false);
799 wallet_xpubs[xpub].emplace(desc_str,
wallet->IsActiveScriptPubKeyMan(*spkm), desc_spkm->HasPrivKey(xpub.pubkey.GetID()));
800 if (std::optional<CKey> key = priv ? desc_spkm->GetKey(xpub.pubkey.GetID()) : std::nullopt) {
801 wallet_xprvs[xpub] =
CExtKey(xpub, *key);
807 for (
const auto& [xpub, descs] : wallet_xpubs) {
808 bool has_xprv =
false;
810 for (
const auto& [desc, active, has_priv] : descs) {
813 d.
pushKV(
"active", active);
814 has_xprv |= has_priv;
820 xpub_info.
pushKV(
"has_private", has_xprv);
824 xpub_info.
pushKV(
"descriptors", std::move(descriptors));
826 response.
push_back(std::move(xpub_info));
837 "Creates the wallet's descriptor for the given address type. "
838 "The address type must be one that the wallet does not already have a descriptor for."
843 {
"internal",
RPCArg::Type::BOOL,
RPCArg::DefaultHint{
"Both external and internal will be generated unless this parameter is specified"},
"Whether to only make one descriptor that is internal (if parameter is true) or external (if parameter is false)"},
844 {
"hdkey",
RPCArg::Type::STR,
RPCArg::DefaultHint{
"The HD key used by all other active descriptors"},
"The HD key that the wallet knows the private key of, listed using 'gethdkeys', to use for this descriptor's key"},
869 std::optional<OutputType> output_type =
ParseOutputType(request.params[0].get_str());
875 UniValue internal_only{options[
"internal"]};
878 std::vector<bool> internals;
879 if (internal_only.isNull()) {
881 internals.push_back(
true);
883 internals.push_back(internal_only.get_bool());
886 LOCK(pwallet->cs_wallet);
890 if (hdkey.isNull()) {
891 std::set<CExtPubKey> active_xpubs = pwallet->GetActiveHDPubKeys();
892 if (active_xpubs.size() != 1) {
895 xpub = *active_xpubs.begin();
903 std::optional<CKey> key = pwallet->GetKey(xpub.
pubkey.
GetID());
907 CExtKey active_hdkey(xpub, *key);
909 std::vector<std::reference_wrapper<DescriptorScriptPubKeyMan>> spkms;
911 for (
bool internal : internals) {
914 if (!pwallet->GetScriptPubKeyMan(w_id)) {
915 spkms.emplace_back(pwallet->SetupDescriptorScriptPubKeyMan(batch, active_hdkey, *output_type, internal));
924 for (
const auto& spkm : spkms) {
925 std::string desc_str;
926 bool ok = spkm.get().GetDescriptorString(desc_str,
false);
928 descs.push_back(desc_str);
931 out.pushKV(
"descs", std::move(descs));
946#ifdef ENABLE_EXTERNAL_SIGNER
1057#ifdef ENABLE_EXTERNAL_SIGNER
int64_t CAmount
Amount in satoshis (Can be negative)
#define CHECK_NONFATAL(condition)
Identity function.
An outpoint - a combination of a transaction hash and an index n into its vout.
CKeyID GetID() const
Get the KeyID of this public key (hash of its serialization)
An input of a transaction.
auto Arg(std::string_view key) const
Helper to get a required or default-valued request argument.
auto MaybeArg(std::string_view key) const
Helper to get an optional request argument.
void push_back(UniValue val)
void pushKV(std::string key, UniValue val)
A CWallet maintains a set of transactions and balances, and provides the ability to create new transa...
Access to the wallet database.
Descriptor with some wallet metadata.
std::shared_ptr< Descriptor > descriptor
RAII object to check and reserve a wallet rescan.
bool reserve(bool with_passphrase=false)
UniValue ValueFromAmount(const CAmount amount)
bool DecodeHexTx(CMutableTransaction &tx, const std::string &hex_tx, bool try_no_witness=false, bool try_witness=true)
const std::string CURRENCY_UNIT
std::string EncodeExtKey(const CExtKey &key)
CExtPubKey DecodeExtPubKey(const std::string &str)
std::string EncodeExtPubKey(const CExtPubKey &key)
void ReadDatabaseArgs(const ArgsManager &args, DBOptions &options)
bilingual_str ErrorString(const Result< T > &result)
void ReadDatabaseArgs(const ArgsManager &args, DatabaseOptions &options)
Balance GetBalance(const CWallet &wallet, const int min_depth, bool avoid_reuse)
std::shared_ptr< CWallet > LoadWallet(WalletContext &context, const std::string &name, std::optional< bool > load_on_start, const DatabaseOptions &options, DatabaseStatus &status, bilingual_str &error, std::vector< bilingual_str > &warnings)
static RPCHelpMan loadwallet()
std::shared_ptr< CWallet > GetWalletForJSONRPCRequest(const JSONRPCRequest &request)
Figures out what wallet, if any, to use for a JSONRPCRequest.
RPCHelpMan listreceivedbyaddress()
std::vector< std::shared_ptr< CWallet > > GetWallets(WalletContext &context)
RPCHelpMan keypoolrefill()
RPCHelpMan removeprunedfunds()
RPCHelpMan listlockunspent()
static const RPCResult RESULT_LAST_PROCESSED_BLOCK
bool GetWalletNameFromJSONRPCRequest(const JSONRPCRequest &request, std::string &wallet_name)
RPCHelpMan walletprocesspsbt()
void HandleWalletError(const std::shared_ptr< CWallet > wallet, DatabaseStatus &status, bilingual_str &error)
void EnsureWalletIsUnlocked(const CWallet &wallet)
static RPCHelpMan getwalletinfo()
RPCHelpMan backupwallet()
static RPCHelpMan listwalletdir()
RPCHelpMan walletpassphrase()
const std::string HELP_REQUIRING_PASSPHRASE
RPCHelpMan getreceivedbyaddress()
RPCHelpMan walletdisplayaddress()
RPCHelpMan importprunedfunds()
util::Result< MigrationResult > MigrateLegacyToDescriptor(std::shared_ptr< CWallet > local_wallet, const SecureString &passphrase, WalletContext &context, bool was_loaded)
Requirement: The wallet provided to this function must be isolated, with no attachment to the node's ...
RPCHelpMan simulaterawtransaction()
static RPCHelpMan setwalletflag()
std::underlying_type_t< isminetype > isminefilter
used for bitflags of isminetype
RPCHelpMan walletcreatefundedpsbt()
bool RemoveWallet(WalletContext &context, const std::shared_ptr< CWallet > &wallet, std::optional< bool > load_on_start)
WalletContext & EnsureWalletContext(const std::any &context)
RPCHelpMan listaddressgroupings()
RPCHelpMan walletpassphrasechange()
fs::path GetWalletDir()
Get the path of the wallet directory.
RPCHelpMan abandontransaction()
RPCHelpMan listdescriptors()
RPCHelpMan listtransactions()
RPCHelpMan signrawtransactionwithwallet()
static RPCHelpMan listwallets()
static RPCHelpMan upgradewallet()
static constexpr int64_t UNKNOWN_TIME
Constant representing an unknown spkm creation time.
static const std::map< std::string, WalletFlags > WALLET_FLAG_MAP
static RPCHelpMan unloadwallet()
RPCHelpMan listsinceblock()
RPCHelpMan restorewallet()
void AppendLastProcessedBlock(UniValue &entry, const CWallet &wallet)
bool ParseIncludeWatchonly(const UniValue &include_watchonly, const CWallet &wallet)
Used by RPC commands that have an include_watchonly parameter.
RPCHelpMan getreceivedbylabel()
RPCHelpMan importdescriptors()
RPCHelpMan getrawchangeaddress()
static RPCHelpMan createwallet()
RPCHelpMan getaddressinfo()
RPCHelpMan encryptwallet()
RPCHelpMan gettransaction()
RPCHelpMan getaddressesbylabel()
RPCHelpMan fundrawtransaction()
static const std::map< uint64_t, std::string > WALLET_FLAG_CAVEATS
std::shared_ptr< CWallet > CreateWallet(WalletContext &context, const std::string &name, std::optional< bool > load_on_start, DatabaseOptions &options, DatabaseStatus &status, bilingual_str &error, std::vector< bilingual_str > &warnings)
static RPCHelpMan migratewallet()
RPCHelpMan rescanblockchain()
@ WALLET_FLAG_EXTERNAL_SIGNER
Indicates that the wallet needs an external signer.
@ WALLET_FLAG_AVOID_REUSE
@ WALLET_FLAG_DESCRIPTORS
Indicate that this wallet supports DescriptorScriptPubKeyMan.
@ WALLET_FLAG_DISABLE_PRIVATE_KEYS
@ WALLET_FLAG_BLANK_WALLET
Flag set when a wallet contains no HD seed and no private keys, scripts, addresses,...
void WaitForDeleteWallet(std::shared_ptr< CWallet > &&wallet)
Explicitly delete the wallet.
static constexpr uint64_t MUTABLE_WALLET_FLAGS
RPCHelpMan getnewaddress()
RPCHelpMan listreceivedbylabel()
std::shared_ptr< CWallet > GetWallet(WalletContext &context, const std::string &name)
RPCHelpMan getunconfirmedbalance()
std::span< const CRPCCommand > GetWalletRPCCommands()
RPCHelpMan sendtoaddress()
std::vector< std::pair< fs::path, std::string > > ListDatabases(const fs::path &wallet_dir)
Recursively list database paths in directory.
static RPCHelpMan createwalletdescriptor()
WalletDescriptor GenerateWalletDescriptor(const CExtPubKey &master_key, const OutputType &addr_type, bool internal)
std::optional< OutputType > ParseOutputType(const std::string &type)
UniValue JSONRPCError(int code, const std::string &message)
RPCErrorCode
Bitcoin RPC error codes.
@ RPC_MISC_ERROR
General application defined errors.
@ RPC_WALLET_ENCRYPTION_FAILED
Failed to encrypt the wallet.
@ RPC_INVALID_PARAMETER
Invalid, missing or duplicate parameter.
@ RPC_WALLET_ERROR
Wallet errors.
@ RPC_WALLET_ALREADY_LOADED
This same wallet is already loaded.
@ RPC_WALLET_NOT_FOUND
Invalid wallet specified.
@ RPC_DESERIALIZATION_ERROR
Error parsing or validating structure in raw format.
@ RPC_INVALID_ADDRESS_OR_KEY
Invalid address or key.
std::string HelpExampleCli(const std::string &methodname, const std::string &args)
std::string HelpExampleRpcNamed(const std::string &methodname, const RPCArgList &args)
void PushWarnings(const UniValue &warnings, UniValue &obj)
Push warning messages to an RPC "warnings" field as a JSON array of strings.
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.
void RPCTypeCheckObj(const UniValue &o, const std::map< std::string, UniValueType > &typesExpected, bool fAllowNull, bool fStrict)
std::string HelpExampleCliNamed(const std::string &methodname, const RPCArgList &args)
uint256 DescriptorID(const Descriptor &desc)
Unique identifier that may not change over time, unless explicitly marked as not backwards compatible...
std::basic_string< char, std::char_traits< char >, secure_allocator< char > > SecureString
A mutable version of CTransaction.
std::vector< CTxOut > vout
Txid GetHash() const
Compute the hash of this CMutableTransaction.
@ STR_HEX
Special type that is a STR with only hex chars.
@ OBJ_NAMED_PARAMS
Special type that behaves almost exactly like OBJ, defining an options object with a list of pre-defi...
std::string DefaultHint
Hint for default value.
@ OMITTED
Optional argument for which the default value is omitted from help text for one of two reasons:
@ NUM_TIME
Special numeric to denote unix epoch time.
@ STR_AMOUNT
Special string to represent a floating point amount.
Wrapper for UniValue::VType, which includes typeAny: Used to denote don't care type.
SecureString create_passphrase
WalletContext struct containing references to state shared between CWallet instances,...
consteval auto _(util::TranslatedLiteral str)
bilingual_str Untranslated(std::string original)
Mark a bilingual_str as untranslated.