Bitcoin Core  22.99.0
P2P Digital Currency
scriptpubkeyman.cpp
Go to the documentation of this file.
1 // Copyright (c) 2019-2020 The Bitcoin Core developers
2 // Distributed under the MIT software license, see the accompanying
3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 
5 #include <key_io.h>
6 #include <logging.h>
7 #include <outputtype.h>
8 #include <script/descriptor.h>
9 #include <script/sign.h>
10 #include <util/bip32.h>
11 #include <util/strencodings.h>
12 #include <util/string.h>
13 #include <util/system.h>
14 #include <util/time.h>
15 #include <util/translation.h>
16 #include <wallet/scriptpubkeyman.h>
17 
18 #include <optional>
19 
21 const uint32_t BIP32_HARDENED_KEY_LIMIT = 0x80000000;
22 
24 {
25  if (LEGACY_OUTPUT_TYPES.count(type) == 0) {
26  error = _("Error: Legacy wallets only support the \"legacy\", \"p2sh-segwit\", and \"bech32\" address types").translated;
27  return false;
28  }
29  assert(type != OutputType::BECH32M);
30 
32  error.clear();
33 
34  // Generate a new key that is added to wallet
35  CPubKey new_key;
36  if (!GetKeyFromPool(new_key, type)) {
37  error = _("Error: Keypool ran out, please call keypoolrefill first").translated;
38  return false;
39  }
40  LearnRelatedScripts(new_key, type);
41  dest = GetDestinationForKey(new_key, type);
42  return true;
43 }
44 
45 typedef std::vector<unsigned char> valtype;
46 
47 namespace {
48 
55 enum class IsMineSigVersion
56 {
57  TOP = 0,
58  P2SH = 1,
59  WITNESS_V0 = 2,
60 };
61 
67 enum class IsMineResult
68 {
69  NO = 0,
70  WATCH_ONLY = 1,
71  SPENDABLE = 2,
72  INVALID = 3,
73 };
74 
75 bool PermitsUncompressed(IsMineSigVersion sigversion)
76 {
77  return sigversion == IsMineSigVersion::TOP || sigversion == IsMineSigVersion::P2SH;
78 }
79 
80 bool HaveKeys(const std::vector<valtype>& pubkeys, const LegacyScriptPubKeyMan& keystore)
81 {
82  for (const valtype& pubkey : pubkeys) {
83  CKeyID keyID = CPubKey(pubkey).GetID();
84  if (!keystore.HaveKey(keyID)) return false;
85  }
86  return true;
87 }
88 
97 IsMineResult IsMineInner(const LegacyScriptPubKeyMan& keystore, const CScript& scriptPubKey, IsMineSigVersion sigversion, bool recurse_scripthash=true)
98 {
99  IsMineResult ret = IsMineResult::NO;
100 
101  std::vector<valtype> vSolutions;
102  TxoutType whichType = Solver(scriptPubKey, vSolutions);
103 
104  CKeyID keyID;
105  switch (whichType) {
110  break;
111  case TxoutType::PUBKEY:
112  keyID = CPubKey(vSolutions[0]).GetID();
113  if (!PermitsUncompressed(sigversion) && vSolutions[0].size() != 33) {
114  return IsMineResult::INVALID;
115  }
116  if (keystore.HaveKey(keyID)) {
117  ret = std::max(ret, IsMineResult::SPENDABLE);
118  }
119  break;
121  {
122  if (sigversion == IsMineSigVersion::WITNESS_V0) {
123  // P2WPKH inside P2WSH is invalid.
124  return IsMineResult::INVALID;
125  }
126  if (sigversion == IsMineSigVersion::TOP && !keystore.HaveCScript(CScriptID(CScript() << OP_0 << vSolutions[0]))) {
127  // We do not support bare witness outputs unless the P2SH version of it would be
128  // acceptable as well. This protects against matching before segwit activates.
129  // This also applies to the P2WSH case.
130  break;
131  }
132  ret = std::max(ret, IsMineInner(keystore, GetScriptForDestination(PKHash(uint160(vSolutions[0]))), IsMineSigVersion::WITNESS_V0));
133  break;
134  }
136  keyID = CKeyID(uint160(vSolutions[0]));
137  if (!PermitsUncompressed(sigversion)) {
138  CPubKey pubkey;
139  if (keystore.GetPubKey(keyID, pubkey) && !pubkey.IsCompressed()) {
140  return IsMineResult::INVALID;
141  }
142  }
143  if (keystore.HaveKey(keyID)) {
144  ret = std::max(ret, IsMineResult::SPENDABLE);
145  }
146  break;
148  {
149  if (sigversion != IsMineSigVersion::TOP) {
150  // P2SH inside P2WSH or P2SH is invalid.
151  return IsMineResult::INVALID;
152  }
153  CScriptID scriptID = CScriptID(uint160(vSolutions[0]));
154  CScript subscript;
155  if (keystore.GetCScript(scriptID, subscript)) {
156  ret = std::max(ret, recurse_scripthash ? IsMineInner(keystore, subscript, IsMineSigVersion::P2SH) : IsMineResult::SPENDABLE);
157  }
158  break;
159  }
161  {
162  if (sigversion == IsMineSigVersion::WITNESS_V0) {
163  // P2WSH inside P2WSH is invalid.
164  return IsMineResult::INVALID;
165  }
166  if (sigversion == IsMineSigVersion::TOP && !keystore.HaveCScript(CScriptID(CScript() << OP_0 << vSolutions[0]))) {
167  break;
168  }
169  uint160 hash;
170  CRIPEMD160().Write(vSolutions[0].data(), vSolutions[0].size()).Finalize(hash.begin());
171  CScriptID scriptID = CScriptID(hash);
172  CScript subscript;
173  if (keystore.GetCScript(scriptID, subscript)) {
174  ret = std::max(ret, recurse_scripthash ? IsMineInner(keystore, subscript, IsMineSigVersion::WITNESS_V0) : IsMineResult::SPENDABLE);
175  }
176  break;
177  }
178 
179  case TxoutType::MULTISIG:
180  {
181  // Never treat bare multisig outputs as ours (they can still be made watchonly-though)
182  if (sigversion == IsMineSigVersion::TOP) {
183  break;
184  }
185 
186  // Only consider transactions "mine" if we own ALL the
187  // keys involved. Multi-signature transactions that are
188  // partially owned (somebody else has a key that can spend
189  // them) enable spend-out-from-under-you attacks, especially
190  // in shared-wallet situations.
191  std::vector<valtype> keys(vSolutions.begin()+1, vSolutions.begin()+vSolutions.size()-1);
192  if (!PermitsUncompressed(sigversion)) {
193  for (size_t i = 0; i < keys.size(); i++) {
194  if (keys[i].size() != 33) {
195  return IsMineResult::INVALID;
196  }
197  }
198  }
199  if (HaveKeys(keys, keystore)) {
200  ret = std::max(ret, IsMineResult::SPENDABLE);
201  }
202  break;
203  }
204  } // no default case, so the compiler can warn about missing cases
205 
206  if (ret == IsMineResult::NO && keystore.HaveWatchOnly(scriptPubKey)) {
207  ret = std::max(ret, IsMineResult::WATCH_ONLY);
208  }
209  return ret;
210 }
211 
212 } // namespace
213 
215 {
216  switch (IsMineInner(*this, script, IsMineSigVersion::TOP)) {
217  case IsMineResult::INVALID:
218  case IsMineResult::NO:
219  return ISMINE_NO;
220  case IsMineResult::WATCH_ONLY:
221  return ISMINE_WATCH_ONLY;
222  case IsMineResult::SPENDABLE:
223  return ISMINE_SPENDABLE;
224  }
225  assert(false);
226 }
227 
228 bool LegacyScriptPubKeyMan::CheckDecryptionKey(const CKeyingMaterial& master_key, bool accept_no_keys)
229 {
230  {
231  LOCK(cs_KeyStore);
232  assert(mapKeys.empty());
233 
234  bool keyPass = mapCryptedKeys.empty(); // Always pass when there are no encrypted keys
235  bool keyFail = false;
236  CryptedKeyMap::const_iterator mi = mapCryptedKeys.begin();
238  for (; mi != mapCryptedKeys.end(); ++mi)
239  {
240  const CPubKey &vchPubKey = (*mi).second.first;
241  const std::vector<unsigned char> &vchCryptedSecret = (*mi).second.second;
242  CKey key;
243  if (!DecryptKey(master_key, vchCryptedSecret, vchPubKey, key))
244  {
245  keyFail = true;
246  break;
247  }
248  keyPass = true;
250  break;
251  else {
252  // Rewrite these encrypted keys with checksums
253  batch.WriteCryptedKey(vchPubKey, vchCryptedSecret, mapKeyMetadata[vchPubKey.GetID()]);
254  }
255  }
256  if (keyPass && keyFail)
257  {
258  LogPrintf("The wallet is probably corrupted: Some keys decrypt but not all.\n");
259  throw std::runtime_error("Error unlocking wallet: some keys decrypt but not all. Your wallet file may be corrupt.");
260  }
261  if (keyFail || (!keyPass && !accept_no_keys))
262  return false;
264  }
265  return true;
266 }
267 
269 {
270  LOCK(cs_KeyStore);
271  encrypted_batch = batch;
272  if (!mapCryptedKeys.empty()) {
273  encrypted_batch = nullptr;
274  return false;
275  }
276 
277  KeyMap keys_to_encrypt;
278  keys_to_encrypt.swap(mapKeys); // Clear mapKeys so AddCryptedKeyInner will succeed.
279  for (const KeyMap::value_type& mKey : keys_to_encrypt)
280  {
281  const CKey &key = mKey.second;
282  CPubKey vchPubKey = key.GetPubKey();
283  CKeyingMaterial vchSecret(key.begin(), key.end());
284  std::vector<unsigned char> vchCryptedSecret;
285  if (!EncryptSecret(master_key, vchSecret, vchPubKey.GetHash(), vchCryptedSecret)) {
286  encrypted_batch = nullptr;
287  return false;
288  }
289  if (!AddCryptedKey(vchPubKey, vchCryptedSecret)) {
290  encrypted_batch = nullptr;
291  return false;
292  }
293  }
294  encrypted_batch = nullptr;
295  return true;
296 }
297 
298 bool LegacyScriptPubKeyMan::GetReservedDestination(const OutputType type, bool internal, CTxDestination& address, int64_t& index, CKeyPool& keypool, std::string& error)
299 {
300  if (LEGACY_OUTPUT_TYPES.count(type) == 0) {
301  error = _("Error: Legacy wallets only support the \"legacy\", \"p2sh-segwit\", and \"bech32\" address types").translated;
302  return false;
303  }
304  assert(type != OutputType::BECH32M);
305 
306  LOCK(cs_KeyStore);
307  if (!CanGetAddresses(internal)) {
308  error = _("Error: Keypool ran out, please call keypoolrefill first").translated;
309  return false;
310  }
311 
312  if (!ReserveKeyFromKeyPool(index, keypool, internal)) {
313  error = _("Error: Keypool ran out, please call keypoolrefill first").translated;
314  return false;
315  }
316  address = GetDestinationForKey(keypool.vchPubKey, type);
317  return true;
318 }
319 
320 bool LegacyScriptPubKeyMan::TopUpInactiveHDChain(const CKeyID seed_id, int64_t index, bool internal)
321 {
322  LOCK(cs_KeyStore);
323 
324  if (m_storage.IsLocked()) return false;
325 
326  auto it = m_inactive_hd_chains.find(seed_id);
327  if (it == m_inactive_hd_chains.end()) {
328  return false;
329  }
330 
331  CHDChain& chain = it->second;
332 
333  // Top up key pool
334  int64_t target_size = std::max(gArgs.GetArg("-keypool", DEFAULT_KEYPOOL_SIZE), (int64_t) 1);
335 
336  // "size" of the keypools. Not really the size, actually the difference between index and the chain counter
337  // Since chain counter is 1 based and index is 0 based, one of them needs to be offset by 1.
338  int64_t kp_size = (internal ? chain.nInternalChainCounter : chain.nExternalChainCounter) - (index + 1);
339 
340  // make sure the keypool fits the user-selected target (-keypool)
341  int64_t missing = std::max(target_size - kp_size, (int64_t) 0);
342 
343  if (missing > 0) {
345  for (int64_t i = missing; i > 0; --i) {
346  GenerateNewKey(batch, chain, internal);
347  }
348  if (internal) {
349  WalletLogPrintf("inactive seed with id %s added %d internal keys\n", HexStr(seed_id), missing);
350  } else {
351  WalletLogPrintf("inactive seed with id %s added %d keys\n", HexStr(seed_id), missing);
352  }
353  }
354  return true;
355 }
356 
358 {
359  LOCK(cs_KeyStore);
360  // extract addresses and check if they match with an unused keypool key
361  for (const auto& keyid : GetAffectedKeys(script, *this)) {
362  std::map<CKeyID, int64_t>::const_iterator mi = m_pool_key_to_index.find(keyid);
363  if (mi != m_pool_key_to_index.end()) {
364  WalletLogPrintf("%s: Detected a used keypool key, mark all keypool keys up to this key as used\n", __func__);
365  MarkReserveKeysAsUsed(mi->second);
366 
367  if (!TopUp()) {
368  WalletLogPrintf("%s: Topping up keypool failed (locked wallet)\n", __func__);
369  }
370  }
371 
372  // Find the key's metadata and check if it's seed id (if it has one) is inactive, i.e. it is not the current m_hd_chain seed id.
373  // If so, TopUp the inactive hd chain
374  auto it = mapKeyMetadata.find(keyid);
375  if (it != mapKeyMetadata.end()){
376  CKeyMetadata meta = it->second;
377  if (!meta.hd_seed_id.IsNull() && meta.hd_seed_id != m_hd_chain.seed_id) {
378  bool internal = (meta.key_origin.path[1] & ~BIP32_HARDENED_KEY_LIMIT) != 0;
379  int64_t index = meta.key_origin.path[2] & ~BIP32_HARDENED_KEY_LIMIT;
380 
381  if (!TopUpInactiveHDChain(meta.hd_seed_id, index, internal)) {
382  WalletLogPrintf("%s: Adding inactive seed keys failed\n", __func__);
383  }
384  }
385  }
386  }
387 }
388 
390 {
391  LOCK(cs_KeyStore);
393  return;
394  }
395 
396  std::unique_ptr<WalletBatch> batch = std::make_unique<WalletBatch>(m_storage.GetDatabase());
397  for (auto& meta_pair : mapKeyMetadata) {
398  CKeyMetadata& meta = meta_pair.second;
399  if (!meta.hd_seed_id.IsNull() && !meta.has_key_origin && meta.hdKeypath != "s") { // If the hdKeypath is "s", that's the seed and it doesn't have a key origin
400  CKey key;
401  GetKey(meta.hd_seed_id, key);
402  CExtKey masterKey;
403  masterKey.SetSeed(key.begin(), key.size());
404  // Add to map
405  CKeyID master_id = masterKey.key.GetPubKey().GetID();
406  std::copy(master_id.begin(), master_id.begin() + 4, meta.key_origin.fingerprint);
407  if (!ParseHDKeypath(meta.hdKeypath, meta.key_origin.path)) {
408  throw std::runtime_error("Invalid stored hdKeypath");
409  }
410  meta.has_key_origin = true;
413  }
414 
415  // Write meta to wallet
416  CPubKey pubkey;
417  if (GetPubKey(meta_pair.first, pubkey)) {
418  batch->WriteKeyMetadata(meta, pubkey, true);
419  }
420  }
421  }
422 }
423 
425 {
426  if ((CanGenerateKeys() && !force) || m_storage.IsLocked()) {
427  return false;
428  }
429 
431  if (!NewKeyPool()) {
432  return false;
433  }
434  return true;
435 }
436 
438 {
439  return !m_hd_chain.seed_id.IsNull();
440 }
441 
442 bool LegacyScriptPubKeyMan::CanGetAddresses(bool internal) const
443 {
444  LOCK(cs_KeyStore);
445  // Check if the keypool has keys
446  bool keypool_has_keys;
447  if (internal && m_storage.CanSupportFeature(FEATURE_HD_SPLIT)) {
448  keypool_has_keys = setInternalKeyPool.size() > 0;
449  } else {
450  keypool_has_keys = KeypoolCountExternalKeys() > 0;
451  }
452  // If the keypool doesn't have keys, check if we can generate them
453  if (!keypool_has_keys) {
454  return CanGenerateKeys();
455  }
456  return keypool_has_keys;
457 }
458 
459 bool LegacyScriptPubKeyMan::Upgrade(int prev_version, int new_version, bilingual_str& error)
460 {
461  LOCK(cs_KeyStore);
462  bool hd_upgrade = false;
463  bool split_upgrade = false;
464  if (IsFeatureSupported(new_version, FEATURE_HD) && !IsHDEnabled()) {
465  WalletLogPrintf("Upgrading wallet to HD\n");
467 
468  // generate a new master key
469  CPubKey masterPubKey = GenerateNewSeed();
470  SetHDSeed(masterPubKey);
471  hd_upgrade = true;
472  }
473  // Upgrade to HD chain split if necessary
474  if (!IsFeatureSupported(prev_version, FEATURE_HD_SPLIT) && IsFeatureSupported(new_version, FEATURE_HD_SPLIT)) {
475  WalletLogPrintf("Upgrading wallet to use HD chain split\n");
477  split_upgrade = FEATURE_HD_SPLIT > prev_version;
478  // Upgrade the HDChain
482  throw std::runtime_error(std::string(__func__) + ": writing chain failed");
483  }
484  }
485  }
486  // Mark all keys currently in the keypool as pre-split
487  if (split_upgrade) {
489  }
490  // Regenerate the keypool if upgraded to HD
491  if (hd_upgrade) {
492  if (!TopUp()) {
493  error = _("Unable to generate keys");
494  return false;
495  }
496  }
497  return true;
498 }
499 
501 {
502  LOCK(cs_KeyStore);
503  return !mapKeys.empty() || !mapCryptedKeys.empty();
504 }
505 
507 {
508  LOCK(cs_KeyStore);
509  setInternalKeyPool.clear();
510  setExternalKeyPool.clear();
511  m_pool_key_to_index.clear();
512  // Note: can't top-up keypool here, because wallet is locked.
513  // User will be prompted to unlock wallet the next operation
514  // that requires a new key.
515 }
516 
517 static int64_t GetOldestKeyTimeInPool(const std::set<int64_t>& setKeyPool, WalletBatch& batch) {
518  if (setKeyPool.empty()) {
519  return GetTime();
520  }
521 
522  CKeyPool keypool;
523  int64_t nIndex = *(setKeyPool.begin());
524  if (!batch.ReadPool(nIndex, keypool)) {
525  throw std::runtime_error(std::string(__func__) + ": read oldest key in keypool failed");
526  }
527  assert(keypool.vchPubKey.IsValid());
528  return keypool.nTime;
529 }
530 
532 {
533  LOCK(cs_KeyStore);
534 
536 
537  // load oldest key from keypool, get time and return
538  int64_t oldestKey = GetOldestKeyTimeInPool(setExternalKeyPool, batch);
540  oldestKey = std::max(GetOldestKeyTimeInPool(setInternalKeyPool, batch), oldestKey);
541  if (!set_pre_split_keypool.empty()) {
542  oldestKey = std::max(GetOldestKeyTimeInPool(set_pre_split_keypool, batch), oldestKey);
543  }
544  }
545 
546  return oldestKey;
547 }
548 
550 {
551  LOCK(cs_KeyStore);
552  return setExternalKeyPool.size() + set_pre_split_keypool.size();
553 }
554 
556 {
557  LOCK(cs_KeyStore);
558  return setInternalKeyPool.size() + setExternalKeyPool.size() + set_pre_split_keypool.size();
559 }
560 
562 {
563  LOCK(cs_KeyStore);
564  return nTimeFirstKey;
565 }
566 
567 std::unique_ptr<SigningProvider> LegacyScriptPubKeyMan::GetSolvingProvider(const CScript& script) const
568 {
569  return std::make_unique<LegacySigningProvider>(*this);
570 }
571 
573 {
574  IsMineResult ismine = IsMineInner(*this, script, IsMineSigVersion::TOP, /* recurse_scripthash= */ false);
575  if (ismine == IsMineResult::SPENDABLE || ismine == IsMineResult::WATCH_ONLY) {
576  // If ismine, it means we recognize keys or script ids in the script, or
577  // are watching the script itself, and we can at least provide metadata
578  // or solving information, even if not able to sign fully.
579  return true;
580  } else {
581  // If, given the stuff in sigdata, we could make a valid sigature, then we can provide for this script
582  ProduceSignature(*this, DUMMY_SIGNATURE_CREATOR, script, sigdata);
583  if (!sigdata.signatures.empty()) {
584  // If we could make signatures, make sure we have a private key to actually make a signature
585  bool has_privkeys = false;
586  for (const auto& key_sig_pair : sigdata.signatures) {
587  has_privkeys |= HaveKey(key_sig_pair.first);
588  }
589  return has_privkeys;
590  }
591  return false;
592  }
593 }
594 
595 bool LegacyScriptPubKeyMan::SignTransaction(CMutableTransaction& tx, const std::map<COutPoint, Coin>& coins, int sighash, std::map<int, std::string>& input_errors) const
596 {
597  return ::SignTransaction(tx, this, coins, sighash, input_errors);
598 }
599 
600 SigningResult LegacyScriptPubKeyMan::SignMessage(const std::string& message, const PKHash& pkhash, std::string& str_sig) const
601 {
602  CKey key;
603  if (!GetKey(ToKeyID(pkhash), key)) {
605  }
606 
607  if (MessageSign(key, message, str_sig)) {
608  return SigningResult::OK;
609  }
611 }
612 
613 TransactionError LegacyScriptPubKeyMan::FillPSBT(PartiallySignedTransaction& psbtx, const PrecomputedTransactionData& txdata, int sighash_type, bool sign, bool bip32derivs, int* n_signed) const
614 {
615  if (n_signed) {
616  *n_signed = 0;
617  }
618  for (unsigned int i = 0; i < psbtx.tx->vin.size(); ++i) {
619  const CTxIn& txin = psbtx.tx->vin[i];
620  PSBTInput& input = psbtx.inputs.at(i);
621 
622  if (PSBTInputSigned(input)) {
623  continue;
624  }
625 
626  // Get the Sighash type
627  if (sign && input.sighash_type > 0 && input.sighash_type != sighash_type) {
629  }
630 
631  // Check non_witness_utxo has specified prevout
632  if (input.non_witness_utxo) {
633  if (txin.prevout.n >= input.non_witness_utxo->vout.size()) {
635  }
636  } else if (input.witness_utxo.IsNull()) {
637  // There's no UTXO so we can just skip this now
638  continue;
639  }
640  SignatureData sigdata;
641  input.FillSignatureData(sigdata);
642  SignPSBTInput(HidingSigningProvider(this, !sign, !bip32derivs), psbtx, i, &txdata, sighash_type);
643 
644  bool signed_one = PSBTInputSigned(input);
645  if (n_signed && (signed_one || !sign)) {
646  // If sign is false, we assume that we _could_ sign if we get here. This
647  // will never have false negatives; it is hard to tell under what i
648  // circumstances it could have false positives.
649  (*n_signed)++;
650  }
651  }
652 
653  // Fill in the bip32 keypaths and redeemscripts for the outputs so that hardware wallets can identify change
654  for (unsigned int i = 0; i < psbtx.tx->vout.size(); ++i) {
655  UpdatePSBTOutput(HidingSigningProvider(this, true, !bip32derivs), psbtx, i);
656  }
657 
658  return TransactionError::OK;
659 }
660 
661 std::unique_ptr<CKeyMetadata> LegacyScriptPubKeyMan::GetMetadata(const CTxDestination& dest) const
662 {
663  LOCK(cs_KeyStore);
664 
665  CKeyID key_id = GetKeyForDestination(*this, dest);
666  if (!key_id.IsNull()) {
667  auto it = mapKeyMetadata.find(key_id);
668  if (it != mapKeyMetadata.end()) {
669  return std::make_unique<CKeyMetadata>(it->second);
670  }
671  }
672 
673  CScript scriptPubKey = GetScriptForDestination(dest);
674  auto it = m_script_metadata.find(CScriptID(scriptPubKey));
675  if (it != m_script_metadata.end()) {
676  return std::make_unique<CKeyMetadata>(it->second);
677  }
678 
679  return nullptr;
680 }
681 
683 {
684  return uint256::ONE;
685 }
686 
692 {
694  if (nCreateTime <= 1) {
695  // Cannot determine birthday information, so set the wallet birthday to
696  // the beginning of time.
697  nTimeFirstKey = 1;
698  } else if (!nTimeFirstKey || nCreateTime < nTimeFirstKey) {
699  nTimeFirstKey = nCreateTime;
700  }
701 }
702 
703 bool LegacyScriptPubKeyMan::LoadKey(const CKey& key, const CPubKey &pubkey)
704 {
705  return AddKeyPubKeyInner(key, pubkey);
706 }
707 
708 bool LegacyScriptPubKeyMan::AddKeyPubKey(const CKey& secret, const CPubKey &pubkey)
709 {
710  LOCK(cs_KeyStore);
712  return LegacyScriptPubKeyMan::AddKeyPubKeyWithDB(batch, secret, pubkey);
713 }
714 
715 bool LegacyScriptPubKeyMan::AddKeyPubKeyWithDB(WalletBatch& batch, const CKey& secret, const CPubKey& pubkey)
716 {
718 
719  // Make sure we aren't adding private keys to private key disabled wallets
721 
722  // FillableSigningProvider has no concept of wallet databases, but calls AddCryptedKey
723  // which is overridden below. To avoid flushes, the database handle is
724  // tunneled through to it.
725  bool needsDB = !encrypted_batch;
726  if (needsDB) {
727  encrypted_batch = &batch;
728  }
729  if (!AddKeyPubKeyInner(secret, pubkey)) {
730  if (needsDB) encrypted_batch = nullptr;
731  return false;
732  }
733  if (needsDB) encrypted_batch = nullptr;
734 
735  // check if we need to remove from watch-only
736  CScript script;
737  script = GetScriptForDestination(PKHash(pubkey));
738  if (HaveWatchOnly(script)) {
739  RemoveWatchOnly(script);
740  }
741  script = GetScriptForRawPubKey(pubkey);
742  if (HaveWatchOnly(script)) {
743  RemoveWatchOnly(script);
744  }
745 
746  if (!m_storage.HasEncryptionKeys()) {
747  return batch.WriteKey(pubkey,
748  secret.GetPrivKey(),
749  mapKeyMetadata[pubkey.GetID()]);
750  }
752  return true;
753 }
754 
756 {
757  /* A sanity check was added in pull #3843 to avoid adding redeemScripts
758  * that never can be redeemed. However, old wallets may still contain
759  * these. Do not add them to the wallet and warn. */
760  if (redeemScript.size() > MAX_SCRIPT_ELEMENT_SIZE)
761  {
762  std::string strAddr = EncodeDestination(ScriptHash(redeemScript));
763  WalletLogPrintf("%s: Warning: This wallet contains a redeemScript of size %i which exceeds maximum size %i thus can never be redeemed. Do not use address %s.\n", __func__, redeemScript.size(), MAX_SCRIPT_ELEMENT_SIZE, strAddr);
764  return true;
765  }
766 
767  return FillableSigningProvider::AddCScript(redeemScript);
768 }
769 
771 {
772  LOCK(cs_KeyStore);
774  mapKeyMetadata[keyID] = meta;
775 }
776 
778 {
779  LOCK(cs_KeyStore);
781  m_script_metadata[script_id] = meta;
782 }
783 
785 {
786  LOCK(cs_KeyStore);
787  if (!m_storage.HasEncryptionKeys()) {
788  return FillableSigningProvider::AddKeyPubKey(key, pubkey);
789  }
790 
791  if (m_storage.IsLocked()) {
792  return false;
793  }
794 
795  std::vector<unsigned char> vchCryptedSecret;
796  CKeyingMaterial vchSecret(key.begin(), key.end());
797  if (!EncryptSecret(m_storage.GetEncryptionKey(), vchSecret, pubkey.GetHash(), vchCryptedSecret)) {
798  return false;
799  }
800 
801  if (!AddCryptedKey(pubkey, vchCryptedSecret)) {
802  return false;
803  }
804  return true;
805 }
806 
807 bool LegacyScriptPubKeyMan::LoadCryptedKey(const CPubKey &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret, bool checksum_valid)
808 {
809  // Set fDecryptionThoroughlyChecked to false when the checksum is invalid
810  if (!checksum_valid) {
812  }
813 
814  return AddCryptedKeyInner(vchPubKey, vchCryptedSecret);
815 }
816 
817 bool LegacyScriptPubKeyMan::AddCryptedKeyInner(const CPubKey &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret)
818 {
819  LOCK(cs_KeyStore);
820  assert(mapKeys.empty());
821 
822  mapCryptedKeys[vchPubKey.GetID()] = make_pair(vchPubKey, vchCryptedSecret);
824  return true;
825 }
826 
828  const std::vector<unsigned char> &vchCryptedSecret)
829 {
830  if (!AddCryptedKeyInner(vchPubKey, vchCryptedSecret))
831  return false;
832  {
833  LOCK(cs_KeyStore);
834  if (encrypted_batch)
835  return encrypted_batch->WriteCryptedKey(vchPubKey,
836  vchCryptedSecret,
837  mapKeyMetadata[vchPubKey.GetID()]);
838  else
839  return WalletBatch(m_storage.GetDatabase()).WriteCryptedKey(vchPubKey,
840  vchCryptedSecret,
841  mapKeyMetadata[vchPubKey.GetID()]);
842  }
843 }
844 
846 {
847  LOCK(cs_KeyStore);
848  return setWatchOnly.count(dest) > 0;
849 }
850 
852 {
853  LOCK(cs_KeyStore);
854  return (!setWatchOnly.empty());
855 }
856 
857 static bool ExtractPubKey(const CScript &dest, CPubKey& pubKeyOut)
858 {
859  std::vector<std::vector<unsigned char>> solutions;
860  return Solver(dest, solutions) == TxoutType::PUBKEY &&
861  (pubKeyOut = CPubKey(solutions[0])).IsFullyValid();
862 }
863 
865 {
866  {
867  LOCK(cs_KeyStore);
868  setWatchOnly.erase(dest);
869  CPubKey pubKey;
870  if (ExtractPubKey(dest, pubKey)) {
871  mapWatchKeys.erase(pubKey.GetID());
872  }
873  // Related CScripts are not removed; having superfluous scripts around is
874  // harmless (see comment in ImplicitlyLearnRelatedKeyScripts).
875  }
876 
877  if (!HaveWatchOnly())
878  NotifyWatchonlyChanged(false);
880  return false;
881 
882  return true;
883 }
884 
886 {
887  return AddWatchOnlyInMem(dest);
888 }
889 
891 {
892  LOCK(cs_KeyStore);
893  setWatchOnly.insert(dest);
894  CPubKey pubKey;
895  if (ExtractPubKey(dest, pubKey)) {
896  mapWatchKeys[pubKey.GetID()] = pubKey;
898  }
899  return true;
900 }
901 
903 {
904  if (!AddWatchOnlyInMem(dest))
905  return false;
906  const CKeyMetadata& meta = m_script_metadata[CScriptID(dest)];
909  if (batch.WriteWatchOnly(dest, meta)) {
911  return true;
912  }
913  return false;
914 }
915 
916 bool LegacyScriptPubKeyMan::AddWatchOnlyWithDB(WalletBatch &batch, const CScript& dest, int64_t create_time)
917 {
918  m_script_metadata[CScriptID(dest)].nCreateTime = create_time;
919  return AddWatchOnlyWithDB(batch, dest);
920 }
921 
923 {
925  return AddWatchOnlyWithDB(batch, dest);
926 }
927 
928 bool LegacyScriptPubKeyMan::AddWatchOnly(const CScript& dest, int64_t nCreateTime)
929 {
930  m_script_metadata[CScriptID(dest)].nCreateTime = nCreateTime;
931  return AddWatchOnly(dest);
932 }
933 
935 {
936  LOCK(cs_KeyStore);
937  m_hd_chain = chain;
938 }
939 
941 {
942  LOCK(cs_KeyStore);
943  // Store the new chain
945  throw std::runtime_error(std::string(__func__) + ": writing chain failed");
946  }
947  // When there's an old chain, add it as an inactive chain as we are now rotating hd chains
948  if (!m_hd_chain.seed_id.IsNull()) {
950  }
951 
952  m_hd_chain = chain;
953 }
954 
956 {
957  LOCK(cs_KeyStore);
958  assert(!chain.seed_id.IsNull());
959  m_inactive_hd_chains[chain.seed_id] = chain;
960 }
961 
962 bool LegacyScriptPubKeyMan::HaveKey(const CKeyID &address) const
963 {
964  LOCK(cs_KeyStore);
965  if (!m_storage.HasEncryptionKeys()) {
966  return FillableSigningProvider::HaveKey(address);
967  }
968  return mapCryptedKeys.count(address) > 0;
969 }
970 
971 bool LegacyScriptPubKeyMan::GetKey(const CKeyID &address, CKey& keyOut) const
972 {
973  LOCK(cs_KeyStore);
974  if (!m_storage.HasEncryptionKeys()) {
975  return FillableSigningProvider::GetKey(address, keyOut);
976  }
977 
978  CryptedKeyMap::const_iterator mi = mapCryptedKeys.find(address);
979  if (mi != mapCryptedKeys.end())
980  {
981  const CPubKey &vchPubKey = (*mi).second.first;
982  const std::vector<unsigned char> &vchCryptedSecret = (*mi).second.second;
983  return DecryptKey(m_storage.GetEncryptionKey(), vchCryptedSecret, vchPubKey, keyOut);
984  }
985  return false;
986 }
987 
989 {
990  CKeyMetadata meta;
991  {
992  LOCK(cs_KeyStore);
993  auto it = mapKeyMetadata.find(keyID);
994  if (it != mapKeyMetadata.end()) {
995  meta = it->second;
996  }
997  }
998  if (meta.has_key_origin) {
999  std::copy(meta.key_origin.fingerprint, meta.key_origin.fingerprint + 4, info.fingerprint);
1000  info.path = meta.key_origin.path;
1001  } else { // Single pubkeys get the master fingerprint of themselves
1002  std::copy(keyID.begin(), keyID.begin() + 4, info.fingerprint);
1003  }
1004  return true;
1005 }
1006 
1007 bool LegacyScriptPubKeyMan::GetWatchPubKey(const CKeyID &address, CPubKey &pubkey_out) const
1008 {
1009  LOCK(cs_KeyStore);
1010  WatchKeyMap::const_iterator it = mapWatchKeys.find(address);
1011  if (it != mapWatchKeys.end()) {
1012  pubkey_out = it->second;
1013  return true;
1014  }
1015  return false;
1016 }
1017 
1018 bool LegacyScriptPubKeyMan::GetPubKey(const CKeyID &address, CPubKey& vchPubKeyOut) const
1019 {
1020  LOCK(cs_KeyStore);
1021  if (!m_storage.HasEncryptionKeys()) {
1022  if (!FillableSigningProvider::GetPubKey(address, vchPubKeyOut)) {
1023  return GetWatchPubKey(address, vchPubKeyOut);
1024  }
1025  return true;
1026  }
1027 
1028  CryptedKeyMap::const_iterator mi = mapCryptedKeys.find(address);
1029  if (mi != mapCryptedKeys.end())
1030  {
1031  vchPubKeyOut = (*mi).second.first;
1032  return true;
1033  }
1034  // Check for watch-only pubkeys
1035  return GetWatchPubKey(address, vchPubKeyOut);
1036 }
1037 
1039 {
1043  bool fCompressed = m_storage.CanSupportFeature(FEATURE_COMPRPUBKEY); // default to compressed public keys if we want 0.6.0 wallets
1044 
1045  CKey secret;
1046 
1047  // Create new metadata
1048  int64_t nCreationTime = GetTime();
1049  CKeyMetadata metadata(nCreationTime);
1050 
1051  // use HD key derivation if HD was enabled during wallet creation and a seed is present
1052  if (IsHDEnabled()) {
1053  DeriveNewChildKey(batch, metadata, secret, hd_chain, (m_storage.CanSupportFeature(FEATURE_HD_SPLIT) ? internal : false));
1054  } else {
1055  secret.MakeNewKey(fCompressed);
1056  }
1057 
1058  // Compressed public keys were introduced in version 0.6.0
1059  if (fCompressed) {
1061  }
1062 
1063  CPubKey pubkey = secret.GetPubKey();
1064  assert(secret.VerifyPubKey(pubkey));
1065 
1066  mapKeyMetadata[pubkey.GetID()] = metadata;
1067  UpdateTimeFirstKey(nCreationTime);
1068 
1069  if (!AddKeyPubKeyWithDB(batch, secret, pubkey)) {
1070  throw std::runtime_error(std::string(__func__) + ": AddKey failed");
1071  }
1072  return pubkey;
1073 }
1074 
1075 void LegacyScriptPubKeyMan::DeriveNewChildKey(WalletBatch &batch, CKeyMetadata& metadata, CKey& secret, CHDChain& hd_chain, bool internal)
1076 {
1077  // for now we use a fixed keypath scheme of m/0'/0'/k
1078  CKey seed; //seed (256bit)
1079  CExtKey masterKey; //hd master key
1080  CExtKey accountKey; //key at m/0'
1081  CExtKey chainChildKey; //key at m/0'/0' (external) or m/0'/1' (internal)
1082  CExtKey childKey; //key at m/0'/0'/<n>'
1083 
1084  // try to get the seed
1085  if (!GetKey(hd_chain.seed_id, seed))
1086  throw std::runtime_error(std::string(__func__) + ": seed not found");
1087 
1088  masterKey.SetSeed(seed.begin(), seed.size());
1089 
1090  // derive m/0'
1091  // use hardened derivation (child keys >= 0x80000000 are hardened after bip32)
1092  masterKey.Derive(accountKey, BIP32_HARDENED_KEY_LIMIT);
1093 
1094  // derive m/0'/0' (external chain) OR m/0'/1' (internal chain)
1095  assert(internal ? m_storage.CanSupportFeature(FEATURE_HD_SPLIT) : true);
1096  accountKey.Derive(chainChildKey, BIP32_HARDENED_KEY_LIMIT+(internal ? 1 : 0));
1097 
1098  // derive child key at next index, skip keys already known to the wallet
1099  do {
1100  // always derive hardened keys
1101  // childIndex | BIP32_HARDENED_KEY_LIMIT = derive childIndex in hardened child-index-range
1102  // example: 1 | BIP32_HARDENED_KEY_LIMIT == 0x80000001 == 2147483649
1103  if (internal) {
1104  chainChildKey.Derive(childKey, hd_chain.nInternalChainCounter | BIP32_HARDENED_KEY_LIMIT);
1105  metadata.hdKeypath = "m/0'/1'/" + ToString(hd_chain.nInternalChainCounter) + "'";
1106  metadata.key_origin.path.push_back(0 | BIP32_HARDENED_KEY_LIMIT);
1107  metadata.key_origin.path.push_back(1 | BIP32_HARDENED_KEY_LIMIT);
1108  metadata.key_origin.path.push_back(hd_chain.nInternalChainCounter | BIP32_HARDENED_KEY_LIMIT);
1109  hd_chain.nInternalChainCounter++;
1110  }
1111  else {
1112  chainChildKey.Derive(childKey, hd_chain.nExternalChainCounter | BIP32_HARDENED_KEY_LIMIT);
1113  metadata.hdKeypath = "m/0'/0'/" + ToString(hd_chain.nExternalChainCounter) + "'";
1114  metadata.key_origin.path.push_back(0 | BIP32_HARDENED_KEY_LIMIT);
1115  metadata.key_origin.path.push_back(0 | BIP32_HARDENED_KEY_LIMIT);
1116  metadata.key_origin.path.push_back(hd_chain.nExternalChainCounter | BIP32_HARDENED_KEY_LIMIT);
1117  hd_chain.nExternalChainCounter++;
1118  }
1119  } while (HaveKey(childKey.key.GetPubKey().GetID()));
1120  secret = childKey.key;
1121  metadata.hd_seed_id = hd_chain.seed_id;
1122  CKeyID master_id = masterKey.key.GetPubKey().GetID();
1123  std::copy(master_id.begin(), master_id.begin() + 4, metadata.key_origin.fingerprint);
1124  metadata.has_key_origin = true;
1125  // update the chain model in the database
1126  if (hd_chain.seed_id == m_hd_chain.seed_id && !batch.WriteHDChain(hd_chain))
1127  throw std::runtime_error(std::string(__func__) + ": writing HD chain model failed");
1128 }
1129 
1130 void LegacyScriptPubKeyMan::LoadKeyPool(int64_t nIndex, const CKeyPool &keypool)
1131 {
1132  LOCK(cs_KeyStore);
1133  if (keypool.m_pre_split) {
1134  set_pre_split_keypool.insert(nIndex);
1135  } else if (keypool.fInternal) {
1136  setInternalKeyPool.insert(nIndex);
1137  } else {
1138  setExternalKeyPool.insert(nIndex);
1139  }
1140  m_max_keypool_index = std::max(m_max_keypool_index, nIndex);
1141  m_pool_key_to_index[keypool.vchPubKey.GetID()] = nIndex;
1142 
1143  // If no metadata exists yet, create a default with the pool key's
1144  // creation time. Note that this may be overwritten by actually
1145  // stored metadata for that key later, which is fine.
1146  CKeyID keyid = keypool.vchPubKey.GetID();
1147  if (mapKeyMetadata.count(keyid) == 0)
1148  mapKeyMetadata[keyid] = CKeyMetadata(keypool.nTime);
1149 }
1150 
1152 {
1153  // A wallet can generate keys if it has an HD seed (IsHDEnabled) or it is a non-HD wallet (pre FEATURE_HD)
1154  LOCK(cs_KeyStore);
1156 }
1157 
1159 {
1161  CKey key;
1162  key.MakeNewKey(true);
1163  return DeriveNewSeed(key);
1164 }
1165 
1167 {
1168  int64_t nCreationTime = GetTime();
1169  CKeyMetadata metadata(nCreationTime);
1170 
1171  // calculate the seed
1172  CPubKey seed = key.GetPubKey();
1173  assert(key.VerifyPubKey(seed));
1174 
1175  // set the hd keypath to "s" -> Seed, refers the seed to itself
1176  metadata.hdKeypath = "s";
1177  metadata.has_key_origin = false;
1178  metadata.hd_seed_id = seed.GetID();
1179 
1180  {
1181  LOCK(cs_KeyStore);
1182 
1183  // mem store the metadata
1184  mapKeyMetadata[seed.GetID()] = metadata;
1185 
1186  // write the key&metadata to the database
1187  if (!AddKeyPubKey(key, seed))
1188  throw std::runtime_error(std::string(__func__) + ": AddKeyPubKey failed");
1189  }
1190 
1191  return seed;
1192 }
1193 
1195 {
1196  LOCK(cs_KeyStore);
1197  // store the keyid (hash160) together with
1198  // the child index counter in the database
1199  // as a hdchain object
1200  CHDChain newHdChain;
1202  newHdChain.seed_id = seed.GetID();
1203  AddHDChain(newHdChain);
1207 }
1208 
1214 {
1216  return false;
1217  }
1218  {
1219  LOCK(cs_KeyStore);
1221 
1222  for (const int64_t nIndex : setInternalKeyPool) {
1223  batch.ErasePool(nIndex);
1224  }
1225  setInternalKeyPool.clear();
1226 
1227  for (const int64_t nIndex : setExternalKeyPool) {
1228  batch.ErasePool(nIndex);
1229  }
1230  setExternalKeyPool.clear();
1231 
1232  for (const int64_t nIndex : set_pre_split_keypool) {
1233  batch.ErasePool(nIndex);
1234  }
1235  set_pre_split_keypool.clear();
1236 
1237  m_pool_key_to_index.clear();
1238 
1239  if (!TopUp()) {
1240  return false;
1241  }
1242  WalletLogPrintf("LegacyScriptPubKeyMan::NewKeyPool rewrote keypool\n");
1243  }
1244  return true;
1245 }
1246 
1247 bool LegacyScriptPubKeyMan::TopUp(unsigned int kpSize)
1248 {
1249  if (!CanGenerateKeys()) {
1250  return false;
1251  }
1252  {
1253  LOCK(cs_KeyStore);
1254 
1255  if (m_storage.IsLocked()) return false;
1256 
1257  // Top up key pool
1258  unsigned int nTargetSize;
1259  if (kpSize > 0)
1260  nTargetSize = kpSize;
1261  else
1262  nTargetSize = std::max(gArgs.GetArg("-keypool", DEFAULT_KEYPOOL_SIZE), (int64_t) 0);
1263 
1264  // count amount of available keys (internal, external)
1265  // make sure the keypool of external and internal keys fits the user selected target (-keypool)
1266  int64_t missingExternal = std::max(std::max((int64_t) nTargetSize, (int64_t) 1) - (int64_t)setExternalKeyPool.size(), (int64_t) 0);
1267  int64_t missingInternal = std::max(std::max((int64_t) nTargetSize, (int64_t) 1) - (int64_t)setInternalKeyPool.size(), (int64_t) 0);
1268 
1270  {
1271  // don't create extra internal keys
1272  missingInternal = 0;
1273  }
1274  bool internal = false;
1276  for (int64_t i = missingInternal + missingExternal; i--;)
1277  {
1278  if (i < missingInternal) {
1279  internal = true;
1280  }
1281 
1282  CPubKey pubkey(GenerateNewKey(batch, m_hd_chain, internal));
1283  AddKeypoolPubkeyWithDB(pubkey, internal, batch);
1284  }
1285  if (missingInternal + missingExternal > 0) {
1286  WalletLogPrintf("keypool added %d keys (%d internal), size=%u (%u internal)\n", missingInternal + missingExternal, missingInternal, setInternalKeyPool.size() + setExternalKeyPool.size() + set_pre_split_keypool.size(), setInternalKeyPool.size());
1287  }
1288  }
1290  return true;
1291 }
1292 
1293 void LegacyScriptPubKeyMan::AddKeypoolPubkeyWithDB(const CPubKey& pubkey, const bool internal, WalletBatch& batch)
1294 {
1295  LOCK(cs_KeyStore);
1296  assert(m_max_keypool_index < std::numeric_limits<int64_t>::max()); // How in the hell did you use so many keys?
1297  int64_t index = ++m_max_keypool_index;
1298  if (!batch.WritePool(index, CKeyPool(pubkey, internal))) {
1299  throw std::runtime_error(std::string(__func__) + ": writing imported pubkey failed");
1300  }
1301  if (internal) {
1302  setInternalKeyPool.insert(index);
1303  } else {
1304  setExternalKeyPool.insert(index);
1305  }
1306  m_pool_key_to_index[pubkey.GetID()] = index;
1307 }
1308 
1309 void LegacyScriptPubKeyMan::KeepDestination(int64_t nIndex, const OutputType& type)
1310 {
1311  assert(type != OutputType::BECH32M);
1312  // Remove from key pool
1314  batch.ErasePool(nIndex);
1315  CPubKey pubkey;
1316  bool have_pk = GetPubKey(m_index_to_reserved_key.at(nIndex), pubkey);
1317  assert(have_pk);
1318  LearnRelatedScripts(pubkey, type);
1319  m_index_to_reserved_key.erase(nIndex);
1320  WalletLogPrintf("keypool keep %d\n", nIndex);
1321 }
1322 
1323 void LegacyScriptPubKeyMan::ReturnDestination(int64_t nIndex, bool fInternal, const CTxDestination&)
1324 {
1325  // Return to key pool
1326  {
1327  LOCK(cs_KeyStore);
1328  if (fInternal) {
1329  setInternalKeyPool.insert(nIndex);
1330  } else if (!set_pre_split_keypool.empty()) {
1331  set_pre_split_keypool.insert(nIndex);
1332  } else {
1333  setExternalKeyPool.insert(nIndex);
1334  }
1335  CKeyID& pubkey_id = m_index_to_reserved_key.at(nIndex);
1336  m_pool_key_to_index[pubkey_id] = nIndex;
1337  m_index_to_reserved_key.erase(nIndex);
1339  }
1340  WalletLogPrintf("keypool return %d\n", nIndex);
1341 }
1342 
1343 bool LegacyScriptPubKeyMan::GetKeyFromPool(CPubKey& result, const OutputType type, bool internal)
1344 {
1345  assert(type != OutputType::BECH32M);
1346  if (!CanGetAddresses(internal)) {
1347  return false;
1348  }
1349 
1350  CKeyPool keypool;
1351  {
1352  LOCK(cs_KeyStore);
1353  int64_t nIndex;
1355  if (m_storage.IsLocked()) return false;
1357  result = GenerateNewKey(batch, m_hd_chain, internal);
1358  return true;
1359  }
1360  KeepDestination(nIndex, type);
1361  result = keypool.vchPubKey;
1362  }
1363  return true;
1364 }
1365 
1366 bool LegacyScriptPubKeyMan::ReserveKeyFromKeyPool(int64_t& nIndex, CKeyPool& keypool, bool fRequestedInternal)
1367 {
1368  nIndex = -1;
1369  keypool.vchPubKey = CPubKey();
1370  {
1371  LOCK(cs_KeyStore);
1372 
1373  bool fReturningInternal = fRequestedInternal;
1375  bool use_split_keypool = set_pre_split_keypool.empty();
1376  std::set<int64_t>& setKeyPool = use_split_keypool ? (fReturningInternal ? setInternalKeyPool : setExternalKeyPool) : set_pre_split_keypool;
1377 
1378  // Get the oldest key
1379  if (setKeyPool.empty()) {
1380  return false;
1381  }
1382 
1384 
1385  auto it = setKeyPool.begin();
1386  nIndex = *it;
1387  setKeyPool.erase(it);
1388  if (!batch.ReadPool(nIndex, keypool)) {
1389  throw std::runtime_error(std::string(__func__) + ": read failed");
1390  }
1391  CPubKey pk;
1392  if (!GetPubKey(keypool.vchPubKey.GetID(), pk)) {
1393  throw std::runtime_error(std::string(__func__) + ": unknown key in key pool");
1394  }
1395  // If the key was pre-split keypool, we don't care about what type it is
1396  if (use_split_keypool && keypool.fInternal != fReturningInternal) {
1397  throw std::runtime_error(std::string(__func__) + ": keypool entry misclassified");
1398  }
1399  if (!keypool.vchPubKey.IsValid()) {
1400  throw std::runtime_error(std::string(__func__) + ": keypool entry invalid");
1401  }
1402 
1403  assert(m_index_to_reserved_key.count(nIndex) == 0);
1404  m_index_to_reserved_key[nIndex] = keypool.vchPubKey.GetID();
1405  m_pool_key_to_index.erase(keypool.vchPubKey.GetID());
1406  WalletLogPrintf("keypool reserve %d\n", nIndex);
1407  }
1409  return true;
1410 }
1411 
1413 {
1414  assert(type != OutputType::BECH32M);
1415  if (key.IsCompressed() && (type == OutputType::P2SH_SEGWIT || type == OutputType::BECH32)) {
1416  CTxDestination witdest = WitnessV0KeyHash(key.GetID());
1417  CScript witprog = GetScriptForDestination(witdest);
1418  // Make sure the resulting program is solvable.
1419  assert(IsSolvable(*this, witprog));
1420  AddCScript(witprog);
1421  }
1422 }
1423 
1425 {
1426  // OutputType::P2SH_SEGWIT always adds all necessary scripts for all types.
1428 }
1429 
1431 {
1433  bool internal = setInternalKeyPool.count(keypool_id);
1434  if (!internal) assert(setExternalKeyPool.count(keypool_id) || set_pre_split_keypool.count(keypool_id));
1435  std::set<int64_t> *setKeyPool = internal ? &setInternalKeyPool : (set_pre_split_keypool.empty() ? &setExternalKeyPool : &set_pre_split_keypool);
1436  auto it = setKeyPool->begin();
1437 
1439  while (it != std::end(*setKeyPool)) {
1440  const int64_t& index = *(it);
1441  if (index > keypool_id) break; // set*KeyPool is ordered
1442 
1443  CKeyPool keypool;
1444  if (batch.ReadPool(index, keypool)) { //TODO: This should be unnecessary
1445  m_pool_key_to_index.erase(keypool.vchPubKey.GetID());
1446  }
1448  batch.ErasePool(index);
1449  WalletLogPrintf("keypool index %d removed\n", index);
1450  it = setKeyPool->erase(it);
1451  }
1452 }
1453 
1454 std::vector<CKeyID> GetAffectedKeys(const CScript& spk, const SigningProvider& provider)
1455 {
1456  std::vector<CScript> dummy;
1457  FlatSigningProvider out;
1458  InferDescriptor(spk, provider)->Expand(0, DUMMY_SIGNING_PROVIDER, dummy, out);
1459  std::vector<CKeyID> ret;
1460  for (const auto& entry : out.pubkeys) {
1461  ret.push_back(entry.first);
1462  }
1463  return ret;
1464 }
1465 
1467 {
1469  for (auto it = setExternalKeyPool.begin(); it != setExternalKeyPool.end();) {
1470  int64_t index = *it;
1471  CKeyPool keypool;
1472  if (!batch.ReadPool(index, keypool)) {
1473  throw std::runtime_error(std::string(__func__) + ": read keypool entry failed");
1474  }
1475  keypool.m_pre_split = true;
1476  if (!batch.WritePool(index, keypool)) {
1477  throw std::runtime_error(std::string(__func__) + ": writing modified keypool entry failed");
1478  }
1479  set_pre_split_keypool.insert(index);
1480  it = setExternalKeyPool.erase(it);
1481  }
1482 }
1483 
1485 {
1487  return AddCScriptWithDB(batch, redeemScript);
1488 }
1489 
1491 {
1492  if (!FillableSigningProvider::AddCScript(redeemScript))
1493  return false;
1494  if (batch.WriteCScript(Hash160(redeemScript), redeemScript)) {
1496  return true;
1497  }
1498  return false;
1499 }
1500 
1502 {
1503  LOCK(cs_KeyStore);
1504  std::copy(info.fingerprint, info.fingerprint + 4, mapKeyMetadata[pubkey.GetID()].key_origin.fingerprint);
1505  mapKeyMetadata[pubkey.GetID()].key_origin.path = info.path;
1506  mapKeyMetadata[pubkey.GetID()].has_key_origin = true;
1507  mapKeyMetadata[pubkey.GetID()].hdKeypath = WriteHDKeypath(info.path);
1508  return batch.WriteKeyMetadata(mapKeyMetadata[pubkey.GetID()], pubkey, true);
1509 }
1510 
1511 bool LegacyScriptPubKeyMan::ImportScripts(const std::set<CScript> scripts, int64_t timestamp)
1512 {
1514  for (const auto& entry : scripts) {
1515  CScriptID id(entry);
1516  if (HaveCScript(id)) {
1517  WalletLogPrintf("Already have script %s, skipping\n", HexStr(entry));
1518  continue;
1519  }
1520  if (!AddCScriptWithDB(batch, entry)) {
1521  return false;
1522  }
1523 
1524  if (timestamp > 0) {
1525  m_script_metadata[CScriptID(entry)].nCreateTime = timestamp;
1526  }
1527  }
1528  if (timestamp > 0) {
1529  UpdateTimeFirstKey(timestamp);
1530  }
1531 
1532  return true;
1533 }
1534 
1535 bool LegacyScriptPubKeyMan::ImportPrivKeys(const std::map<CKeyID, CKey>& privkey_map, const int64_t timestamp)
1536 {
1538  for (const auto& entry : privkey_map) {
1539  const CKey& key = entry.second;
1540  CPubKey pubkey = key.GetPubKey();
1541  const CKeyID& id = entry.first;
1542  assert(key.VerifyPubKey(pubkey));
1543  // Skip if we already have the key
1544  if (HaveKey(id)) {
1545  WalletLogPrintf("Already have key with pubkey %s, skipping\n", HexStr(pubkey));
1546  continue;
1547  }
1548  mapKeyMetadata[id].nCreateTime = timestamp;
1549  // If the private key is not present in the wallet, insert it.
1550  if (!AddKeyPubKeyWithDB(batch, key, pubkey)) {
1551  return false;
1552  }
1553  UpdateTimeFirstKey(timestamp);
1554  }
1555  return true;
1556 }
1557 
1558 bool LegacyScriptPubKeyMan::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)
1559 {
1561  for (const auto& entry : key_origins) {
1562  AddKeyOriginWithDB(batch, entry.second.first, entry.second.second);
1563  }
1564  for (const CKeyID& id : ordered_pubkeys) {
1565  auto entry = pubkey_map.find(id);
1566  if (entry == pubkey_map.end()) {
1567  continue;
1568  }
1569  const CPubKey& pubkey = entry->second;
1570  CPubKey temp;
1571  if (GetPubKey(id, temp)) {
1572  // Already have pubkey, skipping
1573  WalletLogPrintf("Already have pubkey %s, skipping\n", HexStr(temp));
1574  continue;
1575  }
1576  if (!AddWatchOnlyWithDB(batch, GetScriptForRawPubKey(pubkey), timestamp)) {
1577  return false;
1578  }
1579  mapKeyMetadata[id].nCreateTime = timestamp;
1580 
1581  // Add to keypool only works with pubkeys
1582  if (add_keypool) {
1583  AddKeypoolPubkeyWithDB(pubkey, internal, batch);
1585  }
1586  }
1587  return true;
1588 }
1589 
1590 bool LegacyScriptPubKeyMan::ImportScriptPubKeys(const std::set<CScript>& script_pub_keys, const bool have_solving_data, const int64_t timestamp)
1591 {
1593  for (const CScript& script : script_pub_keys) {
1594  if (!have_solving_data || !IsMine(script)) { // Always call AddWatchOnly for non-solvable watch-only, so that watch timestamp gets updated
1595  if (!AddWatchOnlyWithDB(batch, script, timestamp)) {
1596  return false;
1597  }
1598  }
1599  }
1600  return true;
1601 }
1602 
1603 std::set<CKeyID> LegacyScriptPubKeyMan::GetKeys() const
1604 {
1605  LOCK(cs_KeyStore);
1606  if (!m_storage.HasEncryptionKeys()) {
1608  }
1609  std::set<CKeyID> set_address;
1610  for (const auto& mi : mapCryptedKeys) {
1611  set_address.insert(mi.first);
1612  }
1613  return set_address;
1614 }
1615 
1617 {
1618  // Returns true if this descriptor supports getting new addresses. Conditions where we may be unable to fetch them (e.g. locked) are caught later
1619  if (!CanGetAddresses()) {
1620  error = "No addresses available";
1621  return false;
1622  }
1623  {
1624  LOCK(cs_desc_man);
1625  assert(m_wallet_descriptor.descriptor->IsSingleType()); // This is a combo descriptor which should not be an active descriptor
1626  std::optional<OutputType> desc_addr_type = m_wallet_descriptor.descriptor->GetOutputType();
1627  assert(desc_addr_type);
1628  if (type != *desc_addr_type) {
1629  throw std::runtime_error(std::string(__func__) + ": Types are inconsistent");
1630  }
1631 
1632  TopUp();
1633 
1634  // Get the scriptPubKey from the descriptor
1635  FlatSigningProvider out_keys;
1636  std::vector<CScript> scripts_temp;
1637  if (m_wallet_descriptor.range_end <= m_max_cached_index && !TopUp(1)) {
1638  // We can't generate anymore keys
1639  error = "Error: Keypool ran out, please call keypoolrefill first";
1640  return false;
1641  }
1642  if (!m_wallet_descriptor.descriptor->ExpandFromCache(m_wallet_descriptor.next_index, m_wallet_descriptor.cache, scripts_temp, out_keys)) {
1643  // We can't generate anymore keys
1644  error = "Error: Keypool ran out, please call keypoolrefill first";
1645  return false;
1646  }
1647 
1648  std::optional<OutputType> out_script_type = m_wallet_descriptor.descriptor->GetOutputType();
1649  if (out_script_type && out_script_type == type) {
1650  ExtractDestination(scripts_temp[0], dest);
1651  } else {
1652  throw std::runtime_error(std::string(__func__) + ": Types are inconsistent. Stored type does not match type of newly generated address");
1653  }
1654  m_wallet_descriptor.next_index++;
1655  WalletBatch(m_storage.GetDatabase()).WriteDescriptor(GetID(), m_wallet_descriptor);
1656  return true;
1657  }
1658 }
1659 
1661 {
1662  LOCK(cs_desc_man);
1663  if (m_map_script_pub_keys.count(script) > 0) {
1664  return ISMINE_SPENDABLE;
1665  }
1666  return ISMINE_NO;
1667 }
1668 
1669 bool DescriptorScriptPubKeyMan::CheckDecryptionKey(const CKeyingMaterial& master_key, bool accept_no_keys)
1670 {
1671  LOCK(cs_desc_man);
1672  if (!m_map_keys.empty()) {
1673  return false;
1674  }
1675 
1676  bool keyPass = m_map_crypted_keys.empty(); // Always pass when there are no encrypted keys
1677  bool keyFail = false;
1678  for (const auto& mi : m_map_crypted_keys) {
1679  const CPubKey &pubkey = mi.second.first;
1680  const std::vector<unsigned char> &crypted_secret = mi.second.second;
1681  CKey key;
1682  if (!DecryptKey(master_key, crypted_secret, pubkey, key)) {
1683  keyFail = true;
1684  break;
1685  }
1686  keyPass = true;
1688  break;
1689  }
1690  if (keyPass && keyFail) {
1691  LogPrintf("The wallet is probably corrupted: Some keys decrypt but not all.\n");
1692  throw std::runtime_error("Error unlocking wallet: some keys decrypt but not all. Your wallet file may be corrupt.");
1693  }
1694  if (keyFail || (!keyPass && !accept_no_keys)) {
1695  return false;
1696  }
1698  return true;
1699 }
1700 
1702 {
1703  LOCK(cs_desc_man);
1704  if (!m_map_crypted_keys.empty()) {
1705  return false;
1706  }
1707 
1708  for (const KeyMap::value_type& key_in : m_map_keys)
1709  {
1710  const CKey &key = key_in.second;
1711  CPubKey pubkey = key.GetPubKey();
1712  CKeyingMaterial secret(key.begin(), key.end());
1713  std::vector<unsigned char> crypted_secret;
1714  if (!EncryptSecret(master_key, secret, pubkey.GetHash(), crypted_secret)) {
1715  return false;
1716  }
1717  m_map_crypted_keys[pubkey.GetID()] = make_pair(pubkey, crypted_secret);
1718  batch->WriteCryptedDescriptorKey(GetID(), pubkey, crypted_secret);
1719  }
1720  m_map_keys.clear();
1721  return true;
1722 }
1723 
1724 bool DescriptorScriptPubKeyMan::GetReservedDestination(const OutputType type, bool internal, CTxDestination& address, int64_t& index, CKeyPool& keypool, std::string& error)
1725 {
1726  LOCK(cs_desc_man);
1727  bool result = GetNewDestination(type, address, error);
1728  index = m_wallet_descriptor.next_index - 1;
1729  return result;
1730 }
1731 
1732 void DescriptorScriptPubKeyMan::ReturnDestination(int64_t index, bool internal, const CTxDestination& addr)
1733 {
1734  LOCK(cs_desc_man);
1735  // Only return when the index was the most recent
1736  if (m_wallet_descriptor.next_index - 1 == index) {
1737  m_wallet_descriptor.next_index--;
1738  }
1739  WalletBatch(m_storage.GetDatabase()).WriteDescriptor(GetID(), m_wallet_descriptor);
1741 }
1742 
1743 std::map<CKeyID, CKey> DescriptorScriptPubKeyMan::GetKeys() const
1744 {
1747  KeyMap keys;
1748  for (auto key_pair : m_map_crypted_keys) {
1749  const CPubKey& pubkey = key_pair.second.first;
1750  const std::vector<unsigned char>& crypted_secret = key_pair.second.second;
1751  CKey key;
1752  DecryptKey(m_storage.GetEncryptionKey(), crypted_secret, pubkey, key);
1753  keys[pubkey.GetID()] = key;
1754  }
1755  return keys;
1756  }
1757  return m_map_keys;
1758 }
1759 
1760 bool DescriptorScriptPubKeyMan::TopUp(unsigned int size)
1761 {
1762  LOCK(cs_desc_man);
1763  unsigned int target_size;
1764  if (size > 0) {
1765  target_size = size;
1766  } else {
1767  target_size = std::max(gArgs.GetArg("-keypool", DEFAULT_KEYPOOL_SIZE), (int64_t) 1);
1768  }
1769 
1770  // Calculate the new range_end
1771  int32_t new_range_end = std::max(m_wallet_descriptor.next_index + (int32_t)target_size, m_wallet_descriptor.range_end);
1772 
1773  // If the descriptor is not ranged, we actually just want to fill the first cache item
1774  if (!m_wallet_descriptor.descriptor->IsRange()) {
1775  new_range_end = 1;
1776  m_wallet_descriptor.range_end = 1;
1777  m_wallet_descriptor.range_start = 0;
1778  }
1779 
1780  FlatSigningProvider provider;
1781  provider.keys = GetKeys();
1782 
1784  uint256 id = GetID();
1785  for (int32_t i = m_max_cached_index + 1; i < new_range_end; ++i) {
1786  FlatSigningProvider out_keys;
1787  std::vector<CScript> scripts_temp;
1788  DescriptorCache temp_cache;
1789  // Maybe we have a cached xpub and we can expand from the cache first
1790  if (!m_wallet_descriptor.descriptor->ExpandFromCache(i, m_wallet_descriptor.cache, scripts_temp, out_keys)) {
1791  if (!m_wallet_descriptor.descriptor->Expand(i, provider, scripts_temp, out_keys, &temp_cache)) return false;
1792  }
1793  // Add all of the scriptPubKeys to the scriptPubKey set
1794  for (const CScript& script : scripts_temp) {
1795  m_map_script_pub_keys[script] = i;
1796  }
1797  for (const auto& pk_pair : out_keys.pubkeys) {
1798  const CPubKey& pubkey = pk_pair.second;
1799  if (m_map_pubkeys.count(pubkey) != 0) {
1800  // We don't need to give an error here.
1801  // It doesn't matter which of many valid indexes the pubkey has, we just need an index where we can derive it and it's private key
1802  continue;
1803  }
1804  m_map_pubkeys[pubkey] = i;
1805  }
1806  // Merge and write the cache
1807  DescriptorCache new_items = m_wallet_descriptor.cache.MergeAndDiff(temp_cache);
1808  if (!batch.WriteDescriptorCacheItems(id, new_items)) {
1809  throw std::runtime_error(std::string(__func__) + ": writing cache items failed");
1810  }
1812  }
1813  m_wallet_descriptor.range_end = new_range_end;
1814  batch.WriteDescriptor(GetID(), m_wallet_descriptor);
1815 
1816  // By this point, the cache size should be the size of the entire range
1817  assert(m_wallet_descriptor.range_end - 1 == m_max_cached_index);
1818 
1820  return true;
1821 }
1822 
1824 {
1825  LOCK(cs_desc_man);
1826  if (IsMine(script)) {
1827  int32_t index = m_map_script_pub_keys[script];
1828  if (index >= m_wallet_descriptor.next_index) {
1829  WalletLogPrintf("%s: Detected a used keypool item at index %d, mark all keypool items up to this item as used\n", __func__, index);
1830  m_wallet_descriptor.next_index = index + 1;
1831  }
1832  if (!TopUp()) {
1833  WalletLogPrintf("%s: Topping up keypool failed (locked wallet)\n", __func__);
1834  }
1835  }
1836 }
1837 
1839 {
1840  LOCK(cs_desc_man);
1842  if (!AddDescriptorKeyWithDB(batch, key, pubkey)) {
1843  throw std::runtime_error(std::string(__func__) + ": writing descriptor private key failed");
1844  }
1845 }
1846 
1848 {
1851 
1852  // Check if provided key already exists
1853  if (m_map_keys.find(pubkey.GetID()) != m_map_keys.end() ||
1854  m_map_crypted_keys.find(pubkey.GetID()) != m_map_crypted_keys.end()) {
1855  return true;
1856  }
1857 
1858  if (m_storage.HasEncryptionKeys()) {
1859  if (m_storage.IsLocked()) {
1860  return false;
1861  }
1862 
1863  std::vector<unsigned char> crypted_secret;
1864  CKeyingMaterial secret(key.begin(), key.end());
1865  if (!EncryptSecret(m_storage.GetEncryptionKey(), secret, pubkey.GetHash(), crypted_secret)) {
1866  return false;
1867  }
1868 
1869  m_map_crypted_keys[pubkey.GetID()] = make_pair(pubkey, crypted_secret);
1870  return batch.WriteCryptedDescriptorKey(GetID(), pubkey, crypted_secret);
1871  } else {
1872  m_map_keys[pubkey.GetID()] = key;
1873  return batch.WriteDescriptorKey(GetID(), pubkey, key.GetPrivKey());
1874  }
1875 }
1876 
1877 bool DescriptorScriptPubKeyMan::SetupDescriptorGeneration(const CExtKey& master_key, OutputType addr_type, bool internal)
1878 {
1879  if (addr_type == OutputType::BECH32M) {
1880  // Don't allow setting up taproot descriptors yet
1881  // TODO: Allow setting up taproot descriptors
1882  return false;
1883  }
1884 
1885  LOCK(cs_desc_man);
1887 
1888  // Ignore when there is already a descriptor
1889  if (m_wallet_descriptor.descriptor) {
1890  return false;
1891  }
1892 
1893  int64_t creation_time = GetTime();
1894 
1895  std::string xpub = EncodeExtPubKey(master_key.Neuter());
1896 
1897  // Build descriptor string
1898  std::string desc_prefix;
1899  std::string desc_suffix = "/*)";
1900  switch (addr_type) {
1901  case OutputType::LEGACY: {
1902  desc_prefix = "pkh(" + xpub + "/44'";
1903  break;
1904  }
1905  case OutputType::P2SH_SEGWIT: {
1906  desc_prefix = "sh(wpkh(" + xpub + "/49'";
1907  desc_suffix += ")";
1908  break;
1909  }
1910  case OutputType::BECH32: {
1911  desc_prefix = "wpkh(" + xpub + "/84'";
1912  break;
1913  }
1914  case OutputType::BECH32M: assert(false); // TODO: Setup taproot descriptor
1915  } // no default case, so the compiler can warn about missing cases
1916  assert(!desc_prefix.empty());
1917 
1918  // Mainnet derives at 0', testnet and regtest derive at 1'
1919  if (Params().IsTestChain()) {
1920  desc_prefix += "/1'";
1921  } else {
1922  desc_prefix += "/0'";
1923  }
1924 
1925  std::string internal_path = internal ? "/1" : "/0";
1926  std::string desc_str = desc_prefix + "/0'" + internal_path + desc_suffix;
1927 
1928  // Make the descriptor
1929  FlatSigningProvider keys;
1930  std::string error;
1931  std::unique_ptr<Descriptor> desc = Parse(desc_str, keys, error, false);
1932  WalletDescriptor w_desc(std::move(desc), creation_time, 0, 0, 0);
1933  m_wallet_descriptor = w_desc;
1934 
1935  // Store the master private key, and descriptor
1937  if (!AddDescriptorKeyWithDB(batch, master_key.key, master_key.key.GetPubKey())) {
1938  throw std::runtime_error(std::string(__func__) + ": writing descriptor master private key failed");
1939  }
1940  if (!batch.WriteDescriptor(GetID(), m_wallet_descriptor)) {
1941  throw std::runtime_error(std::string(__func__) + ": writing descriptor failed");
1942  }
1943 
1944  // TopUp
1945  TopUp();
1946 
1948  return true;
1949 }
1950 
1952 {
1953  LOCK(cs_desc_man);
1954  return m_wallet_descriptor.descriptor->IsRange();
1955 }
1956 
1958 {
1959  // We can only give out addresses from descriptors that are single type (not combo), ranged,
1960  // and either have cached keys or can generate more keys (ignoring encryption)
1961  LOCK(cs_desc_man);
1962  return m_wallet_descriptor.descriptor->IsSingleType() &&
1963  m_wallet_descriptor.descriptor->IsRange() &&
1964  (HavePrivateKeys() || m_wallet_descriptor.next_index < m_wallet_descriptor.range_end);
1965 }
1966 
1968 {
1969  LOCK(cs_desc_man);
1970  return m_map_keys.size() > 0 || m_map_crypted_keys.size() > 0;
1971 }
1972 
1974 {
1975  // This is only used for getwalletinfo output and isn't relevant to descriptor wallets.
1976  // The magic number 0 indicates that it shouldn't be displayed so that's what we return.
1977  return 0;
1978 }
1979 
1980 
1982 {
1983  LOCK(cs_desc_man);
1984  return m_wallet_descriptor.range_end - m_wallet_descriptor.next_index;
1985 }
1986 
1988 {
1989  LOCK(cs_desc_man);
1990  return m_wallet_descriptor.creation_time;
1991 }
1992 
1993 std::unique_ptr<FlatSigningProvider> DescriptorScriptPubKeyMan::GetSigningProvider(const CScript& script, bool include_private) const
1994 {
1995  LOCK(cs_desc_man);
1996 
1997  // Find the index of the script
1998  auto it = m_map_script_pub_keys.find(script);
1999  if (it == m_map_script_pub_keys.end()) {
2000  return nullptr;
2001  }
2002  int32_t index = it->second;
2003 
2004  return GetSigningProvider(index, include_private);
2005 }
2006 
2007 std::unique_ptr<FlatSigningProvider> DescriptorScriptPubKeyMan::GetSigningProvider(const CPubKey& pubkey) const
2008 {
2009  LOCK(cs_desc_man);
2010 
2011  // Find index of the pubkey
2012  auto it = m_map_pubkeys.find(pubkey);
2013  if (it == m_map_pubkeys.end()) {
2014  return nullptr;
2015  }
2016  int32_t index = it->second;
2017 
2018  // Always try to get the signing provider with private keys. This function should only be called during signing anyways
2019  return GetSigningProvider(index, true);
2020 }
2021 
2022 std::unique_ptr<FlatSigningProvider> DescriptorScriptPubKeyMan::GetSigningProvider(int32_t index, bool include_private) const
2023 {
2025  // Get the scripts, keys, and key origins for this script
2026  std::unique_ptr<FlatSigningProvider> out_keys = std::make_unique<FlatSigningProvider>();
2027  std::vector<CScript> scripts_temp;
2028  if (!m_wallet_descriptor.descriptor->ExpandFromCache(index, m_wallet_descriptor.cache, scripts_temp, *out_keys)) return nullptr;
2029 
2030  if (HavePrivateKeys() && include_private) {
2031  FlatSigningProvider master_provider;
2032  master_provider.keys = GetKeys();
2033  m_wallet_descriptor.descriptor->ExpandPrivate(index, master_provider, *out_keys);
2034  }
2035 
2036  return out_keys;
2037 }
2038 
2039 std::unique_ptr<SigningProvider> DescriptorScriptPubKeyMan::GetSolvingProvider(const CScript& script) const
2040 {
2041  return GetSigningProvider(script, false);
2042 }
2043 
2045 {
2046  return IsMine(script);
2047 }
2048 
2049 bool DescriptorScriptPubKeyMan::SignTransaction(CMutableTransaction& tx, const std::map<COutPoint, Coin>& coins, int sighash, std::map<int, std::string>& input_errors) const
2050 {
2051  std::unique_ptr<FlatSigningProvider> keys = std::make_unique<FlatSigningProvider>();
2052  for (const auto& coin_pair : coins) {
2053  std::unique_ptr<FlatSigningProvider> coin_keys = GetSigningProvider(coin_pair.second.out.scriptPubKey, true);
2054  if (!coin_keys) {
2055  continue;
2056  }
2057  *keys = Merge(*keys, *coin_keys);
2058  }
2059 
2060  return ::SignTransaction(tx, keys.get(), coins, sighash, input_errors);
2061 }
2062 
2063 SigningResult DescriptorScriptPubKeyMan::SignMessage(const std::string& message, const PKHash& pkhash, std::string& str_sig) const
2064 {
2065  std::unique_ptr<FlatSigningProvider> keys = GetSigningProvider(GetScriptForDestination(pkhash), true);
2066  if (!keys) {
2068  }
2069 
2070  CKey key;
2071  if (!keys->GetKey(ToKeyID(pkhash), key)) {
2073  }
2074 
2075  if (!MessageSign(key, message, str_sig)) {
2077  }
2078  return SigningResult::OK;
2079 }
2080 
2081 TransactionError DescriptorScriptPubKeyMan::FillPSBT(PartiallySignedTransaction& psbtx, const PrecomputedTransactionData& txdata, int sighash_type, bool sign, bool bip32derivs, int* n_signed) const
2082 {
2083  if (n_signed) {
2084  *n_signed = 0;
2085  }
2086  for (unsigned int i = 0; i < psbtx.tx->vin.size(); ++i) {
2087  const CTxIn& txin = psbtx.tx->vin[i];
2088  PSBTInput& input = psbtx.inputs.at(i);
2089 
2090  if (PSBTInputSigned(input)) {
2091  continue;
2092  }
2093 
2094  // Get the Sighash type
2095  if (sign && input.sighash_type > 0 && input.sighash_type != sighash_type) {
2097  }
2098 
2099  // Get the scriptPubKey to know which SigningProvider to use
2100  CScript script;
2101  if (!input.witness_utxo.IsNull()) {
2102  script = input.witness_utxo.scriptPubKey;
2103  } else if (input.non_witness_utxo) {
2104  if (txin.prevout.n >= input.non_witness_utxo->vout.size()) {
2106  }
2107  script = input.non_witness_utxo->vout[txin.prevout.n].scriptPubKey;
2108  } else {
2109  // There's no UTXO so we can just skip this now
2110  continue;
2111  }
2112  SignatureData sigdata;
2113  input.FillSignatureData(sigdata);
2114 
2115  std::unique_ptr<FlatSigningProvider> keys = std::make_unique<FlatSigningProvider>();
2116  std::unique_ptr<FlatSigningProvider> script_keys = GetSigningProvider(script, sign);
2117  if (script_keys) {
2118  *keys = Merge(*keys, *script_keys);
2119  } else {
2120  // Maybe there are pubkeys listed that we can sign for
2121  script_keys = std::make_unique<FlatSigningProvider>();
2122  for (const auto& pk_pair : input.hd_keypaths) {
2123  const CPubKey& pubkey = pk_pair.first;
2124  std::unique_ptr<FlatSigningProvider> pk_keys = GetSigningProvider(pubkey);
2125  if (pk_keys) {
2126  *keys = Merge(*keys, *pk_keys);
2127  }
2128  }
2129  }
2130 
2131  SignPSBTInput(HidingSigningProvider(keys.get(), !sign, !bip32derivs), psbtx, i, &txdata, sighash_type);
2132 
2133  bool signed_one = PSBTInputSigned(input);
2134  if (n_signed && (signed_one || !sign)) {
2135  // If sign is false, we assume that we _could_ sign if we get here. This
2136  // will never have false negatives; it is hard to tell under what i
2137  // circumstances it could have false positives.
2138  (*n_signed)++;
2139  }
2140  }
2141 
2142  // Fill in the bip32 keypaths and redeemscripts for the outputs so that hardware wallets can identify change
2143  for (unsigned int i = 0; i < psbtx.tx->vout.size(); ++i) {
2144  std::unique_ptr<SigningProvider> keys = GetSolvingProvider(psbtx.tx->vout.at(i).scriptPubKey);
2145  if (!keys) {
2146  continue;
2147  }
2148  UpdatePSBTOutput(HidingSigningProvider(keys.get(), true, !bip32derivs), psbtx, i);
2149  }
2150 
2151  return TransactionError::OK;
2152 }
2153 
2154 std::unique_ptr<CKeyMetadata> DescriptorScriptPubKeyMan::GetMetadata(const CTxDestination& dest) const
2155 {
2156  std::unique_ptr<SigningProvider> provider = GetSigningProvider(GetScriptForDestination(dest));
2157  if (provider) {
2158  KeyOriginInfo orig;
2159  CKeyID key_id = GetKeyForDestination(*provider, dest);
2160  if (provider->GetKeyOrigin(key_id, orig)) {
2161  LOCK(cs_desc_man);
2162  std::unique_ptr<CKeyMetadata> meta = std::make_unique<CKeyMetadata>();
2163  meta->key_origin = orig;
2164  meta->has_key_origin = true;
2165  meta->nCreateTime = m_wallet_descriptor.creation_time;
2166  return meta;
2167  }
2168  }
2169  return nullptr;
2170 }
2171 
2173 {
2174  LOCK(cs_desc_man);
2175  std::string desc_str = m_wallet_descriptor.descriptor->ToString();
2176  uint256 id;
2177  CSHA256().Write((unsigned char*)desc_str.data(), desc_str.size()).Finalize(id.begin());
2178  return id;
2179 }
2180 
2182 {
2183  LOCK(cs_desc_man);
2184  m_wallet_descriptor.cache = cache;
2185  for (int32_t i = m_wallet_descriptor.range_start; i < m_wallet_descriptor.range_end; ++i) {
2186  FlatSigningProvider out_keys;
2187  std::vector<CScript> scripts_temp;
2188  if (!m_wallet_descriptor.descriptor->ExpandFromCache(i, m_wallet_descriptor.cache, scripts_temp, out_keys)) {
2189  throw std::runtime_error("Error: Unable to expand wallet descriptor from cache");
2190  }
2191  // Add all of the scriptPubKeys to the scriptPubKey set
2192  for (const CScript& script : scripts_temp) {
2193  if (m_map_script_pub_keys.count(script) != 0) {
2194  throw std::runtime_error(strprintf("Error: Already loaded script at index %d as being at index %d", i, m_map_script_pub_keys[script]));
2195  }
2196  m_map_script_pub_keys[script] = i;
2197  }
2198  for (const auto& pk_pair : out_keys.pubkeys) {
2199  const CPubKey& pubkey = pk_pair.second;
2200  if (m_map_pubkeys.count(pubkey) != 0) {
2201  // We don't need to give an error here.
2202  // It doesn't matter which of many valid indexes the pubkey has, we just need an index where we can derive it and it's private key
2203  continue;
2204  }
2205  m_map_pubkeys[pubkey] = i;
2206  }
2208  }
2209 }
2210 
2211 bool DescriptorScriptPubKeyMan::AddKey(const CKeyID& key_id, const CKey& key)
2212 {
2213  LOCK(cs_desc_man);
2214  m_map_keys[key_id] = key;
2215  return true;
2216 }
2217 
2218 bool DescriptorScriptPubKeyMan::AddCryptedKey(const CKeyID& key_id, const CPubKey& pubkey, const std::vector<unsigned char>& crypted_key)
2219 {
2220  LOCK(cs_desc_man);
2221  if (!m_map_keys.empty()) {
2222  return false;
2223  }
2224 
2225  m_map_crypted_keys[key_id] = make_pair(pubkey, crypted_key);
2226  return true;
2227 }
2228 
2230 {
2231  LOCK(cs_desc_man);
2232  return m_wallet_descriptor.descriptor != nullptr && desc.descriptor != nullptr && m_wallet_descriptor.descriptor->ToString() == desc.descriptor->ToString();
2233 }
2234 
2236 {
2237  LOCK(cs_desc_man);
2239  if (!batch.WriteDescriptor(GetID(), m_wallet_descriptor)) {
2240  throw std::runtime_error(std::string(__func__) + ": writing descriptor failed");
2241  }
2242 }
2243 
2245 {
2246  return m_wallet_descriptor;
2247 }
2248 
2249 const std::vector<CScript> DescriptorScriptPubKeyMan::GetScriptPubKeys() const
2250 {
2251  LOCK(cs_desc_man);
2252  std::vector<CScript> script_pub_keys;
2253  script_pub_keys.reserve(m_map_script_pub_keys.size());
2254 
2255  for (auto const& script_pub_key: m_map_script_pub_keys) {
2256  script_pub_keys.push_back(script_pub_key.first);
2257  }
2258  return script_pub_keys;
2259 }
2260 
2262 {
2263  LOCK(cs_desc_man);
2264 
2265  FlatSigningProvider provider;
2266  provider.keys = GetKeys();
2267 
2268  return m_wallet_descriptor.descriptor->ToNormalizedString(provider, out, &m_wallet_descriptor.cache);
2269 }
2270 
2272 {
2273  LOCK(cs_desc_man);
2275  return;
2276  }
2277 
2278  // Skip if we have the last hardened xpub cache
2279  if (m_wallet_descriptor.cache.GetCachedLastHardenedExtPubKeys().size() > 0) {
2280  return;
2281  }
2282 
2283  // Expand the descriptor
2284  FlatSigningProvider provider;
2285  provider.keys = GetKeys();
2286  FlatSigningProvider out_keys;
2287  std::vector<CScript> scripts_temp;
2288  DescriptorCache temp_cache;
2289  if (!m_wallet_descriptor.descriptor->Expand(0, provider, scripts_temp, out_keys, &temp_cache)){
2290  throw std::runtime_error("Unable to expand descriptor");
2291  }
2292 
2293  // Cache the last hardened xpubs
2294  DescriptorCache diff = m_wallet_descriptor.cache.MergeAndDiff(temp_cache);
2296  throw std::runtime_error(std::string(__func__) + ": writing cache items failed");
2297  }
2298 }
2299 
2301 {
2302  LOCK(cs_desc_man);
2303  std::string error;
2304  if (!CanUpdateToWalletDescriptor(descriptor, error)) {
2305  throw std::runtime_error(std::string(__func__) + ": " + error);
2306  }
2307 
2308  m_map_pubkeys.clear();
2309  m_map_script_pub_keys.clear();
2310  m_max_cached_index = -1;
2311  m_wallet_descriptor = descriptor;
2312 }
2313 
2315 {
2316  LOCK(cs_desc_man);
2317  if (!HasWalletDescriptor(descriptor)) {
2318  error = "can only update matching descriptor";
2319  return false;
2320  }
2321 
2322  if (descriptor.range_start > m_wallet_descriptor.range_start ||
2323  descriptor.range_end < m_wallet_descriptor.range_end) {
2324  // Use inclusive range for error
2325  error = strprintf("new range must include current range = [%d,%d]",
2326  m_wallet_descriptor.range_start,
2327  m_wallet_descriptor.range_end - 1);
2328  return false;
2329  }
2330 
2331  return true;
2332 }
WalletBatch::WritePool
bool WritePool(int64_t nPool, const CKeyPool &keypool)
Definition: walletdb.cpp:192
LegacyScriptPubKeyMan::TopUp
bool TopUp(unsigned int size=0) override
Fills internal address pool.
Definition: scriptpubkeyman.cpp:1247
DescriptorScriptPubKeyMan::CheckDecryptionKey
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. it decrypts all of the ke...
Definition: scriptpubkeyman.cpp:1669
WriteHDKeypath
std::string WriteHDKeypath(const std::vector< uint32_t > &keypath)
Write HD keypaths as strings.
Definition: bip32.cpp:63
CTxIn
An input of a transaction.
Definition: transaction.h:65
LegacyScriptPubKeyMan::KeepDestination
void KeepDestination(int64_t index, const OutputType &type) override
Definition: scriptpubkeyman.cpp:1309
DescriptorScriptPubKeyMan::SignMessage
SigningResult SignMessage(const std::string &message, const PKHash &pkhash, std::string &str_sig) const override
Sign a message with the given script.
Definition: scriptpubkeyman.cpp:2063
ScriptPubKeyMan::m_storage
WalletStorage & m_storage
Definition: scriptpubkeyman.h:172
LegacyScriptPubKeyMan::AddKeypoolPubkeyWithDB
void AddKeypoolPubkeyWithDB(const CPubKey &pubkey, const bool internal, WalletBatch &batch)
Definition: scriptpubkeyman.cpp:1293
LegacyScriptPubKeyMan::HavePrivateKeys
bool HavePrivateKeys() const override
Definition: scriptpubkeyman.cpp:500
OP_0
@ OP_0
Definition: script.h:68
WalletBatch::WriteDescriptor
bool WriteDescriptor(const uint256 &desc_id, const WalletDescriptor &descriptor)
Definition: walletdb.cpp:239
bip32.h
Parse
std::unique_ptr< Descriptor > Parse(const std::string &descriptor, FlatSigningProvider &out, std::string &error, bool require_checksum)
Parse a descriptor string.
Definition: descriptor.cpp:1399
LegacyScriptPubKeyMan::TopUpInactiveHDChain
bool TopUpInactiveHDChain(const CKeyID seed_id, int64_t index, bool internal)
Like TopUp() but adds keys for inactive HD chains.
Definition: scriptpubkeyman.cpp:320
CHDChain::nExternalChainCounter
uint32_t nExternalChainCounter
Definition: walletdb.h:88
valtype
std::vector< unsigned char > valtype
Definition: scriptpubkeyman.cpp:45
PSBTInput::non_witness_utxo
CTransactionRef non_witness_utxo
Definition: psbt.h:51
LegacyScriptPubKeyMan::IsHDEnabled
bool IsHDEnabled() const override
Definition: scriptpubkeyman.cpp:437
WalletBatch::WriteCScript
bool WriteCScript(const uint160 &hash, const CScript &redeemScript)
Definition: walletdb.cpp:149
LegacyScriptPubKeyMan::UpdateTimeFirstKey
void UpdateTimeFirstKey(int64_t nCreateTime) EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore)
Update wallet first key creation time.
Definition: scriptpubkeyman.cpp:691
_
bilingual_str _(const char *psz)
Translation function.
Definition: translation.h:57
FillableSigningProvider::KeyMap
std::map< CKeyID, CKey > KeyMap
Definition: signingprovider.h:70
WalletBatch::WriteCryptedDescriptorKey
bool WriteCryptedDescriptorKey(const uint256 &desc_id, const CPubKey &pubkey, const std::vector< unsigned char > &secret)
Definition: walletdb.cpp:230
OutputType
OutputType
Definition: outputtype.h:17
ToString
std::string ToString(const T &t)
Locale-independent version of std::to_string.
Definition: string.h:79
SigningResult::OK
@ OK
No error.
LegacyScriptPubKeyMan::GetWatchPubKey
bool GetWatchPubKey(const CKeyID &address, CPubKey &pubkey_out) const
Fetches a pubkey from mapWatchKeys if it exists there.
Definition: scriptpubkeyman.cpp:1007
assert
assert(!tx.IsCoinBase())
FEATURE_HD_SPLIT
@ FEATURE_HD_SPLIT
Definition: walletutil.h:23
CSHA256::Write
CSHA256 & Write(const unsigned char *data, size_t len)
Definition: sha256.cpp:637
DEFAULT_KEYPOOL_SIZE
static const unsigned int DEFAULT_KEYPOOL_SIZE
Default for -keypool.
Definition: scriptpubkeyman.h:48
Solver
TxoutType Solver(const CScript &scriptPubKey, std::vector< std::vector< unsigned char >> &vSolutionsRet)
Parse a scriptPubKey and identify script type for standard scripts.
Definition: standard.cpp:144
EncryptSecret
bool EncryptSecret(const CKeyingMaterial &vMasterKey, const CKeyingMaterial &vchPlaintext, const uint256 &nIV, std::vector< unsigned char > &vchCiphertext)
Definition: crypter.cpp:107
FillableSigningProvider::GetKeys
virtual std::set< CKeyID > GetKeys() const
Definition: signingprovider.cpp:132
LegacyScriptPubKeyMan::AddKeyPubKey
bool AddKeyPubKey(const CKey &key, const CPubKey &pubkey) override
Adds a key to the store, and saves it to disk.
Definition: scriptpubkeyman.cpp:708
LegacyScriptPubKeyMan::AddWatchOnly
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...
Definition: scriptpubkeyman.cpp:922
CRIPEMD160
A hasher class for RIPEMD-160.
Definition: ripemd160.h:12
DescriptorScriptPubKeyMan::MarkUnusedAddresses
void MarkUnusedAddresses(const CScript &script) override
Mark unused addresses as being used.
Definition: scriptpubkeyman.cpp:1823
LegacyScriptPubKeyMan::MarkUnusedAddresses
void MarkUnusedAddresses(const CScript &script) override
Mark unused addresses as being used.
Definition: scriptpubkeyman.cpp:357
CKey::MakeNewKey
void MakeNewKey(bool fCompressed)
Generate a new private key using a cryptographic PRNG.
Definition: key.cpp:160
CKeyPool
A key from a CWallet's keypool.
Definition: scriptpubkeyman.h:101
CKeyMetadata::nVersion
int nVersion
Definition: walletdb.h:128
DescriptorScriptPubKeyMan::SetupDescriptorGeneration
bool SetupDescriptorGeneration(const CExtKey &master_key, OutputType addr_type, bool internal)
Setup descriptors based on the given CExtkey.
Definition: scriptpubkeyman.cpp:1877
LegacyScriptPubKeyMan::GetKeyPoolSize
unsigned int GetKeyPoolSize() const override
Definition: scriptpubkeyman.cpp:555
TxoutType
TxoutType
Definition: standard.h:59
key_io.h
DescriptorScriptPubKeyMan::GetSolvingProvider
std::unique_ptr< SigningProvider > GetSolvingProvider(const CScript &script) const override
Definition: scriptpubkeyman.cpp:2039
LegacyScriptPubKeyMan::AddCryptedKeyInner
bool AddCryptedKeyInner(const CPubKey &vchPubKey, const std::vector< unsigned char > &vchCryptedSecret)
Definition: scriptpubkeyman.cpp:817
TxoutType::NONSTANDARD
@ NONSTANDARD
LegacyScriptPubKeyMan::m_index_to_reserved_key
std::map< int64_t, CKeyID > m_index_to_reserved_key
Definition: scriptpubkeyman.h:322
TxoutType::WITNESS_UNKNOWN
@ WITNESS_UNKNOWN
Only for Witness versions not already defined above.
DUMMY_SIGNATURE_CREATOR
const BaseSignatureCreator & DUMMY_SIGNATURE_CREATOR
A signature creator that just produces 71-byte empty signatures.
Definition: sign.cpp:591
LegacyScriptPubKeyMan::CanGetAddresses
bool CanGetAddresses(bool internal=false) const override
Definition: scriptpubkeyman.cpp:442
OutputType::LEGACY
@ LEGACY
FEATURE_HD
@ FEATURE_HD
Definition: walletutil.h:21
CHDChain::nVersion
int nVersion
Definition: walletdb.h:95
CRIPEMD160::Finalize
void Finalize(unsigned char hash[OUTPUT_SIZE])
Definition: ripemd160.cpp:273
LegacyScriptPubKeyMan::LoadKeyPool
void LoadKeyPool(int64_t nIndex, const CKeyPool &keypool)
Load a keypool entry.
Definition: scriptpubkeyman.cpp:1130
DescriptorScriptPubKeyMan::HasWalletDescriptor
bool HasWalletDescriptor(const WalletDescriptor &desc) const
Definition: scriptpubkeyman.cpp:2229
GetScriptForDestination
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
Definition: standard.cpp:351
LegacyScriptPubKeyMan::LearnRelatedScripts
void LearnRelatedScripts(const CPubKey &key, OutputType)
Explicitly make the wallet learn the related scripts for outputs to the given key.
Definition: scriptpubkeyman.cpp:1412
string.h
ISMINE_WATCH_ONLY
@ ISMINE_WATCH_ONLY
Definition: ismine.h:41
CExtKey::Derive
bool Derive(CExtKey &out, unsigned int nChild) const
Definition: key.cpp:314
bilingual_str
Bilingual messages:
Definition: translation.h:16
ExtractPubKey
static bool ExtractPubKey(const CScript &dest, CPubKey &pubKeyOut)
Definition: scriptpubkeyman.cpp:857
CKey::GetPrivKey
CPrivKey GetPrivKey() const
Convert the private key to a CPrivKey (serialized OpenSSL private key data).
Definition: key.cpp:174
outputtype.h
DescriptorScriptPubKeyMan::IsMine
isminetype IsMine(const CScript &script) const override
Definition: scriptpubkeyman.cpp:1660
CKeyingMaterial
std::vector< unsigned char, secure_allocator< unsigned char > > CKeyingMaterial
Definition: crypter.h:61
DescriptorScriptPubKeyMan::UpdateWalletDescriptor
void UpdateWalletDescriptor(WalletDescriptor &descriptor)
Definition: scriptpubkeyman.cpp:2300
FlatSigningProvider::keys
std::map< CKeyID, CKey > keys
Definition: signingprovider.h:54
PartiallySignedTransaction::inputs
std::vector< PSBTInput > inputs
Definition: psbt.h:394
LegacyScriptPubKeyMan::UpgradeKeyMetadata
void UpgradeKeyMetadata()
Upgrade stored CKeyMetadata objects to store key origin info as KeyOriginInfo.
Definition: scriptpubkeyman.cpp:389
LegacyScriptPubKeyMan::NewKeyPool
bool NewKeyPool()
Mark old keypool keys as used, and generate all new keys.
Definition: scriptpubkeyman.cpp:1213
LegacyScriptPubKeyMan::LoadKeyMetadata
void LoadKeyMetadata(const CKeyID &keyID, const CKeyMetadata &metadata)
Load metadata (used by LoadWallet)
Definition: scriptpubkeyman.cpp:770
DescriptorScriptPubKeyMan::IsHDEnabled
bool IsHDEnabled() const override
Definition: scriptpubkeyman.cpp:1951
SigningProvider
An interface to be implemented by keystores that support signing.
Definition: signingprovider.h:18
LegacyScriptPubKeyMan::GetTimeFirstKey
int64_t GetTimeFirstKey() const override
Definition: scriptpubkeyman.cpp:561
GetTime
int64_t GetTime()
DEPRECATED Use either GetTimeSeconds (not mockable) or GetTime<T> (mockable)
Definition: time.cpp:26
LegacyScriptPubKeyMan::Encrypt
bool Encrypt(const CKeyingMaterial &master_key, WalletBatch *batch) override
Definition: scriptpubkeyman.cpp:268
LegacyScriptPubKeyMan::GetKeyFromPool
bool GetKeyFromPool(CPubKey &key, const OutputType type, bool internal=false)
Fetches a key from the keypool.
Definition: scriptpubkeyman.cpp:1343
LegacyScriptPubKeyMan::SetHDSeed
void SetHDSeed(const CPubKey &key)
Definition: scriptpubkeyman.cpp:1194
Merge
FlatSigningProvider Merge(const FlatSigningProvider &a, const FlatSigningProvider &b)
Definition: signingprovider.cpp:67
LegacyScriptPubKeyMan::FillPSBT
TransactionError FillPSBT(PartiallySignedTransaction &psbt, const PrecomputedTransactionData &txdata, int sighash_type=1, bool sign=true, bool bip32derivs=false, int *n_signed=nullptr) const override
Adds script and derivation path information to a PSBT, and optionally signs it.
Definition: scriptpubkeyman.cpp:613
ScriptPubKeyMan::WalletLogPrintf
void WalletLogPrintf(std::string fmt, Params... parameters) const
Prepends the wallet name in logging output to ease debugging in multi-wallet use cases.
Definition: scriptpubkeyman.h:243
DescriptorScriptPubKeyMan::UpgradeDescriptorCache
void UpgradeDescriptorCache()
Definition: scriptpubkeyman.cpp:2271
CKeyMetadata::hdKeypath
std::string hdKeypath
Definition: walletdb.h:130
DescriptorScriptPubKeyMan::CanProvide
bool CanProvide(const CScript &script, SignatureData &sigdata) override
Whether this ScriptPubKeyMan can provide a SigningProvider (via GetSolvingProvider) that,...
Definition: scriptpubkeyman.cpp:2044
LegacyScriptPubKeyMan::GetKeys
std::set< CKeyID > GetKeys() const override
Definition: scriptpubkeyman.cpp:1603
CHDChain::VERSION_HD_CHAIN_SPLIT
static const int VERSION_HD_CHAIN_SPLIT
Definition: walletdb.h:93
LegacyScriptPubKeyMan::m_pool_key_to_index
std::map< CKeyID, int64_t > m_pool_key_to_index
Definition: scriptpubkeyman.h:320
CKeyID
A reference to a CKey: the Hash160 of its serialized public key.
Definition: pubkey.h:22
GetDestinationForKey
CTxDestination GetDestinationForKey(const CPubKey &key, OutputType type)
Get a destination of the requested type (if possible) to the specified key.
Definition: outputtype.cpp:52
LegacyScriptPubKeyMan
Definition: scriptpubkeyman.h:261
DescriptorScriptPubKeyMan::GetSigningProvider
std::unique_ptr< FlatSigningProvider > GetSigningProvider(const CScript &script, bool include_private=false) const
Definition: scriptpubkeyman.cpp:1993
CKeyPool::nTime
int64_t nTime
The time at which the key was generated. Set in AddKeypoolPubKeyWithDB.
Definition: scriptpubkeyman.h:105
DUMMY_SIGNING_PROVIDER
const SigningProvider & DUMMY_SIGNING_PROVIDER
Definition: signingprovider.cpp:12
DescriptorScriptPubKeyMan::KeyMap
std::map< CKeyID, CKey > KeyMap
Definition: scriptpubkeyman.h:525
LegacyScriptPubKeyMan::m_inactive_hd_chains
std::unordered_map< CKeyID, CHDChain, SaltedSipHasher > m_inactive_hd_chains
Definition: scriptpubkeyman.h:311
LegacyScriptPubKeyMan::LoadKey
bool LoadKey(const CKey &key, const CPubKey &pubkey)
Adds a key to the store, without saving it to disk (used by LoadWallet)
Definition: scriptpubkeyman.cpp:703
LegacyScriptPubKeyMan::GetKey
bool GetKey(const CKeyID &address, CKey &keyOut) const override
Definition: scriptpubkeyman.cpp:971
GetAffectedKeys
std::vector< CKeyID > GetAffectedKeys(const CScript &spk, const SigningProvider &provider)
Definition: scriptpubkeyman.cpp:1454
TxoutType::WITNESS_V1_TAPROOT
@ WITNESS_V1_TAPROOT
SigningResult
SigningResult
Definition: message.h:42
LegacyScriptPubKeyMan::ReturnDestination
void ReturnDestination(int64_t index, bool internal, const CTxDestination &) override
Definition: scriptpubkeyman.cpp:1323
LegacyScriptPubKeyMan::MarkPreSplitKeys
void MarkPreSplitKeys() EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore)
Definition: scriptpubkeyman.cpp:1466
DescriptorScriptPubKeyMan::m_decryption_thoroughly_checked
bool m_decryption_thoroughly_checked
keeps track of whether Unlock has run a thorough check before
Definition: scriptpubkeyman.h:535
AssertLockHeld
AssertLockHeld(pool.cs)
SignPSBTInput
bool SignPSBTInput(const SigningProvider &provider, PartiallySignedTransaction &psbt, int index, const PrecomputedTransactionData *txdata, int sighash, SignatureData *out_sigdata)
Signs a PSBTInput, verifying that all provided data matches what is being signed.
Definition: psbt.cpp:250
CKey::end
const unsigned char * end() const
Definition: key.h:90
FillableSigningProvider::ImplicitlyLearnRelatedKeyScripts
void ImplicitlyLearnRelatedKeyScripts(const CPubKey &pubkey) EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore)
Definition: signingprovider.cpp:85
scriptpubkeyman.h
DescriptorScriptPubKeyMan::HavePrivateKeys
bool HavePrivateKeys() const override
Definition: scriptpubkeyman.cpp:1967
WitnessV0KeyHash
Definition: standard.h:109
LegacyScriptPubKeyMan::Upgrade
bool Upgrade(int prev_version, int new_version, bilingual_str &error) override
Upgrades the wallet to the specified version.
Definition: scriptpubkeyman.cpp:459
LegacyScriptPubKeyMan::KeypoolCountExternalKeys
size_t KeypoolCountExternalKeys() const
Definition: scriptpubkeyman.cpp:549
LegacyScriptPubKeyMan::GetReservedDestination
bool GetReservedDestination(const OutputType type, bool internal, CTxDestination &address, int64_t &index, CKeyPool &keypool, std::string &error) override
Definition: scriptpubkeyman.cpp:298
OutputType::BECH32M
@ BECH32M
FEATURE_PRE_SPLIT_KEYPOOL
@ FEATURE_PRE_SPLIT_KEYPOOL
Definition: walletutil.h:27
DescriptorScriptPubKeyMan::CanGetAddresses
bool CanGetAddresses(bool internal=false) const override
Definition: scriptpubkeyman.cpp:1957
CKey::begin
const unsigned char * begin() const
Definition: key.h:89
strencodings.h
CTxOut::IsNull
bool IsNull() const
Definition: transaction.h:149
TransactionError
TransactionError
Definition: error.h:22
WalletStorage::GetDatabase
virtual WalletDatabase & GetDatabase() const =0
DescriptorScriptPubKeyMan::ReturnDestination
void ReturnDestination(int64_t index, bool internal, const CTxDestination &addr) override
Definition: scriptpubkeyman.cpp:1732
DescriptorScriptPubKeyMan::AddDescriptorKey
void AddDescriptorKey(const CKey &key, const CPubKey &pubkey)
Definition: scriptpubkeyman.cpp:1838
LegacyScriptPubKeyMan::LoadCScript
bool LoadCScript(const CScript &redeemScript)
Adds a CScript to the store.
Definition: scriptpubkeyman.cpp:755
TxoutType::WITNESS_V0_SCRIPTHASH
@ WITNESS_V0_SCRIPTHASH
CKeyMetadata::has_key_origin
bool has_key_origin
Whether the key_origin is useful.
Definition: walletdb.h:133
DescriptorScriptPubKeyMan::FillPSBT
TransactionError FillPSBT(PartiallySignedTransaction &psbt, const PrecomputedTransactionData &txdata, int sighash_type=1, bool sign=true, bool bip32derivs=false, int *n_signed=nullptr) const override
Adds script and derivation path information to a PSBT, and optionally signs it.
Definition: scriptpubkeyman.cpp:2081
CKeyMetadata::VERSION_WITH_KEY_ORIGIN
static const int VERSION_WITH_KEY_ORIGIN
Definition: walletdb.h:126
CHDChain::VERSION_HD_BASE
static const int VERSION_HD_BASE
Definition: walletdb.h:92
isminetype
isminetype
IsMine() return codes, which depend on ScriptPubKeyMan implementation.
Definition: ismine.h:38
TxoutType::PUBKEY
@ PUBKEY
CKeyPool::m_pre_split
bool m_pre_split
Whether this key was generated for a keypool before the wallet was upgraded to HD-split.
Definition: scriptpubkeyman.h:111
LegacyScriptPubKeyMan::LoadHDChain
void LoadHDChain(const CHDChain &chain)
Load a HD chain model (used by LoadWallet)
Definition: scriptpubkeyman.cpp:934
CTxDestination
std::variant< CNoDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, WitnessUnknown > CTxDestination
A txout script template with a specific destination.
Definition: standard.h:157
SignatureData
Definition: sign.h:64
LegacyScriptPubKeyMan::AddKeyPubKeyInner
bool AddKeyPubKeyInner(const CKey &key, const CPubKey &pubkey)
Definition: scriptpubkeyman.cpp:784
FillableSigningProvider::GetPubKey
virtual bool GetPubKey(const CKeyID &address, CPubKey &vchPubKeyOut) const override
Definition: signingprovider.cpp:108
WalletBatch::ReadPool
bool ReadPool(int64_t nPool, CKeyPool &keypool)
Definition: walletdb.cpp:187
LegacyScriptPubKeyMan::DeriveNewSeed
CPubKey DeriveNewSeed(const CKey &key)
Definition: scriptpubkeyman.cpp:1166
PSBTInput::hd_keypaths
std::map< CPubKey, KeyOriginInfo > hd_keypaths
Definition: psbt.h:57
GetScriptForRawPubKey
CScript GetScriptForRawPubKey(const CPubKey &pubKey)
Generate a P2PK script for the given pubkey.
Definition: standard.cpp:356
CExtKey
Definition: key.h:156
LegacyScriptPubKeyMan::GenerateNewSeed
CPubKey GenerateNewSeed()
Definition: scriptpubkeyman.cpp:1158
ScriptPubKeyMan::NotifyWatchonlyChanged
boost::signals2::signal< void(bool fHaveWatchOnly)> NotifyWatchonlyChanged
Watch-only address added.
Definition: scriptpubkeyman.h:245
LegacyScriptPubKeyMan::HaveKey
bool HaveKey(const CKeyID &address) const override
Definition: scriptpubkeyman.cpp:962
LegacyScriptPubKeyMan::DeriveNewChildKey
void DeriveNewChildKey(WalletBatch &batch, CKeyMetadata &metadata, CKey &secret, CHDChain &hd_chain, bool internal=false) EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore)
Definition: scriptpubkeyman.cpp:1075
LegacyScriptPubKeyMan::GenerateNewKey
CPubKey GenerateNewKey(WalletBatch &batch, CHDChain &hd_chain, bool internal=false) EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore)
Generate a new key.
Definition: scriptpubkeyman.cpp:1038
CTxOut::scriptPubKey
CScript scriptPubKey
Definition: transaction.h:132
LegacyScriptPubKeyMan::SetupGeneration
bool SetupGeneration(bool force=false) override
Sets up the key generation stuff, i.e.
Definition: scriptpubkeyman.cpp:424
LegacyScriptPubKeyMan::GetNewDestination
bool GetNewDestination(const OutputType type, CTxDestination &dest, std::string &error) override
Definition: scriptpubkeyman.cpp:23
FEATURE_COMPRPUBKEY
@ FEATURE_COMPRPUBKEY
Definition: walletutil.h:19
SigningResult::PRIVATE_KEY_NOT_AVAILABLE
@ PRIVATE_KEY_NOT_AVAILABLE
CPubKey::GetHash
uint256 GetHash() const
Get the 256-bit hash of this public key.
Definition: pubkey.h:166
LegacyScriptPubKeyMan::HaveWatchOnly
bool HaveWatchOnly(const CScript &dest) const
Returns whether the watch-only script is in the wallet.
Definition: scriptpubkeyman.cpp:845
LegacyScriptPubKeyMan::RewriteDB
void RewriteDB() override
The action to do when the DB needs rewrite.
Definition: scriptpubkeyman.cpp:506
DescriptorScriptPubKeyMan::AddCryptedKey
bool AddCryptedKey(const CKeyID &key_id, const CPubKey &pubkey, const std::vector< unsigned char > &crypted_key)
Definition: scriptpubkeyman.cpp:2218
WalletBatch::EraseWatchOnly
bool EraseWatchOnly(const CScript &script)
Definition: walletdb.cpp:162
CRIPEMD160::Write
CRIPEMD160 & Write(const unsigned char *data, size_t len)
Definition: ripemd160.cpp:247
LegacyScriptPubKeyMan::m_hd_chain
CHDChain m_hd_chain
Definition: scriptpubkeyman.h:310
time.h
CHDChain::nInternalChainCounter
uint32_t nInternalChainCounter
Definition: walletdb.h:89
LegacyScriptPubKeyMan::CheckDecryptionKey
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. it decrypts all of the ke...
Definition: scriptpubkeyman.cpp:228
TransactionError::SIGHASH_MISMATCH
@ SIGHASH_MISMATCH
sign.h
PartiallySignedTransaction::tx
std::optional< CMutableTransaction > tx
Definition: psbt.h:393
ArgsManager::GetArg
std::string GetArg(const std::string &strArg, const std::string &strDefault) const
Return string argument or default value.
Definition: system.cpp:588
LogPrintf
#define LogPrintf(...)
Definition: logging.h:184
LegacyScriptPubKeyMan::SignMessage
SigningResult SignMessage(const std::string &message, const PKHash &pkhash, std::string &str_sig) const override
Sign a message with the given script.
Definition: scriptpubkeyman.cpp:600
WalletBatch::ErasePool
bool ErasePool(int64_t nPool)
Definition: walletdb.cpp:197
FillableSigningProvider::HaveCScript
virtual bool HaveCScript(const CScriptID &hash) const override
Definition: signingprovider.cpp:163
WalletStorage::HasEncryptionKeys
virtual bool HasEncryptionKeys() const =0
SigVersion::WITNESS_V0
@ WITNESS_V0
Witness v0 (P2WPKH and P2WSH); see BIP 141.
CKeyPool::vchPubKey
CPubKey vchPubKey
The public key.
Definition: scriptpubkeyman.h:107
DescriptorCache::MergeAndDiff
DescriptorCache MergeAndDiff(const DescriptorCache &other)
Combine another DescriptorCache into this one.
Definition: descriptor.cpp:1465
SignatureData::signatures
std::map< CKeyID, SigPair > signatures
BIP 174 style partial signatures for the input. May contain all signatures necessary for producing a ...
Definition: sign.h:72
GetKeyForDestination
CKeyID GetKeyForDestination(const SigningProvider &store, const CTxDestination &dest)
Return the CKeyID of the key involved in a script (if there is a unique one).
Definition: signingprovider.cpp:191
LegacyScriptPubKeyMan::ImportPubKeys
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)
Definition: scriptpubkeyman.cpp:1558
LegacyScriptPubKeyMan::GetOldestKeyPoolTime
int64_t GetOldestKeyPoolTime() const override
Definition: scriptpubkeyman.cpp:531
UpdatePSBTOutput
void UpdatePSBTOutput(const SigningProvider &provider, PartiallySignedTransaction &psbt, int index)
Updates a PSBTOutput with information from provider.
Definition: psbt.cpp:213
PrecomputedTransactionData
Definition: interpreter.h:150
bilingual_str::translated
std::string translated
Definition: translation.h:18
LegacyScriptPubKeyMan::AddCScript
bool AddCScript(const CScript &redeemScript) override
Definition: scriptpubkeyman.cpp:1484
TxoutType::SCRIPTHASH
@ SCRIPTHASH
DecryptKey
bool DecryptKey(const CKeyingMaterial &vMasterKey, const std::vector< unsigned char > &vchCryptedSecret, const CPubKey &vchPubKey, CKey &key)
Definition: crypter.cpp:127
uint256
256-bit opaque blob.
Definition: uint256.h:124
ISMINE_NO
@ ISMINE_NO
Definition: ismine.h:40
LegacyScriptPubKeyMan::AddCScriptWithDB
bool AddCScriptWithDB(WalletBatch &batch, const CScript &script)
Adds a script to the store and saves it to disk.
Definition: scriptpubkeyman.cpp:1490
LegacyScriptPubKeyMan::LearnAllRelatedScripts
void LearnAllRelatedScripts(const CPubKey &key)
Same as LearnRelatedScripts, but when the OutputType is not known (and could be anything).
Definition: scriptpubkeyman.cpp:1424
FlatSigningProvider::pubkeys
std::map< CKeyID, CPubKey > pubkeys
Definition: signingprovider.h:52
CSHA256::Finalize
void Finalize(unsigned char hash[OUTPUT_SIZE])
Definition: sha256.cpp:663
CKey::GetPubKey
CPubKey GetPubKey() const
Compute the public key from a private key.
Definition: key.cpp:187
WalletStorage::UnsetBlankWalletFlag
virtual void UnsetBlankWalletFlag(WalletBatch &)=0
CScript
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:404
LegacyScriptPubKeyMan::IsMine
isminetype IsMine(const CScript &script) const override
Definition: scriptpubkeyman.cpp:214
WalletBatch::WriteHDChain
bool WriteHDChain(const CHDChain &chain)
write the hdchain model (external chain child index counter)
Definition: walletdb.cpp:1045
ExtractDestination
bool ExtractDestination(const CScript &scriptPubKey, CTxDestination &addressRet)
Parse a standard scriptPubKey for the destination address.
Definition: standard.cpp:213
WALLET_FLAG_BLANK_WALLET
@ WALLET_FLAG_BLANK_WALLET
Flag set when a wallet contains no HD seed and no private keys, scripts, addresses,...
Definition: walletutil.h:62
DescriptorScriptPubKeyMan::GetOldestKeyPoolTime
int64_t GetOldestKeyPoolTime() const override
Definition: scriptpubkeyman.cpp:1973
LegacyScriptPubKeyMan::ImportPrivKeys
bool ImportPrivKeys(const std::map< CKeyID, CKey > &privkey_map, const int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore)
Definition: scriptpubkeyman.cpp:1535
WalletStorage::IsWalletFlagSet
virtual bool IsWalletFlagSet(uint64_t) const =0
IsFeatureSupported
bool IsFeatureSupported(int wallet_version, int feature_version)
Definition: walletutil.cpp:32
LegacyScriptPubKeyMan::GetID
uint256 GetID() const override
Definition: scriptpubkeyman.cpp:682
DescriptorCache
Cache for single descriptor's derived extended pubkeys.
Definition: descriptor.h:19
LEGACY_OUTPUT_TYPES
static const std::unordered_set< OutputType > LEGACY_OUTPUT_TYPES
OutputTypes supported by the LegacyScriptPubKeyMan.
Definition: scriptpubkeyman.h:255
TxoutType::NULL_DATA
@ NULL_DATA
unspendable OP_RETURN script that carries data
WALLET_FLAG_DISABLE_PRIVATE_KEYS
@ WALLET_FLAG_DISABLE_PRIVATE_KEYS
Definition: walletutil.h:50
CPubKey::IsCompressed
bool IsCompressed() const
Check whether this is a compressed public key.
Definition: pubkey.h:194
LegacyScriptPubKeyMan::LoadCryptedKey
bool LoadCryptedKey(const CPubKey &vchPubKey, const std::vector< unsigned char > &vchCryptedSecret, bool checksum_valid)
Adds an encrypted key to the store, without saving it to disk (used by LoadWallet)
Definition: scriptpubkeyman.cpp:807
OutputType::P2SH_SEGWIT
@ P2SH_SEGWIT
LegacyScriptPubKeyMan::AddCryptedKey
bool AddCryptedKey(const CPubKey &vchPubKey, const std::vector< unsigned char > &vchCryptedSecret)
Adds an encrypted key to the store, and saves it to disk.
Definition: scriptpubkeyman.cpp:827
ISMINE_SPENDABLE
@ ISMINE_SPENDABLE
Definition: ismine.h:42
TxoutType::PUBKEYHASH
@ PUBKEYHASH
ProduceSignature
bool ProduceSignature(const SigningProvider &provider, const BaseSignatureCreator &creator, const CScript &fromPubKey, SignatureData &sigdata)
Produce a script signature using a generic signature creator.
Definition: sign.cpp:344
WalletBatch::WriteDescriptorKey
bool WriteDescriptorKey(const uint256 &desc_id, const CPubKey &pubkey, const CPrivKey &privkey)
Definition: walletdb.cpp:219
DescriptorScriptPubKeyMan::GetID
uint256 GetID() const override
Definition: scriptpubkeyman.cpp:2172
OutputType::BECH32
@ BECH32
system.h
BlockFilterType::INVALID
@ INVALID
PKHash
Definition: standard.h:79
DescriptorScriptPubKeyMan::GetReservedDestination
bool GetReservedDestination(const OutputType type, bool internal, CTxDestination &address, int64_t &index, CKeyPool &keypool, std::string &error) override
Definition: scriptpubkeyman.cpp:1724
ToKeyID
CKeyID ToKeyID(const PKHash &key_hash)
Definition: standard.cpp:34
strprintf
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1164
DescriptorScriptPubKeyMan::AddDescriptorKeyWithDB
bool AddDescriptorKeyWithDB(WalletBatch &batch, const CKey &key, const CPubKey &pubkey) EXCLUSIVE_LOCKS_REQUIRED(cs_desc_man)
Definition: scriptpubkeyman.cpp:1847
LegacyScriptPubKeyMan::LoadScriptMetadata
void LoadScriptMetadata(const CScriptID &script_id, const CKeyMetadata &metadata)
Definition: scriptpubkeyman.cpp:777
CKeyMetadata::hd_seed_id
CKeyID hd_seed_id
Definition: walletdb.h:131
PSBTInput::FillSignatureData
void FillSignatureData(SignatureData &sigdata) const
Definition: psbt.cpp:85
uint160
160-bit opaque blob.
Definition: uint256.h:113
CExtKey::SetSeed
void SetSeed(const unsigned char *seed, unsigned int nSeedLen)
Definition: key.cpp:322
DescriptorScriptPubKeyMan::cs_desc_man
RecursiveMutex cs_desc_man
Definition: scriptpubkeyman.h:560
CPubKey
An encapsulated public key.
Definition: pubkey.h:32
CKey::size
unsigned int size() const
Simple read-only vector-like interface.
Definition: key.h:88
GetOldestKeyTimeInPool
static int64_t GetOldestKeyTimeInPool(const std::set< int64_t > &setKeyPool, WalletBatch &batch)
Definition: scriptpubkeyman.cpp:517
LegacyScriptPubKeyMan::CanProvide
bool CanProvide(const CScript &script, SignatureData &sigdata) override
Whether this ScriptPubKeyMan can provide a SigningProvider (via GetSolvingProvider) that,...
Definition: scriptpubkeyman.cpp:572
ScriptContext::P2SH
@ P2SH
P2SH redeemScript.
base_blob::IsNull
bool IsNull() const
Definition: uint256.h:31
WalletBatch::WriteCryptedKey
bool WriteCryptedKey(const CPubKey &vchPubKey, const std::vector< unsigned char > &vchCryptedSecret, const CKeyMetadata &keyMeta)
Definition: walletdb.cpp:118
LegacyScriptPubKeyMan::ImportScriptPubKeys
bool ImportScriptPubKeys(const std::set< CScript > &script_pub_keys, const bool have_solving_data, const int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore)
Definition: scriptpubkeyman.cpp:1590
PSBTInput
A structure for PSBTs which contain per-input information.
Definition: psbt.h:49
LegacyScriptPubKeyMan::AddKeyOriginWithDB
bool AddKeyOriginWithDB(WalletBatch &batch, const CPubKey &pubkey, const KeyOriginInfo &info)
Add a KeyOriginInfo to the wallet.
Definition: scriptpubkeyman.cpp:1501
WALLET_FLAG_LAST_HARDENED_XPUB_CACHED
@ WALLET_FLAG_LAST_HARDENED_XPUB_CACHED
Definition: walletutil.h:47
CKey
An encapsulated private key.
Definition: key.h:27
CKey::VerifyPubKey
bool VerifyPubKey(const CPubKey &vchPubKey) const
Verify thoroughly whether a private key and a public key match.
Definition: key.cpp:235
DescriptorScriptPubKeyMan::GetKeyPoolSize
unsigned int GetKeyPoolSize() const override
Definition: scriptpubkeyman.cpp:1981
DescriptorScriptPubKeyMan::GetMetadata
std::unique_ptr< CKeyMetadata > GetMetadata(const CTxDestination &dest) const override
Definition: scriptpubkeyman.cpp:2154
translation.h
Hash160
uint160 Hash160(const T1 &in1)
Compute the 160-bit hash an object.
Definition: hash.h:92
FillableSigningProvider::GetKey
virtual bool GetKey(const CKeyID &address, CKey &keyOut) const override
Definition: signingprovider.cpp:142
IsSolvable
bool IsSolvable(const SigningProvider &provider, const CScript &script)
Definition: sign.cpp:594
CHDChain
Definition: walletdb.h:85
COutPoint::n
uint32_t n
Definition: transaction.h:30
DescriptorScriptPubKeyMan::GetWalletDescriptor
const WalletDescriptor GetWalletDescriptor() const EXCLUSIVE_LOCKS_REQUIRED(cs_desc_man)
Definition: scriptpubkeyman.cpp:2244
DescriptorScriptPubKeyMan::TopUp
bool TopUp(unsigned int size=0) override
Fills internal address pool.
Definition: scriptpubkeyman.cpp:1760
LegacyScriptPubKeyMan::GetSolvingProvider
std::unique_ptr< SigningProvider > GetSolvingProvider(const CScript &script) const override
Definition: scriptpubkeyman.cpp:567
PartiallySignedTransaction
A version of CTransaction with the PSBT format.
Definition: psbt.h:391
LOCK
#define LOCK(cs)
Definition: sync.h:232
gArgs
ArgsManager gArgs
Definition: system.cpp:84
CHDChain::seed_id
CKeyID seed_id
seed hash160
Definition: walletdb.h:90
TransactionError::OK
@ OK
No error.
LegacyScriptPubKeyMan::LoadWatchOnly
bool LoadWatchOnly(const CScript &dest)
Adds a watch-only address to the store, without saving it to disk (used by LoadWallet)
Definition: scriptpubkeyman.cpp:885
CTxIn::prevout
COutPoint prevout
Definition: transaction.h:68
WalletStorage::GetEncryptionKey
virtual const CKeyingMaterial & GetEncryptionKey() const =0
logging.h
SigningResult::SIGNING_FAILED
@ SIGNING_FAILED
DescriptorScriptPubKeyMan::m_max_cached_index
int32_t m_max_cached_index
Definition: scriptpubkeyman.h:529
prevector::size
size_type size() const
Definition: prevector.h:282
LegacyScriptPubKeyMan::GetPubKey
bool GetPubKey(const CKeyID &address, CPubKey &vchPubKeyOut) const override
Definition: scriptpubkeyman.cpp:1018
FillableSigningProvider::AddKeyPubKey
virtual bool AddKeyPubKey(const CKey &key, const CPubKey &pubkey)
Definition: signingprovider.cpp:118
TxoutType::MULTISIG
@ MULTISIG
WalletBatch::WriteKeyMetadata
bool WriteKeyMetadata(const CKeyMetadata &meta, const CPubKey &pubkey, const bool overwrite)
Definition: walletdb.cpp:98
BIP32_HARDENED_KEY_LIMIT
const uint32_t BIP32_HARDENED_KEY_LIMIT
Value for the first BIP 32 hardened derivation. Can be used as a bit mask and as a value....
Definition: scriptpubkeyman.cpp:21
LegacyScriptPubKeyMan::RemoveWatchOnly
bool RemoveWatchOnly(const CScript &dest)
Remove a watch only script from the keystore.
Definition: scriptpubkeyman.cpp:864
CSHA256
A hasher class for SHA-256.
Definition: sha256.h:13
Params
const CChainParams & Params()
Return the currently selected parameters.
Definition: chainparams.cpp:535
LegacyScriptPubKeyMan::HaveWatchOnly
bool HaveWatchOnly() const
Returns whether there are any watch-only things in the wallet.
Definition: scriptpubkeyman.cpp:851
LegacyScriptPubKeyMan::ImportScripts
bool ImportScripts(const std::set< CScript > scripts, int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore)
Definition: scriptpubkeyman.cpp:1511
WalletBatch::WriteWatchOnly
bool WriteWatchOnly(const CScript &script, const CKeyMetadata &keymeta)
Definition: walletdb.cpp:154
DescriptorScriptPubKeyMan::AddKey
bool AddKey(const CKeyID &key_id, const CKey &key)
Definition: scriptpubkeyman.cpp:2211
DescriptorScriptPubKeyMan::GetKeys
KeyMap GetKeys() const EXCLUSIVE_LOCKS_REQUIRED(cs_desc_man)
Definition: scriptpubkeyman.cpp:1743
CKeyPool::fInternal
bool fInternal
Whether this keypool entry is in the internal keypool (for change outputs)
Definition: scriptpubkeyman.h:109
WalletDescriptor::range_end
int32_t range_end
Definition: walletutil.h:81
LegacyScriptPubKeyMan::MarkReserveKeysAsUsed
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.
Definition: scriptpubkeyman.cpp:1430
LegacyScriptPubKeyMan::AddHDChain
void AddHDChain(const CHDChain &chain)
Definition: scriptpubkeyman.cpp:940
PSBTInputSigned
bool PSBTInputSigned(const PSBTInput &input)
Checks whether a PSBTInput is already signed.
Definition: psbt.cpp:197
CKeyMetadata::key_origin
KeyOriginInfo key_origin
Definition: walletdb.h:132
CKeyMetadata::nCreateTime
int64_t nCreateTime
Definition: walletdb.h:129
FillableSigningProvider::GetCScript
virtual bool GetCScript(const CScriptID &hash, CScript &redeemScriptOut) const override
Definition: signingprovider.cpp:179
FillableSigningProvider::AddCScript
virtual bool AddCScript(const CScript &redeemScript)
Definition: signingprovider.cpp:153
WalletBatch::WriteDescriptorCacheItems
bool WriteDescriptorCacheItems(const uint256 &desc_id, const DescriptorCache &cache)
Definition: walletdb.cpp:265
valtype
std::vector< unsigned char > valtype
Definition: interpreter.cpp:15
EncodeExtPubKey
std::string EncodeExtPubKey(const CExtPubKey &key)
Definition: key_io.cpp:222
MAX_SCRIPT_ELEMENT_SIZE
static const unsigned int MAX_SCRIPT_ELEMENT_SIZE
Definition: script.h:23
WalletDescriptor::range_start
int32_t range_start
Definition: walletutil.h:80
KeyOriginInfo::path
std::vector< uint32_t > path
Definition: keyorigin.h:14
WalletDescriptor
Descriptor with some wallet metadata.
Definition: walletutil.h:75
DescriptorScriptPubKeyMan::WriteDescriptor
void WriteDescriptor()
Definition: scriptpubkeyman.cpp:2235
LegacyScriptPubKeyMan::GetKeyOrigin
bool GetKeyOrigin(const CKeyID &keyid, KeyOriginInfo &info) const override
Definition: scriptpubkeyman.cpp:988
MessageSign
bool MessageSign(const CKey &privkey, const std::string &message, std::string &signature)
Sign a message.
Definition: message.cpp:56
LegacyScriptPubKeyMan::fDecryptionThoroughlyChecked
bool fDecryptionThoroughlyChecked
keeps track of whether Unlock has run a thorough check before
Definition: scriptpubkeyman.h:265
CPubKey::IsValid
bool IsValid() const
Definition: pubkey.h:185
SignTransaction
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.
Definition: rawtransaction_util.cpp:278
FillableSigningProvider::HaveKey
virtual bool HaveKey(const CKeyID &address) const override
Definition: signingprovider.cpp:126
DescriptorScriptPubKeyMan::GetTimeFirstKey
int64_t GetTimeFirstKey() const override
Definition: scriptpubkeyman.cpp:1987
DescriptorScriptPubKeyMan::GetScriptPubKeys
const std::vector< CScript > GetScriptPubKeys() const
Definition: scriptpubkeyman.cpp:2249
FillableSigningProvider::cs_KeyStore
RecursiveMutex cs_KeyStore
Definition: signingprovider.h:125
TxoutType::WITNESS_V0_KEYHASH
@ WITNESS_V0_KEYHASH
HidingSigningProvider
Definition: signingprovider.h:33
error
bool error(const char *fmt, const Args &... args)
Definition: system.h:49
LegacyScriptPubKeyMan::AddWatchOnlyInMem
bool AddWatchOnlyInMem(const CScript &dest)
Definition: scriptpubkeyman.cpp:890
WalletDescriptor::descriptor
std::shared_ptr< Descriptor > descriptor
Definition: walletutil.h:78
WalletStorage::IsLocked
virtual bool IsLocked() const =0
CMutableTransaction
A mutable version of CTransaction.
Definition: transaction.h:344
LegacyScriptPubKeyMan::AddInactiveHDChain
void AddInactiveHDChain(const CHDChain &chain)
Definition: scriptpubkeyman.cpp:955
ParseHDKeypath
bool ParseHDKeypath(const std::string &keypath_str, std::vector< uint32_t > &keypath)
Parse an HD keypaths like "m/7/0'/2000".
Definition: bip32.cpp:12
ScriptContext::TOP
@ TOP
Top-level scriptPubKey.
LegacyScriptPubKeyMan::CanGenerateKeys
bool CanGenerateKeys() const
Definition: scriptpubkeyman.cpp:1151
DescriptorScriptPubKeyMan::SignTransaction
bool SignTransaction(CMutableTransaction &tx, const std::map< COutPoint, Coin > &coins, int sighash, std::map< int, std::string > &input_errors) const override
Creates new signatures and adds them to the transaction.
Definition: scriptpubkeyman.cpp:2049
InferDescriptor
std::unique_ptr< Descriptor > InferDescriptor(const CScript &script, const SigningProvider &provider)
Find a descriptor for the specified script, using information from provider where possible.
Definition: descriptor.cpp:1418
DescriptorScriptPubKeyMan::GetNewDestination
bool GetNewDestination(const OutputType type, CTxDestination &dest, std::string &error) override
Definition: scriptpubkeyman.cpp:1616
CExtKey::Neuter
CExtPubKey Neuter() const
Definition: key.cpp:333
DescriptorScriptPubKeyMan::SetCache
void SetCache(const DescriptorCache &cache)
Definition: scriptpubkeyman.cpp:2181
CScriptID
A reference to a CScript: the Hash160 of its serialization (see script.h)
Definition: standard.h:25
DescriptorScriptPubKeyMan::Encrypt
bool Encrypt(const CKeyingMaterial &master_key, WalletBatch *batch) override
Definition: scriptpubkeyman.cpp:1701
WalletBatch::WriteKey
bool WriteKey(const CPubKey &vchPubKey, const CPrivKey &vchPrivKey, const CKeyMetadata &keyMeta)
Definition: walletdb.cpp:103
ScriptPubKeyMan::NotifyCanGetAddressesChanged
boost::signals2::signal< void()> NotifyCanGetAddressesChanged
Keypool has new keys.
Definition: scriptpubkeyman.h:251
HexStr
std::string HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
Definition: strencodings.cpp:594
PSBTInput::witness_utxo
CTxOut witness_utxo
Definition: psbt.h:52
KeyOriginInfo::fingerprint
unsigned char fingerprint[4]
First 32 bits of the Hash160 of the public key at the root of the path.
Definition: keyorigin.h:13
TransactionError::MISSING_INPUTS
@ MISSING_INPUTS
WalletBatch
Access to the wallet database.
Definition: walletdb.h:176
WALLET_FLAG_KEY_ORIGIN_METADATA
@ WALLET_FLAG_KEY_ORIGIN_METADATA
Definition: walletutil.h:44
LegacyScriptPubKeyMan::GetMetadata
std::unique_ptr< CKeyMetadata > GetMetadata(const CTxDestination &dest) const override
Definition: scriptpubkeyman.cpp:661
LegacyScriptPubKeyMan::ReserveKeyFromKeyPool
bool ReserveKeyFromKeyPool(int64_t &nIndex, CKeyPool &keypool, bool fRequestedInternal)
Reserves a key from the keypool and sets nIndex to its index.
Definition: scriptpubkeyman.cpp:1366
WalletStorage::SetMinVersion
virtual void SetMinVersion(enum WalletFeature, WalletBatch *=nullptr)=0
CExtKey::key
CKey key
Definition: key.h:161
PSBTInput::sighash_type
int sighash_type
Definition: psbt.h:60
CKeyMetadata
Definition: walletdb.h:121
LegacyScriptPubKeyMan::AddKeyPubKeyWithDB
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.
Definition: scriptpubkeyman.cpp:715
WalletStorage::CanSupportFeature
virtual bool CanSupportFeature(enum WalletFeature) const =0
ScriptHash
Definition: standard.h:89
DescriptorScriptPubKeyMan::CanUpdateToWalletDescriptor
bool CanUpdateToWalletDescriptor(const WalletDescriptor &descriptor, std::string &error)
Definition: scriptpubkeyman.cpp:2314
base_blob::begin
unsigned char * begin()
Definition: uint256.h:58
DescriptorScriptPubKeyMan::GetDescriptorString
bool GetDescriptorString(std::string &out) const
Definition: scriptpubkeyman.cpp:2261
EncodeDestination
std::string EncodeDestination(const CTxDestination &dest)
Definition: key_io.cpp:256
KeyOriginInfo
Definition: keyorigin.h:11
WALLET_FLAG_DESCRIPTORS
@ WALLET_FLAG_DESCRIPTORS
Indicate that this wallet supports DescriptorScriptPubKeyMan.
Definition: walletutil.h:65
FlatSigningProvider
Definition: signingprovider.h:49
descriptor.h
CPubKey::GetID
CKeyID GetID() const
Get the KeyID of this public key (hash of its serialization)
Definition: pubkey.h:160
LegacyScriptPubKeyMan::AddWatchOnlyWithDB
bool AddWatchOnlyWithDB(WalletBatch &batch, const CScript &dest) EXCLUSIVE_LOCKS_REQUIRED(cs_KeyStore)
Definition: scriptpubkeyman.cpp:902
uint256::ONE
static const uint256 ONE
Definition: uint256.h:130
LegacyScriptPubKeyMan::SignTransaction
bool SignTransaction(CMutableTransaction &tx, const std::map< COutPoint, Coin > &coins, int sighash, std::map< int, std::string > &input_errors) const override
Creates new signatures and adds them to the transaction.
Definition: scriptpubkeyman.cpp:595