backup.cpp
1 // Copyright (c) 2009-present The Bitcoin Core developers 2 // Distributed under the MIT software license, see the accompanying 3 // file COPYING or http://www.opensource.org/licenses/mit-license.php. 4 5 #include <chain.h> 6 #include <clientversion.h> 7 #include <core_io.h> 8 #include <hash.h> 9 #include <interfaces/chain.h> 10 #include <key_io.h> 11 #include <merkleblock.h> 12 #include <node/types.h> 13 #include <rpc/util.h> 14 #include <script/descriptor.h> 15 #include <script/script.h> 16 #include <script/solver.h> 17 #include <sync.h> 18 #include <uint256.h> 19 #include <util/bip32.h> 20 #include <util/fs.h> 21 #include <util/time.h> 22 #include <util/translation.h> 23 #include <wallet/rpc/util.h> 24 #include <wallet/wallet.h> 25 26 #include <cstdint> 27 #include <fstream> 28 #include <tuple> 29 #include <string> 30 31 #include <univalue.h> 32 33 34 35 using interfaces::FoundBlock; 36 37 namespace wallet { 38 RPCHelpMan importprunedfunds() 39 { 40 return RPCHelpMan{ 41 "importprunedfunds", 42 "Imports funds without rescan. Corresponding address or script must previously be included in wallet. Aimed towards pruned wallets. The end-user is responsible to import additional transactions that subsequently spend the imported outputs or rescan after the point in the blockchain the transaction is included.\n", 43 { 44 {"rawtransaction", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "A raw transaction in hex funding an already-existing address in wallet"}, 45 {"txoutproof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The hex output from gettxoutproof that contains the transaction"}, 46 }, 47 RPCResult{RPCResult::Type::NONE, "", ""}, 48 RPCExamples{""}, 49 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue 50 { 51 std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request); 52 if (!pwallet) return UniValue::VNULL; 53 54 CMutableTransaction tx; 55 if (!DecodeHexTx(tx, request.params[0].get_str())) { 56 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed. Make sure the tx has at least one input."); 57 } 58 59 DataStream ssMB{ParseHexV(request.params[1], "proof")}; 60 CMerkleBlock merkleBlock; 61 ssMB >> merkleBlock; 62 63 //Search partial merkle tree in proof for our transaction and index in valid block 64 std::vector<Txid> vMatch; 65 std::vector<unsigned int> vIndex; 66 if (merkleBlock.txn.ExtractMatches(vMatch, vIndex) != merkleBlock.header.hashMerkleRoot) { 67 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Something wrong with merkleblock"); 68 } 69 70 LOCK(pwallet->cs_wallet); 71 int height; 72 if (!pwallet->chain().findAncestorByHash(pwallet->GetLastBlockHash(), merkleBlock.header.GetHash(), FoundBlock().height(height))) { 73 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found in chain"); 74 } 75 76 std::vector<Txid>::const_iterator it; 77 if ((it = std::find(vMatch.begin(), vMatch.end(), tx.GetHash())) == vMatch.end()) { 78 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Transaction given doesn't exist in proof"); 79 } 80 81 unsigned int txnIndex = vIndex[it - vMatch.begin()]; 82 83 CTransactionRef tx_ref = MakeTransactionRef(tx); 84 if (pwallet->IsMine(*tx_ref)) { 85 pwallet->AddToWallet(std::move(tx_ref), TxStateConfirmed{merkleBlock.header.GetHash(), height, static_cast<int>(txnIndex)}); 86 return UniValue::VNULL; 87 } 88 89 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No addresses in wallet correspond to included transaction"); 90 }, 91 }; 92 } 93 94 RPCHelpMan removeprunedfunds() 95 { 96 return RPCHelpMan{ 97 "removeprunedfunds", 98 "Deletes the specified transaction from the wallet. Meant for use with pruned wallets and as a companion to importprunedfunds. This will affect wallet balances.\n", 99 { 100 {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The hex-encoded id of the transaction you are deleting"}, 101 }, 102 RPCResult{RPCResult::Type::NONE, "", ""}, 103 RPCExamples{ 104 HelpExampleCli("removeprunedfunds", "\"a8d0c0184dde994a09ec054286f1ce581bebf46446a512166eae7628734ea0a5\"") + 105 "\nAs a JSON-RPC call\n" 106 + HelpExampleRpc("removeprunedfunds", "\"a8d0c0184dde994a09ec054286f1ce581bebf46446a512166eae7628734ea0a5\"") 107 }, 108 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue 109 { 110 std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request); 111 if (!pwallet) return UniValue::VNULL; 112 113 LOCK(pwallet->cs_wallet); 114 115 Txid hash{Txid::FromUint256(ParseHashV(request.params[0], "txid"))}; 116 std::vector<Txid> vHash; 117 vHash.push_back(hash); 118 if (auto res = pwallet->RemoveTxs(vHash); !res) { 119 throw JSONRPCError(RPC_WALLET_ERROR, util::ErrorString(res).original); 120 } 121 122 return UniValue::VNULL; 123 }, 124 }; 125 } 126 127 static int64_t GetImportTimestamp(const UniValue& data, int64_t now) 128 { 129 if (data.exists("timestamp")) { 130 const UniValue& timestamp = data["timestamp"]; 131 if (timestamp.isNum()) { 132 return timestamp.getInt<int64_t>(); 133 } else if (timestamp.isStr() && timestamp.get_str() == "now") { 134 return now; 135 } 136 throw JSONRPCError(RPC_TYPE_ERROR, strprintf("Expected number or \"now\" timestamp value for key. got type %s", uvTypeName(timestamp.type()))); 137 } 138 throw JSONRPCError(RPC_TYPE_ERROR, "Missing required timestamp field for key"); 139 } 140 141 static UniValue ProcessDescriptorImport(CWallet& wallet, const UniValue& data, const int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) 142 { 143 UniValue warnings(UniValue::VARR); 144 UniValue result(UniValue::VOBJ); 145 146 try { 147 if (!data.exists("desc")) { 148 throw JSONRPCError(RPC_INVALID_PARAMETER, "Descriptor not found."); 149 } 150 151 const std::string& descriptor = data["desc"].get_str(); 152 const bool active = data.exists("active") ? data["active"].get_bool() : false; 153 const std::string label{LabelFromValue(data["label"])}; 154 155 // Parse descriptor string 156 FlatSigningProvider keys; 157 std::string error; 158 auto parsed_descs = Parse(descriptor, keys, error, /* require_checksum = */ true); 159 if (parsed_descs.empty()) { 160 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, error); 161 } 162 std::optional<bool> internal; 163 if (data.exists("internal")) { 164 if (parsed_descs.size() > 1) { 165 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Cannot have multipath descriptor while also specifying \'internal\'"); 166 } 167 internal = data["internal"].get_bool(); 168 } 169 170 // Range check 171 std::optional<bool> is_ranged; 172 int64_t range_start = 0, range_end = 1, next_index = 0; 173 if (!parsed_descs.at(0)->IsRange() && data.exists("range")) { 174 throw JSONRPCError(RPC_INVALID_PARAMETER, "Range should not be specified for an un-ranged descriptor"); 175 } else if (parsed_descs.at(0)->IsRange()) { 176 if (data.exists("range")) { 177 auto range = ParseDescriptorRange(data["range"]); 178 range_start = range.first; 179 range_end = range.second + 1; // Specified range end is inclusive, but we need range end as exclusive 180 } else { 181 warnings.push_back("Range not given, using default keypool range"); 182 range_start = 0; 183 range_end = wallet.m_keypool_size; 184 } 185 next_index = range_start; 186 is_ranged = true; 187 188 if (data.exists("next_index")) { 189 next_index = data["next_index"].getInt<int64_t>(); 190 // bound checks 191 if (next_index < range_start || next_index >= range_end) { 192 throw JSONRPCError(RPC_INVALID_PARAMETER, "next_index is out of range"); 193 } 194 } 195 } 196 197 // Active descriptors must be ranged 198 if (active && !parsed_descs.at(0)->IsRange()) { 199 throw JSONRPCError(RPC_INVALID_PARAMETER, "Active descriptors must be ranged"); 200 } 201 202 // Multipath descriptors should not have a label 203 if (parsed_descs.size() > 1 && data.exists("label")) { 204 throw JSONRPCError(RPC_INVALID_PARAMETER, "Multipath descriptors should not have a label"); 205 } 206 207 // Ranged descriptors should not have a label 208 if (is_ranged.has_value() && is_ranged.value() && data.exists("label")) { 209 throw JSONRPCError(RPC_INVALID_PARAMETER, "Ranged descriptors should not have a label"); 210 } 211 212 bool desc_internal = internal.has_value() && internal.value(); 213 // Internal addresses should not have a label either 214 if (desc_internal && data.exists("label")) { 215 throw JSONRPCError(RPC_INVALID_PARAMETER, "Internal addresses should not have a label"); 216 } 217 218 // Combo descriptor check 219 if (active && !parsed_descs.at(0)->IsSingleType()) { 220 throw JSONRPCError(RPC_WALLET_ERROR, "Combo descriptors cannot be set to active"); 221 } 222 223 // If the wallet disabled private keys, abort if private keys exist 224 if (wallet.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) && !keys.keys.empty()) { 225 throw JSONRPCError(RPC_WALLET_ERROR, "Cannot import private keys to a wallet with private keys disabled"); 226 } 227 228 for (size_t j = 0; j < parsed_descs.size(); ++j) { 229 auto parsed_desc = std::move(parsed_descs[j]); 230 if (parsed_descs.size() == 2) { 231 desc_internal = j == 1; 232 } else if (parsed_descs.size() > 2) { 233 CHECK_NONFATAL(!desc_internal); 234 } 235 // Need to ExpandPrivate to check if private keys are available for all pubkeys 236 FlatSigningProvider expand_keys; 237 std::vector<CScript> scripts; 238 if (!parsed_desc->Expand(0, keys, scripts, expand_keys)) { 239 throw JSONRPCError(RPC_WALLET_ERROR, "Cannot expand descriptor. Probably because of hardened derivations without private keys provided"); 240 } 241 parsed_desc->ExpandPrivate(0, keys, expand_keys); 242 243 // Check if all private keys are provided 244 bool have_all_privkeys = !expand_keys.keys.empty(); 245 for (const auto& entry : expand_keys.origins) { 246 const CKeyID& key_id = entry.first; 247 CKey key; 248 if (!expand_keys.GetKey(key_id, key)) { 249 have_all_privkeys = false; 250 break; 251 } 252 } 253 254 // If private keys are enabled, check some things. 255 if (!wallet.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) { 256 if (keys.keys.empty()) { 257 throw JSONRPCError(RPC_WALLET_ERROR, "Cannot import descriptor without private keys to a wallet with private keys enabled"); 258 } 259 if (!have_all_privkeys) { 260 warnings.push_back("Not all private keys provided. Some wallet functionality may return unexpected errors"); 261 } 262 } 263 264 WalletDescriptor w_desc(std::move(parsed_desc), timestamp, range_start, range_end, next_index); 265 266 // Add descriptor to the wallet 267 auto spk_manager_res = wallet.AddWalletDescriptor(w_desc, keys, label, desc_internal); 268 269 if (!spk_manager_res) { 270 throw JSONRPCError(RPC_WALLET_ERROR, strprintf("Could not add descriptor '%s': %s", descriptor, util::ErrorString(spk_manager_res).original)); 271 } 272 273 auto& spk_manager = spk_manager_res.value().get(); 274 275 // Set descriptor as active if necessary 276 if (active) { 277 if (!w_desc.descriptor->GetOutputType()) { 278 warnings.push_back("Unknown output type, cannot set descriptor to active."); 279 } else { 280 wallet.AddActiveScriptPubKeyMan(spk_manager.GetID(), *w_desc.descriptor->GetOutputType(), desc_internal); 281 } 282 } else { 283 if (w_desc.descriptor->GetOutputType()) { 284 wallet.DeactivateScriptPubKeyMan(spk_manager.GetID(), *w_desc.descriptor->GetOutputType(), desc_internal); 285 } 286 } 287 } 288 289 result.pushKV("success", UniValue(true)); 290 } catch (const UniValue& e) { 291 result.pushKV("success", UniValue(false)); 292 result.pushKV("error", e); 293 } 294 PushWarnings(warnings, result); 295 return result; 296 } 297 298 RPCHelpMan importdescriptors() 299 { 300 return RPCHelpMan{ 301 "importdescriptors", 302 "Import descriptors. This will trigger a rescan of the blockchain based on the earliest timestamp of all descriptors being imported. Requires a new wallet backup.\n" 303 "When importing descriptors with multipath key expressions, if the multipath specifier contains exactly two elements, the descriptor produced from the second element will be imported as an internal descriptor.\n" 304 "\nNote: This call can take over an hour to complete if using an early timestamp; during that time, other rpc calls\n" 305 "may report that the imported keys, addresses or scripts exist but related transactions are still missing.\n" 306 "The rescan is significantly faster if block filters are available (using startup option \"-blockfilterindex=1\").\n", 307 { 308 {"requests", RPCArg::Type::ARR, RPCArg::Optional::NO, "Data to be imported", 309 { 310 {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "", 311 { 312 {"desc", RPCArg::Type::STR, RPCArg::Optional::NO, "Descriptor to import."}, 313 {"active", RPCArg::Type::BOOL, RPCArg::Default{false}, "Set this descriptor to be the active descriptor for the corresponding output type/externality"}, 314 {"range", RPCArg::Type::RANGE, RPCArg::Optional::OMITTED, "If a ranged descriptor is used, this specifies the end or the range (in the form [begin,end]) to import"}, 315 {"next_index", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "If a ranged descriptor is set to active, this specifies the next index to generate addresses from"}, 316 {"timestamp", RPCArg::Type::NUM, RPCArg::Optional::NO, "Time from which to start rescanning the blockchain for this descriptor, in " + UNIX_EPOCH_TIME + "\n" 317 "Use the string \"now\" to substitute the current synced blockchain time.\n" 318 "\"now\" can be specified to bypass scanning, for outputs which are known to never have been used, and\n" 319 "0 can be specified to scan the entire blockchain. Blocks up to 2 hours before the earliest timestamp\n" 320 "of all descriptors being imported will be scanned as well as the mempool.", 321 RPCArgOptions{.type_str={"timestamp | \"now\"", "integer / string"}} 322 }, 323 {"internal", RPCArg::Type::BOOL, RPCArg::Default{false}, "Whether matching outputs should be treated as not incoming payments (e.g. change)"}, 324 {"label", RPCArg::Type::STR, RPCArg::Default{""}, "Label to assign to the address, only allowed with internal=false. Disabled for ranged descriptors"}, 325 }, 326 }, 327 }, 328 RPCArgOptions{.oneline_description="requests"}}, 329 }, 330 RPCResult{ 331 RPCResult::Type::ARR, "", "Response is an array with the same size as the input that has the execution result", 332 { 333 {RPCResult::Type::OBJ, "", "", 334 { 335 {RPCResult::Type::BOOL, "success", ""}, 336 {RPCResult::Type::ARR, "warnings", /*optional=*/true, "", 337 { 338 {RPCResult::Type::STR, "", ""}, 339 }}, 340 {RPCResult::Type::OBJ, "error", /*optional=*/true, "", 341 { 342 {RPCResult::Type::ELISION, "", "JSONRPC error"}, 343 }}, 344 }}, 345 } 346 }, 347 RPCExamples{ 348 HelpExampleCli("importdescriptors", "'[{ \"desc\": \"<my descriptor>\", \"timestamp\":1455191478, \"internal\": true }, " 349 "{ \"desc\": \"<my descriptor 2>\", \"label\": \"example 2\", \"timestamp\": 1455191480 }]'") + 350 HelpExampleCli("importdescriptors", "'[{ \"desc\": \"<my descriptor>\", \"timestamp\":1455191478, \"active\": true, \"range\": [0,100], \"label\": \"<my bech32 wallet>\" }]'") 351 }, 352 [&](const RPCHelpMan& self, const JSONRPCRequest& main_request) -> UniValue 353 { 354 std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(main_request); 355 if (!pwallet) return UniValue::VNULL; 356 CWallet& wallet{*pwallet}; 357 358 // Make sure the results are valid at least up to the most recent block 359 // the user could have gotten from another RPC command prior to now 360 wallet.BlockUntilSyncedToCurrentChain(); 361 362 WalletRescanReserver reserver(*pwallet); 363 if (!reserver.reserve(/*with_passphrase=*/true)) { 364 throw JSONRPCError(RPC_WALLET_ERROR, "Wallet is currently rescanning. Abort existing rescan or wait."); 365 } 366 367 // Ensure that the wallet is not locked for the remainder of this RPC, as 368 // the passphrase is used to top up the keypool. 369 LOCK(pwallet->m_relock_mutex); 370 371 const UniValue& requests = main_request.params[0]; 372 const int64_t minimum_timestamp = 1; 373 int64_t now = 0; 374 int64_t lowest_timestamp = 0; 375 bool rescan = false; 376 UniValue response(UniValue::VARR); 377 { 378 LOCK(pwallet->cs_wallet); 379 EnsureWalletIsUnlocked(*pwallet); 380 381 CHECK_NONFATAL(pwallet->chain().findBlock(pwallet->GetLastBlockHash(), FoundBlock().time(lowest_timestamp).mtpTime(now))); 382 383 // Get all timestamps and extract the lowest timestamp 384 for (const UniValue& request : requests.getValues()) { 385 // This throws an error if "timestamp" doesn't exist 386 const int64_t timestamp = std::max(GetImportTimestamp(request, now), minimum_timestamp); 387 const UniValue result = ProcessDescriptorImport(*pwallet, request, timestamp); 388 response.push_back(result); 389 390 if (lowest_timestamp > timestamp ) { 391 lowest_timestamp = timestamp; 392 } 393 394 // If we know the chain tip, and at least one request was successful then allow rescan 395 if (!rescan && result["success"].get_bool()) { 396 rescan = true; 397 } 398 } 399 pwallet->ConnectScriptPubKeyManNotifiers(); 400 pwallet->RefreshAllTXOs(); 401 } 402 403 // Rescan the blockchain using the lowest timestamp 404 if (rescan) { 405 int64_t scanned_time = pwallet->RescanFromTime(lowest_timestamp, reserver, /*update=*/true); 406 pwallet->ResubmitWalletTransactions(node::TxBroadcast::MEMPOOL_NO_BROADCAST, /*force=*/true); 407 408 if (pwallet->IsAbortingRescan()) { 409 throw JSONRPCError(RPC_MISC_ERROR, "Rescan aborted by user."); 410 } 411 412 if (scanned_time > lowest_timestamp) { 413 std::vector<UniValue> results = response.getValues(); 414 response.clear(); 415 response.setArray(); 416 417 // Compose the response 418 for (unsigned int i = 0; i < requests.size(); ++i) { 419 const UniValue& request = requests.getValues().at(i); 420 421 // If the descriptor timestamp is within the successfully scanned 422 // range, or if the import result already has an error set, let 423 // the result stand unmodified. Otherwise replace the result 424 // with an error message. 425 if (scanned_time <= GetImportTimestamp(request, now) || results.at(i).exists("error")) { 426 response.push_back(results.at(i)); 427 } else { 428 std::string error_msg{strprintf("Rescan failed for descriptor with timestamp %d. There " 429 "was an error reading a block from time %d, which is after or within %d seconds " 430 "of key creation, and could contain transactions pertaining to the desc. As a " 431 "result, transactions and coins using this desc may not appear in the wallet.", 432 GetImportTimestamp(request, now), scanned_time - TIMESTAMP_WINDOW - 1, TIMESTAMP_WINDOW)}; 433 if (pwallet->chain().havePruned()) { 434 error_msg += strprintf(" This error could be caused by pruning or data corruption " 435 "(see bitcoind log for details) and could be dealt with by downloading and " 436 "rescanning the relevant blocks (see -reindex option and rescanblockchain RPC)."); 437 } else if (pwallet->chain().hasAssumedValidChain()) { 438 error_msg += strprintf(" This error is likely caused by an in-progress assumeutxo " 439 "background sync. Check logs or getchainstates RPC for assumeutxo background " 440 "sync progress and try again later."); 441 } else { 442 error_msg += strprintf(" This error could potentially caused by data corruption. If " 443 "the issue persists you may want to reindex (see -reindex option)."); 444 } 445 446 UniValue result = UniValue(UniValue::VOBJ); 447 result.pushKV("success", UniValue(false)); 448 result.pushKV("error", JSONRPCError(RPC_MISC_ERROR, error_msg)); 449 response.push_back(std::move(result)); 450 } 451 } 452 } 453 } 454 455 return response; 456 }, 457 }; 458 } 459 460 RPCHelpMan listdescriptors() 461 { 462 return RPCHelpMan{ 463 "listdescriptors", 464 "List all descriptors present in a wallet.\n", 465 { 466 {"private", RPCArg::Type::BOOL, RPCArg::Default{false}, "Show private descriptors."} 467 }, 468 RPCResult{RPCResult::Type::OBJ, "", "", { 469 {RPCResult::Type::STR, "wallet_name", "Name of wallet this operation was performed on"}, 470 {RPCResult::Type::ARR, "descriptors", "Array of descriptor objects (sorted by descriptor string representation)", 471 { 472 {RPCResult::Type::OBJ, "", "", { 473 {RPCResult::Type::STR, "desc", "Descriptor string representation"}, 474 {RPCResult::Type::NUM, "timestamp", "The creation time of the descriptor"}, 475 {RPCResult::Type::BOOL, "active", "Whether this descriptor is currently used to generate new addresses"}, 476 {RPCResult::Type::BOOL, "internal", /*optional=*/true, "True if this descriptor is used to generate change addresses. False if this descriptor is used to generate receiving addresses; defined only for active descriptors"}, 477 {RPCResult::Type::ARR_FIXED, "range", /*optional=*/true, "Defined only for ranged descriptors", { 478 {RPCResult::Type::NUM, "", "Range start inclusive"}, 479 {RPCResult::Type::NUM, "", "Range end inclusive"}, 480 }}, 481 {RPCResult::Type::NUM, "next", /*optional=*/true, "Same as next_index field. Kept for compatibility reason."}, 482 {RPCResult::Type::NUM, "next_index", /*optional=*/true, "The next index to generate addresses from; defined only for ranged descriptors"}, 483 }}, 484 }} 485 }}, 486 RPCExamples{ 487 HelpExampleCli("listdescriptors", "") + HelpExampleRpc("listdescriptors", "") 488 + HelpExampleCli("listdescriptors", "true") + HelpExampleRpc("listdescriptors", "true") 489 }, 490 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue 491 { 492 const std::shared_ptr<const CWallet> wallet = GetWalletForJSONRPCRequest(request); 493 if (!wallet) return UniValue::VNULL; 494 495 const bool priv = !request.params[0].isNull() && request.params[0].get_bool(); 496 if (priv) { 497 EnsureWalletIsUnlocked(*wallet); 498 } 499 500 LOCK(wallet->cs_wallet); 501 502 const auto active_spk_mans = wallet->GetActiveScriptPubKeyMans(); 503 504 struct WalletDescInfo { 505 std::string descriptor; 506 uint64_t creation_time; 507 bool active; 508 std::optional<bool> internal; 509 std::optional<std::pair<int64_t,int64_t>> range; 510 int64_t next_index; 511 }; 512 513 std::vector<WalletDescInfo> wallet_descriptors; 514 for (const auto& spk_man : wallet->GetAllScriptPubKeyMans()) { 515 const auto desc_spk_man = dynamic_cast<DescriptorScriptPubKeyMan*>(spk_man); 516 if (!desc_spk_man) { 517 throw JSONRPCError(RPC_WALLET_ERROR, "Unexpected ScriptPubKey manager type."); 518 } 519 LOCK(desc_spk_man->cs_desc_man); 520 const auto& wallet_descriptor = desc_spk_man->GetWalletDescriptor(); 521 std::string descriptor; 522 if (!desc_spk_man->GetDescriptorString(descriptor, priv)) { 523 throw JSONRPCError(RPC_WALLET_ERROR, "Can't get descriptor string."); 524 } 525 const bool is_range = wallet_descriptor.descriptor->IsRange(); 526 wallet_descriptors.push_back({ 527 descriptor, 528 wallet_descriptor.creation_time, 529 active_spk_mans.count(desc_spk_man) != 0, 530 wallet->IsInternalScriptPubKeyMan(desc_spk_man), 531 is_range ? std::optional(std::make_pair(wallet_descriptor.range_start, wallet_descriptor.range_end)) : std::nullopt, 532 wallet_descriptor.next_index 533 }); 534 } 535 536 std::sort(wallet_descriptors.begin(), wallet_descriptors.end(), [](const auto& a, const auto& b) { 537 return a.descriptor < b.descriptor; 538 }); 539 540 UniValue descriptors(UniValue::VARR); 541 for (const WalletDescInfo& info : wallet_descriptors) { 542 UniValue spk(UniValue::VOBJ); 543 spk.pushKV("desc", info.descriptor); 544 spk.pushKV("timestamp", info.creation_time); 545 spk.pushKV("active", info.active); 546 if (info.internal.has_value()) { 547 spk.pushKV("internal", info.internal.value()); 548 } 549 if (info.range.has_value()) { 550 UniValue range(UniValue::VARR); 551 range.push_back(info.range->first); 552 range.push_back(info.range->second - 1); 553 spk.pushKV("range", std::move(range)); 554 spk.pushKV("next", info.next_index); 555 spk.pushKV("next_index", info.next_index); 556 } 557 descriptors.push_back(std::move(spk)); 558 } 559 560 UniValue response(UniValue::VOBJ); 561 response.pushKV("wallet_name", wallet->GetName()); 562 response.pushKV("descriptors", std::move(descriptors)); 563 564 return response; 565 }, 566 }; 567 } 568 569 RPCHelpMan backupwallet() 570 { 571 return RPCHelpMan{ 572 "backupwallet", 573 "Safely copies the current wallet file to the specified destination, which can either be a directory or a path with a filename.\n", 574 { 575 {"destination", RPCArg::Type::STR, RPCArg::Optional::NO, "The destination directory or file"}, 576 }, 577 RPCResult{RPCResult::Type::NONE, "", ""}, 578 RPCExamples{ 579 HelpExampleCli("backupwallet", "\"backup.dat\"") 580 + HelpExampleRpc("backupwallet", "\"backup.dat\"") 581 }, 582 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue 583 { 584 const std::shared_ptr<const CWallet> pwallet = GetWalletForJSONRPCRequest(request); 585 if (!pwallet) return UniValue::VNULL; 586 587 // Make sure the results are valid at least up to the most recent block 588 // the user could have gotten from another RPC command prior to now 589 pwallet->BlockUntilSyncedToCurrentChain(); 590 591 LOCK(pwallet->cs_wallet); 592 593 std::string strDest = request.params[0].get_str(); 594 if (!pwallet->BackupWallet(strDest)) { 595 throw JSONRPCError(RPC_WALLET_ERROR, "Error: Wallet backup failed!"); 596 } 597 598 return UniValue::VNULL; 599 }, 600 }; 601 } 602 603 604 RPCHelpMan restorewallet() 605 { 606 return RPCHelpMan{ 607 "restorewallet", 608 "Restores and loads a wallet from backup.\n" 609 "\nThe rescan is significantly faster if block filters are available" 610 "\n(using startup option \"-blockfilterindex=1\").\n", 611 { 612 {"wallet_name", RPCArg::Type::STR, RPCArg::Optional::NO, "The name that will be applied to the restored wallet"}, 613 {"backup_file", RPCArg::Type::STR, RPCArg::Optional::NO, "The backup file that will be used to restore the wallet."}, 614 {"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."}, 615 }, 616 RPCResult{ 617 RPCResult::Type::OBJ, "", "", 618 { 619 {RPCResult::Type::STR, "name", "The wallet name if restored successfully."}, 620 {RPCResult::Type::ARR, "warnings", /*optional=*/true, "Warning messages, if any, related to restoring and loading the wallet.", 621 { 622 {RPCResult::Type::STR, "", ""}, 623 }}, 624 } 625 }, 626 RPCExamples{ 627 HelpExampleCli("restorewallet", "\"testwallet\" \"home\\backups\\backup-file.bak\"") 628 + HelpExampleRpc("restorewallet", "\"testwallet\" \"home\\backups\\backup-file.bak\"") 629 + HelpExampleCliNamed("restorewallet", {{"wallet_name", "testwallet"}, {"backup_file", "home\\backups\\backup-file.bak\""}, {"load_on_startup", true}}) 630 + HelpExampleRpcNamed("restorewallet", {{"wallet_name", "testwallet"}, {"backup_file", "home\\backups\\backup-file.bak\""}, {"load_on_startup", true}}) 631 }, 632 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue 633 { 634 635 WalletContext& context = EnsureWalletContext(request.context); 636 637 auto backup_file = fs::u8path(request.params[1].get_str()); 638 639 std::string wallet_name = request.params[0].get_str(); 640 641 std::optional<bool> load_on_start = request.params[2].isNull() ? std::nullopt : std::optional<bool>(request.params[2].get_bool()); 642 643 DatabaseStatus status; 644 bilingual_str error; 645 std::vector<bilingual_str> warnings; 646 647 const std::shared_ptr<CWallet> wallet = RestoreWallet(context, backup_file, wallet_name, load_on_start, status, error, warnings); 648 649 HandleWalletError(wallet, status, error); 650 651 UniValue obj(UniValue::VOBJ); 652 obj.pushKV("name", wallet->GetName()); 653 PushWarnings(warnings, obj); 654 655 return obj; 656 657 }, 658 }; 659 } 660 } // namespace wallet