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