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