Bitcoin Core 29.99.0
P2P Digital Currency
wallet.cpp
Go to the documentation of this file.
1// Copyright (c) 2010 Satoshi Nakamoto
2// Copyright (c) 2009-present The Bitcoin Core developers
3// Distributed under the MIT software license, see the accompanying
4// file COPYING or http://www.opensource.org/licenses/mit-license.php.
5
6#include <bitcoin-build-config.h> // IWYU pragma: keep
7
8#include <core_io.h>
9#include <key_io.h>
10#include <rpc/server.h>
11#include <rpc/util.h>
12#include <univalue.h>
13#include <util/translation.h>
14#include <wallet/context.h>
15#include <wallet/receive.h>
16#include <wallet/rpc/util.h>
17#include <wallet/rpc/wallet.h>
18#include <wallet/wallet.h>
19#include <wallet/walletutil.h>
20
21#include <optional>
22
23
24namespace wallet {
25
26static const std::map<uint64_t, std::string> WALLET_FLAG_CAVEATS{
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."},
31};
32
34{
35 return RPCHelpMan{"getwalletinfo",
36 "Returns an object containing various wallet state info.\n",
37 {},
40 {
41 {
42 {RPCResult::Type::STR, "walletname", "the wallet name"},
43 {RPCResult::Type::NUM, "walletversion", "(DEPRECATED) only related to unsupported legacy wallet, returns the latest version 169900 for backwards compatibility"},
44 {RPCResult::Type::STR, "format", "the database format (only sqlite)"},
45 {RPCResult::Type::NUM, "txcount", "the total number of transactions in the wallet"},
46 {RPCResult::Type::NUM, "keypoolsize", "how many new keys are pre-generated (only counts external keys)"},
47 {RPCResult::Type::NUM, "keypoolsize_hd_internal", /*optional=*/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)"},
48 {RPCResult::Type::NUM_TIME, "unlocked_until", /*optional=*/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)"},
49 {RPCResult::Type::STR_AMOUNT, "paytxfee", "the transaction fee configuration, set in " + CURRENCY_UNIT + "/kvB"},
50 {RPCResult::Type::BOOL, "private_keys_enabled", "false if privatekeys are disabled for this wallet (enforced watch-only wallet)"},
51 {RPCResult::Type::BOOL, "avoid_reuse", "whether this wallet tracks clean/dirty coins in terms of reuse"},
52 {RPCResult::Type::OBJ, "scanning", "current scanning details, or false if no scan is in progress",
53 {
54 {RPCResult::Type::NUM, "duration", "elapsed seconds since scan start"},
55 {RPCResult::Type::NUM, "progress", "scanning progress percentage [0.0, 1.0]"},
56 }, /*skip_type_check=*/true},
57 {RPCResult::Type::BOOL, "descriptors", "whether this wallet uses descriptors for output script management"},
58 {RPCResult::Type::BOOL, "external_signer", "whether this wallet is configured to use an external signer such as a hardware wallet"},
59 {RPCResult::Type::BOOL, "blank", "Whether this wallet intentionally does not contain any keys, scripts, or descriptors"},
60 {RPCResult::Type::NUM_TIME, "birthtime", /*optional=*/true, "The start time for blocks scanning. It could be modified by (re)importing any descriptor with an earlier timestamp."},
61 {RPCResult::Type::ARR, "flags", "The flags currently set on the wallet",
62 {
63 {RPCResult::Type::STR, "flag", "The name of the flag"},
64 }},
66 }},
67 },
69 HelpExampleCli("getwalletinfo", "")
70 + HelpExampleRpc("getwalletinfo", "")
71 },
72 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
73{
74 const std::shared_ptr<const CWallet> pwallet = GetWalletForJSONRPCRequest(request);
75 if (!pwallet) return UniValue::VNULL;
76
77 // Make sure the results are valid at least up to the most recent block
78 // the user could have gotten from another RPC command prior to now
79 pwallet->BlockUntilSyncedToCurrentChain();
80
81 LOCK(pwallet->cs_wallet);
82
84
85 const int latest_legacy_wallet_minversion{169900};
86
87 size_t kpExternalSize = pwallet->KeypoolCountExternalKeys();
88 obj.pushKV("walletname", pwallet->GetName());
89 obj.pushKV("walletversion", latest_legacy_wallet_minversion);
90 obj.pushKV("format", pwallet->GetDatabase().Format());
91 obj.pushKV("txcount", (int)pwallet->mapWallet.size());
92 obj.pushKV("keypoolsize", (int64_t)kpExternalSize);
93 obj.pushKV("keypoolsize_hd_internal", pwallet->GetKeyPoolSize() - kpExternalSize);
94
95 if (pwallet->IsCrypted()) {
96 obj.pushKV("unlocked_until", pwallet->nRelockTime);
97 }
98 obj.pushKV("paytxfee", ValueFromAmount(pwallet->m_pay_tx_fee.GetFeePerK()));
99 obj.pushKV("private_keys_enabled", !pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
100 obj.pushKV("avoid_reuse", pwallet->IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE));
101 if (pwallet->IsScanning()) {
102 UniValue scanning(UniValue::VOBJ);
103 scanning.pushKV("duration", Ticks<std::chrono::seconds>(pwallet->ScanningDuration()));
104 scanning.pushKV("progress", pwallet->ScanningProgress());
105 obj.pushKV("scanning", std::move(scanning));
106 } else {
107 obj.pushKV("scanning", false);
108 }
109 obj.pushKV("descriptors", pwallet->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS));
110 obj.pushKV("external_signer", pwallet->IsWalletFlagSet(WALLET_FLAG_EXTERNAL_SIGNER));
111 obj.pushKV("blank", pwallet->IsWalletFlagSet(WALLET_FLAG_BLANK_WALLET));
112 if (int64_t birthtime = pwallet->GetBirthTime(); birthtime != UNKNOWN_TIME) {
113 obj.pushKV("birthtime", birthtime);
114 }
115
116 // Push known flags
118 uint64_t wallet_flags = pwallet->GetWalletFlags();
119 for (uint64_t i = 0; i < 64; ++i) {
120 uint64_t flag = uint64_t{1} << i;
121 if (flag & wallet_flags) {
122 if (flag & KNOWN_WALLET_FLAGS) {
123 flags.push_back(WALLET_FLAG_TO_STRING.at(WalletFlags{flag}));
124 } else {
125 flags.push_back(strprintf("unknown_flag_%u", i));
126 }
127 }
128 }
129 obj.pushKV("flags", flags);
130
131 AppendLastProcessedBlock(obj, *pwallet);
132 return obj;
133},
134 };
135}
136
138{
139 return RPCHelpMan{"listwalletdir",
140 "Returns a list of wallets in the wallet directory.\n",
141 {},
142 RPCResult{
143 RPCResult::Type::OBJ, "", "",
144 {
145 {RPCResult::Type::ARR, "wallets", "",
146 {
147 {RPCResult::Type::OBJ, "", "",
148 {
149 {RPCResult::Type::STR, "name", "The wallet name"},
150 {RPCResult::Type::ARR, "warnings", /*optional=*/true, "Warning messages, if any, related to loading the wallet.",
151 {
152 {RPCResult::Type::STR, "", ""},
153 }},
154 }},
155 }},
156 }
157 },
159 HelpExampleCli("listwalletdir", "")
160 + HelpExampleRpc("listwalletdir", "")
161 },
162 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
163{
164 UniValue wallets(UniValue::VARR);
165 for (const auto& [path, db_type] : ListDatabases(GetWalletDir())) {
167 wallet.pushKV("name", path.utf8string());
168 UniValue warnings(UniValue::VARR);
169 if (db_type == "bdb") {
170 warnings.push_back("This wallet is a legacy wallet and will need to be migrated with migratewallet before it can be loaded");
171 }
172 wallet.pushKV("warnings", warnings);
173 wallets.push_back(std::move(wallet));
174 }
175
176 UniValue result(UniValue::VOBJ);
177 result.pushKV("wallets", std::move(wallets));
178 return result;
179},
180 };
181}
182
184{
185 return RPCHelpMan{"listwallets",
186 "Returns a list of currently loaded wallets.\n"
187 "For full information on the wallet, use \"getwalletinfo\"\n",
188 {},
189 RPCResult{
190 RPCResult::Type::ARR, "", "",
191 {
192 {RPCResult::Type::STR, "walletname", "the wallet name"},
193 }
194 },
196 HelpExampleCli("listwallets", "")
197 + HelpExampleRpc("listwallets", "")
198 },
199 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
200{
202
203 WalletContext& context = EnsureWalletContext(request.context);
204 for (const std::shared_ptr<CWallet>& wallet : GetWallets(context)) {
205 LOCK(wallet->cs_wallet);
206 obj.push_back(wallet->GetName());
207 }
208
209 return obj;
210},
211 };
212}
213
215{
216 return RPCHelpMan{
217 "loadwallet",
218 "Loads a wallet from a wallet file or directory."
219 "\nNote that all wallet command-line options used when starting bitcoind will be"
220 "\napplied to the new wallet.\n",
221 {
222 {"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."},
223 {"load_on_startup", RPCArg::Type::BOOL, RPCArg::Optional::OMITTED, "Save wallet name to persistent settings and load on startup. True to add wallet to startup list, false to remove, null to leave unchanged."},
224 },
225 RPCResult{
226 RPCResult::Type::OBJ, "", "",
227 {
228 {RPCResult::Type::STR, "name", "The wallet name if loaded successfully."},
229 {RPCResult::Type::ARR, "warnings", /*optional=*/true, "Warning messages, if any, related to loading the wallet.",
230 {
231 {RPCResult::Type::STR, "", ""},
232 }},
233 }
234 },
236 "\nLoad wallet from the wallet dir:\n"
237 + HelpExampleCli("loadwallet", "\"walletname\"")
238 + HelpExampleRpc("loadwallet", "\"walletname\"")
239 + "\nLoad wallet using absolute path (Unix):\n"
240 + HelpExampleCli("loadwallet", "\"/path/to/walletname/\"")
241 + HelpExampleRpc("loadwallet", "\"/path/to/walletname/\"")
242 + "\nLoad wallet using absolute path (Windows):\n"
243 + HelpExampleCli("loadwallet", "\"DriveLetter:\\path\\to\\walletname\\\"")
244 + HelpExampleRpc("loadwallet", "\"DriveLetter:\\path\\to\\walletname\\\"")
245 },
246 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
247{
248 WalletContext& context = EnsureWalletContext(request.context);
249 const std::string name(request.params[0].get_str());
250
251 DatabaseOptions options;
252 DatabaseStatus status;
253 ReadDatabaseArgs(*context.args, options);
254 options.require_existing = true;
255 bilingual_str error;
256 std::vector<bilingual_str> warnings;
257 std::optional<bool> load_on_start = request.params[1].isNull() ? std::nullopt : std::optional<bool>(request.params[1].get_bool());
258
259 {
260 LOCK(context.wallets_mutex);
261 if (std::any_of(context.wallets.begin(), context.wallets.end(), [&name](const auto& wallet) { return wallet->GetName() == name; })) {
262 throw JSONRPCError(RPC_WALLET_ALREADY_LOADED, "Wallet \"" + name + "\" is already loaded.");
263 }
264 }
265
266 std::shared_ptr<CWallet> const wallet = LoadWallet(context, name, load_on_start, options, status, error, warnings);
267
268 HandleWalletError(wallet, status, error);
269
271 obj.pushKV("name", wallet->GetName());
272 PushWarnings(warnings, obj);
273
274 return obj;
275},
276 };
277}
278
280{
281 std::string flags;
282 for (auto& it : STRING_TO_WALLET_FLAG)
283 if (it.second & MUTABLE_WALLET_FLAGS)
284 flags += (flags == "" ? "" : ", ") + it.first;
285
286 return RPCHelpMan{
287 "setwalletflag",
288 "Change the state of the given wallet flag for a wallet.\n",
289 {
290 {"flag", RPCArg::Type::STR, RPCArg::Optional::NO, "The name of the flag to change. Current available flags: " + flags},
291 {"value", RPCArg::Type::BOOL, RPCArg::Default{true}, "The new state."},
292 },
293 RPCResult{
294 RPCResult::Type::OBJ, "", "",
295 {
296 {RPCResult::Type::STR, "flag_name", "The name of the flag that was modified"},
297 {RPCResult::Type::BOOL, "flag_state", "The new state of the flag"},
298 {RPCResult::Type::STR, "warnings", /*optional=*/true, "Any warnings associated with the change"},
299 }
300 },
302 HelpExampleCli("setwalletflag", "avoid_reuse")
303 + HelpExampleRpc("setwalletflag", "\"avoid_reuse\"")
304 },
305 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
306{
307 std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
308 if (!pwallet) return UniValue::VNULL;
309
310 std::string flag_str = request.params[0].get_str();
311 bool value = request.params[1].isNull() || request.params[1].get_bool();
312
313 if (!STRING_TO_WALLET_FLAG.count(flag_str)) {
314 throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Unknown wallet flag: %s", flag_str));
315 }
316
317 auto flag = STRING_TO_WALLET_FLAG.at(flag_str);
318
319 if (!(flag & MUTABLE_WALLET_FLAGS)) {
320 throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Wallet flag is immutable: %s", flag_str));
321 }
322
324
325 if (pwallet->IsWalletFlagSet(flag) == value) {
326 throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Wallet flag is already set to %s: %s", value ? "true" : "false", flag_str));
327 }
328
329 res.pushKV("flag_name", flag_str);
330 res.pushKV("flag_state", value);
331
332 if (value) {
333 pwallet->SetWalletFlag(flag);
334 } else {
335 pwallet->UnsetWalletFlag(flag);
336 }
337
338 if (flag && value && WALLET_FLAG_CAVEATS.count(flag)) {
339 res.pushKV("warnings", WALLET_FLAG_CAVEATS.at(flag));
340 }
341
342 return res;
343},
344 };
345}
346
348{
349 return RPCHelpMan{
350 "createwallet",
351 "Creates and loads a new wallet.\n",
352 {
353 {"wallet_name", RPCArg::Type::STR, RPCArg::Optional::NO, "The name for the new wallet. If this is a path, the wallet will be created at the path location."},
354 {"disable_private_keys", RPCArg::Type::BOOL, RPCArg::Default{false}, "Disable the possibility of private keys (only watchonlys are possible in this mode)."},
355 {"blank", RPCArg::Type::BOOL, RPCArg::Default{false}, "Create a blank wallet. A blank wallet has no keys."},
356 {"passphrase", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "Encrypt the wallet with this passphrase."},
357 {"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."},
358 {"descriptors", RPCArg::Type::BOOL, RPCArg::Default{true}, "If set, must be \"true\""},
359 {"load_on_startup", RPCArg::Type::BOOL, RPCArg::Optional::OMITTED, "Save wallet name to persistent settings and load on startup. True to add wallet to startup list, false to remove, null to leave unchanged."},
360 {"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."},
361 },
362 RPCResult{
363 RPCResult::Type::OBJ, "", "",
364 {
365 {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."},
366 {RPCResult::Type::ARR, "warnings", /*optional=*/true, "Warning messages, if any, related to creating and loading the wallet.",
367 {
368 {RPCResult::Type::STR, "", ""},
369 }},
370 }
371 },
373 HelpExampleCli("createwallet", "\"testwallet\"")
374 + HelpExampleRpc("createwallet", "\"testwallet\"")
375 + HelpExampleCliNamed("createwallet", {{"wallet_name", "descriptors"}, {"avoid_reuse", true}, {"load_on_startup", true}})
376 + HelpExampleRpcNamed("createwallet", {{"wallet_name", "descriptors"}, {"avoid_reuse", true}, {"load_on_startup", true}})
377 },
378 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
379{
380 WalletContext& context = EnsureWalletContext(request.context);
381 uint64_t flags = 0;
382 if (!request.params[1].isNull() && request.params[1].get_bool()) {
384 }
385
386 if (!request.params[2].isNull() && request.params[2].get_bool()) {
388 }
389 SecureString passphrase;
390 passphrase.reserve(100);
391 std::vector<bilingual_str> warnings;
392 if (!request.params[3].isNull()) {
393 passphrase = std::string_view{request.params[3].get_str()};
394 if (passphrase.empty()) {
395 // Empty string means unencrypted
396 warnings.emplace_back(Untranslated("Empty string given as passphrase, wallet will not be encrypted."));
397 }
398 }
399
400 if (!request.params[4].isNull() && request.params[4].get_bool()) {
402 }
404 if (!self.Arg<bool>("descriptors")) {
405 throw JSONRPCError(RPC_WALLET_ERROR, "descriptors argument must be set to \"true\"; it is no longer possible to create a legacy wallet.");
406 }
407 if (!request.params[7].isNull() && request.params[7].get_bool()) {
408#ifdef ENABLE_EXTERNAL_SIGNER
410#else
411 throw JSONRPCError(RPC_WALLET_ERROR, "Compiled without external signing support (required for external signing)");
412#endif
413 }
414
415 DatabaseOptions options;
416 DatabaseStatus status;
417 ReadDatabaseArgs(*context.args, options);
418 options.require_create = true;
419 options.create_flags = flags;
420 options.create_passphrase = passphrase;
421 bilingual_str error;
422 std::optional<bool> load_on_start = request.params[6].isNull() ? std::nullopt : std::optional<bool>(request.params[6].get_bool());
423 const std::shared_ptr<CWallet> wallet = CreateWallet(context, request.params[0].get_str(), load_on_start, options, status, error, warnings);
424 if (!wallet) {
425 RPCErrorCode code = status == DatabaseStatus::FAILED_ENCRYPT ? RPC_WALLET_ENCRYPTION_FAILED : RPC_WALLET_ERROR;
426 throw JSONRPCError(code, error.original);
427 }
428
430 obj.pushKV("name", wallet->GetName());
431 PushWarnings(warnings, obj);
432
433 return obj;
434},
435 };
436}
437
439{
440 return RPCHelpMan{"unloadwallet",
441 "Unloads the wallet referenced by the request endpoint or the wallet_name argument.\n"
442 "If both are specified, they must be identical.",
443 {
444 {"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."},
445 {"load_on_startup", RPCArg::Type::BOOL, RPCArg::Optional::OMITTED, "Save wallet name to persistent settings and load on startup. True to add wallet to startup list, false to remove, null to leave unchanged."},
446 },
448 {RPCResult::Type::ARR, "warnings", /*optional=*/true, "Warning messages, if any, related to unloading the wallet.",
449 {
450 {RPCResult::Type::STR, "", ""},
451 }},
452 }},
454 HelpExampleCli("unloadwallet", "wallet_name")
455 + HelpExampleRpc("unloadwallet", "wallet_name")
456 },
457 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
458{
459 const std::string wallet_name{EnsureUniqueWalletName(request, self.MaybeArg<std::string>("wallet_name"))};
460
461 WalletContext& context = EnsureWalletContext(request.context);
462 std::shared_ptr<CWallet> wallet = GetWallet(context, wallet_name);
463 if (!wallet) {
464 throw JSONRPCError(RPC_WALLET_NOT_FOUND, "Requested wallet does not exist or is not loaded");
465 }
466
467 std::vector<bilingual_str> warnings;
468 {
469 WalletRescanReserver reserver(*wallet);
470 if (!reserver.reserve()) {
471 throw JSONRPCError(RPC_WALLET_ERROR, "Wallet is currently rescanning. Abort existing rescan or wait.");
472 }
473
474 // Release the "main" shared pointer and prevent further notifications.
475 // Note that any attempt to load the same wallet would fail until the wallet
476 // is destroyed (see CheckUniqueFileid).
477 std::optional<bool> load_on_start{self.MaybeArg<bool>("load_on_startup")};
478 if (!RemoveWallet(context, wallet, load_on_start, warnings)) {
479 throw JSONRPCError(RPC_MISC_ERROR, "Requested wallet already unloaded");
480 }
481 }
482
483 WaitForDeleteWallet(std::move(wallet));
484
485 UniValue result(UniValue::VOBJ);
486 PushWarnings(warnings, result);
487
488 return result;
489},
490 };
491}
492
494{
495 return RPCHelpMan{
496 "simulaterawtransaction",
497 "Calculate the balance change resulting in the signing and broadcasting of the given transaction(s).\n",
498 {
499 {"rawtxs", RPCArg::Type::ARR, RPCArg::Optional::OMITTED, "An array of hex strings of raw transactions.\n",
500 {
502 },
503 },
505 {
506 {"include_watchonly", RPCArg::Type::BOOL, RPCArg::Default{false}, "(DEPRECATED) No longer used"},
507 },
508 },
509 },
510 RPCResult{
511 RPCResult::Type::OBJ, "", "",
512 {
513 {RPCResult::Type::STR_AMOUNT, "balance_change", "The wallet balance change (negative means decrease)."},
514 }
515 },
517 HelpExampleCli("simulaterawtransaction", "[\"myhex\"]")
518 + HelpExampleRpc("simulaterawtransaction", "[\"myhex\"]")
519 },
520 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
521{
522 const std::shared_ptr<const CWallet> rpc_wallet = GetWalletForJSONRPCRequest(request);
523 if (!rpc_wallet) return UniValue::VNULL;
524 const CWallet& wallet = *rpc_wallet;
525
526 LOCK(wallet.cs_wallet);
527
528 const auto& txs = request.params[0].get_array();
529 CAmount changes{0};
530 std::map<COutPoint, CAmount> new_utxos; // UTXO:s that were made available in transaction array
531 std::set<COutPoint> spent;
532
533 for (size_t i = 0; i < txs.size(); ++i) {
535 if (!DecodeHexTx(mtx, txs[i].get_str(), /* try_no_witness */ true, /* try_witness */ true)) {
536 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Transaction hex string decoding failure.");
537 }
538
539 // Fetch previous transactions (inputs)
540 std::map<COutPoint, Coin> coins;
541 for (const CTxIn& txin : mtx.vin) {
542 coins[txin.prevout]; // Create empty map entry keyed by prevout.
543 }
544 wallet.chain().findCoins(coins);
545
546 // Fetch debit; we are *spending* these; if the transaction is signed and
547 // broadcast, we will lose everything in these
548 for (const auto& txin : mtx.vin) {
549 const auto& outpoint = txin.prevout;
550 if (spent.count(outpoint)) {
551 throw JSONRPCError(RPC_INVALID_PARAMETER, "Transaction(s) are spending the same output more than once");
552 }
553 if (new_utxos.count(outpoint)) {
554 changes -= new_utxos.at(outpoint);
555 new_utxos.erase(outpoint);
556 } else {
557 if (coins.at(outpoint).IsSpent()) {
558 throw JSONRPCError(RPC_INVALID_PARAMETER, "One or more transaction inputs are missing or have been spent already");
559 }
560 changes -= wallet.GetDebit(txin);
561 }
562 spent.insert(outpoint);
563 }
564
565 // Iterate over outputs; we are *receiving* these, if the wallet considers
566 // them "mine"; if the transaction is signed and broadcast, we will receive
567 // everything in these
568 // Also populate new_utxos in case these are spent in later transactions
569
570 const auto& hash = mtx.GetHash();
571 for (size_t i = 0; i < mtx.vout.size(); ++i) {
572 const auto& txout = mtx.vout[i];
573 bool is_mine = wallet.IsMine(txout);
574 changes += new_utxos[COutPoint(hash, i)] = is_mine ? txout.nValue : 0;
575 }
576 }
577
578 UniValue result(UniValue::VOBJ);
579 result.pushKV("balance_change", ValueFromAmount(changes));
580
581 return result;
582}
583 };
584}
585
587{
588 return RPCHelpMan{
589 "migratewallet",
590 "Migrate the wallet to a descriptor wallet.\n"
591 "A new wallet backup will need to be made.\n"
592 "\nThe migration process will create a backup of the wallet before migrating. This backup\n"
593 "file will be named <wallet name>-<timestamp>.legacy.bak and can be found in the directory\n"
594 "for this wallet. In the event of an incorrect migration, the backup can be restored using restorewallet."
595 "\nEncrypted wallets must have the passphrase provided as an argument to this call.\n"
596 "\nThis RPC may take a long time to complete. Increasing the RPC client timeout is recommended.",
597 {
598 {"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."},
599 {"passphrase", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "The wallet passphrase"},
600 },
601 RPCResult{
602 RPCResult::Type::OBJ, "", "",
603 {
604 {RPCResult::Type::STR, "wallet_name", "The name of the primary migrated wallet"},
605 {RPCResult::Type::STR, "watchonly_name", /*optional=*/true, "The name of the migrated wallet containing the watchonly scripts"},
606 {RPCResult::Type::STR, "solvables_name", /*optional=*/true, "The name of the migrated wallet containing solvable but not watched scripts"},
607 {RPCResult::Type::STR, "backup_path", "The location of the backup of the original wallet"},
608 }
609 },
611 HelpExampleCli("migratewallet", "")
612 + HelpExampleRpc("migratewallet", "")
613 },
614 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
615 {
616 const std::string wallet_name{EnsureUniqueWalletName(request, self.MaybeArg<std::string>("wallet_name"))};
617
618 SecureString wallet_pass;
619 wallet_pass.reserve(100);
620 if (!request.params[1].isNull()) {
621 wallet_pass = std::string_view{request.params[1].get_str()};
622 }
623
624 WalletContext& context = EnsureWalletContext(request.context);
625 util::Result<MigrationResult> res = MigrateLegacyToDescriptor(wallet_name, wallet_pass, context);
626 if (!res) {
627 throw JSONRPCError(RPC_WALLET_ERROR, util::ErrorString(res).original);
628 }
629
631 r.pushKV("wallet_name", res->wallet_name);
632 if (res->watchonly_wallet) {
633 r.pushKV("watchonly_name", res->watchonly_wallet->GetName());
634 }
635 if (res->solvables_wallet) {
636 r.pushKV("solvables_name", res->solvables_wallet->GetName());
637 }
638 r.pushKV("backup_path", res->backup_path.utf8string());
639
640 return r;
641 },
642 };
643}
644
646{
647 return RPCHelpMan{
648 "gethdkeys",
649 "List all BIP 32 HD keys in the wallet and which descriptors use them.\n",
650 {
652 {"active_only", RPCArg::Type::BOOL, RPCArg::Default{false}, "Show the keys for only active descriptors"},
653 {"private", RPCArg::Type::BOOL, RPCArg::Default{false}, "Show private keys"}
654 }},
655 },
657 {
658 {RPCResult::Type::OBJ, "", "", {
659 {RPCResult::Type::STR, "xpub", "The extended public key"},
660 {RPCResult::Type::BOOL, "has_private", "Whether the wallet has the private key for this xpub"},
661 {RPCResult::Type::STR, "xprv", /*optional=*/true, "The extended private key if \"private\" is true"},
662 {RPCResult::Type::ARR, "descriptors", "Array of descriptor objects that use this HD key",
663 {
664 {RPCResult::Type::OBJ, "", "", {
665 {RPCResult::Type::STR, "desc", "Descriptor string representation"},
666 {RPCResult::Type::BOOL, "active", "Whether this descriptor is currently used to generate new addresses"},
667 }},
668 }},
669 }},
670 }
671 }},
673 HelpExampleCli("gethdkeys", "") + HelpExampleRpc("gethdkeys", "")
674 + HelpExampleCliNamed("gethdkeys", {{"active_only", "true"}, {"private", "true"}}) + HelpExampleRpcNamed("gethdkeys", {{"active_only", "true"}, {"private", "true"}})
675 },
676 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
677 {
678 const std::shared_ptr<const CWallet> wallet = GetWalletForJSONRPCRequest(request);
679 if (!wallet) return UniValue::VNULL;
680
681 LOCK(wallet->cs_wallet);
682
683 UniValue options{request.params[0].isNull() ? UniValue::VOBJ : request.params[0]};
684 const bool active_only{options.exists("active_only") ? options["active_only"].get_bool() : false};
685 const bool priv{options.exists("private") ? options["private"].get_bool() : false};
686 if (priv) {
688 }
689
690
691 std::set<ScriptPubKeyMan*> spkms;
692 if (active_only) {
693 spkms = wallet->GetActiveScriptPubKeyMans();
694 } else {
695 spkms = wallet->GetAllScriptPubKeyMans();
696 }
697
698 std::map<CExtPubKey, std::set<std::tuple<std::string, bool, bool>>> wallet_xpubs;
699 std::map<CExtPubKey, CExtKey> wallet_xprvs;
700 for (auto* spkm : spkms) {
701 auto* desc_spkm{dynamic_cast<DescriptorScriptPubKeyMan*>(spkm)};
702 CHECK_NONFATAL(desc_spkm);
703 LOCK(desc_spkm->cs_desc_man);
704 WalletDescriptor w_desc = desc_spkm->GetWalletDescriptor();
705
706 // Retrieve the pubkeys from the descriptor
707 std::set<CPubKey> desc_pubkeys;
708 std::set<CExtPubKey> desc_xpubs;
709 w_desc.descriptor->GetPubKeys(desc_pubkeys, desc_xpubs);
710 for (const CExtPubKey& xpub : desc_xpubs) {
711 std::string desc_str;
712 bool ok = desc_spkm->GetDescriptorString(desc_str, false);
713 CHECK_NONFATAL(ok);
714 wallet_xpubs[xpub].emplace(desc_str, wallet->IsActiveScriptPubKeyMan(*spkm), desc_spkm->HasPrivKey(xpub.pubkey.GetID()));
715 if (std::optional<CKey> key = priv ? desc_spkm->GetKey(xpub.pubkey.GetID()) : std::nullopt) {
716 wallet_xprvs[xpub] = CExtKey(xpub, *key);
717 }
718 }
719 }
720
721 UniValue response(UniValue::VARR);
722 for (const auto& [xpub, descs] : wallet_xpubs) {
723 bool has_xprv = false;
724 UniValue descriptors(UniValue::VARR);
725 for (const auto& [desc, active, has_priv] : descs) {
727 d.pushKV("desc", desc);
728 d.pushKV("active", active);
729 has_xprv |= has_priv;
730
731 descriptors.push_back(std::move(d));
732 }
733 UniValue xpub_info(UniValue::VOBJ);
734 xpub_info.pushKV("xpub", EncodeExtPubKey(xpub));
735 xpub_info.pushKV("has_private", has_xprv);
736 if (priv) {
737 xpub_info.pushKV("xprv", EncodeExtKey(wallet_xprvs.at(xpub)));
738 }
739 xpub_info.pushKV("descriptors", std::move(descriptors));
740
741 response.push_back(std::move(xpub_info));
742 }
743
744 return response;
745 },
746 };
747}
748
750{
751 return RPCHelpMan{"createwalletdescriptor",
752 "Creates the wallet's descriptor for the given address type. "
753 "The address type must be one that the wallet does not already have a descriptor for."
755 {
756 {"type", RPCArg::Type::STR, RPCArg::Optional::NO, "The address type the descriptor will produce. Options are " + FormatAllOutputTypes() + "."},
758 {"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)"},
759 {"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"},
760 }},
761 },
762 RPCResult{
763 RPCResult::Type::OBJ, "", "",
764 {
765 {RPCResult::Type::ARR, "descs", "The public descriptors that were added to the wallet",
766 {{RPCResult::Type::STR, "", ""}}
767 }
768 },
769 },
771 HelpExampleCli("createwalletdescriptor", "bech32m")
772 + HelpExampleRpc("createwalletdescriptor", "bech32m")
773 },
774 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
775 {
776 std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
777 if (!pwallet) return UniValue::VNULL;
778
779 std::optional<OutputType> output_type = ParseOutputType(request.params[0].get_str());
780 if (!output_type) {
781 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("Unknown address type '%s'", request.params[0].get_str()));
782 }
783
784 UniValue options{request.params[1].isNull() ? UniValue::VOBJ : request.params[1]};
785 UniValue internal_only{options["internal"]};
786 UniValue hdkey{options["hdkey"]};
787
788 std::vector<bool> internals;
789 if (internal_only.isNull()) {
790 internals.push_back(false);
791 internals.push_back(true);
792 } else {
793 internals.push_back(internal_only.get_bool());
794 }
795
796 LOCK(pwallet->cs_wallet);
797 EnsureWalletIsUnlocked(*pwallet);
798
799 CExtPubKey xpub;
800 if (hdkey.isNull()) {
801 std::set<CExtPubKey> active_xpubs = pwallet->GetActiveHDPubKeys();
802 if (active_xpubs.size() != 1) {
803 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Unable to determine which HD key to use from active descriptors. Please specify with 'hdkey'");
804 }
805 xpub = *active_xpubs.begin();
806 } else {
807 xpub = DecodeExtPubKey(hdkey.get_str());
808 if (!xpub.pubkey.IsValid()) {
809 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Unable to parse HD key. Please provide a valid xpub");
810 }
811 }
812
813 std::optional<CKey> key = pwallet->GetKey(xpub.pubkey.GetID());
814 if (!key) {
815 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("Private key for %s is not known", EncodeExtPubKey(xpub)));
816 }
817 CExtKey active_hdkey(xpub, *key);
818
819 std::vector<std::reference_wrapper<DescriptorScriptPubKeyMan>> spkms;
820 WalletBatch batch{pwallet->GetDatabase()};
821 for (bool internal : internals) {
822 WalletDescriptor w_desc = GenerateWalletDescriptor(xpub, *output_type, internal);
823 uint256 w_id = DescriptorID(*w_desc.descriptor);
824 if (!pwallet->GetScriptPubKeyMan(w_id)) {
825 spkms.emplace_back(pwallet->SetupDescriptorScriptPubKeyMan(batch, active_hdkey, *output_type, internal));
826 }
827 }
828 if (spkms.empty()) {
829 throw JSONRPCError(RPC_WALLET_ERROR, "Descriptor already exists");
830 }
831
832 // Fetch each descspkm from the wallet in order to get the descriptor strings
834 for (const auto& spkm : spkms) {
835 std::string desc_str;
836 bool ok = spkm.get().GetDescriptorString(desc_str, false);
837 CHECK_NONFATAL(ok);
838 descs.push_back(desc_str);
839 }
841 out.pushKV("descs", std::move(descs));
842 return out;
843 }
844 };
845}
846
847// addresses
856#ifdef ENABLE_EXTERNAL_SIGNER
858#endif // ENABLE_EXTERNAL_SIGNER
859
860// backup
867
868// coins
876
877// encryption
882
883// spend
895
896// signmessage
898
899// transactions
908
909std::span<const CRPCCommand> GetWalletRPCCommands()
910{
911 static const CRPCCommand commands[]{
912 {"rawtransactions", &fundrawtransaction},
913 {"wallet", &abandontransaction},
914 {"wallet", &abortrescan},
915 {"wallet", &backupwallet},
916 {"wallet", &bumpfee},
917 {"wallet", &psbtbumpfee},
918 {"wallet", &createwallet},
919 {"wallet", &createwalletdescriptor},
920 {"wallet", &restorewallet},
921 {"wallet", &encryptwallet},
922 {"wallet", &getaddressesbylabel},
923 {"wallet", &getaddressinfo},
924 {"wallet", &getbalance},
925 {"wallet", &gethdkeys},
926 {"wallet", &getnewaddress},
927 {"wallet", &getrawchangeaddress},
928 {"wallet", &getreceivedbyaddress},
929 {"wallet", &getreceivedbylabel},
930 {"wallet", &gettransaction},
931 {"wallet", &getbalances},
932 {"wallet", &getwalletinfo},
933 {"wallet", &importdescriptors},
934 {"wallet", &importprunedfunds},
935 {"wallet", &keypoolrefill},
936 {"wallet", &listaddressgroupings},
937 {"wallet", &listdescriptors},
938 {"wallet", &listlabels},
939 {"wallet", &listlockunspent},
940 {"wallet", &listreceivedbyaddress},
941 {"wallet", &listreceivedbylabel},
942 {"wallet", &listsinceblock},
943 {"wallet", &listtransactions},
944 {"wallet", &listunspent},
945 {"wallet", &listwalletdir},
946 {"wallet", &listwallets},
947 {"wallet", &loadwallet},
948 {"wallet", &lockunspent},
949 {"wallet", &migratewallet},
950 {"wallet", &removeprunedfunds},
951 {"wallet", &rescanblockchain},
952 {"wallet", &send},
953 {"wallet", &sendmany},
954 {"wallet", &sendtoaddress},
955 {"wallet", &setlabel},
956 {"wallet", &settxfee},
957 {"wallet", &setwalletflag},
958 {"wallet", &signmessage},
959 {"wallet", &signrawtransactionwithwallet},
960 {"wallet", &simulaterawtransaction},
961 {"wallet", &sendall},
962 {"wallet", &unloadwallet},
963 {"wallet", &walletcreatefundedpsbt},
964#ifdef ENABLE_EXTERNAL_SIGNER
965 {"wallet", &walletdisplayaddress},
966#endif // ENABLE_EXTERNAL_SIGNER
967 {"wallet", &walletlock},
968 {"wallet", &walletpassphrase},
969 {"wallet", &walletpassphrasechange},
970 {"wallet", &walletprocesspsbt},
971 };
972 return commands;
973}
974} // namespace wallet
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:12
int flags
Definition: bitcoin-tx.cpp:529
#define CHECK_NONFATAL(condition)
Identity function.
Definition: check.h:102
An outpoint - a combination of a transaction hash and an index n into its vout.
Definition: transaction.h:29
CKeyID GetID() const
Get the KeyID of this public key (hash of its serialization)
Definition: pubkey.h:164
bool IsValid() const
Definition: pubkey.h:189
An input of a transaction.
Definition: transaction.h:67
COutPoint prevout
Definition: transaction.h:69
auto Arg(std::string_view key) const
Helper to get a required or default-valued request argument.
Definition: util.h:444
auto MaybeArg(std::string_view key) const
Helper to get an optional request argument.
Definition: util.h:476
void push_back(UniValue val)
Definition: univalue.cpp:104
@ VNULL
Definition: univalue.h:24
@ VOBJ
Definition: univalue.h:24
@ VARR
Definition: univalue.h:24
bool isNull() const
Definition: univalue.h:81
void pushKV(std::string key, UniValue val)
Definition: univalue.cpp:126
256-bit opaque blob.
Definition: uint256.h:196
A CWallet maintains a set of transactions and balances, and provides the ability to create new transa...
Definition: wallet.h:311
Access to the wallet database.
Definition: walletdb.h:190
Descriptor with some wallet metadata.
Definition: walletutil.h:64
std::shared_ptr< Descriptor > descriptor
Definition: walletutil.h:66
RAII object to check and reserve a wallet rescan.
Definition: wallet.h:1075
bool reserve(bool with_passphrase=false)
Definition: wallet.h:1085
UniValue ValueFromAmount(const CAmount amount)
Definition: core_write.cpp:26
bool DecodeHexTx(CMutableTransaction &tx, const std::string &hex_tx, bool try_no_witness=false, bool try_witness=true)
Definition: core_read.cpp:196
const std::string CURRENCY_UNIT
Definition: feerate.h:18
std::string EncodeExtKey(const CExtKey &key)
Definition: key_io.cpp:283
CExtPubKey DecodeExtPubKey(const std::string &str)
Definition: key_io.cpp:244
std::string EncodeExtPubKey(const CExtPubKey &key)
Definition: key_io.cpp:257
void ReadDatabaseArgs(const ArgsManager &args, DBOptions &options)
bilingual_str ErrorString(const Result< T > &result)
Definition: result.h:93
void ReadDatabaseArgs(const ArgsManager &args, DatabaseOptions &options)
Definition: db.cpp:153
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)
Definition: wallet.cpp:363
RPCHelpMan walletlock()
Definition: encrypt.cpp:178
static RPCHelpMan loadwallet()
Definition: wallet.cpp:214
std::shared_ptr< CWallet > GetWalletForJSONRPCRequest(const JSONRPCRequest &request)
Figures out what wallet, if any, to use for a JSONRPCRequest.
Definition: util.cpp:63
RPCHelpMan listreceivedbyaddress()
std::vector< std::shared_ptr< CWallet > > GetWallets(WalletContext &context)
Definition: wallet.cpp:193
RPCHelpMan keypoolrefill()
Definition: addresses.cpp:218
RPCHelpMan removeprunedfunds()
Definition: backup.cpp:93
RPCHelpMan listlockunspent()
Definition: coins.cpp:348
static const RPCResult RESULT_LAST_PROCESSED_BLOCK
Definition: util.h:28
RPCHelpMan walletprocesspsbt()
Definition: spend.cpp:1619
void HandleWalletError(const std::shared_ptr< CWallet > wallet, DatabaseStatus &status, bilingual_str &error)
Definition: util.cpp:126
void EnsureWalletIsUnlocked(const CWallet &wallet)
Definition: util.cpp:87
static RPCHelpMan getwalletinfo()
Definition: wallet.cpp:33
RPCHelpMan backupwallet()
Definition: backup.cpp:566
static RPCHelpMan listwalletdir()
Definition: wallet.cpp:137
RPCHelpMan walletpassphrase()
Definition: encrypt.cpp:13
const std::string HELP_REQUIRING_PASSPHRASE
Definition: util.cpp:19
RPCHelpMan psbtbumpfee()
Definition: spend.cpp:1215
util::Result< MigrationResult > MigrateLegacyToDescriptor(std::shared_ptr< CWallet > local_wallet, const SecureString &passphrase, WalletContext &context)
Requirement: The wallet provided to this function must be isolated, with no attachment to the node's ...
Definition: wallet.cpp:4218
RPCHelpMan getreceivedbyaddress()
Definition: coins.cpp:80
RPCHelpMan walletdisplayaddress()
Definition: addresses.cpp:633
RPCHelpMan getbalance()
Definition: coins.cpp:164
RPCHelpMan importprunedfunds()
Definition: backup.cpp:37
RPCHelpMan simulaterawtransaction()
Definition: wallet.cpp:493
static RPCHelpMan setwalletflag()
Definition: wallet.cpp:279
RPCHelpMan walletcreatefundedpsbt()
Definition: spend.cpp:1703
bool RemoveWallet(WalletContext &context, const std::shared_ptr< CWallet > &wallet, std::optional< bool > load_on_start)
Definition: wallet.cpp:187
WalletContext & EnsureWalletContext(const std::any &context)
Definition: util.cpp:94
RPCHelpMan listaddressgroupings()
Definition: addresses.cpp:157
RPCHelpMan walletpassphrasechange()
Definition: encrypt.cpp:118
fs::path GetWalletDir()
Get the path of the wallet directory.
Definition: walletutil.cpp:13
RPCHelpMan abandontransaction()
RPCHelpMan settxfee()
Definition: spend.cpp:430
RPCHelpMan listdescriptors()
Definition: backup.cpp:457
RPCHelpMan listtransactions()
RPCHelpMan signrawtransactionwithwallet()
Definition: spend.cpp:889
std::string EnsureUniqueWalletName(const JSONRPCRequest &request, const std::string *wallet_name)
Ensures that a wallet name is specified across the endpoint and wallet_name.
Definition: util.cpp:32
static RPCHelpMan listwallets()
Definition: wallet.cpp:183
RPCHelpMan signmessage()
Definition: signmessage.cpp:14
static constexpr int64_t UNKNOWN_TIME
Constant representing an unknown spkm creation time.
RPCHelpMan sendall()
Definition: spend.cpp:1341
static RPCHelpMan unloadwallet()
Definition: wallet.cpp:438
RPCHelpMan listsinceblock()
RPCHelpMan bumpfee()
Definition: spend.cpp:1214
RPCHelpMan lockunspent()
Definition: coins.cpp:215
RPCHelpMan abortrescan()
RPCHelpMan restorewallet()
Definition: backup.cpp:601
RPCHelpMan listlabels()
Definition: addresses.cpp:576
void AppendLastProcessedBlock(UniValue &entry, const CWallet &wallet)
Definition: util.cpp:154
RPCHelpMan getreceivedbylabel()
Definition: coins.cpp:122
RPCHelpMan importdescriptors()
Definition: backup.cpp:295
RPCHelpMan getbalances()
Definition: coins.cpp:402
RPCHelpMan getrawchangeaddress()
Definition: addresses.cpp:72
RPCHelpMan setlabel()
Definition: addresses.cpp:118
static RPCHelpMan createwallet()
Definition: wallet.cpp:347
RPCHelpMan sendmany()
Definition: spend.cpp:336
RPCHelpMan getaddressinfo()
Definition: addresses.cpp:368
static constexpr uint64_t KNOWN_WALLET_FLAGS
Definition: wallet.h:151
RPCHelpMan encryptwallet()
Definition: encrypt.cpp:221
RPCHelpMan gettransaction()
RPCHelpMan getaddressesbylabel()
Definition: addresses.cpp:515
RPCHelpMan fundrawtransaction()
Definition: spend.cpp:754
static const std::map< uint64_t, std::string > WALLET_FLAG_CAVEATS
Definition: wallet.cpp:26
RPCHelpMan listunspent()
Definition: coins.cpp:457
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)
Definition: wallet.cpp:376
static RPCHelpMan migratewallet()
Definition: wallet.cpp:586
RPCHelpMan rescanblockchain()
WalletFlags
Definition: walletutil.h:15
@ WALLET_FLAG_EXTERNAL_SIGNER
Indicates that the wallet needs an external signer.
Definition: walletutil.h:56
@ WALLET_FLAG_AVOID_REUSE
Definition: walletutil.h:21
@ WALLET_FLAG_DESCRIPTORS
Indicate that this wallet supports DescriptorScriptPubKeyMan.
Definition: walletutil.h:53
@ WALLET_FLAG_DISABLE_PRIVATE_KEYS
Definition: walletutil.h:30
@ WALLET_FLAG_BLANK_WALLET
Flag set when a wallet contains no HD seed and no private keys, scripts, addresses,...
Definition: walletutil.h:50
RPCHelpMan gethdkeys()
Definition: wallet.cpp:645
void WaitForDeleteWallet(std::shared_ptr< CWallet > &&wallet)
Explicitly delete the wallet.
Definition: wallet.cpp:253
static const std::map< std::string, WalletFlags > STRING_TO_WALLET_FLAG
Definition: wallet.h:173
static constexpr uint64_t MUTABLE_WALLET_FLAGS
Definition: wallet.h:160
RPCHelpMan getnewaddress()
Definition: addresses.cpp:21
RPCHelpMan listreceivedbylabel()
std::shared_ptr< CWallet > GetWallet(WalletContext &context, const std::string &name)
Definition: wallet.cpp:206
std::span< const CRPCCommand > GetWalletRPCCommands()
Definition: wallet.cpp:909
static const std::map< WalletFlags, std::string > WALLET_FLAG_TO_STRING
Definition: wallet.h:163
RPCHelpMan send()
Definition: spend.cpp:1217
RPCHelpMan sendtoaddress()
Definition: spend.cpp:238
std::vector< std::pair< fs::path, std::string > > ListDatabases(const fs::path &wallet_dir)
Recursively list database paths in directory.
Definition: db.cpp:23
DatabaseStatus
Definition: db.h:186
static RPCHelpMan createwalletdescriptor()
Definition: wallet.cpp:749
WalletDescriptor GenerateWalletDescriptor(const CExtPubKey &master_key, const OutputType &addr_type, bool internal)
Definition: walletutil.cpp:35
std::string FormatAllOutputTypes()
Definition: outputtype.cpp:49
std::optional< OutputType > ParseOutputType(const std::string &type)
Definition: outputtype.cpp:23
UniValue JSONRPCError(int code, const std::string &message)
Definition: request.cpp:70
const char * name
Definition: rest.cpp:50
RPCErrorCode
Bitcoin RPC error codes.
Definition: protocol.h:25
@ RPC_MISC_ERROR
General application defined errors.
Definition: protocol.h:40
@ RPC_WALLET_ENCRYPTION_FAILED
Failed to encrypt the wallet.
Definition: protocol.h:78
@ RPC_INVALID_PARAMETER
Invalid, missing or duplicate parameter.
Definition: protocol.h:44
@ RPC_WALLET_ERROR
Wallet errors.
Definition: protocol.h:71
@ RPC_WALLET_ALREADY_LOADED
This same wallet is already loaded.
Definition: protocol.h:82
@ RPC_WALLET_NOT_FOUND
Invalid wallet specified.
Definition: protocol.h:80
@ RPC_DESERIALIZATION_ERROR
Error parsing or validating structure in raw format.
Definition: protocol.h:46
@ RPC_INVALID_ADDRESS_OR_KEY
Invalid address or key.
Definition: protocol.h:42
std::string HelpExampleCli(const std::string &methodname, const std::string &args)
Definition: util.cpp:186
std::string HelpExampleRpcNamed(const std::string &methodname, const RPCArgList &args)
Definition: util.cpp:210
void PushWarnings(const UniValue &warnings, UniValue &obj)
Push warning messages to an RPC "warnings" field as a JSON array of strings.
Definition: util.cpp:1382
std::string HelpExampleRpc(const std::string &methodname, const std::string &args)
Definition: util.cpp:204
const std::string UNIX_EPOCH_TIME
String used to describe UNIX epoch time in documentation, factored out to a constant for consistency.
Definition: util.cpp:46
std::string HelpExampleCliNamed(const std::string &methodname, const RPCArgList &args)
Definition: util.cpp:191
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
Definition: secure.h:58
Definition: key.h:227
CPubKey pubkey
Definition: pubkey.h:352
A mutable version of CTransaction.
Definition: transaction.h:378
std::vector< CTxOut > vout
Definition: transaction.h:380
Txid GetHash() const
Compute the hash of this CMutableTransaction.
Definition: transaction.cpp:69
std::vector< CTxIn > vin
Definition: transaction.h:379
@ 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.
Definition: util.h:220
@ OMITTED
Optional argument for which the default value is omitted from help text for one of two reasons:
@ NO
Required arg.
@ NUM_TIME
Special numeric to denote unix epoch time.
@ STR_AMOUNT
Special string to represent a floating point amount.
Bilingual messages:
Definition: translation.h:24
std::string original
Definition: translation.h:25
bool require_existing
Definition: db.h:173
SecureString create_passphrase
Definition: db.h:177
uint64_t create_flags
Definition: db.h:176
WalletContext struct containing references to state shared between CWallet instances,...
Definition: context.h:36
ArgsManager * args
Definition: context.h:39
#define LOCK(cs)
Definition: sync.h:259
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1172
bilingual_str Untranslated(std::string original)
Mark a bilingual_str as untranslated.
Definition: translation.h:82