5 #include <chainparams.h>
32 error =
_(
"Error: Keypool ran out, please call keypoolrefill first")
51 enum class IsMineSigVersion {
61 enum class IsMineResult {
68 bool HaveKeys(
const std::vector<valtype> &pubkeys,
70 for (
const valtype &pubkey : pubkeys) {
90 IsMineSigVersion sigversion,
91 bool recurse_scripthash =
true) {
92 IsMineResult ret = IsMineResult::NO;
94 std::vector<valtype> vSolutions;
105 ret = std::max(ret, IsMineResult::SPENDABLE);
111 ret = std::max(ret, IsMineResult::SPENDABLE);
115 if (sigversion != IsMineSigVersion::TOP) {
117 return IsMineResult::INVALID;
121 if (keystore.
GetCScript(scriptID, subscript)) {
122 ret = std::max(ret, recurse_scripthash
123 ? IsMineInner(keystore, subscript,
124 IsMineSigVersion::P2SH)
125 : IsMineResult::SPENDABLE);
132 if (sigversion == IsMineSigVersion::TOP) {
141 std::vector<valtype> keys(vSolutions.begin() + 1,
142 vSolutions.begin() + vSolutions.size() -
144 if (HaveKeys(keys, keystore)) {
145 ret = std::max(ret, IsMineResult::SPENDABLE);
151 if (ret == IsMineResult::NO && keystore.
HaveWatchOnly(scriptPubKey)) {
152 ret = std::max(ret, IsMineResult::WATCH_ONLY);
160 switch (IsMineInner(*
this, script, IsMineSigVersion::TOP)) {
161 case IsMineResult::INVALID:
162 case IsMineResult::NO:
164 case IsMineResult::WATCH_ONLY:
166 case IsMineResult::SPENDABLE:
179 bool keyPass = mapCryptedKeys.empty();
180 bool keyFail =
false;
181 CryptedKeyMap::const_iterator mi = mapCryptedKeys.begin();
183 for (; mi != mapCryptedKeys.end(); ++mi) {
184 const CPubKey &vchPubKey = (*mi).second.first;
185 const std::vector<uint8_t> &vchCryptedSecret = (*mi).second.second;
187 if (!
DecryptKey(master_key, vchCryptedSecret, vchPubKey, key)) {
197 mapKeyMetadata[vchPubKey.
GetID()]);
200 if (keyPass && keyFail) {
201 LogPrintf(
"The wallet is probably corrupted: Some keys decrypt but "
203 throw std::runtime_error(
204 "Error unlocking wallet: some keys decrypt but not all. Your "
205 "wallet file may be corrupt.");
207 if (keyFail || (!keyPass && !accept_no_keys)) {
218 encrypted_batch = batch;
219 if (!mapCryptedKeys.empty()) {
220 encrypted_batch =
nullptr;
226 keys_to_encrypt.swap(mapKeys);
227 for (
const KeyMap::value_type &mKey : keys_to_encrypt) {
228 const CKey &key = mKey.second;
231 std::vector<uint8_t> vchCryptedSecret;
234 encrypted_batch =
nullptr;
238 encrypted_batch =
nullptr;
242 encrypted_batch =
nullptr;
264 int64_t index,
bool internal) {
279 int64_t target_size =
290 int64_t missing = std::max(target_size - kp_size, (int64_t)0);
294 for (int64_t i = missing; i > 0; --i) {
299 HexStr(seed_id), missing);
302 HexStr(seed_id), missing);
312 std::map<CKeyID, int64_t>::const_iterator mi =
316 "keys up to this key as used\n",
322 "%s: Topping up keypool failed (locked wallet)\n",
330 auto it = mapKeyMetadata.find(keyid);
331 if (it != mapKeyMetadata.end()) {
357 for (
auto &meta_pair : mapKeyMetadata) {
369 std::copy(master_id.
begin(), master_id.
begin() + 4,
372 throw std::runtime_error(
"Invalid stored hdKeypath");
381 if (
GetPubKey(meta_pair.first, pubkey)) {
382 batch->WriteKeyMetadata(meta, pubkey,
true);
407 bool keypool_has_keys;
409 keypool_has_keys = setInternalKeyPool.size() > 0;
414 if (!keypool_has_keys) {
417 return keypool_has_keys;
422 bool hd_upgrade =
false;
423 bool split_upgrade =
false;
446 error =
_(
"Unable to generate keys");
455 return !mapKeys.empty() || !mapCryptedKeys.empty();
460 setInternalKeyPool.clear();
461 setExternalKeyPool.clear();
470 if (setKeyPool.empty()) {
475 int64_t nIndex = *(setKeyPool.begin());
476 if (!batch.
ReadPool(nIndex, keypool)) {
477 throw std::runtime_error(std::string(__func__) +
478 ": read oldest key in keypool failed");
482 return keypool.
nTime;
495 if (!set_pre_split_keypool.empty()) {
507 return setExternalKeyPool.size() + set_pre_split_keypool.size();
512 return setInternalKeyPool.size() + setExternalKeyPool.size() +
513 set_pre_split_keypool.size();
518 return nTimeFirstKey;
521 std::unique_ptr<SigningProvider>
523 return std::make_unique<LegacySigningProvider>(*
this);
528 IsMineResult ismine = IsMineInner(*
this, script, IsMineSigVersion::TOP,
530 if (ismine == IsMineResult::SPENDABLE ||
531 ismine == IsMineResult::WATCH_ONLY) {
543 bool has_privkeys =
false;
544 for (
const auto &key_sig_pair : sigdata.
signatures) {
545 has_privkeys |=
HaveKey(key_sig_pair.first);
554 SigHashType sighash, std::map<int, std::string> &input_errors)
const {
560 std::string &str_sig)
const {
575 bool bip32derivs)
const {
576 for (
size_t i = 0; i < psbtx.
tx->vin.size(); ++i) {
601 for (
size_t i = 0; i < psbtx.
tx->vout.size(); ++i) {
609 std::unique_ptr<CKeyMetadata>
615 auto it = mapKeyMetadata.find(key_id);
616 if (it != mapKeyMetadata.end()) {
617 return std::make_unique<CKeyMetadata>(it->second);
622 auto it = m_script_metadata.find(
CScriptID(scriptPubKey));
623 if (it != m_script_metadata.end()) {
624 return std::make_unique<CKeyMetadata>(it->second);
640 if (nCreateTime <= 1) {
644 }
else if (!nTimeFirstKey || nCreateTime < nTimeFirstKey) {
645 nTimeFirstKey = nCreateTime;
671 bool needsDB = !encrypted_batch;
673 encrypted_batch = &batch;
677 encrypted_batch =
nullptr;
683 encrypted_batch =
nullptr;
700 mapKeyMetadata[pubkey.
GetID()]);
713 std::string strAddr =
716 "of size %i which exceeds maximum size %i thus can "
717 "never be redeemed. Do not use address %s.\n",
730 mapKeyMetadata[keyID] = meta;
737 m_script_metadata[script_id] = meta;
751 std::vector<uint8_t> vchCryptedSecret;
754 pubkey.
GetHash(), vchCryptedSecret)) {
765 const CPubKey &vchPubKey,
const std::vector<uint8_t> &vchCryptedSecret,
766 bool checksum_valid) {
768 if (!checksum_valid) {
776 const CPubKey &vchPubKey,
const std::vector<uint8_t> &vchCryptedSecret) {
780 mapCryptedKeys[vchPubKey.
GetID()] = make_pair(vchPubKey, vchCryptedSecret);
785 const CPubKey &vchPubKey,
const std::vector<uint8_t> &vchCryptedSecret) {
791 if (encrypted_batch) {
792 return encrypted_batch->WriteCryptedKey(
793 vchPubKey, vchCryptedSecret, mapKeyMetadata[vchPubKey.
GetID()]);
798 mapKeyMetadata[vchPubKey.
GetID()]);
803 return setWatchOnly.count(dest) > 0;
808 return (!setWatchOnly.empty());
812 std::vector<std::vector<uint8_t>> solutions;
814 (pubKeyOut =
CPubKey(solutions[0])).IsFullyValid();
820 setWatchOnly.erase(dest);
823 mapWatchKeys.erase(pubKey.
GetID());
840 setWatchOnly.insert(dest);
843 mapWatchKeys[pubKey.
GetID()] = pubKey;
866 int64_t create_time) {
867 m_script_metadata[
CScriptID(dest)].nCreateTime = create_time;
877 int64_t nCreateTime) {
878 m_script_metadata[
CScriptID(dest)].nCreateTime = nCreateTime;
891 throw std::runtime_error(std::string(__func__) +
892 ": writing chain failed");
914 return mapCryptedKeys.count(address) > 0;
923 CryptedKeyMap::const_iterator mi = mapCryptedKeys.find(address);
924 if (mi != mapCryptedKeys.end()) {
925 const CPubKey &vchPubKey = (*mi).second.first;
926 const std::vector<uint8_t> &vchCryptedSecret = (*mi).second.second;
938 auto it = mapKeyMetadata.find(keyID);
939 if (it != mapKeyMetadata.end()) {
957 WatchKeyMap::const_iterator it = mapWatchKeys.find(address);
958 if (it != mapWatchKeys.end()) {
959 pubkey_out = it->second;
975 CryptedKeyMap::const_iterator mi = mapCryptedKeys.find(address);
976 if (mi != mapCryptedKeys.end()) {
977 vchPubKeyOut = (*mi).second.first;
997 int64_t nCreationTime =
GetTime();
1004 batch, metadata, secret, hd_chain,
1018 mapKeyMetadata[pubkey.
GetID()] = metadata;
1022 throw std::runtime_error(std::string(__func__) +
": AddKey failed");
1046 throw std::runtime_error(std::string(__func__) +
": seed not found");
1058 accountKey.
Derive(chainChildKey,
1089 secret = childKey.
key;
1092 std::copy(master_id.
begin(), master_id.
begin() + 4,
1098 throw std::runtime_error(std::string(__func__) +
1099 ": writing HD chain model failed");
1107 set_pre_split_keypool.insert(nIndex);
1109 setInternalKeyPool.insert(nIndex);
1111 setExternalKeyPool.insert(nIndex);
1113 m_max_keypool_index = std::max(m_max_keypool_index, nIndex);
1120 if (mapKeyMetadata.count(keyid) == 0) {
1140 int64_t nCreationTime =
GetTime();
1155 mapKeyMetadata[seed.
GetID()] = metadata;
1159 throw std::runtime_error(std::string(__func__) +
1160 ": AddKeyPubKey failed");
1192 for (
const int64_t nIndex : setInternalKeyPool) {
1195 setInternalKeyPool.clear();
1197 for (
const int64_t nIndex : setExternalKeyPool) {
1200 setExternalKeyPool.clear();
1202 for (int64_t nIndex : set_pre_split_keypool) {
1205 set_pre_split_keypool.clear();
1213 WalletLogPrintf(
"LegacyScriptPubKeyMan::NewKeyPool rewrote keypool\n");
1229 unsigned int nTargetSize;
1231 nTargetSize = kpSize;
1233 nTargetSize = std::max<int64_t>(
1240 int64_t missingExternal = std::max<int64_t>(
1241 std::max<int64_t>(nTargetSize, 1) - setExternalKeyPool.size(), 0);
1242 int64_t missingInternal = std::max<int64_t>(
1243 std::max<int64_t>(nTargetSize, 1) - setInternalKeyPool.size(), 0);
1247 missingInternal = 0;
1249 bool internal =
false;
1251 for (int64_t i = missingInternal + missingExternal; i--;) {
1252 if (i < missingInternal) {
1259 if (missingInternal + missingExternal > 0) {
1261 "keypool added %d keys (%d internal), size=%u (%u internal)\n",
1262 missingInternal + missingExternal, missingInternal,
1263 setInternalKeyPool.size() + setExternalKeyPool.size() +
1264 set_pre_split_keypool.size(),
1265 setInternalKeyPool.size());
1273 const bool internal,
1277 assert(m_max_keypool_index < std::numeric_limits<int64_t>::max());
1278 int64_t index = ++m_max_keypool_index;
1280 throw std::runtime_error(std::string(__func__) +
1281 ": writing imported pubkey failed");
1284 setInternalKeyPool.insert(index);
1286 setExternalKeyPool.insert(index);
1310 setInternalKeyPool.insert(nIndex);
1311 }
else if (!set_pre_split_keypool.empty()) {
1312 set_pre_split_keypool.insert(nIndex);
1314 setExternalKeyPool.insert(nIndex);
1353 bool fRequestedInternal) {
1359 bool fReturningInternal = fRequestedInternal;
1360 fReturningInternal &=
1363 bool use_split_keypool = set_pre_split_keypool.empty();
1364 std::set<int64_t> &setKeyPool =
1366 ? (fReturningInternal ? setInternalKeyPool : setExternalKeyPool)
1367 : set_pre_split_keypool;
1370 if (setKeyPool.empty()) {
1376 auto it = setKeyPool.begin();
1378 setKeyPool.erase(it);
1379 if (!batch.
ReadPool(nIndex, keypool)) {
1380 throw std::runtime_error(std::string(__func__) +
": read failed");
1384 throw std::runtime_error(std::string(__func__) +
1385 ": unknown key in key pool");
1388 if (use_split_keypool && keypool.
fInternal != fReturningInternal) {
1389 throw std::runtime_error(std::string(__func__) +
1390 ": keypool entry misclassified");
1393 throw std::runtime_error(std::string(__func__) +
1394 ": keypool entry invalid");
1417 bool internal = setInternalKeyPool.count(keypool_id);
1419 assert(setExternalKeyPool.count(keypool_id) ||
1420 set_pre_split_keypool.count(keypool_id));
1423 std::set<int64_t> *setKeyPool =
1424 internal ? &setInternalKeyPool
1425 : (set_pre_split_keypool.empty() ? &setExternalKeyPool
1426 : &set_pre_split_keypool);
1427 auto it = setKeyPool->begin();
1430 while (it != std::end(*setKeyPool)) {
1431 const int64_t &index = *(it);
1432 if (index > keypool_id) {
1438 if (batch.
ReadPool(index, keypool)) {
1445 it = setKeyPool->erase(it);
1451 std::vector<CScript> dummy;
1455 std::vector<CKeyID> ret;
1456 for (
const auto &entry : out.
pubkeys) {
1457 ret.push_back(entry.first);
1464 for (
auto it = setExternalKeyPool.begin();
1465 it != setExternalKeyPool.end();) {
1466 int64_t index = *it;
1468 if (!batch.
ReadPool(index, keypool)) {
1469 throw std::runtime_error(std::string(__func__) +
1470 ": read keypool entry failed");
1474 throw std::runtime_error(std::string(__func__) +
1475 ": writing modified keypool entry failed");
1477 set_pre_split_keypool.insert(index);
1478 it = setExternalKeyPool.erase(it);
1488 const CScript &redeemScript) {
1504 mapKeyMetadata[pubkey.
GetID()].key_origin.fingerprint);
1505 mapKeyMetadata[pubkey.
GetID()].key_origin.path = info.
path;
1506 mapKeyMetadata[pubkey.
GetID()].has_key_origin =
true;
1512 int64_t timestamp) {
1514 for (
const auto &entry : scripts) {
1525 if (timestamp > 0) {
1526 m_script_metadata[
CScriptID(entry)].nCreateTime = timestamp;
1529 if (timestamp > 0) {
1537 const std::map<CKeyID, CKey> &privkey_map,
const int64_t timestamp) {
1539 for (
const auto &entry : privkey_map) {
1540 const CKey &key = entry.second;
1542 const CKeyID &
id = entry.first;
1550 mapKeyMetadata[id].nCreateTime = timestamp;
1561 const std::vector<CKeyID> &ordered_pubkeys,
1562 const std::map<CKeyID, CPubKey> &pubkey_map,
1563 const std::map<
CKeyID, std::pair<CPubKey, KeyOriginInfo>> &key_origins,
1564 const bool add_keypool,
const bool internal,
const int64_t timestamp) {
1566 for (
const auto &entry : key_origins) {
1569 for (
const CKeyID &
id : ordered_pubkeys) {
1570 auto entry = pubkey_map.find(
id);
1571 if (entry == pubkey_map.end()) {
1574 const CPubKey &pubkey = entry->second;
1585 mapKeyMetadata[id].nCreateTime = timestamp;
1597 const std::set<CScript> &script_pub_keys,
const bool have_solving_data,
1598 const int64_t timestamp) {
1600 for (
const CScript &script : script_pub_keys) {
1601 if (!have_solving_data || !
IsMine(script)) {
1617 std::set<CKeyID> set_address;
1618 for (
const auto &mi : mapCryptedKeys) {
1619 set_address.insert(mi.first);
1628 std::string &
error) {
1633 error =
"No addresses available";
1639 assert(m_wallet_descriptor.descriptor->IsSingleType());
1640 std::optional<OutputType> desc_addr_type =
1641 m_wallet_descriptor.descriptor->GetOutputType();
1643 if (type != *desc_addr_type) {
1644 throw std::runtime_error(std::string(__func__) +
1645 ": Types are inconsistent");
1652 std::vector<CScript> scripts_temp;
1655 error =
"Error: Keypool ran out, please call keypoolrefill first";
1658 if (!m_wallet_descriptor.descriptor->ExpandFromCache(
1659 m_wallet_descriptor.next_index, m_wallet_descriptor.cache,
1660 scripts_temp, out_keys)) {
1662 error =
"Error: Keypool ran out, please call keypoolrefill first";
1666 std::optional<OutputType> out_script_type =
1667 m_wallet_descriptor.descriptor->GetOutputType();
1668 if (out_script_type && out_script_type == type) {
1671 throw std::runtime_error(
1672 std::string(__func__) +
1673 ": Types are inconsistent. Stored type does not match type of "
1674 "newly generated address");
1676 m_wallet_descriptor.next_index++;
1685 if (m_map_script_pub_keys.count(script) > 0) {
1694 if (!m_map_keys.empty()) {
1699 bool keyPass = m_map_crypted_keys.empty();
1700 bool keyFail =
false;
1701 for (
const auto &mi : m_map_crypted_keys) {
1702 const CPubKey &pubkey = mi.second.first;
1703 const std::vector<uint8_t> &crypted_secret = mi.second.second;
1705 if (!
DecryptKey(master_key, crypted_secret, pubkey, key)) {
1714 if (keyPass && keyFail) {
1715 LogPrintf(
"The wallet is probably corrupted: Some keys decrypt but not "
1717 throw std::runtime_error(
1718 "Error unlocking wallet: some keys decrypt but not all. Your "
1719 "wallet file may be corrupt.");
1721 if (keyFail || (!keyPass && !accept_no_keys)) {
1731 if (!m_map_crypted_keys.empty()) {
1735 for (
const KeyMap::value_type &key_in : m_map_keys) {
1736 const CKey &key = key_in.second;
1739 std::vector<uint8_t> crypted_secret;
1744 m_map_crypted_keys[pubkey.
GetID()] = make_pair(pubkey, crypted_secret);
1759 index = m_wallet_descriptor.next_index - 1;
1767 if (m_wallet_descriptor.next_index - 1 == index) {
1768 m_wallet_descriptor.next_index--;
1779 for (
auto key_pair : m_map_crypted_keys) {
1780 const CPubKey &pubkey = key_pair.second.first;
1781 const std::vector<uint8_t> &crypted_secret = key_pair.second.second;
1785 keys[pubkey.
GetID()] = key;
1794 unsigned int target_size;
1798 target_size = std::max(
1803 int32_t new_range_end =
1804 std::max(m_wallet_descriptor.next_index + int32_t(target_size),
1805 m_wallet_descriptor.range_end);
1809 if (!m_wallet_descriptor.descriptor->IsRange()) {
1811 m_wallet_descriptor.range_end = 1;
1812 m_wallet_descriptor.range_start = 0;
1822 std::vector<CScript> scripts_temp;
1825 if (!m_wallet_descriptor.descriptor->ExpandFromCache(
1826 i, m_wallet_descriptor.cache, scripts_temp, out_keys)) {
1827 if (!m_wallet_descriptor.descriptor->Expand(
1828 i, provider, scripts_temp, out_keys, &temp_cache)) {
1833 for (
const CScript &script : scripts_temp) {
1834 m_map_script_pub_keys[script] = i;
1836 for (
const auto &pk_pair : out_keys.
pubkeys) {
1837 const CPubKey &pubkey = pk_pair.second;
1838 if (m_map_pubkeys.count(pubkey) != 0) {
1845 m_map_pubkeys[pubkey] = i;
1848 for (
const auto &parent_xpub_pair :
1851 if (m_wallet_descriptor.cache.GetCachedParentExtPubKey(
1852 parent_xpub_pair.first, xpub)) {
1853 if (xpub != parent_xpub_pair.second) {
1854 throw std::runtime_error(
1855 std::string(__func__) +
1856 ": New cached parent xpub does not match already "
1857 "cached parent xpub");
1862 parent_xpub_pair.first)) {
1863 throw std::runtime_error(std::string(__func__) +
1864 ": writing cache item failed");
1866 m_wallet_descriptor.cache.CacheParentExtPubKey(
1867 parent_xpub_pair.first, parent_xpub_pair.second);
1869 for (
const auto &derived_xpub_map_pair :
1871 for (
const auto &derived_xpub_pair : derived_xpub_map_pair.second) {
1873 if (m_wallet_descriptor.cache.GetCachedDerivedExtPubKey(
1874 derived_xpub_map_pair.first, derived_xpub_pair.first,
1876 if (xpub != derived_xpub_pair.second) {
1877 throw std::runtime_error(
1878 std::string(__func__) +
1879 ": New cached derived xpub does not match already "
1880 "cached derived xpub");
1885 derived_xpub_pair.second,
id,
1886 derived_xpub_map_pair.first, derived_xpub_pair.first)) {
1887 throw std::runtime_error(std::string(__func__) +
1888 ": writing cache item failed");
1890 m_wallet_descriptor.cache.CacheDerivedExtPubKey(
1891 derived_xpub_map_pair.first, derived_xpub_pair.first,
1892 derived_xpub_pair.second);
1897 m_wallet_descriptor.range_end = new_range_end;
1910 int32_t index = m_map_script_pub_keys[script];
1911 if (index >= m_wallet_descriptor.next_index) {
1913 "mark all keypool items up to this item as used\n",
1915 m_wallet_descriptor.next_index = index + 1;
1929 throw std::runtime_error(std::string(__func__) +
1930 ": writing descriptor private key failed");
1941 if (m_map_keys.find(pubkey.
GetID()) != m_map_keys.end() ||
1942 m_map_crypted_keys.find(pubkey.
GetID()) != m_map_crypted_keys.end()) {
1951 std::vector<uint8_t> crypted_secret;
1954 pubkey.
GetHash(), crypted_secret)) {
1958 m_map_crypted_keys[pubkey.
GetID()] = make_pair(pubkey, crypted_secret);
1961 m_map_keys[pubkey.
GetID()] = key;
1972 if (m_wallet_descriptor.descriptor) {
1976 int64_t creation_time =
GetTime();
1981 std::string desc_prefix;
1982 std::string desc_suffix =
"/*)";
1983 switch (addr_type) {
1985 desc_prefix =
"pkh(" + xpub +
"/44'";
1989 assert(!desc_prefix.empty());
1993 desc_prefix +=
"/1'";
1995 desc_prefix +=
"/0'";
1998 std::string internal_path =
m_internal ?
"/1" :
"/0";
1999 std::string desc_str = desc_prefix +
"/0'" + internal_path + desc_suffix;
2004 std::unique_ptr<Descriptor> desc =
Parse(desc_str, keys,
error,
false);
2006 m_wallet_descriptor = w_desc;
2012 throw std::runtime_error(
2013 std::string(__func__) +
2014 ": writing descriptor master private key failed");
2017 throw std::runtime_error(std::string(__func__) +
2018 ": writing descriptor failed");
2030 return m_wallet_descriptor.descriptor->IsRange();
2038 return m_wallet_descriptor.descriptor->IsSingleType() &&
2039 m_wallet_descriptor.descriptor->IsRange() &&
2041 m_wallet_descriptor.next_index < m_wallet_descriptor.range_end);
2046 return m_map_keys.size() > 0 || m_map_crypted_keys.size() > 0;
2065 return m_wallet_descriptor.range_end - m_wallet_descriptor.next_index;
2070 return m_wallet_descriptor.creation_time;
2073 std::unique_ptr<FlatSigningProvider>
2075 bool include_private)
const {
2079 auto it = m_map_script_pub_keys.find(script);
2080 if (it == m_map_script_pub_keys.end()) {
2083 int32_t index = it->second;
2088 std::unique_ptr<FlatSigningProvider>
2093 auto it = m_map_pubkeys.find(pubkey);
2094 if (it == m_map_pubkeys.end()) {
2097 int32_t index = it->second;
2104 std::unique_ptr<FlatSigningProvider>
2106 bool include_private)
const {
2109 std::unique_ptr<FlatSigningProvider> out_keys =
2110 std::make_unique<FlatSigningProvider>();
2111 std::vector<CScript> scripts_temp;
2112 if (!m_wallet_descriptor.descriptor->ExpandFromCache(
2113 index, m_wallet_descriptor.cache, scripts_temp, *out_keys)) {
2120 m_wallet_descriptor.descriptor->ExpandPrivate(index, master_provider,
2127 std::unique_ptr<SigningProvider>
2139 SigHashType sighash, std::map<int, std::string> &input_errors)
const {
2140 std::unique_ptr<FlatSigningProvider> keys =
2141 std::make_unique<FlatSigningProvider>();
2142 for (
const auto &coin_pair : coins) {
2143 std::unique_ptr<FlatSigningProvider> coin_keys =
2148 *keys =
Merge(*keys, *coin_keys);
2157 std::string &str_sig)
const {
2158 std::unique_ptr<FlatSigningProvider> keys =
2165 if (!keys->GetKey(
ToKeyID(pkhash), key)) {
2178 bool bip32derivs)
const {
2179 for (
size_t i = 0; i < psbtx.
tx->vin.size(); ++i) {
2203 std::unique_ptr<FlatSigningProvider> keys =
2204 std::make_unique<FlatSigningProvider>();
2205 std::unique_ptr<FlatSigningProvider> script_keys =
2208 *keys =
Merge(*keys, *script_keys);
2211 script_keys = std::make_unique<FlatSigningProvider>();
2213 const CPubKey &pubkey = pk_pair.first;
2214 std::unique_ptr<FlatSigningProvider> pk_keys =
2217 *keys =
Merge(*keys, *pk_keys);
2223 psbtx, i, sighash_type);
2228 for (
size_t i = 0; i < psbtx.
tx->vout.size(); ++i) {
2229 std::unique_ptr<SigningProvider> keys =
2241 std::unique_ptr<CKeyMetadata>
2243 std::unique_ptr<SigningProvider> provider =
2248 if (provider->GetKeyOrigin(key_id, orig)) {
2250 std::unique_ptr<CKeyMetadata> meta =
2251 std::make_unique<CKeyMetadata>();
2252 meta->key_origin = orig;
2253 meta->has_key_origin =
true;
2254 meta->nCreateTime = m_wallet_descriptor.creation_time;
2263 std::string desc_str = m_wallet_descriptor.descriptor->ToString();
2266 .
Write((uint8_t *)desc_str.data(), desc_str.size())
2277 m_wallet_descriptor.cache = cache;
2278 for (int32_t i = m_wallet_descriptor.range_start;
2279 i < m_wallet_descriptor.range_end; ++i) {
2281 std::vector<CScript> scripts_temp;
2282 if (!m_wallet_descriptor.descriptor->ExpandFromCache(
2283 i, m_wallet_descriptor.cache, scripts_temp, out_keys)) {
2284 throw std::runtime_error(
2285 "Error: Unable to expand wallet descriptor from cache");
2288 for (
const CScript &script : scripts_temp) {
2289 if (m_map_script_pub_keys.count(script) != 0) {
2290 throw std::runtime_error(
2291 strprintf(
"Error: Already loaded script at index %d as "
2292 "being at index %d",
2293 i, m_map_script_pub_keys[script]));
2295 m_map_script_pub_keys[script] = i;
2297 for (
const auto &pk_pair : out_keys.
pubkeys) {
2298 const CPubKey &pubkey = pk_pair.second;
2299 if (m_map_pubkeys.count(pubkey) != 0) {
2306 m_map_pubkeys[pubkey] = i;
2314 m_map_keys[key_id] = key;
2320 const std::vector<uint8_t> &crypted_key) {
2322 if (!m_map_keys.empty()) {
2326 m_map_crypted_keys[key_id] = make_pair(pubkey, crypted_key);
2333 return m_wallet_descriptor.descriptor !=
nullptr &&
2335 m_wallet_descriptor.descriptor->ToString() ==
2343 throw std::runtime_error(std::string(__func__) +
2344 ": writing descriptor failed");
2349 return m_wallet_descriptor;
2354 std::vector<CScript> script_pub_keys;
2355 script_pub_keys.reserve(m_map_script_pub_keys.size());
2357 for (
auto const &script_pub_key : m_map_script_pub_keys) {
2358 script_pub_keys.push_back(script_pub_key.first);
2360 return script_pub_keys;
2368 throw std::runtime_error(std::string(__func__) +
": " +
error);
2371 m_map_pubkeys.clear();
2372 m_map_script_pub_keys.clear();
2374 m_wallet_descriptor = descriptor;
2381 error =
"can only update matching descriptor";
2385 if (descriptor.
range_start > m_wallet_descriptor.range_start ||
2386 descriptor.
range_end < m_wallet_descriptor.range_end) {
2388 error =
strprintf(
"new range must include current range = [%d,%d]",
2389 m_wallet_descriptor.range_start,
2390 m_wallet_descriptor.range_end - 1);
@ TOP
Top-level scriptPubKey.
bool ParseHDKeypath(const std::string &keypath_str, std::vector< uint32_t > &keypath)
Parse an HD keypaths like "m/7/0'/2000".
std::string WriteHDKeypath(const std::vector< uint32_t > &keypath)
Write HD keypaths as strings.
int64_t GetIntArg(const std::string &strArg, int64_t nDefault) const
Return integer argument or default value.
bool IsTestChain() const
If this chain is exclusively used for testing.
static const int VERSION_HD_BASE
uint32_t nInternalChainCounter
CKeyID seed_id
seed hash160
static const int VERSION_HD_CHAIN_SPLIT
uint32_t nExternalChainCounter
An encapsulated secp256k1 private key.
const uint8_t * begin() const
unsigned int size() const
Simple read-only vector-like interface.
CPrivKey GetPrivKey() const
Convert the private key to a CPrivKey (serialized OpenSSL private key data).
void MakeNewKey(bool fCompressed)
Generate a new private key using a cryptographic PRNG.
CPubKey GetPubKey() const
Compute the public key from a private key.
const uint8_t * end() const
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.
A key from a CWallet's keypool.
bool fInternal
Whether this keypool entry is in the internal keypool (for change outputs)
CPubKey vchPubKey
The public key.
int64_t nTime
The time at which the key was generated. Set in AddKeypoolPubKeyWithDB.
bool m_pre_split
Whether this key was generated for a keypool before the wallet was upgraded to HD-split.
A mutable version of CTransaction.
An encapsulated public key.
CKeyID GetID() const
Get the KeyID of this public key (hash of its serialization)
uint256 GetHash() const
Get the 256-bit hash of this public key.
A hasher class for SHA-256.
CSHA256 & Write(const uint8_t *data, size_t len)
void Finalize(uint8_t hash[OUTPUT_SIZE])
Serialized script, used inside transaction inputs and outputs.
A reference to a CScript: the Hash160 of its serialization (see script.h)
Cache for single descriptor's derived extended pubkeys.
const ExtPubKeyMap GetCachedParentExtPubKeys() const
Retrieve all cached parent xpubs.
const std::unordered_map< uint32_t, ExtPubKeyMap > GetCachedDerivedExtPubKeys() const
Retrieve all cached derived xpubs.
int64_t GetOldestKeyPoolTime() const override
void ReturnDestination(int64_t index, bool internal, const CTxDestination &addr) override
bool AddKey(const CKeyID &key_id, const CKey &key)
void MarkUnusedAddresses(const CScript &script) override
Mark unused addresses as being used.
bool HavePrivateKeys() const override
bool AddCryptedKey(const CKeyID &key_id, const CPubKey &pubkey, const std::vector< uint8_t > &crypted_key)
SigningResult SignMessage(const std::string &message, const PKHash &pkhash, std::string &str_sig) const override
Sign a message with the given script.
bool CanUpdateToWalletDescriptor(const WalletDescriptor &descriptor, std::string &error)
TransactionError FillPSBT(PartiallySignedTransaction &psbt, SigHashType sighash_type=SigHashType().withForkId(), bool sign=true, bool bip32derivs=false) const override
Adds script and derivation path information to a PSBT, and optionally signs it.
bool TopUp(unsigned int size=0) override
Fills internal address pool.
void SetInternal(bool internal) override
std::unique_ptr< SigningProvider > GetSolvingProvider(const CScript &script) const override
bool HasWalletDescriptor(const WalletDescriptor &desc) const
int64_t GetTimeFirstKey() const override
bool CanProvide(const CScript &script, SignatureData &sigdata) override
Whether this ScriptPubKeyMan can provide a SigningProvider (via GetSolvingProvider) that,...
bool GetReservedDestination(const OutputType type, bool internal, CTxDestination &address, int64_t &index, CKeyPool &keypool) override
bool GetNewDestination(const OutputType type, CTxDestination &dest, std::string &error) override
RecursiveMutex cs_desc_man
unsigned int GetKeyPoolSize() const override
bool SetupDescriptorGeneration(const CExtKey &master_key, OutputType addr_type)
Setup descriptors based on the given CExtkey.
void AddDescriptorKey(const CKey &key, const CPubKey &pubkey)
std::unique_ptr< CKeyMetadata > GetMetadata(const CTxDestination &dest) const override
size_t KeypoolCountExternalKeys() const override
int32_t m_max_cached_index
bool SignTransaction(CMutableTransaction &tx, const std::map< COutPoint, Coin > &coins, SigHashType sighash, std::map< int, std::string > &input_errors) const override
Creates new signatures and adds them to the transaction.
bool m_decryption_thoroughly_checked
keeps track of whether Unlock has run a thorough check before
KeyMap GetKeys() const EXCLUSIVE_LOCKS_REQUIRED(cs_desc_man)
std::unique_ptr< FlatSigningProvider > GetSigningProvider(const CScript &script, bool include_private=false) const
const std::vector< CScript > GetScriptPubKeys() const
std::map< CKeyID, CKey > KeyMap
bool Encrypt(const CKeyingMaterial &master_key, WalletBatch *batch) override
bool AddDescriptorKeyWithDB(WalletBatch &batch, const CKey &key, const CPubKey &pubkey) EXCLUSIVE_LOCKS_REQUIRED(cs_desc_man)
void UpdateWalletDescriptor(WalletDescriptor &descriptor)
void SetCache(const DescriptorCache &cache)
uint256 GetID() const override
const WalletDescriptor GetWalletDescriptor() const EXCLUSIVE_LOCKS_REQUIRED(cs_desc_man)
isminetype IsMine(const CScript &script) const override
bool CheckDecryptionKey(const CKeyingMaterial &master_key, bool accept_no_keys=false) override
Check that the given decryption key is valid for this ScriptPubKeyMan, i.e.
bool IsHDEnabled() const override
bool CanGetAddresses(bool internal=false) const override
Returns true if the wallet can give out new addresses.
virtual bool AddKeyPubKey(const CKey &key, const CPubKey &pubkey)
virtual bool GetPubKey(const CKeyID &address, CPubKey &vchPubKeyOut) const override
virtual bool GetCScript(const CScriptID &hash, CScript &redeemScriptOut) const override
virtual bool GetKey(const CKeyID &address, CKey &keyOut) const override
virtual bool AddCScript(const CScript &redeemScript)
virtual std::set< CKeyID > GetKeys() const
std::map< CKeyID, CKey > KeyMap
virtual bool HaveCScript(const CScriptID &hash) const override
RecursiveMutex cs_KeyStore
virtual bool HaveKey(const CKeyID &address) const override
bool GetKeyOrigin(const CKeyID &keyid, KeyOriginInfo &info) const override
std::map< int64_t, CKeyID > m_index_to_reserved_key
void UpgradeKeyMetadata()
Upgrade stored CKeyMetadata objects to store key origin info as KeyOriginInfo.
bool AddCryptedKeyInner(const CPubKey &vchPubKey, const std::vector< uint8_t > &vchCryptedSecret)
bool fDecryptionThoroughlyChecked
keeps track of whether Unlock has run a thorough check before
int64_t GetOldestKeyPoolTime() const override
bool GetReservedDestination(const OutputType type, bool internal, CTxDestination &address, int64_t &index, CKeyPool &keypool) override
uint256 GetID() const override
bool LoadWatchOnly(const CScript &dest)
Adds a watch-only address to the store, without saving it to disk (used by LoadWallet)
std::unique_ptr< SigningProvider > GetSolvingProvider(const CScript &script) const override
void MarkUnusedAddresses(const CScript &script) override
Mark unused addresses as being used.
bool HaveWatchOnly() const
Returns whether there are any watch-only things in the wallet.
bool RemoveWatchOnly(const CScript &dest)
Remove a watch only script from the keystore.
bool GetNewDestination(const OutputType type, CTxDestination &dest, std::string &error) override
bool AddWatchOnlyInMem(const CScript &dest)
void UpdateTimeFirstKey(int64_t nCreateTime) EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore)
Update wallet first key creation time.
void AddKeypoolPubkeyWithDB(const CPubKey &pubkey, const bool internal, WalletBatch &batch)
bool ImportPubKeys(const std::vector< CKeyID > &ordered_pubkeys, const std::map< CKeyID, CPubKey > &pubkey_map, const std::map< CKeyID, std::pair< CPubKey, KeyOriginInfo >> &key_origins, const bool add_keypool, const bool internal, const int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore)
size_t KeypoolCountExternalKeys() const override
void ReturnDestination(int64_t index, bool internal, const CTxDestination &) override
void SetHDSeed(const CPubKey &key)
bool LoadCryptedKey(const CPubKey &vchPubKey, const std::vector< uint8_t > &vchCryptedSecret, bool checksum_valid)
Adds an encrypted key to the store, without saving it to disk (used by LoadWallet)
std::unordered_map< CKeyID, CHDChain, SaltedSipHasher > m_inactive_hd_chains
bool GetKey(const CKeyID &address, CKey &keyOut) const override
void LearnAllRelatedScripts(const CPubKey &key)
Same as LearnRelatedScripts, but when the OutputType is not known (and could be anything).
bool Encrypt(const CKeyingMaterial &master_key, WalletBatch *batch) override
isminetype IsMine(const CScript &script) const override
bool ImportScripts(const std::set< CScript > scripts, int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore)
std::unique_ptr< CKeyMetadata > GetMetadata(const CTxDestination &dest) const override
bool HaveKey(const CKeyID &address) const override
bool ImportPrivKeys(const std::map< CKeyID, CKey > &privkey_map, const int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore)
bool TopUpInactiveHDChain(const CKeyID seed_id, int64_t index, bool internal)
Like TopUp() but adds keys for inactive HD chains.
bool CanGetAddresses(bool internal=false) const override
Returns true if the wallet can give out new addresses.
bool AddKeyPubKeyInner(const CKey &key, const CPubKey &pubkey)
void AddHDChain(const CHDChain &chain)
Set the HD chain model (chain child index counters) and writes it to the database.
bool CheckDecryptionKey(const CKeyingMaterial &master_key, bool accept_no_keys=false) override
Check that the given decryption key is valid for this ScriptPubKeyMan, i.e.
bool CanGenerateKeys() const
void LoadKeyPool(int64_t nIndex, const CKeyPool &keypool)
Load a keypool entry.
bool AddCryptedKey(const CPubKey &vchPubKey, const std::vector< uint8_t > &vchCryptedSecret)
Adds an encrypted key to the store, and saves it to disk.
bool Upgrade(int prev_version, bilingual_str &error) override
Upgrades the wallet to the specified version.
bool IsHDEnabled() const override
bool AddWatchOnlyWithDB(WalletBatch &batch, const CScript &dest) EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore)
bool LoadKey(const CKey &key, const CPubKey &pubkey)
Adds a key to the store, without saving it to disk (used by LoadWallet)
bool AddKeyOriginWithDB(WalletBatch &batch, const CPubKey &pubkey, const KeyOriginInfo &info)
Add a KeyOriginInfo to the wallet.
bool AddWatchOnly(const CScript &dest) EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore)
Private version of AddWatchOnly method which does not accept a timestamp, and which will reset the wa...
bool TopUp(unsigned int size=0) override
Fills internal address pool.
void LoadKeyMetadata(const CKeyID &keyID, const CKeyMetadata &metadata)
Load metadata (used by LoadWallet)
void MarkReserveKeysAsUsed(int64_t keypool_id) EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore)
Marks all keys in the keypool up to and including reserve_key as used.
void LoadHDChain(const CHDChain &chain)
Load a HD chain model (used by LoadWallet)
bool GetPubKey(const CKeyID &address, CPubKey &vchPubKeyOut) const override
void AddInactiveHDChain(const CHDChain &chain)
bool GetWatchPubKey(const CKeyID &address, CPubKey &pubkey_out) const
Fetches a pubkey from mapWatchKeys if it exists there.
TransactionError FillPSBT(PartiallySignedTransaction &psbt, SigHashType sighash_type=SigHashType().withForkId(), bool sign=true, bool bip32derivs=false) const override
Adds script and derivation path information to a PSBT, and optionally signs it.
void LearnRelatedScripts(const CPubKey &key, OutputType)
Explicitly make the wallet learn the related scripts for outputs to the given key.
bool NewKeyPool()
Mark old keypool keys as used, and generate all new keys.
bool ReserveKeyFromKeyPool(int64_t &nIndex, CKeyPool &keypool, bool fRequestedInternal)
Reserves a key from the keypool and sets nIndex to its index.
std::set< CKeyID > GetKeys() const override
void KeepDestination(int64_t index, const OutputType &type) override
bool AddKeyPubKey(const CKey &key, const CPubKey &pubkey) override
Adds a key to the store, and saves it to disk.
CPubKey GenerateNewKey(WalletBatch &batch, CHDChain &hd_chain, bool internal=false) EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore)
Generate a new key.
void MarkPreSplitKeys() EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore)
unsigned int GetKeyPoolSize() const override
bool HavePrivateKeys() const override
bool HaveWatchOnly(const CScript &dest) const
Returns whether the watch-only script is in the wallet.
void SetInternal(bool internal) override
bool SetupGeneration(bool force=false) override
Sets up the key generation stuff, i.e.
CPubKey GenerateNewSeed()
bool ImportScriptPubKeys(const std::set< CScript > &script_pub_keys, const bool have_solving_data, const int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore)
bool AddKeyPubKeyWithDB(WalletBatch &batch, const CKey &key, const CPubKey &pubkey) EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore)
Adds a key to the store, and saves it to disk.
void RewriteDB() override
The action to do when the DB needs rewrite.
CPubKey DeriveNewSeed(const CKey &key)
bool CanProvide(const CScript &script, SignatureData &sigdata) override
Whether this ScriptPubKeyMan can provide a SigningProvider (via GetSolvingProvider) that,...
int64_t GetTimeFirstKey() const override
bool SignTransaction(CMutableTransaction &tx, const std::map< COutPoint, Coin > &coins, SigHashType sighash, std::map< int, std::string > &input_errors) const override
Creates new signatures and adds them to the transaction.
void LoadScriptMetadata(const CScriptID &script_id, const CKeyMetadata &metadata)
SigningResult SignMessage(const std::string &message, const PKHash &pkhash, std::string &str_sig) const override
Sign a message with the given script.
bool LoadCScript(const CScript &redeemScript)
Adds a CScript to the store.
bool AddCScript(const CScript &redeemScript) override
bool AddCScriptWithDB(WalletBatch &batch, const CScript &script)
Adds a script to the store and saves it to disk.
std::map< CKeyID, int64_t > m_pool_key_to_index
bool GetKeyFromPool(CPubKey &key, const OutputType type, bool internal=false)
Fetches a key from the keypool.
void DeriveNewChildKey(WalletBatch &batch, CKeyMetadata &metadata, CKey &secret, CHDChain &hd_chain, bool internal=false) EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore)
WalletStorage & m_storage
boost::signals2::signal< void()> NotifyCanGetAddressesChanged
Keypool has new keys.
boost::signals2::signal< void(bool fHaveWatchOnly)> NotifyWatchonlyChanged
Watch-only address added.
void WalletLogPrintf(std::string fmt, Params... parameters) const
Prepends the wallet name in logging output to ease debugging in multi-wallet use cases.
Signature hash type wrapper class.
uint32_t getRawSigHashType() const
An interface to be implemented by keystores that support signing.
Access to the wallet database.
bool WriteDescriptor(const uint256 &desc_id, const WalletDescriptor &descriptor)
bool WriteDescriptorDerivedCache(const CExtPubKey &xpub, const uint256 &desc_id, uint32_t key_exp_index, uint32_t der_index)
bool ErasePool(int64_t nPool)
bool WriteDescriptorParentCache(const CExtPubKey &xpub, const uint256 &desc_id, uint32_t key_exp_index)
bool WriteCScript(const uint160 &hash, const CScript &redeemScript)
bool EraseWatchOnly(const CScript &script)
bool WriteDescriptorKey(const uint256 &desc_id, const CPubKey &pubkey, const CPrivKey &privkey)
bool ReadPool(int64_t nPool, CKeyPool &keypool)
bool WriteKey(const CPubKey &vchPubKey, const CPrivKey &vchPrivKey, const CKeyMetadata &keyMeta)
bool WriteHDChain(const CHDChain &chain)
write the hdchain model (external chain child index counter)
bool WriteKeyMetadata(const CKeyMetadata &meta, const CPubKey &pubkey, const bool overwrite)
bool WriteWatchOnly(const CScript &script, const CKeyMetadata &keymeta)
bool WritePool(int64_t nPool, const CKeyPool &keypool)
bool WriteCryptedKey(const CPubKey &vchPubKey, const std::vector< uint8_t > &vchCryptedSecret, const CKeyMetadata &keyMeta)
bool WriteCryptedDescriptorKey(const uint256 &desc_id, const CPubKey &pubkey, const std::vector< uint8_t > &secret)
Descriptor with some wallet metadata.
std::shared_ptr< Descriptor > descriptor
virtual bool IsWalletFlagSet(uint64_t) const =0
virtual bool HasEncryptionKeys() const =0
virtual WalletDatabase & GetDatabase()=0
virtual bool IsLocked() const =0
virtual const CKeyingMaterial & GetEncryptionKey() const =0
virtual void UnsetBlankWalletFlag(WalletBatch &)=0
virtual void SetMinVersion(enum WalletFeature, WalletBatch *=nullptr, bool=false)=0
virtual bool CanSupportFeature(enum WalletFeature) const =0
virtual const CChainParams & GetChainParams() const =0
static UniValue Parse(std::string_view raw)
Parse string to UniValue or throw runtime_error if string contains invalid JSON.
const Config & GetConfig()
bool DecryptKey(const CKeyingMaterial &vMasterKey, const std::vector< uint8_t > &vchCryptedSecret, const CPubKey &vchPubKey, CKey &key)
bool EncryptSecret(const CKeyingMaterial &vMasterKey, const CKeyingMaterial &vchPlaintext, const uint256 &nIV, std::vector< uint8_t > &vchCiphertext)
std::vector< uint8_t, secure_allocator< uint8_t > > CKeyingMaterial
std::unique_ptr< Descriptor > InferDescriptor(const CScript &script, const SigningProvider &provider)
Find a descriptor for the specified script, using information from provider where possible.
uint160 Hash160(const T1 &in1)
Compute the 160-bit hash an object.
isminetype
IsMine() return codes.
std::string EncodeDestination(const CTxDestination &dest, const Config &config)
std::string EncodeExtPubKey(const CExtPubKey &key)
bool error(const char *fmt, const Args &...args)
bool MessageSign(const CKey &privkey, const std::string &message, std::string &signature)
Sign a message.
@ PRIVATE_KEY_NOT_AVAILABLE
CTxDestination GetDestinationForKey(const CPubKey &key, OutputType type)
Get a destination of the requested type (if possible) to the specified key.
void UpdatePSBTOutput(const SigningProvider &provider, PartiallySignedTransaction &psbt, int index)
Updates a PSBTOutput with information from provider.
bool PSBTInputSigned(const PSBTInput &input)
Checks whether a PSBTInput is already signed.
bool SignPSBTInput(const SigningProvider &provider, PartiallySignedTransaction &psbt, int index, SigHashType sighash, SignatureData *out_sigdata, bool use_dummy)
Signs a PSBTInput, verifying that all provided data matches what is being signed.
void SignTransaction(CMutableTransaction &mtx, const SigningProvider *keystore, const std::map< COutPoint, Coin > &coins, const UniValue &hashType, UniValue &result)
Sign a transaction with the given keystore and previous transactions.
static const unsigned int MAX_SCRIPT_ELEMENT_SIZE
std::vector< uint8_t > valtype
static bool ExtractPubKey(const CScript &dest, CPubKey &pubKeyOut)
const uint32_t BIP32_HARDENED_KEY_LIMIT
Value for the first BIP 32 hardened derivation.
static int64_t GetOldestKeyTimeInPool(const std::set< int64_t > &setKeyPool, WalletBatch &batch)
std::vector< CKeyID > GetAffectedKeys(const CScript &spk, const SigningProvider &provider)
static const unsigned int DEFAULT_KEYPOOL_SIZE
Default for -keypool.
std::vector< uint8_t > valtype
bool ProduceSignature(const SigningProvider &provider, const BaseSignatureCreator &creator, const CScript &fromPubKey, SignatureData &sigdata)
Produce a script signature using a generic signature creator.
const BaseSignatureCreator & DUMMY_SIGNATURE_CREATOR
A signature creator that just produces 71-byte empty signatures.
const SigningProvider & DUMMY_SIGNING_PROVIDER
FlatSigningProvider Merge(const FlatSigningProvider &a, const FlatSigningProvider &b)
CKeyID GetKeyForDestination(const SigningProvider &store, const CTxDestination &dest)
Return the CKeyID of the key involved in a script (if there is a unique one).
bool ExtractDestination(const CScript &scriptPubKey, CTxDestination &addressRet)
Parse a standard scriptPubKey for the destination address.
CScript GetScriptForRawPubKey(const CPubKey &pubKey)
Generate a P2PK script for the given pubkey.
TxoutType Solver(const CScript &scriptPubKey, std::vector< std::vector< uint8_t >> &vSolutionsRet)
Parse a scriptPubKey and identify script type for standard scripts.
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
CKeyID ToKeyID(const PKHash &key_hash)
std::variant< CNoDestination, PKHash, ScriptHash > CTxDestination
A txout script template with a specific destination.
std::string HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
std::string ToString(const T &t)
Locale-independent version of std::to_string.
CExtPubKey Neuter() const
bool Derive(CExtKey &out, unsigned int nChild) const
void SetSeed(const uint8_t *seed, unsigned int nSeedLen)
std::map< CKeyID, CPubKey > pubkeys
std::map< CKeyID, CKey > keys
std::vector< uint32_t > path
uint8_t fingerprint[4]
First 32 bits of the Hash160 of the public key at the root of the path.
A version of CTransaction with the PSBT format.
std::vector< PSBTInput > inputs
std::optional< CMutableTransaction > tx
std::map< CKeyID, SigPair > signatures
BIP 174 style partial signatures for the input.
bilingual_str _(const char *psz)
Translation function.
@ WALLET_FLAG_DISABLE_PRIVATE_KEYS
@ WALLET_FLAG_KEY_ORIGIN_METADATA
@ WALLET_FLAG_DESCRIPTORS
Indicate that this wallet supports DescriptorScriptPubKeyMan.
@ WALLET_FLAG_BLANK_WALLET
Flag set when a wallet contains no HD seed and no private keys, scripts, addresses,...
@ FEATURE_PRE_SPLIT_KEYPOOL