251                    + HelpExampleCli("loadwallet", "\"DriveLetter:\\path\\to\\walletname\\\"")
252                    + HelpExampleRpc("loadwallet", R"("DriveLetter:\\path\\to\\walletname")")
253                },
254        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
255{
256    WalletContext& context = EnsureWalletContext(request.context);
257    const std::string name(request.params[0].get_str());
258
259    DatabaseOptions options;
260    DatabaseStatus status;
261    ReadDatabaseArgs(*context.args, options);
262    options.require_existing = true;
263    bilingual_str error;
264    std::vector<bilingual_str> warnings;
265    std::optional<bool> load_on_start = request.params[1].isNull() ? std::nullopt : std::optional<bool>(request.params[1].get_bool());
266
267    {
268        LOCK(context.wallets_mutex);
269        if (std::any_of(context.wallets.begin(), context.wallets.end(), [&name](const auto& wallet) { return wallet->GetName() == name; })) {
270            throw JSONRPCError(RPC_WALLET_ALREADY_LOADED, "Wallet \"" + name + "\" is already loaded.");
271        }
272    }
273
274    std::shared_ptr<CWallet> const wallet = LoadWallet(context, name, load_on_start, options, status, error, warnings);
275
276    HandleWalletError(wallet, status, error);
277
278    UniValue obj(UniValue::VOBJ);
279    obj.pushKV("name", wallet->GetName());
280    PushWarnings(warnings, obj);
281
282    return obj;
283},
284    };
285}
286
287static RPCMethod setwalletflag()
288{
289            std::string flags;
290            for (auto& it : STRING_TO_WALLET_FLAG)
291                if (it.second & MUTABLE_WALLET_FLAGS)
292                    flags += (flags == "" ? "" : ", ") + it.first;
293
294    return RPCMethod{
295        "setwalletflag",
296        "Change the state of the given wallet flag for a wallet.\n",
297                {
298                    {"flag", RPCArg::Type::STR, RPCArg::Optional::NO, "The name of the flag to change. Current available flags: " + flags},
299                    {"value", RPCArg::Type::BOOL, RPCArg::Default{true}, "The new state."},
300                },
301                RPCResult{
302                    RPCResult::Type::OBJ, "", "",
303                    {
304                        {RPCResult::Type::STR, "flag_name", "The name of the flag that was modified"},
305                        {RPCResult::Type::BOOL, "flag_state", "The new state of the flag"},
306                        {RPCResult::Type::STR, "warnings", /*optional=*/true, "Any warnings associated with the change"},
307                    }
308                },
309                RPCExamples{
310                    HelpExampleCli("setwalletflag", "avoid_reuse")
311                  + HelpExampleRpc("setwalletflag", "\"avoid_reuse\"")
312                },
313        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
314{
315    std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
316    if (!pwallet) return UniValue::VNULL;
317
318    std::string flag_str = request.params[0].get_str();
319    bool value = request.params[1].isNull() || request.params[1].get_bool();
320
321    if (!STRING_TO_WALLET_FLAG.contains(flag_str)) {
322        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Unknown wallet flag: %s", flag_str));
323    }
324
325    auto flag = STRING_TO_WALLET_FLAG.at(flag_str);
326
327    if (!(flag & MUTABLE_WALLET_FLAGS)) {
328        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Wallet flag is immutable: %s", flag_str));
329    }
330
331    UniValue res(UniValue::VOBJ);
332
333    if (pwallet->IsWalletFlagSet(flag) == value) {
334        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Wallet flag is already set to %s: %s", value ? "true" : "false", flag_str));
335    }
336
337    res.pushKV("flag_name", flag_str);
338    res.pushKV("flag_state", value);
339
340    if (value) {
341        pwallet->SetWalletFlag(flag);
342    } else {
343        pwallet->UnsetWalletFlag(flag);
344    }
345
346    if (flag && value && WALLET_FLAG_CAVEATS.contains(flag)) {
347        res.pushKV("warnings", WALLET_FLAG_CAVEATS.at(flag));
348    }
349
350    return res;
351},
352    };
353}
354
355static RPCMethod createwallet()
356{
357    return RPCMethod{
358        "createwallet",
359        "Creates and loads a new wallet.\n",
360        {
361            {"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."},
362            {"disable_private_keys", RPCArg::Type::BOOL, RPCArg::Default{false}, "Disable the possibility of private keys (only watchonlys are possible in this mode)."},
363            {"blank", RPCArg::Type::BOOL, RPCArg::Default{false}, "Create a blank wallet. A blank wallet has no keys."},
364            {"passphrase", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "Encrypt the wallet with this passphrase."},
365            {"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."},
366            {"descriptors", RPCArg::Type::BOOL, RPCArg::Default{true}, "If set, must be \"true\""},
367            {"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."},
368            {"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."},
369        },
370        RPCResult{
371            RPCResult::Type::OBJ, "", "",
372            {
373                {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."},
374                {RPCResult::Type::ARR, "warnings", /*optional=*/true, "Warning messages, if any, related to creating and loading the wallet.",
375                {
376                    {RPCResult::Type::STR, "", ""},
377                }},
378            }
379        },
380        RPCExamples{
381            HelpExampleCli("createwallet", "\"testwallet\"")
382            + HelpExampleRpc("createwallet", "\"testwallet\"")
383            + HelpExampleCliNamed("createwallet", {{"wallet_name", "descriptors"}, {"avoid_reuse", true}, {"load_on_startup", true}})
384            + HelpExampleRpcNamed("createwallet", {{"wallet_name", "descriptors"}, {"avoid_reuse", true}, {"load_on_startup", true}})
385        },
386        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
387{
388    WalletContext& context = EnsureWalletContext(request.context);
389    uint64_t flags = 0;
390    if (!request.params[1].isNull() && request.params[1].get_bool()) {
391        flags |= WALLET_FLAG_DISABLE_PRIVATE_KEYS;
392    }
393
394    if (!request.params[2].isNull() && request.params[2].get_bool()) {
395        flags |= WALLET_FLAG_BLANK_WALLET;
396    }
397    SecureString passphrase;
398    passphrase.reserve(100);
399    std::vector<bilingual_str> warnings;
400    if (!request.params[3].isNull()) {
401        passphrase = std::string_view{request.params[3].get_str()};
402        if (passphrase.empty()) {
403            // Empty string means unencrypted
404            warnings.emplace_back(Untranslated("Empty string given as passphrase, wallet will not be encrypted."));
405        }
406    }
407
408    if (!request.params[4].isNull() && request.params[4].get_bool()) {
409        flags |= WALLET_FLAG_AVOID_REUSE;
410    }
411    flags |= WALLET_FLAG_DESCRIPTORS;
412    if (!self.Arg<bool>("descriptors")) {
413        throw JSONRPCError(RPC_WALLET_ERROR, "descriptors argument must be set to \"true\"; it is no longer possible to create a legacy wallet.");
414    }
415    if (!request.params[7].isNull() && request.params[7].get_bool()) {
416#ifdef ENABLE_EXTERNAL_SIGNER
417        flags |= WALLET_FLAG_EXTERNAL_SIGNER;
418#else
419        throw JSONRPCError(RPC_WALLET_ERROR, "Compiled without external signing support (required for external signing)");
420#endif
421    }
422
423    DatabaseOptions options;
424    DatabaseStatus status;
425    ReadDatabaseArgs(*context.args, options);
426    options.require_create = true;
427    options.create_flags = flags;
428    options.create_passphrase = passphrase;
429    bilingual_str error;
430    std::optional<bool> load_on_start = request.params[6].isNull() ? std::nullopt : std::optional<bool>(request.params[6].get_bool());
431    const std::shared_ptr<CWallet> wallet = CreateWallet(context, request.params[0].get_str(), load_on_start, options, status, error, warnings);
432    HandleWalletError(wallet, status, error);
433
434    UniValue obj(UniValue::VOBJ);
435    obj.pushKV("name", wallet->GetName());
436    PushWarnings(warnings, obj);
437
438    return obj;
439},
440    };
441}
442
443static RPCMethod unloadwallet()
444{
445    return RPCMethod{"unloadwallet",
446                "Unloads the wallet referenced by the request endpoint or the wallet_name argument.\n"
447                "If both are specified, they must be identical.",
448                {
449                    {"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."},
450                    {"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."},
451                },
452                RPCResult{RPCResult::Type::OBJ, "", "", {
453                    {RPCResult::Type::ARR, "warnings", /*optional=*/true, "Warning messages, if any, related to unloading the wallet.",
454                    {
455                        {RPCResult::Type::STR, "", ""},
456                    }},
457                }},
458                RPCExamples{
459                    HelpExampleCli("unloadwallet", "wallet_name")
460            + HelpExampleRpc("unloadwallet", R"("wallet_name")")
461                },
462        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
463{
464    const std::string wallet_name{EnsureUniqueWalletName(request, self.MaybeArg<std::string_view>("wallet_name"))};
465
466    WalletContext& context = EnsureWalletContext(request.context);
467    std::shared_ptr<CWallet> wallet = GetWallet(context, wallet_name);
468    if (!wallet) {
469        throw JSONRPCError(RPC_WALLET_NOT_FOUND, "Requested wallet does not exist or is not loaded");
470    }
471
472    std::vector<bilingual_str> warnings;
473    {
474        WalletRescanReserver reserver(*wallet);
475        if (!reserver.reserve()) {
476            throw JSONRPCError(RPC_WALLET_ERROR, "Wallet is currently rescanning. Abort existing rescan or wait.");
477        }
478
479        // Release the "main" shared pointer and prevent further notifications.
480        // Note that any attempt to load the same wallet would fail until the wallet
481        // is destroyed (see CheckUniqueFileid).
482        std::optional<bool> load_on_start{self.MaybeArg<bool>("load_on_startup")};
483        if (!RemoveWallet(context, wallet, load_on_start, warnings)) {
484            throw JSONRPCError(RPC_MISC_ERROR, "Requested wallet already unloaded");
485        }
486    }
487
488    WaitForDeleteWallet(std::move(wallet));
489
490    UniValue result(UniValue::VOBJ);
491    PushWarnings(warnings, result);
492
493    return result;
494},
495    };
496}
497
498RPCMethod simulaterawtransaction()
499{
500    return RPCMethod{