5 #if defined(HAVE_CONFIG_H)
42 std::stringstream
ret;
43 for (
const unsigned char c : str) {
44 if (c <= 32 || c >= 128 || c ==
'%') {
54 std::stringstream
ret;
55 for (
unsigned int pos = 0; pos < str.length(); pos++) {
56 unsigned char c = str[pos];
57 if (c ==
'%' && pos+2 < str.length()) {
58 c = (((str[pos+1]>>6)*9+((str[pos+1]-
'0')&15)) << 4) |
59 ((str[pos+2]>>6)*9+((str[pos+2]-
'0')&15));
69 bool fLabelFound =
false;
71 spk_man->GetKey(keyid, key);
73 const auto* address_book_entry =
wallet.FindAddressBookEntry(dest);
74 if (address_book_entry) {
75 if (!strAddr.empty()) {
93 int64_t scanned_time =
wallet.RescanFromTime(time_begin, reserver, update);
94 if (
wallet.IsAbortingRescan()) {
96 }
else if (scanned_time > time_begin) {
103 auto& chain{
wallet.chain()};
104 if (!chain.havePruned()) {
112 if (found && !chain.hasBlocks(tip_hash, height)) {
120 "\nAdds a private key (as returned by dumpprivkey) to your wallet. Requires a new wallet backup.\n"
121 "Hint: use importmulti to import more than one private key.\n"
122 "\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\n"
123 "may report that the imported key exists but related transactions are still missing, leading to temporarily incorrect/bogus balances and unspent outputs until rescan completes.\n"
124 "The rescan parameter can be set to false if the key was never used to create transactions. If it is set to false,\n"
125 "but the key was used to create transactions, rescanblockchain needs to be called with the appropriate block range.\n"
126 "Note: Use \"getwalletinfo\" to query the scanning progress.\n"
127 "Note: This command is only compatible with legacy wallets. Use \"importdescriptors\" with \"combo(X)\" for descriptor wallets.\n",
135 "\nDump a private key\n"
137 "\nImport the private key with rescan\n"
139 "\nImport using a label and without rescan\n"
140 +
HelpExampleCli(
"importprivkey",
"\"mykey\" \"testing\" false") +
141 "\nImport using default blank label and without rescan\n"
143 "\nAs a JSON-RPC call\n"
144 +
HelpExampleRpc(
"importprivkey",
"\"mykey\", \"testing\", false")
160 LOCK(pwallet->cs_wallet);
164 std::string strSecret = request.params[0].get_str();
168 if (!request.params[2].isNull())
169 fRescan = request.params[2].get_bool();
171 if (fRescan && pwallet->chain().havePruned()) {
178 if (fRescan && !reserver.
reserve()) {
189 pwallet->MarkDirty();
195 if (!request.params[1].isNull() || !pwallet->FindAddressBookEntry(dest)) {
201 if (!pwallet->ImportPrivKeys({{vchAddress, key}}, 1)) {
223 "\nAdds an address or script (in hex) that can be watched as if it were in your wallet but cannot be used to spend. Requires a new wallet backup.\n"
224 "\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\n"
225 "may report that the imported address exists but related transactions are still missing, leading to temporarily incorrect/bogus balances and unspent outputs until rescan completes.\n"
226 "The rescan parameter can be set to false if the key was never used to create transactions. If it is set to false,\n"
227 "but the key was used to create transactions, rescanblockchain needs to be called with the appropriate block range.\n"
228 "If you have the full public key, you should call importpubkey instead of this.\n"
229 "Hint: use importmulti to import more than one address.\n"
230 "\nNote: If you import a non-standard raw script in hex form, outputs sending to it will be treated\n"
231 "as change, and not show up in many RPCs.\n"
232 "Note: Use \"getwalletinfo\" to query the scanning progress.\n"
233 "Note: This command is only compatible with legacy wallets. Use \"importdescriptors\" for descriptor wallets.\n",
242 "\nImport an address with rescan\n"
244 "\nImport using a label without rescan\n"
245 +
HelpExampleCli(
"importaddress",
"\"myaddress\" \"testing\" false") +
246 "\nAs a JSON-RPC call\n"
247 +
HelpExampleRpc(
"importaddress",
"\"myaddress\", \"testing\", false")
260 if (!request.params[2].isNull())
261 fRescan = request.params[2].get_bool();
263 if (fRescan && pwallet->chain().havePruned()) {
271 if (fRescan && !reserver.
reserve()) {
277 if (!request.params[3].isNull())
278 fP2SH = request.params[3].get_bool();
281 LOCK(pwallet->cs_wallet);
292 pwallet->MarkDirty();
295 }
else if (
IsHex(request.params[0].get_str())) {
296 std::vector<unsigned char> data(
ParseHex(request.params[0].get_str()));
297 CScript redeem_script(data.begin(), data.end());
299 std::set<CScript> scripts = {redeem_script};
300 pwallet->ImportScripts(scripts, 0);
306 pwallet->ImportScriptPubKeys(strLabel, scripts,
false,
true, 1);
314 pwallet->ResubmitWalletTransactions(
false,
true);
325 "\nImports 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",
338 if (!
DecodeHexTx(tx, request.params[0].get_str())) {
348 std::vector<uint256> vMatch;
349 std::vector<unsigned int> vIndex;
354 LOCK(pwallet->cs_wallet);
356 if (!pwallet->chain().findAncestorByHash(pwallet->GetLastBlockHash(), merkleBlock.
header.
GetHash(),
FoundBlock().height(height))) {
360 std::vector<uint256>::const_iterator it;
361 if ((it = std::find(vMatch.begin(), vMatch.end(), hashTx)) == vMatch.end()) {
365 unsigned int txnIndex = vIndex[it - vMatch.begin()];
368 if (pwallet->IsMine(*tx_ref)) {
381 "\nDeletes the specified transaction from the wallet. Meant for use with pruned wallets and as a companion to importprunedfunds. This will affect wallet balances.\n",
387 HelpExampleCli(
"removeprunedfunds",
"\"a8d0c0184dde994a09ec054286f1ce581bebf46446a512166eae7628734ea0a5\"") +
388 "\nAs a JSON-RPC call\n"
389 +
HelpExampleRpc(
"removeprunedfunds",
"\"a8d0c0184dde994a09ec054286f1ce581bebf46446a512166eae7628734ea0a5\"")
396 LOCK(pwallet->cs_wallet);
399 std::vector<uint256> vHash;
400 vHash.push_back(hash);
401 if (
auto res = pwallet->RemoveTxs(vHash); !res) {
413 "\nAdds a public key (in hex) that can be watched as if it were in your wallet but cannot be used to spend. Requires a new wallet backup.\n"
414 "Hint: use importmulti to import more than one public key.\n"
415 "\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\n"
416 "may report that the imported pubkey exists but related transactions are still missing, leading to temporarily incorrect/bogus balances and unspent outputs until rescan completes.\n"
417 "The rescan parameter can be set to false if the key was never used to create transactions. If it is set to false,\n"
418 "but the key was used to create transactions, rescanblockchain needs to be called with the appropriate block range.\n"
419 "Note: Use \"getwalletinfo\" to query the scanning progress.\n"
420 "Note: This command is only compatible with legacy wallets. Use \"importdescriptors\" with \"combo(X)\" for descriptor wallets.\n",
428 "\nImport a public key with rescan\n"
430 "\nImport using a label without rescan\n"
431 +
HelpExampleCli(
"importpubkey",
"\"mypubkey\" \"testing\" false") +
432 "\nAs a JSON-RPC call\n"
433 +
HelpExampleRpc(
"importpubkey",
"\"mypubkey\", \"testing\", false")
446 if (!request.params[2].isNull())
447 fRescan = request.params[2].get_bool();
449 if (fRescan && pwallet->chain().havePruned()) {
457 if (fRescan && !reserver.
reserve()) {
461 if (!
IsHex(request.params[0].get_str()))
463 std::vector<unsigned char> data(
ParseHex(request.params[0].get_str()));
469 LOCK(pwallet->cs_wallet);
471 std::set<CScript> script_pub_keys;
476 pwallet->MarkDirty();
478 pwallet->ImportScriptPubKeys(strLabel, script_pub_keys,
true,
true, 1);
480 pwallet->ImportPubKeys({pubKey.
GetID()}, {{pubKey.
GetID(), pubKey}} , {},
false,
false, 1);
485 pwallet->ResubmitWalletTransactions(
false,
true);
497 "\nImports keys from a wallet dump file (see dumpwallet). Requires a new wallet backup to include imported keys.\n"
498 "Note: Blockchain and Mempool will be rescanned after a successful import. Use \"getwalletinfo\" to query the scanning progress.\n"
499 "Note: This command is only compatible with legacy wallets.\n",
505 "\nDump the wallet\n"
507 "\nImport the wallet\n"
509 "\nImport using the json rpc call\n"
524 int64_t nTimeBegin = 0;
527 LOCK(pwallet->cs_wallet);
532 file.open(
fs::u8path(request.params[0].get_str()), std::ios::in | std::ios::ate);
533 if (!file.is_open()) {
538 int64_t nFilesize = std::max((int64_t)1, (int64_t)file.tellg());
539 file.seekg(0, file.beg);
543 pwallet->chain().showProgress(
strprintf(
"%s " +
_(
"Importing…").translated, pwallet->GetDisplayName()), 0,
false);
544 std::vector<std::tuple<CKey, int64_t, bool, std::string>> keys;
545 std::vector<std::pair<CScript, int64_t>> scripts;
546 while (file.good()) {
547 pwallet->chain().showProgress(
"", std::max(1, std::min(50, (
int)(((
double)file.tellg() / (
double)nFilesize) * 100))),
false);
549 std::getline(file, line);
550 if (line.empty() || line[0] ==
'#')
553 std::vector<std::string> vstr =
SplitString(line,
' ');
559 std::string strLabel;
561 for (
unsigned int nStr = 2; nStr < vstr.size(); nStr++) {
562 if (vstr[nStr].front() ==
'#')
564 if (vstr[nStr] ==
"change=1")
566 if (vstr[nStr] ==
"reserve=1")
568 if (vstr[nStr].substr(0,6) ==
"label=") {
573 nTimeBegin = std::min(nTimeBegin, nTime);
574 keys.emplace_back(key, nTime, fLabel, strLabel);
575 }
else if(
IsHex(vstr[0])) {
576 std::vector<unsigned char> vData(
ParseHex(vstr[0]));
579 if (birth_time > 0) nTimeBegin = std::min(nTimeBegin, birth_time);
580 scripts.emplace_back(script, birth_time);
587 pwallet->chain().showProgress(
"", 100,
false);
590 double total = (double)(keys.size() + scripts.size());
592 for (
const auto& key_tuple : keys) {
593 pwallet->chain().showProgress(
"", std::max(50, std::min(75, (
int)((progress / total) * 100) + 50)),
false);
594 const CKey& key = std::get<0>(key_tuple);
595 int64_t time = std::get<1>(key_tuple);
596 bool has_label = std::get<2>(key_tuple);
597 std::string label = std::get<3>(key_tuple);
605 if (!pwallet->ImportPrivKeys({{keyid, key}}, time)) {
612 pwallet->SetAddressBook(
PKHash(keyid), label, AddressPurpose::RECEIVE);
615 for (
const auto& script_pair : scripts) {
616 pwallet->chain().showProgress(
"", std::max(50, std::min(75, (
int)((progress / total) * 100) + 50)),
false);
617 const CScript& script = script_pair.first;
618 int64_t time = script_pair.second;
620 if (!pwallet->ImportScripts({script}, time)) {
621 pwallet->WalletLogPrintf(
"Error importing script %s\n",
HexStr(script));
628 pwallet->chain().showProgress(
"", 100,
false);
630 pwallet->chain().showProgress(
"", 100,
false);
632 pwallet->MarkDirty();
645 "\nReveals the private key corresponding to 'address'.\n"
646 "Then the importprivkey can be used with this output\n"
647 "Note: This command is only compatible with legacy wallets.\n",
670 std::string strAddress = request.params[0].get_str();
676 if (keyid.IsNull()) {
680 if (!spk_man.
GetKey(keyid, vchSecret)) {
692 "\nDumps all wallet keys in a human-readable format to a server-side file. This does not allow overwriting existing files.\n"
693 "Imported scripts are included in the dumpfile, but corresponding BIP173 addresses, etc. may not be added automatically by importwallet.\n"
694 "Note that if your wallet contains keys which are not derived from your HD seed (e.g. imported keys), these are not covered by\n"
695 "only backing up the seed itself, and must be backed up too (e.g. ensure you back up the whole dumpfile).\n"
696 "Note: This command is only compatible with legacy wallets.\n",
720 wallet.BlockUntilSyncedToCurrentChain();
743 std::map<CKeyID, int64_t> mapKeyBirth;
744 wallet.GetKeyBirthTimes(mapKeyBirth);
746 int64_t block_time = 0;
754 std::set<CScriptID> scripts = spk_man.
GetCScripts();
757 std::vector<std::pair<int64_t, CKeyID> > vKeyBirth;
758 vKeyBirth.reserve(mapKeyBirth.size());
759 for (
const auto& entry : mapKeyBirth) {
760 vKeyBirth.emplace_back(entry.second, entry.first);
763 std::sort(vKeyBirth.begin(), vKeyBirth.end());
768 file <<
strprintf(
"# * Best block at time of backup was %i (%s),\n",
wallet.GetLastBlockHeight(),
wallet.GetLastBlockHash().ToString());
777 if (spk_man.
GetKey(seed_id, seed)) {
781 file <<
"# extended private masterkey: " <<
EncodeExtKey(masterKey) <<
"\n\n";
784 for (std::vector<std::pair<int64_t, CKeyID> >::const_iterator it = vKeyBirth.begin(); it != vKeyBirth.end(); it++) {
785 const CKeyID &keyid = it->second;
788 std::string strLabel;
790 if (spk_man.
GetKey(keyid, key)) {
792 const auto it{spk_man.mapKeyMetadata.find(keyid)};
793 if (it != spk_man.mapKeyMetadata.end()) metadata = it->second;
797 }
else if (keyid == seed_id) {
799 }
else if (mapKeyPool.count(keyid)) {
802 file <<
"inactivehdseed=1";
810 for (
const CScriptID &scriptid : scripts) {
812 std::string create_time =
"0";
815 auto it = spk_man.m_script_metadata.find(scriptid);
816 if (it != spk_man.m_script_metadata.end()) {
821 file <<
strprintf(
" # addr=%s\n", address);
825 file <<
"# End of dump\n";
861 std::vector<std::vector<unsigned char>> solverdata;
864 switch (script_type) {
881 if (!subscript)
return "missing redeemscript";
882 if (
CScriptID(*subscript) !=
id)
return "redeemScript does not match the scriptPubKey";
887 for (
size_t i = 1; i + 1< solverdata.size(); ++i) {
897 if (!subscript)
return "missing witnessscript";
898 if (
CScriptID(*subscript) !=
id)
return "witnessScript does not match the scriptPubKey or redeemScript";
899 if (script_ctx == ScriptContext::TOP) {
909 if (script_ctx == ScriptContext::TOP) {
915 return "unspendable script";
919 return "unrecognized script";
924 static UniValue ProcessImportLegacy(
ImportData& import_data, std::map<CKeyID, CPubKey>& pubkey_map, std::map<CKeyID, CKey>& privkey_map, std::set<CScript>& script_pub_keys,
bool& have_solving_data,
const UniValue& data, std::vector<CKeyID>& ordered_pubkeys)
929 const UniValue& scriptPubKey = data[
"scriptPubKey"];
934 const std::string& output = isScript ? scriptPubKey.
get_str() : scriptPubKey[
"address"].
get_str();
937 const std::string& strRedeemScript = data.
exists(
"redeemscript") ? data[
"redeemscript"].
get_str() :
"";
938 const std::string& witness_script_hex = data.
exists(
"witnessscript") ? data[
"witnessscript"].
get_str() :
"";
941 const bool internal = data.
exists(
"internal") ? data[
"internal"].
get_bool() :
false;
942 const bool watchOnly = data.
exists(
"watchonly") ? data[
"watchonly"].
get_bool() :
false;
944 if (data.
exists(
"range")) {
960 if (!
IsHex(output)) {
963 std::vector<unsigned char> vData(
ParseHex(output));
964 script =
CScript(vData.begin(), vData.end());
970 script_pub_keys.emplace(script);
973 if (strRedeemScript.size()) {
974 if (!
IsHex(strRedeemScript)) {
977 auto parsed_redeemscript =
ParseHex(strRedeemScript);
978 import_data.
redeemscript = std::make_unique<CScript>(parsed_redeemscript.begin(), parsed_redeemscript.end());
980 if (witness_script_hex.size()) {
981 if (!
IsHex(witness_script_hex)) {
984 auto parsed_witnessscript =
ParseHex(witness_script_hex);
985 import_data.
witnessscript = std::make_unique<CScript>(parsed_witnessscript.begin(), parsed_witnessscript.end());
987 for (
size_t i = 0; i < pubKeys.
size(); ++i) {
988 const auto& str = pubKeys[i].
get_str();
997 pubkey_map.emplace(pubkey.
GetID(), pubkey);
998 ordered_pubkeys.push_back(pubkey.
GetID());
1000 for (
size_t i = 0; i < keys.
size(); ++i) {
1001 const auto& str = keys[i].
get_str();
1008 if (pubkey_map.count(
id)) {
1009 pubkey_map.erase(
id);
1011 privkey_map.emplace(
id, key);
1017 if (have_solving_data) {
1022 bool spendable = std::all_of(import_data.
used_keys.begin(), import_data.
used_keys.end(), [&](
const std::pair<CKeyID, bool>& used_key){ return privkey_map.count(used_key.first) > 0; });
1023 if (!watchOnly && !spendable) {
1024 warnings.
push_back(
"Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag.");
1026 if (watchOnly && spendable) {
1027 warnings.
push_back(
"All private keys are provided, outputs will be considered spendable. If this is intentional, do not specify the watchonly flag.");
1031 if (error.empty()) {
1032 for (
const auto& require_key : import_data.
used_keys) {
1033 if (!require_key.second)
continue;
1034 if (pubkey_map.count(require_key.first) == 0 && privkey_map.count(require_key.first) == 0) {
1035 error =
"some required keys are missing";
1040 if (!error.empty()) {
1041 warnings.
push_back(
"Importing as non-solvable: " + error +
". If this is intentional, don't provide any keys, pubkeys, witnessscript, or redeemscript.");
1044 privkey_map.clear();
1045 have_solving_data =
false;
1048 if (import_data.
redeemscript) warnings.
push_back(
"Ignoring redeemscript as this is not a P2SH script.");
1049 if (import_data.
witnessscript) warnings.
push_back(
"Ignoring witnessscript as this is not a (P2SH-)P2WSH script.");
1050 for (
auto it = privkey_map.begin(); it != privkey_map.end(); ) {
1052 if (import_data.
used_keys.count(oldit->first) == 0) {
1053 warnings.
push_back(
"Ignoring irrelevant private key.");
1054 privkey_map.erase(oldit);
1057 for (
auto it = pubkey_map.begin(); it != pubkey_map.end(); ) {
1059 auto key_data_it = import_data.
used_keys.find(oldit->first);
1060 if (key_data_it == import_data.
used_keys.end() || !key_data_it->second) {
1061 warnings.
push_back(
"Ignoring public key \"" +
HexStr(oldit->first) +
"\" as it doesn't appear inside P2PKH or P2WPKH.");
1062 pubkey_map.erase(oldit);
1071 static UniValue ProcessImportDescriptor(
ImportData& import_data, std::map<CKeyID, CPubKey>& pubkey_map, std::map<CKeyID, CKey>& privkey_map, std::set<CScript>& script_pub_keys,
bool& have_solving_data,
const UniValue& data, std::vector<CKeyID>& ordered_pubkeys)
1075 const std::string& descriptor = data[
"desc"].
get_str();
1078 auto parsed_desc =
Parse(descriptor, keys, error,
true);
1086 have_solving_data = parsed_desc->IsSolvable();
1087 const bool watch_only = data.
exists(
"watchonly") ? data[
"watchonly"].
get_bool() :
false;
1089 int64_t range_start = 0, range_end = 0;
1090 if (!parsed_desc->IsRange() && data.
exists(
"range")) {
1092 }
else if (parsed_desc->IsRange()) {
1093 if (!data.
exists(
"range")) {
1102 for (
int i = range_start; i <= range_end; ++i) {
1104 std::vector<CScript> scripts_temp;
1105 parsed_desc->Expand(i, keys, scripts_temp, out_keys);
1106 std::copy(scripts_temp.begin(), scripts_temp.end(), std::inserter(script_pub_keys, script_pub_keys.end()));
1107 for (
const auto& key_pair : out_keys.
pubkeys) {
1108 ordered_pubkeys.push_back(key_pair.first);
1111 for (
const auto& x : out_keys.
scripts) {
1115 parsed_desc->ExpandPrivate(i, keys, out_keys);
1117 std::copy(out_keys.
pubkeys.begin(), out_keys.
pubkeys.end(), std::inserter(pubkey_map, pubkey_map.end()));
1118 std::copy(out_keys.
keys.begin(), out_keys.
keys.end(), std::inserter(privkey_map, privkey_map.end()));
1122 for (
size_t i = 0; i < priv_keys.
size(); ++i) {
1123 const auto& str = priv_keys[i].
get_str();
1132 if (!pubkey_map.count(
id)) {
1133 warnings.
push_back(
"Ignoring irrelevant private key.");
1135 privkey_map.emplace(
id, key);
1143 bool spendable = std::all_of(pubkey_map.begin(), pubkey_map.end(),
1144 [&](
const std::pair<CKeyID, CPubKey>& used_key) {
1145 return privkey_map.count(used_key.first) > 0;
1147 [&](
const std::pair<
CKeyID, std::pair<CPubKey, KeyOriginInfo>>& entry) {
1148 return privkey_map.count(entry.first) > 0;
1150 if (!watch_only && !spendable) {
1151 warnings.
push_back(
"Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag.");
1153 if (watch_only && spendable) {
1154 warnings.
push_back(
"All private keys are provided, outputs will be considered spendable. If this is intentional, do not specify the watchonly flag.");
1166 const bool internal = data.exists(
"internal") ? data[
"internal"].get_bool() :
false;
1168 if (
internal && data.exists(
"label")) {
1172 const bool add_keypool = data.exists(
"keypool") ? data[
"keypool"].get_bool() :
false;
1180 std::map<CKeyID, CPubKey> pubkey_map;
1181 std::map<CKeyID, CKey> privkey_map;
1182 std::set<CScript> script_pub_keys;
1183 std::vector<CKeyID> ordered_pubkeys;
1184 bool have_solving_data;
1186 if (data.exists(
"scriptPubKey") && data.exists(
"desc")) {
1188 }
else if (data.exists(
"scriptPubKey")) {
1189 warnings =
ProcessImportLegacy(import_data, pubkey_map, privkey_map, script_pub_keys, have_solving_data, data, ordered_pubkeys);
1190 }
else if (data.exists(
"desc")) {
1191 warnings =
ProcessImportDescriptor(import_data, pubkey_map, privkey_map, script_pub_keys, have_solving_data, data, ordered_pubkeys);
1202 for (
const CScript& script : script_pub_keys) {
1213 if (!
wallet.ImportPrivKeys(privkey_map, timestamp)) {
1216 if (!
wallet.ImportPubKeys(ordered_pubkeys, pubkey_map, import_data.
key_origins, add_keypool,
internal, timestamp)) {
1219 if (!
wallet.ImportScriptPubKeys(label, script_pub_keys, have_solving_data, !
internal, timestamp)) {
1226 result.
pushKV(
"error", e);
1238 if (data.
exists(
"timestamp")) {
1239 const UniValue& timestamp = data[
"timestamp"];
1240 if (timestamp.
isNum()) {
1241 return timestamp.
getInt<int64_t>();
1242 }
else if (timestamp.
isStr() && timestamp.
get_str() ==
"now") {
1253 "\nImport addresses/scripts (with private or public keys, redeem script (P2SH)), optionally rescanning the blockchain from the earliest creation time of the imported scripts. Requires a new wallet backup.\n"
1254 "If an address/script is imported without all of the private keys required to spend from that address, it will be watchonly. The 'watchonly' option must be set to true in this case or a warning will be returned.\n"
1255 "Conversely, if all the private keys are provided and the address/script is spendable, the watchonly option must be set to false, or a warning will be returned.\n"
1256 "\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\n"
1257 "may report that the imported keys, addresses or scripts exist but related transactions are still missing.\n"
1258 "The rescan parameter can be set to false if the key was never used to create transactions. If it is set to false,\n"
1259 "but the key was used to create transactions, rescanblockchain needs to be called with the appropriate block range.\n"
1260 "Note: Use \"getwalletinfo\" to query the scanning progress.\n"
1261 "Note: This command is only compatible with legacy wallets. Use \"importdescriptors\" for descriptor wallets.\n",
1272 "or the string \"now\" to substitute the current synced blockchain time. The timestamp of the oldest\n"
1273 "key will determine how far back blockchain rescans need to begin for missing wallet transactions.\n"
1274 "\"now\" can be specified to bypass scanning, for keys which are known to never have been used, and\n"
1275 "0 can be specified to scan the entire blockchain. Blocks up to 2 hours before the earliest key\n"
1276 "creation time of all keys being imported by the importmulti call will be scanned.",
1281 {
"pubkeys",
RPCArg::Type::ARR,
RPCArg::Default{
UniValue::VARR},
"Array of strings giving pubkeys to import. They must occur in P2PKH or P2WPKH scripts. They are not required when the private key is also provided (see the \"keys\" argument).",
1295 {
"keypool",
RPCArg::Type::BOOL,
RPCArg::Default{
false},
"Stating whether imported public keys should be added to the keypool for when users request new addresses. Only allowed when wallet private keys are disabled"},
1307 RPCResult::Type::ARR,
"",
"Response is an array with the same size as the input that has the execution result",
1324 HelpExampleCli(
"importmulti",
"'[{ \"scriptPubKey\": { \"address\": \"<my address>\" }, \"timestamp\":1455191478 }, "
1325 "{ \"scriptPubKey\": { \"address\": \"<my 2nd address>\" }, \"label\": \"example 2\", \"timestamp\": 1455191480 }]'") +
1326 HelpExampleCli(
"importmulti",
"'[{ \"scriptPubKey\": { \"address\": \"<my address>\" }, \"timestamp\":1455191478 }]' '{ \"rescan\": false}'")
1336 wallet.BlockUntilSyncedToCurrentChain();
1340 const UniValue& requests = mainRequest.params[0];
1343 bool fRescan =
true;
1345 if (!mainRequest.params[1].isNull()) {
1346 const UniValue& options = mainRequest.params[1];
1348 if (options.
exists(
"rescan")) {
1349 fRescan = options[
"rescan"].
get_bool();
1354 if (fRescan && !reserver.
reserve()) {
1359 bool fRunScan =
false;
1360 int64_t nLowestTimestamp = 0;
1363 LOCK(pwallet->cs_wallet);
1366 bool is_watchonly{
true};
1367 for (
size_t i = 0; i < requests.
size(); ++i) {
1368 const UniValue& request = requests[i];
1369 if (!request.
exists(
"watchonly") || !request[
"watchonly"].
get_bool()) {
1370 is_watchonly =
false;
1378 CHECK_NONFATAL(pwallet->chain().findBlock(pwallet->GetLastBlockHash(),
FoundBlock().time(nLowestTimestamp).mtpTime(now)));
1383 const int64_t minimumTimestamp = 1;
1395 if (result[
"success"].get_bool()) {
1400 if (timestamp < nLowestTimestamp) {
1401 nLowestTimestamp = timestamp;
1405 if (fRescan && fRunScan && requests.
size()) {
1406 int64_t scannedTime = pwallet->RescanFromTime(nLowestTimestamp, reserver,
true);
1407 pwallet->ResubmitWalletTransactions(
false,
true);
1409 if (pwallet->IsAbortingRescan()) {
1412 if (scannedTime > nLowestTimestamp) {
1413 std::vector<UniValue> results = response.
getValues();
1422 if (scannedTime <=
GetImportTimestamp(request, now) || results.at(i).exists(
"error")) {
1431 strprintf(
"Rescan failed for key with creation timestamp %d. There was an error reading a "
1432 "block from time %d, which is after or within %d seconds of key creation, and "
1433 "could contain transactions pertaining to the key. As a result, transactions "
1434 "and coins using this key may not appear in the wallet. This error could be "
1435 "caused by pruning or data corruption (see bitcoind log for details) and could "
1436 "be dealt with by downloading and rescanning the relevant blocks (see -reindex "
1437 "option and rescanblockchain RPC).",
1457 if (!data.exists(
"desc")) {
1461 const std::string& descriptor = data[
"desc"].get_str();
1462 const bool active = data.exists(
"active") ? data[
"active"].get_bool() :
false;
1463 const bool internal = data.exists(
"internal") ? data[
"internal"].get_bool() :
false;
1469 auto parsed_desc =
Parse(descriptor, keys, error,
true);
1475 int64_t range_start = 0, range_end = 1, next_index = 0;
1476 if (!parsed_desc->IsRange() && data.exists(
"range")) {
1478 }
else if (parsed_desc->IsRange()) {
1479 if (data.exists(
"range")) {
1481 range_start = range.first;
1482 range_end = range.second + 1;
1484 warnings.
push_back(
"Range not given, using default keypool range");
1486 range_end =
wallet.m_keypool_size;
1488 next_index = range_start;
1490 if (data.exists(
"next_index")) {
1491 next_index = data[
"next_index"].getInt<int64_t>();
1493 if (next_index < range_start || next_index >= range_end) {
1500 if (active && !parsed_desc->IsRange()) {
1505 if (data.exists(
"range") && data.exists(
"label")) {
1510 if (
internal && data.exists(
"label")) {
1515 if (active && !parsed_desc->IsSingleType()) {
1526 std::vector<CScript> scripts;
1527 if (!parsed_desc->Expand(0, keys, scripts, expand_keys)) {
1528 throw JSONRPCError(
RPC_WALLET_ERROR,
"Cannot expand descriptor. Probably because of hardened derivations without private keys provided");
1530 parsed_desc->ExpandPrivate(0, keys, expand_keys);
1533 bool have_all_privkeys = !expand_keys.
keys.empty();
1534 for (
const auto& entry : expand_keys.
origins) {
1535 const CKeyID& key_id = entry.first;
1537 if (!expand_keys.
GetKey(key_id, key)) {
1538 have_all_privkeys =
false;
1545 if (keys.
keys.empty()) {
1548 if (!have_all_privkeys) {
1549 warnings.
push_back(
"Not all private keys provided. Some wallet functionality may return unexpected errors");
1553 WalletDescriptor w_desc(std::move(parsed_desc), timestamp, range_start, range_end, next_index);
1556 auto existing_spk_manager =
wallet.GetDescriptorScriptPubKeyMan(w_desc);
1557 if (existing_spk_manager) {
1558 if (!existing_spk_manager->CanUpdateToWalletDescriptor(w_desc, error)) {
1564 auto spk_manager =
wallet.AddWalletDescriptor(w_desc, keys, label,
internal);
1565 if (spk_manager ==
nullptr) {
1572 warnings.
push_back(
"Unknown output type, cannot set descriptor to active.");
1574 wallet.AddActiveScriptPubKeyMan(spk_manager->GetID(), *w_desc.
descriptor->GetOutputType(),
internal);
1578 wallet.DeactivateScriptPubKeyMan(spk_manager->GetID(), *w_desc.
descriptor->GetOutputType(),
internal);
1585 result.
pushKV(
"error", e);
1594 "\nImport 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"
1595 "\nNote: This call can take over an hour to complete if using an early timestamp; during that time, other rpc calls\n"
1596 "may report that the imported keys, addresses or scripts exist but related transactions are still missing.\n"
1597 "The rescan is significantly faster if block filters are available (using startup option \"-blockfilterindex=1\").\n",
1608 "Use the string \"now\" to substitute the current synced blockchain time.\n"
1609 "\"now\" can be specified to bypass scanning, for outputs which are known to never have been used, and\n"
1610 "0 can be specified to scan the entire blockchain. Blocks up to 2 hours before the earliest timestamp\n"
1611 "of all descriptors being imported will be scanned as well as the mempool.",
1622 RPCResult::Type::ARR,
"",
"Response is an array with the same size as the input that has the execution result",
1639 HelpExampleCli(
"importdescriptors",
"'[{ \"desc\": \"<my descriptor>\", \"timestamp\":1455191478, \"internal\": true }, "
1640 "{ \"desc\": \"<my descriptor 2>\", \"label\": \"example 2\", \"timestamp\": 1455191480 }]'") +
1641 HelpExampleCli(
"importdescriptors",
"'[{ \"desc\": \"<my descriptor>\", \"timestamp\":1455191478, \"active\": true, \"range\": [0,100], \"label\": \"<my bech32 wallet>\" }]'")
1651 wallet.BlockUntilSyncedToCurrentChain();
1659 if (!reserver.
reserve(
true)) {
1665 LOCK(pwallet->m_relock_mutex);
1667 const UniValue& requests = main_request.params[0];
1668 const int64_t minimum_timestamp = 1;
1670 int64_t lowest_timestamp = 0;
1671 bool rescan =
false;
1674 LOCK(pwallet->cs_wallet);
1677 CHECK_NONFATAL(pwallet->chain().findBlock(pwallet->GetLastBlockHash(),
FoundBlock().time(lowest_timestamp).mtpTime(now)));
1682 const int64_t timestamp = std::max(
GetImportTimestamp(request, now), minimum_timestamp);
1686 if (lowest_timestamp > timestamp ) {
1687 lowest_timestamp = timestamp;
1691 if (!rescan && result[
"success"].get_bool()) {
1695 pwallet->ConnectScriptPubKeyManNotifiers();
1700 int64_t scanned_time = pwallet->RescanFromTime(lowest_timestamp, reserver,
true);
1701 pwallet->ResubmitWalletTransactions(
false,
true);
1703 if (pwallet->IsAbortingRescan()) {
1707 if (scanned_time > lowest_timestamp) {
1708 std::vector<UniValue> results = response.
getValues();
1713 for (
unsigned int i = 0; i < requests.
size(); ++i) {
1720 if (scanned_time <=
GetImportTimestamp(request, now) || results.at(i).exists(
"error")) {
1729 strprintf(
"Rescan failed for descriptor with timestamp %d. There was an error reading a "
1730 "block from time %d, which is after or within %d seconds of key creation, and "
1731 "could contain transactions pertaining to the desc. As a result, transactions "
1732 "and coins using this desc may not appear in the wallet. This error could be "
1733 "caused by pruning or data corruption (see bitcoind log for details) and could "
1734 "be dealt with by downloading and rescanning the relevant blocks (see -reindex "
1735 "option and rescanblockchain RPC).",
1752 "\nList descriptors imported into a descriptor-enabled wallet.\n",
1758 {
RPCResult::Type::ARR,
"descriptors",
"Array of descriptor objects (sorted by descriptor string representation)",
1763 {
RPCResult::Type::BOOL,
"active",
"Whether this descriptor is currently used to generate new addresses"},
1764 {
RPCResult::Type::BOOL,
"internal",
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"},
1769 {
RPCResult::Type::NUM,
"next",
true,
"Same as next_index field. Kept for compatibility reason."},
1770 {
RPCResult::Type::NUM,
"next_index",
true,
"The next index to generate addresses from; defined only for ranged descriptors"},
1787 const bool priv = !request.params[0].isNull() && request.params[0].get_bool();
1794 const auto active_spk_mans =
wallet->GetActiveScriptPubKeyMans();
1796 struct WalletDescInfo {
1797 std::string descriptor;
1798 uint64_t creation_time;
1800 std::optional<bool>
internal;
1801 std::optional<std::pair<int64_t,int64_t>> range;
1805 std::vector<WalletDescInfo> wallet_descriptors;
1806 for (
const auto& spk_man :
wallet->GetAllScriptPubKeyMans()) {
1808 if (!desc_spk_man) {
1811 LOCK(desc_spk_man->cs_desc_man);
1812 const auto& wallet_descriptor = desc_spk_man->GetWalletDescriptor();
1813 std::string descriptor;
1814 if (!desc_spk_man->GetDescriptorString(descriptor, priv)) {
1817 const bool is_range = wallet_descriptor.descriptor->IsRange();
1818 wallet_descriptors.push_back({
1820 wallet_descriptor.creation_time,
1821 active_spk_mans.count(desc_spk_man) != 0,
1822 wallet->IsInternalScriptPubKeyMan(desc_spk_man),
1823 is_range ? std::optional(std::make_pair(wallet_descriptor.range_start, wallet_descriptor.range_end)) : std::nullopt,
1824 wallet_descriptor.next_index
1828 std::sort(wallet_descriptors.begin(), wallet_descriptors.end(), [](
const auto& a,
const auto& b) {
1829 return a.descriptor < b.descriptor;
1833 for (
const WalletDescInfo& info : wallet_descriptors) {
1835 spk.
pushKV(
"desc", info.descriptor);
1836 spk.
pushKV(
"timestamp", info.creation_time);
1837 spk.
pushKV(
"active", info.active);
1838 if (info.internal.has_value()) {
1839 spk.
pushKV(
"internal", info.internal.value());
1841 if (info.range.has_value()) {
1844 range.
push_back(info.range->second - 1);
1845 spk.
pushKV(
"range", range);
1846 spk.
pushKV(
"next", info.next_index);
1847 spk.
pushKV(
"next_index", info.next_index);
1854 response.
pushKV(
"descriptors", descriptors);
1864 "\nSafely copies the current wallet file to the specified destination, which can either be a directory or a path with a filename.\n",
1880 pwallet->BlockUntilSyncedToCurrentChain();
1882 LOCK(pwallet->cs_wallet);
1884 std::string strDest = request.params[0].get_str();
1885 if (!pwallet->BackupWallet(strDest)) {
1899 "\nRestores and loads a wallet from backup.\n"
1900 "\nThe rescan is significantly faster if a descriptor wallet is restored"
1901 "\nand block filters are available (using startup option \"-blockfilterindex=1\").\n",
1911 {
RPCResult::Type::ARR,
"warnings",
true,
"Warning messages, if any, related to restoring and loading the wallet.",
1918 HelpExampleCli(
"restorewallet",
"\"testwallet\" \"home\\backups\\backup-file.bak\"")
1919 +
HelpExampleRpc(
"restorewallet",
"\"testwallet\" \"home\\backups\\backup-file.bak\"")
1920 +
HelpExampleCliNamed(
"restorewallet", {{
"wallet_name",
"testwallet"}, {
"backup_file",
"home\\backups\\backup-file.bak\""}, {
"load_on_startup",
true}})
1921 +
HelpExampleRpcNamed(
"restorewallet", {{
"wallet_name",
"testwallet"}, {
"backup_file",
"home\\backups\\backup-file.bak\""}, {
"load_on_startup",
true}})
1928 auto backup_file =
fs::u8path(request.params[1].get_str());
1930 std::string wallet_name = request.params[0].get_str();
1932 std::optional<bool> load_on_start = request.params[2].isNull() ? std::nullopt : std::optional<bool>(request.params[2].get_bool());
1936 std::vector<bilingual_str> warnings;
1938 const std::shared_ptr<CWallet>
wallet =
RestoreWallet(context, backup_file, wallet_name, load_on_start, status, error, warnings);
bool ExtractDestination(const CScript &scriptPubKey, CTxDestination &addressRet)
Parse a scriptPubKey for the destination.
bool IsValidDestination(const CTxDestination &dest)
Check whether a CTxDestination corresponds to one with an address.
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
std::variant< CNoDestination, PubKeyDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, WitnessUnknown > CTxDestination
A txout script categorized into standard templates.
std::string WriteHDKeypath(const std::vector< uint32_t > &keypath, bool apostrophe)
Write HD keypaths as strings.
static constexpr int64_t TIMESTAMP_WINDOW
Timestamp window used as a grace period by code that compares external timestamps (such as timestamps...
#define CHECK_NONFATAL(condition)
Identity function.
#define NONFATAL_UNREACHABLE()
NONFATAL_UNREACHABLE() is a macro that is used to mark unreachable code.
An encapsulated private key.
bool IsValid() const
Check whether this private key is valid.
CPubKey GetPubKey() const
Compute the public key from a private key.
bool VerifyPubKey(const CPubKey &vchPubKey) const
Verify thoroughly whether a private key and a public key match.
A reference to a CKey: the Hash160 of its serialized public key.
Used to relay blocks as header + vector<merkle branch> to filtered nodes.
CBlockHeader header
Public only for unit testing.
uint256 ExtractMatches(std::vector< uint256 > &vMatch, std::vector< unsigned int > &vnIndex)
extract the matching txid's represented by this partial merkle tree and their respective indices with...
An encapsulated public key.
bool IsCompressed() const
Check whether this is a compressed public key.
CKeyID GetID() const
Get the KeyID of this public key (hash of its serialization)
bool IsFullyValid() const
fully validate whether this is a valid public key (more expensive than IsValid())
Serialized script, used inside transaction inputs and outputs.
A reference to a CScript: the Hash160 of its serialization.
Double ended buffer combining vector and stream-like interfaces.
virtual bool GetCScript(const CScriptID &hash, CScript &redeemScriptOut) const override
virtual std::set< CScriptID > GetCScripts() const
RecursiveMutex cs_KeyStore
void push_back(UniValue val)
const std::string & get_str() const
enum VType getType() const
const std::vector< UniValue > & getValues() const
const UniValue & get_array() const
bool exists(const std::string &key) const
void pushKV(std::string key, UniValue val)
constexpr bool IsNull() const
Path class wrapper to block calls to the fs::path(std::string) implicit constructor and the fs::path:...
std::string utf8string() const
Return a UTF-8 representation of the path as a std::string, for compatibility with code using std::st...
Helper for findBlock to selectively return pieces of block data.
iterator insert(iterator pos, const T &value)
CKeyID seed_id
seed hash160
A CWallet maintains a set of transactions and balances, and provides the ability to create new transa...
bool GetKey(const CKeyID &address, CKey &keyOut) const override
const CHDChain & GetHDChain() const
const std::map< CKeyID, int64_t > & GetAllReserveKeys() const
Descriptor with some wallet metadata.
std::shared_ptr< Descriptor > descriptor
RAII object to check and reserve a wallet rescan.
bool reserve(bool with_passphrase=false)
static UniValue Parse(std::string_view raw)
Parse string to UniValue or throw runtime_error if string contains invalid JSON.
std::string FormatFullVersion()
bool DecodeHexTx(CMutableTransaction &tx, const std::string &hex_tx, bool try_no_witness=false, bool try_witness=true)
uint160 RIPEMD160(Span< const unsigned char > data)
Compute the 160-bit RIPEMD-160 hash of an array.
@ WITNESS_V0
Witness v0 (P2WPKH and P2WSH); see BIP 141.
std::string EncodeExtKey(const CExtKey &key)
CTxDestination DecodeDestination(const std::string &str, std::string &error_msg, std::vector< int > *error_locations)
std::string EncodeSecret(const CKey &key)
std::string EncodeDestination(const CTxDestination &dest)
CKey DecodeSecret(const std::string &str)
static path absolute(const path &p)
static path u8path(const std::string &utf8_str)
static bool exists(const path &p)
bilingual_str ErrorString(const Result< T > &result)
static UniValue ProcessDescriptorImport(CWallet &wallet, const UniValue &data, const int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet)
std::shared_ptr< CWallet > GetWalletForJSONRPCRequest(const JSONRPCRequest &request)
Figures out what wallet, if any, to use for a JSONRPCRequest.
static std::string RecurseImportData(const CScript &script, ImportData &import_data, const ScriptContext script_ctx)
RPCHelpMan removeprunedfunds()
RPCHelpMan importwallet()
static void RescanWallet(CWallet &wallet, const WalletRescanReserver &reserver, int64_t time_begin=TIMESTAMP_MIN, bool update=true)
static std::string DecodeDumpString(const std::string &str)
void HandleWalletError(const std::shared_ptr< CWallet > wallet, DatabaseStatus &status, bilingual_str &error)
void EnsureWalletIsUnlocked(const CWallet &wallet)
const LegacyScriptPubKeyMan & EnsureConstLegacyScriptPubKeyMan(const CWallet &wallet)
RPCHelpMan backupwallet()
static UniValue ProcessImportDescriptor(ImportData &import_data, std::map< CKeyID, CPubKey > &pubkey_map, std::map< CKeyID, CKey > &privkey_map, std::set< CScript > &script_pub_keys, bool &have_solving_data, const UniValue &data, std::vector< CKeyID > &ordered_pubkeys)
RPCHelpMan importaddress()
RPCHelpMan importprunedfunds()
LegacyScriptPubKeyMan & EnsureLegacyScriptPubKeyMan(CWallet &wallet, bool also_create)
RPCHelpMan importprivkey()
WalletContext & EnsureWalletContext(const std::any &context)
RPCHelpMan listdescriptors()
RPCHelpMan importpubkey()
static const int64_t TIMESTAMP_MIN
std::string LabelFromValue(const UniValue &value)
RPCHelpMan restorewallet()
static void EnsureBlockDataFromTime(const CWallet &wallet, int64_t timestamp)
std::shared_ptr< CWallet > RestoreWallet(WalletContext &context, const fs::path &backup_file, const std::string &wallet_name, std::optional< bool > load_on_start, DatabaseStatus &status, bilingual_str &error, std::vector< bilingual_str > &warnings)
RPCHelpMan importdescriptors()
int64_t ParseISO8601DateTime(const std::string &str)
static int64_t GetImportTimestamp(const UniValue &data, int64_t now)
static bool GetWalletAddressesForKey(const LegacyScriptPubKeyMan *spk_man, const CWallet &wallet, const CKeyID &keyid, std::string &strAddr, std::string &strLabel) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet)
@ WALLET_FLAG_DESCRIPTORS
Indicate that this wallet supports DescriptorScriptPubKeyMan.
@ WALLET_FLAG_DISABLE_PRIVATE_KEYS
static std::string EncodeDumpString(const std::string &str)
static UniValue ProcessImport(CWallet &wallet, const UniValue &data, const int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet)
static UniValue ProcessImportLegacy(ImportData &import_data, std::map< CKeyID, CPubKey > &pubkey_map, std::map< CKeyID, CKey > &privkey_map, std::set< CScript > &script_pub_keys, bool &have_solving_data, const UniValue &data, std::vector< CKeyID > &ordered_pubkeys)
CTxDestination GetDestinationForKey(const CPubKey &key, OutputType type)
Get a destination of the requested type (if possible) to the specified key.
std::vector< CTxDestination > GetAllDestinationsForKey(const CPubKey &key)
Get all destinations (potentially) supported by the wallet for the given key.
std::optional< OutputType > OutputTypeFromDestination(const CTxDestination &dest)
Get the OutputType for a CTxDestination.
static CTransactionRef MakeTransactionRef(Tx &&txIn)
std::shared_ptr< const CTransaction > CTransactionRef
UniValue JSONRPCError(int code, const std::string &message)
@ RPC_MISC_ERROR
General application defined errors.
@ RPC_TYPE_ERROR
Unexpected type was passed as parameter.
@ RPC_INVALID_PARAMETER
Invalid, missing or duplicate parameter.
@ RPC_WALLET_ERROR
Wallet errors.
@ RPC_DESERIALIZATION_ERROR
Error parsing or validating structure in raw format.
@ RPC_INVALID_ADDRESS_OR_KEY
Invalid address or key.
std::pair< int64_t, int64_t > ParseDescriptorRange(const UniValue &value)
Parse a JSON range specified as int64, or [int64, int64].
std::string HelpExampleCli(const std::string &methodname, const std::string &args)
std::string HelpExampleRpcNamed(const std::string &methodname, const RPCArgList &args)
void PushWarnings(const UniValue &warnings, UniValue &obj)
Push warning messages to an RPC "warnings" field as a JSON array of strings.
std::string HelpExampleRpc(const std::string &methodname, const std::string &args)
std::vector< unsigned char > ParseHexV(const UniValue &v, std::string_view name)
const std::string UNIX_EPOCH_TIME
String used to describe UNIX epoch time in documentation, factored out to a constant for consistency.
std::string HelpExampleCliNamed(const std::string &methodname, const RPCArgList &args)
uint256 ParseHashV(const UniValue &v, std::string_view name)
Utilities: convert hex-encoded Values (throws error if not hex).
CKeyID GetKeyForDestination(const SigningProvider &store, const CTxDestination &dest)
Return the CKeyID of the key involved in a script (if there is a unique one).
TxoutType Solver(const CScript &scriptPubKey, std::vector< std::vector< unsigned char >> &vSolutionsRet)
Parse a scriptPubKey and identify script type for standard scripts.
@ WITNESS_UNKNOWN
Only for Witness versions not already defined above.
@ NULL_DATA
unspendable OP_RETURN script that carries data
std::vector< Byte > ParseHex(std::string_view hex_str)
Like TryParseHex, but returns an empty vector on invalid input.
std::vector< std::string > SplitString(std::string_view str, char sep)
void SetSeed(Span< const std::byte > seed)
A mutable version of CTransaction.
Txid GetHash() const
Compute the hash of this CMutableTransaction.
std::map< CKeyID, std::pair< CPubKey, KeyOriginInfo > > origins
bool GetKey(const CKeyID &keyid, CKey &key) const override
std::map< CKeyID, CPubKey > pubkeys
std::map< CKeyID, CKey > keys
std::map< CScriptID, CScript > scripts
std::vector< uint32_t > path
@ RANGE
Special type that is a NUM or [NUM,NUM].
@ STR_HEX
Special type that is a STR with only hex chars.
@ OBJ_NAMED_PARAMS
Special type that behaves almost exactly like OBJ, defining an options object with a list of pre-defi...
std::string DefaultHint
Hint for default value.
@ OMITTED
Optional argument for which the default value is omitted from help text for one of two reasons:
std::vector< std::string > type_str
Should be empty unless it is supposed to override the auto-generated type strings....
std::string oneline_description
Should be empty unless it is supposed to override the auto-generated summary line.
@ ELISION
Special type to denote elision (...)
@ ARR_FIXED
Special array that has a fixed number of entries.
std::unique_ptr< CScript > redeemscript
Provided redeemScript; will be moved to import_scripts if relevant.
std::map< CKeyID, std::pair< CPubKey, KeyOriginInfo > > key_origins
std::unique_ptr< CScript > witnessscript
Provided witnessScript; will be moved to import_scripts if relevant.
std::map< CKeyID, bool > used_keys
Import these private keys if available (the value indicates whether if the key is required for solvab...
std::set< CScript > import_scripts
State of transaction confirmed in a block.
WalletContext struct containing references to state shared between CWallet instances,...
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
#define EXCLUSIVE_LOCKS_REQUIRED(...)
std::string FormatISO8601DateTime(int64_t nTime)
ISO 8601 formatting is preferred.
bilingual_str _(const char *psz)
Translation function.
const char * uvTypeName(UniValue::VType t)
std::string HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
bool IsHex(std::string_view str)