/tmp/bitcoin/src/wallet/rpc/encrypt.cpp

Source
// Copyright (c) 2011-present The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <rpc/util.h>
#include <scheduler.h>
#include <wallet/context.h>
#include <wallet/rpc/util.h>
#include <wallet/scan.h>
#include <wallet/wallet.h>


namespace wallet {
RPCMethod walletpassphrase()
{
    return RPCMethod{
        "walletpassphrase",
        "Stores the wallet decryption key in memory for 'timeout' seconds.\n"
                "This is needed prior to performing transactions related to private keys such as sending bitcoins\n"
            "\nNote:\n"
            "Issuing the walletpassphrase command while the wallet is already unlocked will set a new unlock\n"
            "time that overrides the old one.\n",
                {
                    {"passphrase", RPCArg::Type::STR, RPCArg::Optional::NO, "The wallet passphrase"},
                    {"timeout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The time to keep the decryption key in seconds; capped at 100000000 (~3 years)."},
                },
                RPCResult{RPCResult::Type::NONE, "", ""},
                RPCExamples{
            "\nUnlock the wallet for 60 seconds\n"
            + HelpExampleCli("walletpassphrase", "\"my pass phrase\" 60") +
            "\nLock the wallet again (before 60 seconds)\n"
            + HelpExampleCli("walletlock", "") +
            "\nAs a JSON-RPC call\n"
            + HelpExampleRpc("walletpassphrase", "\"my pass phrase\", 60")
                },
        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    if (!wallet) return UniValue::VNULL;
    CWallet* const pwallet = wallet.get();

    int64_t nSleepTime;
    int64_t relock_time;
    // Prevent concurrent calls to walletpassphrase with the same wallet.
    LOCK(pwallet->m_unlock_mutex);
    {
        LOCK(pwallet->cs_wallet);

        if (!pwallet->HasEncryptionKeys()) {
            throw JSONRPCError(RPC_WALLET_WRONG_ENC_STATE, "Error: running with an unencrypted wallet, but walletpassphrase was called.");
        }

        // Note that the walletpassphrase is stored in request.params[0] which is not mlock()ed
        SecureString strWalletPass;
        strWalletPass.reserve(100);
        strWalletPass = std::string_view{request.params[0].get_str()};

        // Get the timeout
        nSleepTime = request.params[1].getInt<int64_t>();
        // Timeout cannot be negative, otherwise it will relock immediately
        if (nSleepTime < 0) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, "Timeout cannot be negative.");
        }
        // Clamp timeout to ~3 years to avoid overflow when computing the relock time
        constexpr int64_t MAX_SLEEP_TIME = 100000000;
        if (nSleepTime > MAX_SLEEP_TIME) {
            nSleepTime = MAX_SLEEP_TIME;
        }

        if (strWalletPass.empty()) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, "passphrase cannot be empty");
        }

        if (auto unlocked{pwallet->Unlock(strWalletPass)}; !unlocked) {
            throw JSONRPCError(HandleWalletErrorCode(unlocked.error().code), unlocked.error().message.original);
        }

        pwallet->TopUpKeyPool();

        pwallet->nRelockTime = GetTime() + nSleepTime;
        relock_time = pwallet->nRelockTime;
    }

    // Get wallet scheduler to queue up the relock callback in the future.
    // Scheduled events don't get destructed until they are executed,
    // and they are executed in series in a single scheduler thread so
    // no cs_wallet lock is needed.
    WalletContext& context = EnsureWalletContext(request.context);
    // Keep a weak pointer to the wallet so that it is possible to unload the
    // wallet before the following callback is called. If a valid shared pointer
    // is acquired in the callback then the wallet is still loaded.
    std::weak_ptr<CWallet> weak_wallet = wallet;
    context.scheduler->scheduleFromNow([weak_wallet, relock_time] {
        if (auto shared_wallet = weak_wallet.lock()) {
            LOCK2(shared_wallet->m_relock_mutex, shared_wallet->cs_wallet);
            // Skip if this is not the most recent relock callback.
            if (shared_wallet->nRelockTime != relock_time) return;
            shared_wallet->Lock();
            shared_wallet->nRelockTime = 0;
        }
    }, std::chrono::seconds(nSleepTime));

    return UniValue::VNULL;
},
    };
}


RPCMethod walletpassphrasechange()
{
    return RPCMethod{
        "walletpassphrasechange",
        "Changes the wallet passphrase from 'oldpassphrase' to 'newpassphrase'.\n",
                {
                    {"oldpassphrase", RPCArg::Type::STR, RPCArg::Optional::NO, "The current passphrase"},
                    {"newpassphrase", RPCArg::Type::STR, RPCArg::Optional::NO, "The new passphrase"},
                },
                RPCResult{RPCResult::Type::NONE, "", ""},
                RPCExamples{
                    HelpExampleCli("walletpassphrasechange", "\"old one\" \"new one\"")
            + HelpExampleRpc("walletpassphrasechange", "\"old one\", \"new one\"")
                },
        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
{
    std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
    if (!pwallet) return UniValue::VNULL;

    if (!pwallet->HasEncryptionKeys()) {
        throw JSONRPCError(RPC_WALLET_WRONG_ENC_STATE, "Error: running with an unencrypted wallet, but walletpassphrasechange was called.");
    }

    if (pwallet->Scanner().IsScanningWithPassphrase()) {
        throw JSONRPCError(RPC_WALLET_ERROR, "Error: the wallet is currently being used to rescan the blockchain for related transactions. Please call `abortrescan` before changing the passphrase.");
    }

    LOCK2(pwallet->m_relock_mutex, pwallet->cs_wallet);

    SecureString strOldWalletPass;
    strOldWalletPass.reserve(100);
    strOldWalletPass = std::string_view{request.params[0].get_str()};

    SecureString strNewWalletPass;
    strNewWalletPass.reserve(100);
    strNewWalletPass = std::string_view{request.params[1].get_str()};

    if (strOldWalletPass.empty() || strNewWalletPass.empty()) {
        throw JSONRPCError(RPC_INVALID_PARAMETER, "passphrase cannot be empty");
    }

    if (auto changed{pwallet->ChangeWalletPassphrase(strOldWalletPass, strNewWalletPass)}; !changed) {
        throw JSONRPCError(HandleWalletErrorCode(changed.error().code), changed.error().message.original);
    }

    return UniValue::VNULL;
},
    };
}


RPCMethod walletlock()
{
    return RPCMethod{
        "walletlock",
        "Removes the wallet encryption key from memory, locking the wallet.\n"
                "After calling this method, you will need to call walletpassphrase again\n"
                "before being able to call any methods which require the wallet to be unlocked.\n",
                {},
                RPCResult{RPCResult::Type::NONE, "", ""},
                RPCExamples{
            "\nSet the passphrase for 2 minutes to perform a transaction\n"
            + HelpExampleCli("walletpassphrase", "\"my pass phrase\" 120") +
            "\nPerform a send (requires passphrase set)\n"
            + HelpExampleCli("sendtoaddress", "\"" + EXAMPLE_ADDRESS[0] + "\" 1.0") +
            "\nClear the passphrase since we are done before 2 minutes is up\n"
            + HelpExampleCli("walletlock", "") +
            "\nAs a JSON-RPC call\n"
            + HelpExampleRpc("walletlock", "")
                },
        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
{
    std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
    if (!pwallet) return UniValue::VNULL;

    if (!pwallet->HasEncryptionKeys()) {
        throw JSONRPCError(RPC_WALLET_WRONG_ENC_STATE, "Error: running with an unencrypted wallet, but walletlock was called.");
    }

    if (pwallet->Scanner().IsScanningWithPassphrase()) {
        throw JSONRPCError(RPC_WALLET_ERROR, "Error: the wallet is currently being used to rescan the blockchain for related transactions. Please call `abortrescan` before locking the wallet.");
    }

    LOCK2(pwallet->m_relock_mutex, pwallet->cs_wallet);

    pwallet->Lock();
    pwallet->nRelockTime = 0;

    return UniValue::VNULL;
},
    };
}


RPCMethod encryptwallet()
{
    return RPCMethod{
        "encryptwallet",
        "Encrypts the wallet with 'passphrase'. This is for first time encryption.\n"
        "After this, any calls that interact with private keys such as sending or signing \n"
        "will require the passphrase to be set prior to making these calls.\n"
                "Use the walletpassphrase call for this, and then walletlock call.\n"
                "If the wallet is already encrypted, use the walletpassphrasechange call.\n"
                "** IMPORTANT **\n"
                "For security reasons, the encryption process will generate a new HD seed, resulting\n"
                "in the creation of a fresh set of active descriptors. Therefore, it is crucial to\n"
                "securely back up the newly generated wallet file using the backupwallet RPC.\n",
                {
                    {"passphrase", RPCArg::Type::STR, RPCArg::Optional::NO, "The pass phrase to encrypt the wallet with. It must be at least 1 character, but should be long."},
                },
                RPCResult{RPCResult::Type::STR, "", "A string with further instructions"},
                RPCExamples{
            "\nEncrypt your wallet\n"
            + HelpExampleCli("encryptwallet", "\"my pass phrase\"") +
            "\nNow set the passphrase to use the wallet, such as for signing or sending bitcoin\n"
            + HelpExampleCli("walletpassphrase", "\"my pass phrase\"") +
            "\nNow we can do something like sign\n"
            + HelpExampleCli("signmessage", "\"address\" \"test message\"") +
            "\nNow lock the wallet again by removing the passphrase\n"
            + HelpExampleCli("walletlock", "") +
            "\nAs a JSON-RPC call\n"
            + HelpExampleRpc("encryptwallet", "\"my pass phrase\"")
                },
        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
{
    std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
    if (!pwallet) return UniValue::VNULL;

    if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
        throw JSONRPCError(RPC_WALLET_ENCRYPTION_FAILED, "Error: wallet does not contain private keys, nothing to encrypt.");
    }

    if (pwallet->HasEncryptionKeys()) {
        throw JSONRPCError(RPC_WALLET_WRONG_ENC_STATE, "Error: running with an encrypted wallet, but encryptwallet was called.");
    }

    if (pwallet->Scanner().IsScanningWithPassphrase()) {
        throw JSONRPCError(RPC_WALLET_ERROR, "Error: the wallet is currently being used to rescan the blockchain for related transactions. Please call `abortrescan` before encrypting the wallet.");
    }

    LOCK2(pwallet->m_relock_mutex, pwallet->cs_wallet);

    SecureString strWalletPass;
    strWalletPass.reserve(100);
    strWalletPass = std::string_view{request.params[0].get_str()};

    if (strWalletPass.empty()) {
        throw JSONRPCError(RPC_INVALID_PARAMETER, "passphrase cannot be empty");
    }

    if (!pwallet->EncryptWallet(strWalletPass)) {
        throw JSONRPCError(RPC_WALLET_ENCRYPTION_FAILED, "Error: Failed to encrypt the wallet.");
    }

    return "wallet encrypted; The keypool has been flushed and a new HD seed was generated. You need to make a new backup with the backupwallet RPC.";
},
    };
}
} // namespace wallet

Coverage Report

Created: 2026-10-03 10:33

Line	Count	Source
1		// Copyright (c) 2011-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 <rpc/util.h>
6		#include <scheduler.h>
7		#include <wallet/context.h>
8		#include <wallet/rpc/util.h>
9		#include <wallet/scan.h>
10		#include <wallet/wallet.h>
11
12
13		namespace wallet {
14		RPCMethod walletpassphrase()
15	933	{
16	933	return RPCMethod{
17	933	"walletpassphrase",
18	933	"Stores the wallet decryption key in memory for 'timeout' seconds.\n"
19	933	"This is needed prior to performing transactions related to private keys such as sending bitcoins\n"
20	933	"\nNote:\n"
21	933	"Issuing the walletpassphrase command while the wallet is already unlocked will set a new unlock\n"
22	933	"time that overrides the old one.\n",
23	933	{
24	933	{"passphrase", RPCArg::Type::STR, RPCArg::Optional::NO, "The wallet passphrase"},
25	933	{"timeout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The time to keep the decryption key in seconds; capped at 100000000 (~3 years)."},
26	933	},
27	933	RPCResult{RPCResult::Type::NONE, "", ""},
28	933	RPCExamples{
29	933	"\nUnlock the wallet for 60 seconds\n"
30	933	+ HelpExampleCli("walletpassphrase", "\"my pass phrase\" 60") +
31	933	"\nLock the wallet again (before 60 seconds)\n"
32	933	+ HelpExampleCli("walletlock", "") +
33	933	"\nAs a JSON-RPC call\n"
34	933	+ HelpExampleRpc("walletpassphrase", "\"my pass phrase\", 60")
35	933	},
36	933	[](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
37	933	{
38	62	std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
39	62	if (!wallet) return UniValue::VNULL;
40	62	CWallet* const pwallet = wallet.get();
41
42	62	int64_t nSleepTime;
43	62	int64_t relock_time;
44		// Prevent concurrent calls to walletpassphrase with the same wallet.
45	62	LOCK(pwallet->m_unlock_mutex);
46	62	{
47	62	LOCK(pwallet->cs_wallet);
48
49	62	if (!pwallet->HasEncryptionKeys()) {
50	6	throw JSONRPCError(RPC_WALLET_WRONG_ENC_STATE, "Error: running with an unencrypted wallet, but walletpassphrase was called.");
51	6	}
52
53		// Note that the walletpassphrase is stored in request.params[0] which is not mlock()ed
54	56	SecureString strWalletPass;
55	56	strWalletPass.reserve(100);
56	56	strWalletPass = std::string_view{request.params[0].get_str()};
57
58		// Get the timeout
59	56	nSleepTime = request.params[1].getInt<int64_t>();
60		// Timeout cannot be negative, otherwise it will relock immediately
61	56	if (nSleepTime < 0) {
62	1	throw JSONRPCError(RPC_INVALID_PARAMETER, "Timeout cannot be negative.");
63	1	}
64		// Clamp timeout to ~3 years to avoid overflow when computing the relock time
65	55	constexpr int64_t MAX_SLEEP_TIME = 100000000;
66	55	if (nSleepTime > MAX_SLEEP_TIME) {
67	1	nSleepTime = MAX_SLEEP_TIME;
68	1	}
69
70	55	if (strWalletPass.empty()) {
71	1	throw JSONRPCError(RPC_INVALID_PARAMETER, "passphrase cannot be empty");
72	1	}
73
74	54	if (auto unlocked{pwallet->Unlock(strWalletPass)}; !unlocked) {
75	4	throw JSONRPCError(HandleWalletErrorCode(unlocked.error().code), unlocked.error().message.original);
76	4	}
77
78	50	pwallet->TopUpKeyPool();
79
80	50	pwallet->nRelockTime = GetTime() + nSleepTime;
81	50	relock_time = pwallet->nRelockTime;
82	50	}
83
84		// Get wallet scheduler to queue up the relock callback in the future.
85		// Scheduled events don't get destructed until they are executed,
86		// and they are executed in series in a single scheduler thread so
87		// no cs_wallet lock is needed.
88	0	WalletContext& context = EnsureWalletContext(request.context);
89		// Keep a weak pointer to the wallet so that it is possible to unload the
90		// wallet before the following callback is called. If a valid shared pointer
91		// is acquired in the callback then the wallet is still loaded.
92	50	std::weak_ptr<CWallet> weak_wallet = wallet;
93	50	context.scheduler->scheduleFromNow([weak_wallet, relock_time] {
94	5	if (auto shared_wallet = weak_wallet.lock()) {
95	3	LOCK2(shared_wallet->m_relock_mutex, shared_wallet->cs_wallet);
96		// Skip if this is not the most recent relock callback.
97	3	if (shared_wallet->nRelockTime != relock_time) return;
98	3	shared_wallet->Lock();
99	3	shared_wallet->nRelockTime = 0;
100	3	}
101	5	}, std::chrono::seconds(nSleepTime));
102
103	50	return UniValue::VNULL;
104	54	},
105	933	};
106	933	}
107
108
109		RPCMethod walletpassphrasechange()
110	878	{
111	878	return RPCMethod{
112	878	"walletpassphrasechange",
113	878	"Changes the wallet passphrase from 'oldpassphrase' to 'newpassphrase'.\n",
114	878	{
115	878	{"oldpassphrase", RPCArg::Type::STR, RPCArg::Optional::NO, "The current passphrase"},
116	878	{"newpassphrase", RPCArg::Type::STR, RPCArg::Optional::NO, "The new passphrase"},
117	878	},
118	878	RPCResult{RPCResult::Type::NONE, "", ""},
119	878	RPCExamples{
120	878	HelpExampleCli("walletpassphrasechange", "\"old one\" \"new one\"")
121	878	+ HelpExampleRpc("walletpassphrasechange", "\"old one\", \"new one\"")
122	878	},
123	878	[](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
124	878	{
125	7	std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
126	7	if (!pwallet) return UniValue::VNULL;
127
128	7	if (!pwallet->HasEncryptionKeys()) {
129	1	throw JSONRPCError(RPC_WALLET_WRONG_ENC_STATE, "Error: running with an unencrypted wallet, but walletpassphrasechange was called.");
130	1	}
131
132	6	if (pwallet->Scanner().IsScanningWithPassphrase()) {
133	1	throw JSONRPCError(RPC_WALLET_ERROR, "Error: the wallet is currently being used to rescan the blockchain for related transactions. Please call `abortrescan` before changing the passphrase.");
134	1	}
135
136	5	LOCK2(pwallet->m_relock_mutex, pwallet->cs_wallet);
137
138	5	SecureString strOldWalletPass;
139	5	strOldWalletPass.reserve(100);
140	5	strOldWalletPass = std::string_view{request.params[0].get_str()};
141
142	5	SecureString strNewWalletPass;
143	5	strNewWalletPass.reserve(100);
144	5	strNewWalletPass = std::string_view{request.params[1].get_str()};
145
146	5	if (strOldWalletPass.empty() \|\| strNewWalletPass.empty()) {
147	1	throw JSONRPCError(RPC_INVALID_PARAMETER, "passphrase cannot be empty");
148	1	}
149
150	4	if (auto changed{pwallet->ChangeWalletPassphrase(strOldWalletPass, strNewWalletPass)}; !changed) {
151	2	throw JSONRPCError(HandleWalletErrorCode(changed.error().code), changed.error().message.original);
152	2	}
153
154	2	return UniValue::VNULL;
155	4	},
156	878	};
157	878	}
158
159
160		RPCMethod walletlock()
161	899	{
162	899	return RPCMethod{
163	899	"walletlock",
164	899	"Removes the wallet encryption key from memory, locking the wallet.\n"
165	899	"After calling this method, you will need to call walletpassphrase again\n"
166	899	"before being able to call any methods which require the wallet to be unlocked.\n",
167	899	{},
168	899	RPCResult{RPCResult::Type::NONE, "", ""},
169	899	RPCExamples{
170	899	"\nSet the passphrase for 2 minutes to perform a transaction\n"
171	899	+ HelpExampleCli("walletpassphrase", "\"my pass phrase\" 120") +
172	899	"\nPerform a send (requires passphrase set)\n"
173	899	+ HelpExampleCli("sendtoaddress", "\"" + EXAMPLE_ADDRESS[0] + "\" 1.0") +
174	899	"\nClear the passphrase since we are done before 2 minutes is up\n"
175	899	+ HelpExampleCli("walletlock", "") +
176	899	"\nAs a JSON-RPC call\n"
177	899	+ HelpExampleRpc("walletlock", "")
178	899	},
179	899	[](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
180	899	{
181	28	std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
182	28	if (!pwallet) return UniValue::VNULL;
183
184	28	if (!pwallet->HasEncryptionKeys()) {
185	0	throw JSONRPCError(RPC_WALLET_WRONG_ENC_STATE, "Error: running with an unencrypted wallet, but walletlock was called.");
186	0	}
187
188	28	if (pwallet->Scanner().IsScanningWithPassphrase()) {
189	1	throw JSONRPCError(RPC_WALLET_ERROR, "Error: the wallet is currently being used to rescan the blockchain for related transactions. Please call `abortrescan` before locking the wallet.");
190	1	}
191
192	27	LOCK2(pwallet->m_relock_mutex, pwallet->cs_wallet);
193
194	27	pwallet->Lock();
195	27	pwallet->nRelockTime = 0;
196
197	27	return UniValue::VNULL;
198	28	},
199	899	};
200	899	}
201
202
203		RPCMethod encryptwallet()
204	893	{
205	893	return RPCMethod{
206	893	"encryptwallet",
207	893	"Encrypts the wallet with 'passphrase'. This is for first time encryption.\n"
208	893	"After this, any calls that interact with private keys such as sending or signing \n"
209	893	"will require the passphrase to be set prior to making these calls.\n"
210	893	"Use the walletpassphrase call for this, and then walletlock call.\n"
211	893	"If the wallet is already encrypted, use the walletpassphrasechange call.\n"
212	893	" IMPORTANT \n"
213	893	"For security reasons, the encryption process will generate a new HD seed, resulting\n"
214	893	"in the creation of a fresh set of active descriptors. Therefore, it is crucial to\n"
215	893	"securely back up the newly generated wallet file using the backupwallet RPC.\n",
216	893	{
217	893	{"passphrase", RPCArg::Type::STR, RPCArg::Optional::NO, "The pass phrase to encrypt the wallet with. It must be at least 1 character, but should be long."},
218	893	},
219	893	RPCResult{RPCResult::Type::STR, "", "A string with further instructions"},
220	893	RPCExamples{
221	893	"\nEncrypt your wallet\n"
222	893	+ HelpExampleCli("encryptwallet", "\"my pass phrase\"") +
223	893	"\nNow set the passphrase to use the wallet, such as for signing or sending bitcoin\n"
224	893	+ HelpExampleCli("walletpassphrase", "\"my pass phrase\"") +
225	893	"\nNow we can do something like sign\n"
226	893	+ HelpExampleCli("signmessage", "\"address\" \"test message\"") +
227	893	"\nNow lock the wallet again by removing the passphrase\n"
228	893	+ HelpExampleCli("walletlock", "") +
229	893	"\nAs a JSON-RPC call\n"
230	893	+ HelpExampleRpc("encryptwallet", "\"my pass phrase\"")
231	893	},
232	893	[](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
233	893	{
234	22	std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
235	22	if (!pwallet) return UniValue::VNULL;
236
237	22	if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
238	3	throw JSONRPCError(RPC_WALLET_ENCRYPTION_FAILED, "Error: wallet does not contain private keys, nothing to encrypt.");
239	3	}
240
241	19	if (pwallet->HasEncryptionKeys()) {
242	1	throw JSONRPCError(RPC_WALLET_WRONG_ENC_STATE, "Error: running with an encrypted wallet, but encryptwallet was called.");
243	1	}
244
245	18	if (pwallet->Scanner().IsScanningWithPassphrase()) {
246	0	throw JSONRPCError(RPC_WALLET_ERROR, "Error: the wallet is currently being used to rescan the blockchain for related transactions. Please call `abortrescan` before encrypting the wallet.");
247	0	}
248
249	18	LOCK2(pwallet->m_relock_mutex, pwallet->cs_wallet);
250
251	18	SecureString strWalletPass;
252	18	strWalletPass.reserve(100);
253	18	strWalletPass = std::string_view{request.params[0].get_str()};
254
255	18	if (strWalletPass.empty()) {
256	1	throw JSONRPCError(RPC_INVALID_PARAMETER, "passphrase cannot be empty");
257	1	}
258
259	17	if (!pwallet->EncryptWallet(strWalletPass)) {
260	0	throw JSONRPCError(RPC_WALLET_ENCRYPTION_FAILED, "Error: Failed to encrypt the wallet.");
261	0	}
262
263	17	return "wallet encrypted; The keypool has been flushed and a new HD seed was generated. You need to make a new backup with the backupwallet RPC.";
264	17	},
265	893	};
266	893	}
267		} // namespace wallet