Branch data Line data Source code
1 : : // Copyright (c) 2019-2022 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 <hash.h>
6 : : #include <key_io.h>
7 : : #include <logging.h>
8 : : #include <node/types.h>
9 : : #include <outputtype.h>
10 : : #include <script/descriptor.h>
11 : : #include <script/script.h>
12 : : #include <script/sign.h>
13 : : #include <script/solver.h>
14 : : #include <util/bip32.h>
15 : : #include <util/check.h>
16 : : #include <util/strencodings.h>
17 : : #include <util/string.h>
18 : : #include <util/time.h>
19 : : #include <util/translation.h>
20 : : #include <wallet/scriptpubkeyman.h>
21 : :
22 : : #include <optional>
23 : :
24 : : using common::PSBTError;
25 : : using util::ToString;
26 : :
27 : : namespace wallet {
28 : : //! Value for the first BIP 32 hardened derivation. Can be used as a bit mask and as a value. See BIP 32 for more details.
29 : : const uint32_t BIP32_HARDENED_KEY_LIMIT = 0x80000000;
30 : :
31 : 2 : util::Result<CTxDestination> LegacyScriptPubKeyMan::GetNewDestination(const OutputType type)
32 : : {
33 [ - + ]: 2 : if (LEGACY_OUTPUT_TYPES.count(type) == 0) {
34 : 0 : return util::Error{_("Error: Legacy wallets only support the \"legacy\", \"p2sh-segwit\", and \"bech32\" address types")};
35 : : }
36 [ - + ]: 2 : assert(type != OutputType::BECH32M);
37 : :
38 : : // Fill-up keypool if needed
39 : 2 : TopUp();
40 : :
41 : 2 : LOCK(cs_KeyStore);
42 : :
43 : : // Generate a new key that is added to wallet
44 [ + - ]: 2 : CPubKey new_key;
45 [ + - + + ]: 2 : if (!GetKeyFromPool(new_key, type)) {
46 [ + - ]: 3 : return util::Error{_("Error: Keypool ran out, please call keypoolrefill first")};
47 : : }
48 [ + - ]: 1 : LearnRelatedScripts(new_key, type);
49 [ + - ]: 2 : return GetDestinationForKey(new_key, type);
50 : 2 : }
51 : :
52 : : typedef std::vector<unsigned char> valtype;
53 : :
54 : : namespace {
55 : :
56 : : /**
57 : : * This is an enum that tracks the execution context of a script, similar to
58 : : * SigVersion in script/interpreter. It is separate however because we want to
59 : : * distinguish between top-level scriptPubKey execution and P2SH redeemScript
60 : : * execution (a distinction that has no impact on consensus rules).
61 : : */
62 : : enum class IsMineSigVersion
63 : : {
64 : : TOP = 0, //!< scriptPubKey execution
65 : : P2SH = 1, //!< P2SH redeemScript
66 : : WITNESS_V0 = 2, //!< P2WSH witness script execution
67 : : };
68 : :
69 : : /**
70 : : * This is an internal representation of isminetype + invalidity.
71 : : * Its order is significant, as we return the max of all explored
72 : : * possibilities.
73 : : */
74 : : enum class IsMineResult
75 : : {
76 : : NO = 0, //!< Not ours
77 : : WATCH_ONLY = 1, //!< Included in watch-only balance
78 : : SPENDABLE = 2, //!< Included in all balances
79 : : INVALID = 3, //!< Not spendable by anyone (uncompressed pubkey in segwit, P2SH inside P2SH or witness, witness inside witness)
80 : : };
81 : :
82 : 703 : bool PermitsUncompressed(IsMineSigVersion sigversion)
83 : : {
84 : 703 : return sigversion == IsMineSigVersion::TOP || sigversion == IsMineSigVersion::P2SH;
85 : : }
86 : :
87 : 48 : bool HaveKeys(const std::vector<valtype>& pubkeys, const LegacyDataSPKM& keystore)
88 : : {
89 [ + + ]: 125 : for (const valtype& pubkey : pubkeys) {
90 : 106 : CKeyID keyID = CPubKey(pubkey).GetID();
91 [ + + ]: 106 : if (!keystore.HaveKey(keyID)) return false;
92 : : }
93 : : return true;
94 : : }
95 : :
96 : : //! Recursively solve script and return spendable/watchonly/invalid status.
97 : : //!
98 : : //! @param keystore legacy key and script store
99 : : //! @param scriptPubKey script to solve
100 : : //! @param sigversion script type (top-level / redeemscript / witnessscript)
101 : : //! @param recurse_scripthash whether to recurse into nested p2sh and p2wsh
102 : : //! scripts or simply treat any script that has been
103 : : //! stored in the keystore as spendable
104 : : // NOLINTNEXTLINE(misc-no-recursion)
105 : 1326 : IsMineResult IsMineInner(const LegacyDataSPKM& keystore, const CScript& scriptPubKey, IsMineSigVersion sigversion, bool recurse_scripthash=true)
106 : : {
107 : 1326 : IsMineResult ret = IsMineResult::NO;
108 : :
109 : 1326 : std::vector<valtype> vSolutions;
110 [ + - ]: 1326 : TxoutType whichType = Solver(scriptPubKey, vSolutions);
111 : :
112 [ + + + + : 1326 : CKeyID keyID;
+ + + ]
113 [ + + + + : 1326 : switch (whichType) {
+ + + ]
114 : : case TxoutType::NONSTANDARD:
115 : : case TxoutType::NULL_DATA:
116 : : case TxoutType::WITNESS_UNKNOWN:
117 : : case TxoutType::WITNESS_V1_TAPROOT:
118 : : case TxoutType::ANCHOR:
119 : : break;
120 : 143 : case TxoutType::PUBKEY:
121 [ + - ]: 143 : keyID = CPubKey(vSolutions[0]).GetID();
122 [ - + - - ]: 143 : if (!PermitsUncompressed(sigversion) && vSolutions[0].size() != 33) {
123 : : return IsMineResult::INVALID;
124 : : }
125 [ + - + + ]: 143 : if (keystore.HaveKey(keyID)) {
126 [ - + ]: 112 : ret = std::max(ret, IsMineResult::SPENDABLE);
127 : : }
128 : : break;
129 : 391 : case TxoutType::WITNESS_V0_KEYHASH:
130 : 391 : {
131 [ + + ]: 391 : if (sigversion == IsMineSigVersion::WITNESS_V0) {
132 : : // P2WPKH inside P2WSH is invalid.
133 : : return IsMineResult::INVALID;
134 : : }
135 [ + + + - : 665 : if (sigversion == IsMineSigVersion::TOP && !keystore.HaveCScript(CScriptID(CScript() << OP_0 << vSolutions[0]))) {
+ - + - +
+ + + ]
136 : : // We do not support bare witness outputs unless the P2SH version of it would be
137 : : // acceptable as well. This protects against matching before segwit activates.
138 : : // This also applies to the P2WSH case.
139 : : break;
140 : : }
141 [ + - + - : 389 : ret = std::max(ret, IsMineInner(keystore, GetScriptForDestination(PKHash(uint160(vSolutions[0]))), IsMineSigVersion::WITNESS_V0));
+ + ]
142 : 376 : break;
143 : : }
144 : 515 : case TxoutType::PUBKEYHASH:
145 [ + + ]: 515 : keyID = CKeyID(uint160(vSolutions[0]));
146 [ + + ]: 515 : if (!PermitsUncompressed(sigversion)) {
147 [ + - ]: 377 : CPubKey pubkey;
148 [ + - + - : 377 : if (keystore.GetPubKey(keyID, pubkey) && !pubkey.IsCompressed()) {
+ + ]
149 : : return IsMineResult::INVALID;
150 : : }
151 : : }
152 [ + - + + ]: 513 : if (keystore.HaveKey(keyID)) {
153 [ - + ]: 454 : ret = std::max(ret, IsMineResult::SPENDABLE);
154 : : }
155 : : break;
156 : 165 : case TxoutType::SCRIPTHASH:
157 : 165 : {
158 [ + + ]: 165 : if (sigversion != IsMineSigVersion::TOP) {
159 : : // P2SH inside P2WSH or P2SH is invalid.
160 : : return IsMineResult::INVALID;
161 : : }
162 [ + - ]: 159 : CScriptID scriptID = CScriptID(uint160(vSolutions[0]));
163 : 159 : CScript subscript;
164 [ + - + + ]: 159 : if (keystore.GetCScript(scriptID, subscript)) {
165 [ + + + - : 165 : ret = std::max(ret, recurse_scripthash ? IsMineInner(keystore, subscript, IsMineSigVersion::P2SH) : IsMineResult::SPENDABLE);
+ + ]
166 : : }
167 : 159 : break;
168 : 159 : }
169 : 42 : case TxoutType::WITNESS_V0_SCRIPTHASH:
170 : 42 : {
171 [ + + ]: 42 : if (sigversion == IsMineSigVersion::WITNESS_V0) {
172 : : // P2WSH inside P2WSH is invalid.
173 : : return IsMineResult::INVALID;
174 : : }
175 [ + + + - : 74 : if (sigversion == IsMineSigVersion::TOP && !keystore.HaveCScript(CScriptID(CScript() << OP_0 << vSolutions[0]))) {
+ - + - +
+ + + ]
176 : : break;
177 : : }
178 [ + - ]: 36 : CScriptID scriptID{RIPEMD160(vSolutions[0])};
179 : 36 : CScript subscript;
180 [ + - + + ]: 36 : if (keystore.GetCScript(scriptID, subscript)) {
181 [ + - + - : 48 : ret = std::max(ret, recurse_scripthash ? IsMineInner(keystore, subscript, IsMineSigVersion::WITNESS_V0) : IsMineResult::SPENDABLE);
+ + ]
182 : : }
183 : 36 : break;
184 : 36 : }
185 : :
186 : 62 : case TxoutType::MULTISIG:
187 : 62 : {
188 : : // Never treat bare multisig outputs as ours (they can still be made watchonly-though)
189 [ + + ]: 62 : if (sigversion == IsMineSigVersion::TOP) {
190 : : break;
191 : : }
192 : :
193 : : // Only consider transactions "mine" if we own ALL the
194 : : // keys involved. Multi-signature transactions that are
195 : : // partially owned (somebody else has a key that can spend
196 : : // them) enable spend-out-from-under-you attacks, especially
197 : : // in shared-wallet situations.
198 [ + - ]: 45 : std::vector<valtype> keys(vSolutions.begin()+1, vSolutions.begin()+vSolutions.size()-1);
199 [ + + ]: 45 : if (!PermitsUncompressed(sigversion)) {
200 [ + + ]: 85 : for (size_t i = 0; i < keys.size(); i++) {
201 [ + + ]: 62 : if (keys[i].size() != 33) {
202 : 2 : return IsMineResult::INVALID;
203 : : }
204 : : }
205 : : }
206 [ + - + + ]: 43 : if (HaveKeys(keys, keystore)) {
207 [ - + ]: 18 : ret = std::max(ret, IsMineResult::SPENDABLE);
208 : : }
209 : 43 : break;
210 : 45 : }
211 : : } // no default case, so the compiler can warn about missing cases
212 : :
213 [ + + + - : 1312 : if (ret == IsMineResult::NO && keystore.HaveWatchOnly(scriptPubKey)) {
+ + ]
214 [ - + ]: 106 : ret = std::max(ret, IsMineResult::WATCH_ONLY);
215 : : }
216 : 1312 : return ret;
217 : 1326 : }
218 : :
219 : : } // namespace
220 : :
221 : 758 : isminetype LegacyDataSPKM::IsMine(const CScript& script) const
222 : : {
223 [ + + - + ]: 758 : switch (IsMineInner(*this, script, IsMineSigVersion::TOP)) {
224 : : case IsMineResult::INVALID:
225 : : case IsMineResult::NO:
226 : : return ISMINE_NO;
227 : 105 : case IsMineResult::WATCH_ONLY:
228 : 105 : return ISMINE_WATCH_ONLY;
229 : 581 : case IsMineResult::SPENDABLE:
230 : 581 : return ISMINE_SPENDABLE;
231 : : }
232 : 0 : assert(false);
233 : : }
234 : :
235 : 4 : bool LegacyDataSPKM::CheckDecryptionKey(const CKeyingMaterial& master_key)
236 : : {
237 : 4 : {
238 : 4 : LOCK(cs_KeyStore);
239 [ - + ]: 4 : assert(mapKeys.empty());
240 : :
241 [ + - ]: 4 : bool keyPass = mapCryptedKeys.empty(); // Always pass when there are no encrypted keys
242 : 4 : bool keyFail = false;
243 [ + - ]: 4 : CryptedKeyMap::const_iterator mi = mapCryptedKeys.begin();
244 [ + - + - ]: 4 : WalletBatch batch(m_storage.GetDatabase());
245 [ + + ]: 2006 : for (; mi != mapCryptedKeys.end(); ++mi)
246 : : {
247 [ + - ]: 2005 : const CPubKey &vchPubKey = (*mi).second.first;
248 : 2005 : const std::vector<unsigned char> &vchCryptedSecret = (*mi).second.second;
249 : 2005 : CKey key;
250 [ + - + - ]: 2005 : if (!DecryptKey(master_key, vchCryptedSecret, vchPubKey, key))
251 : : {
252 : : keyFail = true;
253 : : break;
254 : : }
255 : 2005 : keyPass = true;
256 [ + + ]: 2005 : if (fDecryptionThoroughlyChecked)
257 : : break;
258 : : else {
259 : : // Rewrite these encrypted keys with checksums
260 [ + - + - : 2002 : batch.WriteCryptedKey(vchPubKey, vchCryptedSecret, mapKeyMetadata[vchPubKey.GetID()]);
+ - ]
261 : : }
262 : 2005 : }
263 [ - + ]: 4 : if (keyPass && keyFail)
264 : : {
265 [ # # ]: 0 : LogPrintf("The wallet is probably corrupted: Some keys decrypt but not all.\n");
266 [ # # ]: 0 : throw std::runtime_error("Error unlocking wallet: some keys decrypt but not all. Your wallet file may be corrupt.");
267 : : }
268 [ - + ]: 4 : if (keyFail || !keyPass)
269 : 0 : return false;
270 : 4 : fDecryptionThoroughlyChecked = true;
271 [ - - + - ]: 4 : }
272 : 4 : return true;
273 : : }
274 : :
275 : 1 : bool LegacyScriptPubKeyMan::Encrypt(const CKeyingMaterial& master_key, WalletBatch* batch)
276 : : {
277 : 1 : LOCK(cs_KeyStore);
278 : 1 : encrypted_batch = batch;
279 [ - + ]: 1 : if (!mapCryptedKeys.empty()) {
280 : 0 : encrypted_batch = nullptr;
281 : 0 : return false;
282 : : }
283 : :
284 : 1 : KeyMap keys_to_encrypt;
285 : 1 : keys_to_encrypt.swap(mapKeys); // Clear mapKeys so AddCryptedKeyInner will succeed.
286 [ + + ]: 1002 : for (const KeyMap::value_type& mKey : keys_to_encrypt)
287 : : {
288 : 1001 : const CKey &key = mKey.second;
289 [ + - ]: 1001 : CPubKey vchPubKey = key.GetPubKey();
290 [ + - + - : 3003 : CKeyingMaterial vchSecret{UCharCast(key.begin()), UCharCast(key.end())};
+ - ]
291 : 1001 : std::vector<unsigned char> vchCryptedSecret;
292 [ + - + - : 1001 : if (!EncryptSecret(master_key, vchSecret, vchPubKey.GetHash(), vchCryptedSecret)) {
- + ]
293 : 0 : encrypted_batch = nullptr;
294 : 0 : return false;
295 : : }
296 [ + - - + ]: 1001 : if (!AddCryptedKey(vchPubKey, vchCryptedSecret)) {
297 : 0 : encrypted_batch = nullptr;
298 : 0 : return false;
299 : : }
300 : 1001 : }
301 : 1 : encrypted_batch = nullptr;
302 : 1 : return true;
303 : 2 : }
304 : :
305 : 0 : util::Result<CTxDestination> LegacyScriptPubKeyMan::GetReservedDestination(const OutputType type, bool internal, int64_t& index, CKeyPool& keypool)
306 : : {
307 [ # # ]: 0 : if (LEGACY_OUTPUT_TYPES.count(type) == 0) {
308 : 0 : return util::Error{_("Error: Legacy wallets only support the \"legacy\", \"p2sh-segwit\", and \"bech32\" address types")};
309 : : }
310 [ # # ]: 0 : assert(type != OutputType::BECH32M);
311 : :
312 : 0 : LOCK(cs_KeyStore);
313 [ # # # # ]: 0 : if (!CanGetAddresses(internal)) {
314 [ # # ]: 0 : return util::Error{_("Error: Keypool ran out, please call keypoolrefill first")};
315 : : }
316 : :
317 : : // Fill-up keypool if needed
318 [ # # ]: 0 : TopUp();
319 : :
320 [ # # # # ]: 0 : if (!ReserveKeyFromKeyPool(index, keypool, internal)) {
321 [ # # ]: 0 : return util::Error{_("Error: Keypool ran out, please call keypoolrefill first")};
322 : : }
323 [ # # ]: 0 : return GetDestinationForKey(keypool.vchPubKey, type);
324 : 0 : }
325 : :
326 : 0 : bool LegacyScriptPubKeyMan::TopUpInactiveHDChain(const CKeyID seed_id, int64_t index, bool internal)
327 : : {
328 : 0 : LOCK(cs_KeyStore);
329 : :
330 [ # # ]: 0 : auto it = m_inactive_hd_chains.find(seed_id);
331 [ # # ]: 0 : if (it == m_inactive_hd_chains.end()) {
332 : : return false;
333 : : }
334 : :
335 [ # # ]: 0 : CHDChain& chain = it->second;
336 : :
337 [ # # ]: 0 : if (internal) {
338 [ # # ]: 0 : chain.m_next_internal_index = std::max(chain.m_next_internal_index, index + 1);
339 : : } else {
340 [ # # ]: 0 : chain.m_next_external_index = std::max(chain.m_next_external_index, index + 1);
341 : : }
342 : :
343 [ # # # # ]: 0 : WalletBatch batch(m_storage.GetDatabase());
344 [ # # ]: 0 : TopUpChain(batch, chain, 0);
345 : :
346 : 0 : return true;
347 : 0 : }
348 : :
349 : 4 : std::vector<WalletDestination> LegacyScriptPubKeyMan::MarkUnusedAddresses(const CScript& script)
350 : : {
351 : 4 : LOCK(cs_KeyStore);
352 : 4 : std::vector<WalletDestination> result;
353 : : // extract addresses and check if they match with an unused keypool key
354 [ + - - + ]: 4 : for (const auto& keyid : GetAffectedKeys(script, *this)) {
355 [ # # ]: 0 : std::map<CKeyID, int64_t>::const_iterator mi = m_pool_key_to_index.find(keyid);
356 [ # # ]: 0 : if (mi != m_pool_key_to_index.end()) {
357 [ # # ]: 0 : WalletLogPrintf("%s: Detected a used keypool key, mark all keypool keys up to this key as used\n", __func__);
358 [ # # # # ]: 0 : for (const auto& keypool : MarkReserveKeysAsUsed(mi->second)) {
359 : : // derive all possible destinations as any of them could have been used
360 [ # # ]: 0 : for (const auto& type : LEGACY_OUTPUT_TYPES) {
361 [ # # ]: 0 : const auto& dest = GetDestinationForKey(keypool.vchPubKey, type);
362 [ # # ]: 0 : result.push_back({dest, keypool.fInternal});
363 : 0 : }
364 : 0 : }
365 : :
366 [ # # # # ]: 0 : if (!TopUp()) {
367 [ # # ]: 0 : WalletLogPrintf("%s: Topping up keypool failed (locked wallet)\n", __func__);
368 : : }
369 : : }
370 : :
371 : : // 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.
372 : : // If so, TopUp the inactive hd chain
373 : 0 : auto it = mapKeyMetadata.find(keyid);
374 [ # # ]: 0 : if (it != mapKeyMetadata.end()){
375 [ # # ]: 0 : CKeyMetadata meta = it->second;
376 [ # # # # ]: 0 : if (!meta.hd_seed_id.IsNull() && meta.hd_seed_id != m_hd_chain.seed_id) {
377 : 0 : std::vector<uint32_t> path;
378 [ # # ]: 0 : if (meta.has_key_origin) {
379 [ # # ]: 0 : path = meta.key_origin.path;
380 [ # # # # ]: 0 : } else if (!ParseHDKeypath(meta.hdKeypath, path)) {
381 [ # # ]: 0 : WalletLogPrintf("%s: Adding inactive seed keys failed, invalid hdKeypath: %s\n",
382 : : __func__,
383 : : meta.hdKeypath);
384 : : }
385 [ # # ]: 0 : if (path.size() != 3) {
386 [ # # ]: 0 : WalletLogPrintf("%s: Adding inactive seed keys failed, invalid path size: %d, has_key_origin: %s\n",
387 : : __func__,
388 [ # # ]: 0 : path.size(),
389 : : meta.has_key_origin);
390 : : } else {
391 : 0 : bool internal = (path[1] & ~BIP32_HARDENED_KEY_LIMIT) != 0;
392 : 0 : int64_t index = path[2] & ~BIP32_HARDENED_KEY_LIMIT;
393 : :
394 [ # # # # ]: 0 : if (!TopUpInactiveHDChain(meta.hd_seed_id, index, internal)) {
395 [ # # ]: 0 : WalletLogPrintf("%s: Adding inactive seed keys failed\n", __func__);
396 : : }
397 : : }
398 : 0 : }
399 : 0 : }
400 : 0 : }
401 : :
402 [ + - ]: 4 : return result;
403 [ - - ]: 4 : }
404 : :
405 : 1 : void LegacyScriptPubKeyMan::UpgradeKeyMetadata()
406 : : {
407 : 1 : LOCK(cs_KeyStore);
408 [ + - + - : 1 : if (m_storage.IsLocked() || m_storage.IsWalletFlagSet(WALLET_FLAG_KEY_ORIGIN_METADATA)) {
+ - - + ]
409 [ # # ]: 0 : return;
410 : : }
411 : :
412 [ + - + - ]: 1 : std::unique_ptr<WalletBatch> batch = std::make_unique<WalletBatch>(m_storage.GetDatabase());
413 [ + + ]: 1002 : for (auto& meta_pair : mapKeyMetadata) {
414 : 1001 : CKeyMetadata& meta = meta_pair.second;
415 [ + - + + : 1001 : 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
- + ]
416 : 0 : CKey key;
417 [ # # ]: 0 : GetKey(meta.hd_seed_id, key);
418 [ # # ]: 0 : CExtKey masterKey;
419 [ # # # # ]: 0 : masterKey.SetSeed(key);
420 : : // Add to map
421 [ # # # # ]: 0 : CKeyID master_id = masterKey.key.GetPubKey().GetID();
422 : 0 : std::copy(master_id.begin(), master_id.begin() + 4, meta.key_origin.fingerprint);
423 [ # # # # ]: 0 : if (!ParseHDKeypath(meta.hdKeypath, meta.key_origin.path)) {
424 [ # # ]: 0 : throw std::runtime_error("Invalid stored hdKeypath");
425 : : }
426 : 0 : meta.has_key_origin = true;
427 [ # # ]: 0 : if (meta.nVersion < CKeyMetadata::VERSION_WITH_KEY_ORIGIN) {
428 : 0 : meta.nVersion = CKeyMetadata::VERSION_WITH_KEY_ORIGIN;
429 : : }
430 : :
431 : : // Write meta to wallet
432 [ # # ]: 0 : CPubKey pubkey;
433 [ # # # # ]: 0 : if (GetPubKey(meta_pair.first, pubkey)) {
434 [ # # ]: 0 : batch->WriteKeyMetadata(meta, pubkey, true);
435 : : }
436 : 0 : }
437 : : }
438 [ + - ]: 2 : }
439 : :
440 : 3 : bool LegacyScriptPubKeyMan::SetupGeneration(bool force)
441 : : {
442 [ + - + - : 3 : if ((CanGenerateKeys() && !force) || m_storage.IsLocked()) {
- + ]
443 : 0 : return false;
444 : : }
445 : :
446 : 3 : SetHDSeed(GenerateNewSeed());
447 [ - + ]: 3 : if (!NewKeyPool()) {
448 : 0 : return false;
449 : : }
450 : : return true;
451 : : }
452 : :
453 : 2021 : bool LegacyScriptPubKeyMan::IsHDEnabled() const
454 : : {
455 : 2021 : return !m_hd_chain.seed_id.IsNull();
456 : : }
457 : :
458 : 2 : bool LegacyScriptPubKeyMan::CanGetAddresses(bool internal) const
459 : : {
460 : 2 : LOCK(cs_KeyStore);
461 : : // Check if the keypool has keys
462 : 2 : bool keypool_has_keys;
463 [ - + - - : 2 : if (internal && m_storage.CanSupportFeature(FEATURE_HD_SPLIT)) {
- - ]
464 : 0 : keypool_has_keys = setInternalKeyPool.size() > 0;
465 : : } else {
466 [ + - ]: 2 : keypool_has_keys = KeypoolCountExternalKeys() > 0;
467 : : }
468 : : // If the keypool doesn't have keys, check if we can generate them
469 [ + + ]: 2 : if (!keypool_has_keys) {
470 [ + - ]: 1 : return CanGenerateKeys();
471 : : }
472 : : return keypool_has_keys;
473 : 2 : }
474 : :
475 : 0 : bool LegacyScriptPubKeyMan::Upgrade(int prev_version, int new_version, bilingual_str& error)
476 : : {
477 : 0 : LOCK(cs_KeyStore);
478 : :
479 [ # # # # ]: 0 : if (m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
480 : : // Nothing to do here if private keys are not enabled
481 : : return true;
482 : : }
483 : :
484 : 0 : bool hd_upgrade = false;
485 : 0 : bool split_upgrade = false;
486 [ # # # # : 0 : if (IsFeatureSupported(new_version, FEATURE_HD) && !IsHDEnabled()) {
# # # # ]
487 [ # # ]: 0 : WalletLogPrintf("Upgrading wallet to HD\n");
488 [ # # ]: 0 : m_storage.SetMinVersion(FEATURE_HD);
489 : :
490 : : // generate a new master key
491 [ # # ]: 0 : CPubKey masterPubKey = GenerateNewSeed();
492 [ # # ]: 0 : SetHDSeed(masterPubKey);
493 : : hd_upgrade = true;
494 : : }
495 : : // Upgrade to HD chain split if necessary
496 [ # # # # : 0 : if (!IsFeatureSupported(prev_version, FEATURE_HD_SPLIT) && IsFeatureSupported(new_version, FEATURE_HD_SPLIT)) {
# # # # ]
497 [ # # ]: 0 : WalletLogPrintf("Upgrading wallet to use HD chain split\n");
498 [ # # ]: 0 : m_storage.SetMinVersion(FEATURE_PRE_SPLIT_KEYPOOL);
499 : 0 : split_upgrade = FEATURE_HD_SPLIT > prev_version;
500 : : // Upgrade the HDChain
501 [ # # ]: 0 : if (m_hd_chain.nVersion < CHDChain::VERSION_HD_CHAIN_SPLIT) {
502 : 0 : m_hd_chain.nVersion = CHDChain::VERSION_HD_CHAIN_SPLIT;
503 [ # # # # : 0 : if (!WalletBatch(m_storage.GetDatabase()).WriteHDChain(m_hd_chain)) {
# # # # ]
504 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": writing chain failed");
505 : : }
506 : : }
507 : : }
508 : : // Mark all keys currently in the keypool as pre-split
509 [ # # ]: 0 : if (split_upgrade) {
510 [ # # ]: 0 : MarkPreSplitKeys();
511 : : }
512 : : // Regenerate the keypool if upgraded to HD
513 [ # # ]: 0 : if (hd_upgrade) {
514 [ # # # # ]: 0 : if (!NewKeyPool()) {
515 [ # # ]: 0 : error = _("Unable to generate keys");
516 : 0 : return false;
517 : : }
518 : : }
519 : : return true;
520 : 0 : }
521 : :
522 : 0 : bool LegacyScriptPubKeyMan::HavePrivateKeys() const
523 : : {
524 : 0 : LOCK(cs_KeyStore);
525 [ # # # # : 0 : return !mapKeys.empty() || !mapCryptedKeys.empty();
# # ]
526 : 0 : }
527 : :
528 : 0 : bool LegacyScriptPubKeyMan::HaveCryptedKeys() const
529 : : {
530 : 0 : LOCK(cs_KeyStore);
531 [ # # ]: 0 : return !mapCryptedKeys.empty();
532 : 0 : }
533 : :
534 : 0 : void LegacyScriptPubKeyMan::RewriteDB()
535 : : {
536 : 0 : LOCK(cs_KeyStore);
537 : 0 : setInternalKeyPool.clear();
538 : 0 : setExternalKeyPool.clear();
539 [ # # ]: 0 : m_pool_key_to_index.clear();
540 : : // Note: can't top-up keypool here, because wallet is locked.
541 : : // User will be prompted to unlock wallet the next operation
542 : : // that requires a new key.
543 : 0 : }
544 : :
545 : 0 : static int64_t GetOldestKeyTimeInPool(const std::set<int64_t>& setKeyPool, WalletBatch& batch) {
546 [ # # ]: 0 : if (setKeyPool.empty()) {
547 : 0 : return GetTime();
548 : : }
549 : :
550 : 0 : CKeyPool keypool;
551 : 0 : int64_t nIndex = *(setKeyPool.begin());
552 [ # # ]: 0 : if (!batch.ReadPool(nIndex, keypool)) {
553 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": read oldest key in keypool failed");
554 : : }
555 [ # # ]: 0 : assert(keypool.vchPubKey.IsValid());
556 : 0 : return keypool.nTime;
557 : : }
558 : :
559 : 0 : std::optional<int64_t> LegacyScriptPubKeyMan::GetOldestKeyPoolTime() const
560 : : {
561 : 0 : LOCK(cs_KeyStore);
562 : :
563 [ # # # # ]: 0 : WalletBatch batch(m_storage.GetDatabase());
564 : :
565 : : // load oldest key from keypool, get time and return
566 [ # # ]: 0 : int64_t oldestKey = GetOldestKeyTimeInPool(setExternalKeyPool, batch);
567 [ # # # # : 0 : if (IsHDEnabled() && m_storage.CanSupportFeature(FEATURE_HD_SPLIT)) {
# # # # ]
568 [ # # # # ]: 0 : oldestKey = std::max(GetOldestKeyTimeInPool(setInternalKeyPool, batch), oldestKey);
569 [ # # ]: 0 : if (!set_pre_split_keypool.empty()) {
570 [ # # # # ]: 0 : oldestKey = std::max(GetOldestKeyTimeInPool(set_pre_split_keypool, batch), oldestKey);
571 : : }
572 : : }
573 : :
574 : 0 : return oldestKey;
575 [ # # ]: 0 : }
576 : :
577 : 2 : size_t LegacyScriptPubKeyMan::KeypoolCountExternalKeys() const
578 : : {
579 : 2 : LOCK(cs_KeyStore);
580 [ + - ]: 2 : return setExternalKeyPool.size() + set_pre_split_keypool.size();
581 : 2 : }
582 : :
583 : 0 : unsigned int LegacyScriptPubKeyMan::GetKeyPoolSize() const
584 : : {
585 : 0 : LOCK(cs_KeyStore);
586 [ # # ]: 0 : return setInternalKeyPool.size() + setExternalKeyPool.size() + set_pre_split_keypool.size();
587 : 0 : }
588 : :
589 : 32 : int64_t LegacyScriptPubKeyMan::GetTimeFirstKey() const
590 : : {
591 : 32 : LOCK(cs_KeyStore);
592 [ + - ]: 32 : return nTimeFirstKey;
593 : 32 : }
594 : :
595 : 43 : std::unique_ptr<SigningProvider> LegacyDataSPKM::GetSolvingProvider(const CScript& script) const
596 : : {
597 : 43 : return std::make_unique<LegacySigningProvider>(*this);
598 : : }
599 : :
600 : 10 : bool LegacyScriptPubKeyMan::CanProvide(const CScript& script, SignatureData& sigdata)
601 : : {
602 : 10 : IsMineResult ismine = IsMineInner(*this, script, IsMineSigVersion::TOP, /* recurse_scripthash= */ false);
603 [ + + ]: 10 : if (ismine == IsMineResult::SPENDABLE || ismine == IsMineResult::WATCH_ONLY) {
604 : : // If ismine, it means we recognize keys or script ids in the script, or
605 : : // are watching the script itself, and we can at least provide metadata
606 : : // or solving information, even if not able to sign fully.
607 : : return true;
608 : : } else {
609 : : // If, given the stuff in sigdata, we could make a valid signature, then we can provide for this script
610 : 5 : ProduceSignature(*this, DUMMY_SIGNATURE_CREATOR, script, sigdata);
611 [ - + ]: 5 : if (!sigdata.signatures.empty()) {
612 : : // If we could make signatures, make sure we have a private key to actually make a signature
613 : 0 : bool has_privkeys = false;
614 [ # # ]: 0 : for (const auto& key_sig_pair : sigdata.signatures) {
615 : 0 : has_privkeys |= HaveKey(key_sig_pair.first);
616 : : }
617 : : return has_privkeys;
618 : : }
619 : : return false;
620 : : }
621 : : }
622 : :
623 : 0 : bool LegacyScriptPubKeyMan::SignTransaction(CMutableTransaction& tx, const std::map<COutPoint, Coin>& coins, int sighash, std::map<int, bilingual_str>& input_errors) const
624 : : {
625 : 0 : return ::SignTransaction(tx, this, coins, sighash, input_errors);
626 : : }
627 : :
628 : 0 : SigningResult LegacyScriptPubKeyMan::SignMessage(const std::string& message, const PKHash& pkhash, std::string& str_sig) const
629 : : {
630 : 0 : CKey key;
631 [ # # # # : 0 : if (!GetKey(ToKeyID(pkhash), key)) {
# # ]
632 : : return SigningResult::PRIVATE_KEY_NOT_AVAILABLE;
633 : : }
634 : :
635 [ # # # # ]: 0 : if (MessageSign(key, message, str_sig)) {
636 : 0 : return SigningResult::OK;
637 : : }
638 : : return SigningResult::SIGNING_FAILED;
639 : 0 : }
640 : :
641 : 0 : std::optional<PSBTError> LegacyScriptPubKeyMan::FillPSBT(PartiallySignedTransaction& psbtx, const PrecomputedTransactionData& txdata, int sighash_type, bool sign, bool bip32derivs, int* n_signed, bool finalize) const
642 : : {
643 [ # # ]: 0 : if (n_signed) {
644 : 0 : *n_signed = 0;
645 : : }
646 [ # # ]: 0 : for (unsigned int i = 0; i < psbtx.tx->vin.size(); ++i) {
647 : 0 : const CTxIn& txin = psbtx.tx->vin[i];
648 : 0 : PSBTInput& input = psbtx.inputs.at(i);
649 : :
650 [ # # ]: 0 : if (PSBTInputSigned(input)) {
651 : 0 : continue;
652 : : }
653 : :
654 : : // Get the Sighash type
655 [ # # # # : 0 : if (sign && input.sighash_type != std::nullopt && *input.sighash_type != sighash_type) {
# # ]
656 : 0 : return PSBTError::SIGHASH_MISMATCH;
657 : : }
658 : :
659 : : // Check non_witness_utxo has specified prevout
660 [ # # ]: 0 : if (input.non_witness_utxo) {
661 [ # # ]: 0 : if (txin.prevout.n >= input.non_witness_utxo->vout.size()) {
662 : 0 : return PSBTError::MISSING_INPUTS;
663 : : }
664 [ # # ]: 0 : } else if (input.witness_utxo.IsNull()) {
665 : : // There's no UTXO so we can just skip this now
666 : 0 : continue;
667 : : }
668 [ # # ]: 0 : SignPSBTInput(HidingSigningProvider(this, !sign, !bip32derivs), psbtx, i, &txdata, sighash_type, nullptr, finalize);
669 : :
670 : 0 : bool signed_one = PSBTInputSigned(input);
671 [ # # # # ]: 0 : if (n_signed && (signed_one || !sign)) {
672 : : // If sign is false, we assume that we _could_ sign if we get here. This
673 : : // will never have false negatives; it is hard to tell under what i
674 : : // circumstances it could have false positives.
675 : 0 : (*n_signed)++;
676 : : }
677 : : }
678 : :
679 : : // Fill in the bip32 keypaths and redeemscripts for the outputs so that hardware wallets can identify change
680 [ # # ]: 0 : for (unsigned int i = 0; i < psbtx.tx->vout.size(); ++i) {
681 [ # # ]: 0 : UpdatePSBTOutput(HidingSigningProvider(this, true, !bip32derivs), psbtx, i);
682 : : }
683 : :
684 : 0 : return {};
685 : : }
686 : :
687 : 0 : std::unique_ptr<CKeyMetadata> LegacyScriptPubKeyMan::GetMetadata(const CTxDestination& dest) const
688 : : {
689 : 0 : LOCK(cs_KeyStore);
690 : :
691 [ # # ]: 0 : CKeyID key_id = GetKeyForDestination(*this, dest);
692 [ # # ]: 0 : if (!key_id.IsNull()) {
693 : 0 : auto it = mapKeyMetadata.find(key_id);
694 [ # # ]: 0 : if (it != mapKeyMetadata.end()) {
695 [ # # ]: 0 : return std::make_unique<CKeyMetadata>(it->second);
696 : : }
697 : : }
698 : :
699 [ # # ]: 0 : CScript scriptPubKey = GetScriptForDestination(dest);
700 [ # # ]: 0 : auto it = m_script_metadata.find(CScriptID(scriptPubKey));
701 [ # # ]: 0 : if (it != m_script_metadata.end()) {
702 [ # # ]: 0 : return std::make_unique<CKeyMetadata>(it->second);
703 : : }
704 : :
705 : 0 : return nullptr;
706 : 0 : }
707 : :
708 : 32 : uint256 LegacyScriptPubKeyMan::GetID() const
709 : : {
710 : 32 : return uint256::ONE;
711 : : }
712 : :
713 : : /**
714 : : * Update wallet first key creation time. This should be called whenever keys
715 : : * are added to the wallet, with the oldest key creation time.
716 : : */
717 : 10017 : void LegacyScriptPubKeyMan::UpdateTimeFirstKey(int64_t nCreateTime)
718 : : {
719 : 10017 : AssertLockHeld(cs_KeyStore);
720 [ + + ]: 10017 : if (nCreateTime <= 1) {
721 : : // Cannot determine birthday information, so set the wallet birthday to
722 : : // the beginning of time.
723 : 2 : nTimeFirstKey = 1;
724 [ + + + + ]: 10015 : } else if (nTimeFirstKey == UNKNOWN_TIME || nCreateTime < nTimeFirstKey) {
725 : 19 : nTimeFirstKey = nCreateTime;
726 : : }
727 : :
728 : 10017 : NotifyFirstKeyTimeChanged(this, nTimeFirstKey);
729 : 10017 : }
730 : :
731 : 98 : bool LegacyDataSPKM::LoadKey(const CKey& key, const CPubKey &pubkey)
732 : : {
733 : 98 : return AddKeyPubKeyInner(key, pubkey);
734 : : }
735 : :
736 : 29 : bool LegacyScriptPubKeyMan::AddKeyPubKey(const CKey& secret, const CPubKey &pubkey)
737 : : {
738 : 29 : LOCK(cs_KeyStore);
739 [ + - + - ]: 29 : WalletBatch batch(m_storage.GetDatabase());
740 [ + - ]: 29 : return LegacyScriptPubKeyMan::AddKeyPubKeyWithDB(batch, secret, pubkey);
741 [ + - ]: 58 : }
742 : :
743 : 2034 : bool LegacyScriptPubKeyMan::AddKeyPubKeyWithDB(WalletBatch& batch, const CKey& secret, const CPubKey& pubkey)
744 : : {
745 : 2034 : AssertLockHeld(cs_KeyStore);
746 : :
747 : : // Make sure we aren't adding private keys to private key disabled wallets
748 [ - + ]: 2034 : assert(!m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
749 : :
750 : : // FillableSigningProvider has no concept of wallet databases, but calls AddCryptedKey
751 : : // which is overridden below. To avoid flushes, the database handle is
752 : : // tunneled through to it.
753 : 2034 : bool needsDB = !encrypted_batch;
754 [ + - ]: 2034 : if (needsDB) {
755 : 2034 : encrypted_batch = &batch;
756 : : }
757 [ - + ]: 2034 : if (!AddKeyPubKeyInner(secret, pubkey)) {
758 [ # # ]: 0 : if (needsDB) encrypted_batch = nullptr;
759 : 0 : return false;
760 : : }
761 [ + - ]: 2034 : if (needsDB) encrypted_batch = nullptr;
762 : :
763 : : // check if we need to remove from watch-only
764 : 2034 : CScript script;
765 [ + - + - ]: 4068 : script = GetScriptForDestination(PKHash(pubkey));
766 [ + - - + ]: 2034 : if (HaveWatchOnly(script)) {
767 [ # # ]: 0 : RemoveWatchOnly(script);
768 : : }
769 [ + - ]: 4068 : script = GetScriptForRawPubKey(pubkey);
770 [ + - - + ]: 2034 : if (HaveWatchOnly(script)) {
771 [ # # ]: 0 : RemoveWatchOnly(script);
772 : : }
773 : :
774 [ + - ]: 2034 : m_storage.UnsetBlankWalletFlag(batch);
775 [ + - + + ]: 2034 : if (!m_storage.HasEncryptionKeys()) {
776 [ + - ]: 1033 : return batch.WriteKey(pubkey,
777 [ + - ]: 2066 : secret.GetPrivKey(),
778 [ + - + - ]: 1033 : mapKeyMetadata[pubkey.GetID()]);
779 : : }
780 : : return true;
781 : 2034 : }
782 : :
783 : 64 : bool LegacyDataSPKM::LoadCScript(const CScript& redeemScript)
784 : : {
785 : : /* A sanity check was added in pull #3843 to avoid adding redeemScripts
786 : : * that never can be redeemed. However, old wallets may still contain
787 : : * these. Do not add them to the wallet and warn. */
788 [ + + - + ]: 64 : if (redeemScript.size() > MAX_SCRIPT_ELEMENT_SIZE)
789 : : {
790 [ # # ]: 0 : std::string strAddr = EncodeDestination(ScriptHash(redeemScript));
791 [ # # # # ]: 0 : 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);
792 : 0 : return true;
793 : 0 : }
794 : :
795 : 64 : return FillableSigningProvider::AddCScript(redeemScript);
796 : : }
797 : :
798 : 8133 : void LegacyDataSPKM::LoadKeyMetadata(const CKeyID& keyID, const CKeyMetadata& meta)
799 : : {
800 : 8133 : LOCK(cs_KeyStore);
801 [ + - + - ]: 8133 : mapKeyMetadata[keyID] = meta;
802 : 8133 : }
803 : :
804 : 8008 : void LegacyScriptPubKeyMan::LoadKeyMetadata(const CKeyID& keyID, const CKeyMetadata& meta)
805 : : {
806 : 8008 : LOCK(cs_KeyStore);
807 [ + - ]: 8008 : LegacyDataSPKM::LoadKeyMetadata(keyID, meta);
808 [ + - ]: 8008 : UpdateTimeFirstKey(meta.nCreateTime);
809 : 8008 : }
810 : :
811 : 32 : void LegacyDataSPKM::LoadScriptMetadata(const CScriptID& script_id, const CKeyMetadata& meta)
812 : : {
813 : 32 : LOCK(cs_KeyStore);
814 [ + - + - ]: 32 : m_script_metadata[script_id] = meta;
815 : 32 : }
816 : :
817 : 0 : void LegacyScriptPubKeyMan::LoadScriptMetadata(const CScriptID& script_id, const CKeyMetadata& meta)
818 : : {
819 : 0 : LOCK(cs_KeyStore);
820 [ # # ]: 0 : LegacyDataSPKM::LoadScriptMetadata(script_id, meta);
821 [ # # ]: 0 : UpdateTimeFirstKey(meta.nCreateTime);
822 : 0 : }
823 : :
824 : 98 : bool LegacyDataSPKM::AddKeyPubKeyInner(const CKey& key, const CPubKey& pubkey)
825 : : {
826 : 98 : LOCK(cs_KeyStore);
827 [ + - + - ]: 98 : return FillableSigningProvider::AddKeyPubKey(key, pubkey);
828 : 98 : }
829 : :
830 : 2034 : bool LegacyScriptPubKeyMan::AddKeyPubKeyInner(const CKey& key, const CPubKey &pubkey)
831 : : {
832 : 2034 : LOCK(cs_KeyStore);
833 [ + - + + ]: 2034 : if (!m_storage.HasEncryptionKeys()) {
834 [ + - ]: 1033 : return FillableSigningProvider::AddKeyPubKey(key, pubkey);
835 : : }
836 : :
837 [ + - + - ]: 1001 : if (m_storage.IsLocked()) {
838 : : return false;
839 : : }
840 : :
841 : 1001 : std::vector<unsigned char> vchCryptedSecret;
842 [ + - + - : 3003 : CKeyingMaterial vchSecret{UCharCast(key.begin()), UCharCast(key.end())};
+ - ]
843 [ + - + - : 1001 : if (!m_storage.WithEncryptionKey([&](const CKeyingMaterial& encryption_key) {
+ - ]
844 : 1001 : return EncryptSecret(encryption_key, vchSecret, pubkey.GetHash(), vchCryptedSecret);
845 : : })) {
846 : : return false;
847 : : }
848 : :
849 [ + - - + ]: 1001 : if (!AddCryptedKey(pubkey, vchCryptedSecret)) {
850 : 0 : return false;
851 : : }
852 : : return true;
853 : 3035 : }
854 : :
855 : 8030 : bool LegacyDataSPKM::LoadCryptedKey(const CPubKey &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret, bool checksum_valid)
856 : : {
857 : : // Set fDecryptionThoroughlyChecked to false when the checksum is invalid
858 [ + + ]: 8030 : if (!checksum_valid) {
859 : 1 : fDecryptionThoroughlyChecked = false;
860 : : }
861 : :
862 : 8030 : return AddCryptedKeyInner(vchPubKey, vchCryptedSecret);
863 : : }
864 : :
865 : 10032 : bool LegacyDataSPKM::AddCryptedKeyInner(const CPubKey &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret)
866 : : {
867 : 10032 : LOCK(cs_KeyStore);
868 [ - + ]: 10032 : assert(mapKeys.empty());
869 : :
870 [ + - + - : 20064 : mapCryptedKeys[vchPubKey.GetID()] = make_pair(vchPubKey, vchCryptedSecret);
+ - ]
871 [ + - ]: 10032 : ImplicitlyLearnRelatedKeyScripts(vchPubKey);
872 [ + - ]: 10032 : return true;
873 : 10032 : }
874 : :
875 : 2002 : bool LegacyScriptPubKeyMan::AddCryptedKey(const CPubKey &vchPubKey,
876 : : const std::vector<unsigned char> &vchCryptedSecret)
877 : : {
878 [ + - ]: 2002 : if (!AddCryptedKeyInner(vchPubKey, vchCryptedSecret))
879 : : return false;
880 : 2002 : {
881 : 2002 : LOCK(cs_KeyStore);
882 [ + - ]: 2002 : if (encrypted_batch)
883 [ + - ]: 2002 : return encrypted_batch->WriteCryptedKey(vchPubKey,
884 : : vchCryptedSecret,
885 [ + - + - ]: 2002 : mapKeyMetadata[vchPubKey.GetID()]);
886 : : else
887 [ # # # # : 0 : return WalletBatch(m_storage.GetDatabase()).WriteCryptedKey(vchPubKey,
# # ]
888 : : vchCryptedSecret,
889 [ # # # # ]: 0 : mapKeyMetadata[vchPubKey.GetID()]);
890 : 2002 : }
891 : : }
892 : :
893 : 4309 : bool LegacyDataSPKM::HaveWatchOnly(const CScript &dest) const
894 : : {
895 : 4309 : LOCK(cs_KeyStore);
896 [ + - ]: 4309 : return setWatchOnly.count(dest) > 0;
897 : 4309 : }
898 : :
899 : 6 : bool LegacyDataSPKM::HaveWatchOnly() const
900 : : {
901 : 6 : LOCK(cs_KeyStore);
902 [ + - ]: 6 : return (!setWatchOnly.empty());
903 : 6 : }
904 : :
905 : 44 : static bool ExtractPubKey(const CScript &dest, CPubKey& pubKeyOut)
906 : : {
907 : 44 : std::vector<std::vector<unsigned char>> solutions;
908 [ + - + + : 62 : return Solver(dest, solutions) == TxoutType::PUBKEY &&
+ + ]
909 [ + - ]: 62 : (pubKeyOut = CPubKey(solutions[0])).IsFullyValid();
910 : 44 : }
911 : :
912 : 5 : bool LegacyScriptPubKeyMan::RemoveWatchOnly(const CScript &dest)
913 : : {
914 : 5 : {
915 : 5 : LOCK(cs_KeyStore);
916 : 5 : setWatchOnly.erase(dest);
917 [ + - ]: 5 : CPubKey pubKey;
918 [ + - + + ]: 5 : if (ExtractPubKey(dest, pubKey)) {
919 [ + - ]: 2 : mapWatchKeys.erase(pubKey.GetID());
920 : : }
921 : : // Related CScripts are not removed; having superfluous scripts around is
922 : : // harmless (see comment in ImplicitlyLearnRelatedKeyScripts).
923 : 0 : }
924 : :
925 [ + - ]: 5 : if (!HaveWatchOnly())
926 : 5 : NotifyWatchonlyChanged(false);
927 [ + - - + ]: 10 : if (!WalletBatch(m_storage.GetDatabase()).EraseWatchOnly(dest))
928 : 0 : return false;
929 : :
930 : : return true;
931 : : }
932 : :
933 : 37 : bool LegacyDataSPKM::LoadWatchOnly(const CScript &dest)
934 : : {
935 : 37 : return AddWatchOnlyInMem(dest);
936 : : }
937 : :
938 : 39 : bool LegacyDataSPKM::AddWatchOnlyInMem(const CScript &dest)
939 : : {
940 : 39 : LOCK(cs_KeyStore);
941 [ + - ]: 39 : setWatchOnly.insert(dest);
942 [ + - ]: 39 : CPubKey pubKey;
943 [ + - + + ]: 39 : if (ExtractPubKey(dest, pubKey)) {
944 [ + - + - ]: 12 : mapWatchKeys[pubKey.GetID()] = pubKey;
945 [ + - ]: 12 : ImplicitlyLearnRelatedKeyScripts(pubKey);
946 : : }
947 [ + - ]: 39 : return true;
948 : 39 : }
949 : :
950 : 2 : bool LegacyScriptPubKeyMan::AddWatchOnlyWithDB(WalletBatch &batch, const CScript& dest)
951 : : {
952 [ + - ]: 2 : if (!AddWatchOnlyInMem(dest))
953 : : return false;
954 : 2 : const CKeyMetadata& meta = m_script_metadata[CScriptID(dest)];
955 : 2 : UpdateTimeFirstKey(meta.nCreateTime);
956 : 2 : NotifyWatchonlyChanged(true);
957 [ + - ]: 2 : if (batch.WriteWatchOnly(dest, meta)) {
958 : 2 : m_storage.UnsetBlankWalletFlag(batch);
959 : 2 : return true;
960 : : }
961 : : return false;
962 : : }
963 : :
964 : 2 : bool LegacyScriptPubKeyMan::AddWatchOnlyWithDB(WalletBatch &batch, const CScript& dest, int64_t create_time)
965 : : {
966 : 2 : m_script_metadata[CScriptID(dest)].nCreateTime = create_time;
967 : 2 : return AddWatchOnlyWithDB(batch, dest);
968 : : }
969 : :
970 : 0 : bool LegacyScriptPubKeyMan::AddWatchOnly(const CScript& dest)
971 : : {
972 : 0 : WalletBatch batch(m_storage.GetDatabase());
973 [ # # ]: 0 : return AddWatchOnlyWithDB(batch, dest);
974 : 0 : }
975 : :
976 : 0 : bool LegacyScriptPubKeyMan::AddWatchOnly(const CScript& dest, int64_t nCreateTime)
977 : : {
978 : 0 : m_script_metadata[CScriptID(dest)].nCreateTime = nCreateTime;
979 : 0 : return AddWatchOnly(dest);
980 : : }
981 : :
982 : 25 : void LegacyDataSPKM::LoadHDChain(const CHDChain& chain)
983 : : {
984 : 25 : LOCK(cs_KeyStore);
985 [ + - ]: 25 : m_hd_chain = chain;
986 : 25 : }
987 : :
988 : 3 : void LegacyScriptPubKeyMan::AddHDChain(const CHDChain& chain)
989 : : {
990 : 3 : LOCK(cs_KeyStore);
991 : : // Store the new chain
992 [ + - + - : 6 : if (!WalletBatch(m_storage.GetDatabase()).WriteHDChain(chain)) {
+ - - + ]
993 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": writing chain failed");
994 : : }
995 : : // When there's an old chain, add it as an inactive chain as we are now rotating hd chains
996 [ + + ]: 3 : if (!m_hd_chain.seed_id.IsNull()) {
997 [ + - ]: 1 : AddInactiveHDChain(m_hd_chain);
998 : : }
999 : :
1000 [ + - ]: 3 : m_hd_chain = chain;
1001 : 3 : }
1002 : :
1003 : 10 : void LegacyDataSPKM::AddInactiveHDChain(const CHDChain& chain)
1004 : : {
1005 : 10 : LOCK(cs_KeyStore);
1006 [ - + ]: 10 : assert(!chain.seed_id.IsNull());
1007 [ + - + - ]: 10 : m_inactive_hd_chains[chain.seed_id] = chain;
1008 : 10 : }
1009 : :
1010 : 2767 : bool LegacyDataSPKM::HaveKey(const CKeyID &address) const
1011 : : {
1012 : 2767 : LOCK(cs_KeyStore);
1013 [ + - + + ]: 2767 : if (!m_storage.HasEncryptionKeys()) {
1014 [ + - ]: 1737 : return FillableSigningProvider::HaveKey(address);
1015 : : }
1016 : 1030 : return mapCryptedKeys.count(address) > 0;
1017 : 2767 : }
1018 : :
1019 : 2512 : bool LegacyDataSPKM::GetKey(const CKeyID &address, CKey& keyOut) const
1020 : : {
1021 : 2512 : LOCK(cs_KeyStore);
1022 [ + - + + ]: 2512 : if (!m_storage.HasEncryptionKeys()) {
1023 [ + - ]: 1505 : return FillableSigningProvider::GetKey(address, keyOut);
1024 : : }
1025 : :
1026 : 1007 : CryptedKeyMap::const_iterator mi = mapCryptedKeys.find(address);
1027 [ + - ]: 1007 : if (mi != mapCryptedKeys.end())
1028 : : {
1029 [ + - ]: 1007 : const CPubKey &vchPubKey = (*mi).second.first;
1030 : 1007 : const std::vector<unsigned char> &vchCryptedSecret = (*mi).second.second;
1031 [ + - + - ]: 1007 : return m_storage.WithEncryptionKey([&](const CKeyingMaterial& encryption_key) {
1032 : 1007 : return DecryptKey(encryption_key, vchCryptedSecret, vchPubKey, keyOut);
1033 : : });
1034 : : }
1035 : : return false;
1036 : 2512 : }
1037 : :
1038 : 88 : bool LegacyDataSPKM::GetKeyOrigin(const CKeyID& keyID, KeyOriginInfo& info) const
1039 : : {
1040 : 88 : CKeyMetadata meta;
1041 : 88 : {
1042 [ + - ]: 88 : LOCK(cs_KeyStore);
1043 : 88 : auto it = mapKeyMetadata.find(keyID);
1044 [ + + ]: 88 : if (it == mapKeyMetadata.end()) {
1045 [ + - ]: 32 : return false;
1046 : : }
1047 [ + - ]: 56 : meta = it->second;
1048 : 32 : }
1049 [ + + ]: 56 : if (meta.has_key_origin) {
1050 : 32 : std::copy(meta.key_origin.fingerprint, meta.key_origin.fingerprint + 4, info.fingerprint);
1051 [ + - ]: 32 : info.path = meta.key_origin.path;
1052 : : } else { // Single pubkeys get the master fingerprint of themselves
1053 : 24 : std::copy(keyID.begin(), keyID.begin() + 4, info.fingerprint);
1054 : : }
1055 : : return true;
1056 : 88 : }
1057 : :
1058 : 61 : bool LegacyDataSPKM::GetWatchPubKey(const CKeyID &address, CPubKey &pubkey_out) const
1059 : : {
1060 : 61 : LOCK(cs_KeyStore);
1061 : 61 : WatchKeyMap::const_iterator it = mapWatchKeys.find(address);
1062 [ + + ]: 61 : if (it != mapWatchKeys.end()) {
1063 : 50 : pubkey_out = it->second;
1064 : 50 : return true;
1065 : : }
1066 : : return false;
1067 : 61 : }
1068 : :
1069 : 399 : bool LegacyDataSPKM::GetPubKey(const CKeyID &address, CPubKey& vchPubKeyOut) const
1070 : : {
1071 : 399 : LOCK(cs_KeyStore);
1072 [ + - + + ]: 399 : if (!m_storage.HasEncryptionKeys()) {
1073 [ + - + + ]: 381 : if (!FillableSigningProvider::GetPubKey(address, vchPubKeyOut)) {
1074 [ + - ]: 54 : return GetWatchPubKey(address, vchPubKeyOut);
1075 : : }
1076 : : return true;
1077 : : }
1078 : :
1079 : 18 : CryptedKeyMap::const_iterator mi = mapCryptedKeys.find(address);
1080 [ + - ]: 18 : if (mi != mapCryptedKeys.end())
1081 : : {
1082 : 18 : vchPubKeyOut = (*mi).second.first;
1083 : 18 : return true;
1084 : : }
1085 : : // Check for watch-only pubkeys
1086 [ # # ]: 0 : return GetWatchPubKey(address, vchPubKeyOut);
1087 : 399 : }
1088 : :
1089 : 2004 : CPubKey LegacyScriptPubKeyMan::GenerateNewKey(WalletBatch &batch, CHDChain& hd_chain, bool internal)
1090 : : {
1091 [ - + ]: 2004 : assert(!m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
1092 [ - + ]: 2004 : assert(!m_storage.IsWalletFlagSet(WALLET_FLAG_BLANK_WALLET));
1093 : 2004 : AssertLockHeld(cs_KeyStore);
1094 : 2004 : bool fCompressed = m_storage.CanSupportFeature(FEATURE_COMPRPUBKEY); // default to compressed public keys if we want 0.6.0 wallets
1095 : :
1096 : 2004 : CKey secret;
1097 : :
1098 : : // Create new metadata
1099 [ + - ]: 2004 : int64_t nCreationTime = GetTime();
1100 : 2004 : CKeyMetadata metadata(nCreationTime);
1101 : :
1102 : : // use HD key derivation if HD was enabled during wallet creation and a seed is present
1103 [ + - + - ]: 2004 : if (IsHDEnabled()) {
1104 [ + - - + : 2004 : DeriveNewChildKey(batch, metadata, secret, hd_chain, (m_storage.CanSupportFeature(FEATURE_HD_SPLIT) ? internal : false));
+ - ]
1105 : : } else {
1106 [ # # ]: 0 : secret.MakeNewKey(fCompressed);
1107 : : }
1108 : :
1109 : : // Compressed public keys were introduced in version 0.6.0
1110 [ - + ]: 2004 : if (fCompressed) {
1111 [ # # ]: 0 : m_storage.SetMinVersion(FEATURE_COMPRPUBKEY);
1112 : : }
1113 : :
1114 [ + - ]: 2004 : CPubKey pubkey = secret.GetPubKey();
1115 [ + - - + ]: 2004 : assert(secret.VerifyPubKey(pubkey));
1116 : :
1117 [ + - + - : 2004 : mapKeyMetadata[pubkey.GetID()] = metadata;
+ - ]
1118 [ + - ]: 2004 : UpdateTimeFirstKey(nCreationTime);
1119 : :
1120 [ + - - + ]: 2004 : if (!AddKeyPubKeyWithDB(batch, secret, pubkey)) {
1121 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": AddKey failed");
1122 : : }
1123 : 2004 : return pubkey;
1124 : 2004 : }
1125 : :
1126 : : //! Try to derive an extended key, throw if it fails.
1127 : 6012 : static void DeriveExtKey(CExtKey& key_in, unsigned int index, CExtKey& key_out) {
1128 [ - + ]: 6012 : if (!key_in.Derive(key_out, index)) {
1129 [ # # ]: 0 : throw std::runtime_error("Could not derive extended key");
1130 : : }
1131 : 6012 : }
1132 : :
1133 : 2004 : void LegacyScriptPubKeyMan::DeriveNewChildKey(WalletBatch &batch, CKeyMetadata& metadata, CKey& secret, CHDChain& hd_chain, bool internal)
1134 : : {
1135 : : // for now we use a fixed keypath scheme of m/0'/0'/k
1136 : 2004 : CKey seed; //seed (256bit)
1137 [ + - ]: 2004 : CExtKey masterKey; //hd master key
1138 : 2004 : CExtKey accountKey; //key at m/0'
1139 : 2004 : CExtKey chainChildKey; //key at m/0'/0' (external) or m/0'/1' (internal)
1140 : 2004 : CExtKey childKey; //key at m/0'/0'/<n>'
1141 : :
1142 : : // try to get the seed
1143 [ + - - + ]: 2004 : if (!GetKey(hd_chain.seed_id, seed))
1144 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": seed not found");
1145 : :
1146 [ + - + - ]: 4008 : masterKey.SetSeed(seed);
1147 : :
1148 : : // derive m/0'
1149 : : // use hardened derivation (child keys >= 0x80000000 are hardened after bip32)
1150 [ + - ]: 2004 : DeriveExtKey(masterKey, BIP32_HARDENED_KEY_LIMIT, accountKey);
1151 : :
1152 : : // derive m/0'/0' (external chain) OR m/0'/1' (internal chain)
1153 [ - + - - : 2004 : assert(internal ? m_storage.CanSupportFeature(FEATURE_HD_SPLIT) : true);
- - ]
1154 [ + - + - ]: 4008 : DeriveExtKey(accountKey, BIP32_HARDENED_KEY_LIMIT+(internal ? 1 : 0), chainChildKey);
1155 : :
1156 : : // derive child key at next index, skip keys already known to the wallet
1157 : 2004 : do {
1158 : : // always derive hardened keys
1159 : : // childIndex | BIP32_HARDENED_KEY_LIMIT = derive childIndex in hardened child-index-range
1160 : : // example: 1 | BIP32_HARDENED_KEY_LIMIT == 0x80000001 == 2147483649
1161 [ - + ]: 2004 : if (internal) {
1162 [ # # ]: 0 : DeriveExtKey(chainChildKey, hd_chain.nInternalChainCounter | BIP32_HARDENED_KEY_LIMIT, childKey);
1163 [ # # # # ]: 0 : metadata.hdKeypath = "m/0'/1'/" + ToString(hd_chain.nInternalChainCounter) + "'";
1164 [ # # ]: 0 : metadata.key_origin.path.push_back(0 | BIP32_HARDENED_KEY_LIMIT);
1165 [ # # ]: 0 : metadata.key_origin.path.push_back(1 | BIP32_HARDENED_KEY_LIMIT);
1166 [ # # ]: 0 : metadata.key_origin.path.push_back(hd_chain.nInternalChainCounter | BIP32_HARDENED_KEY_LIMIT);
1167 : 0 : hd_chain.nInternalChainCounter++;
1168 : : }
1169 : : else {
1170 [ + - ]: 2004 : DeriveExtKey(chainChildKey, hd_chain.nExternalChainCounter | BIP32_HARDENED_KEY_LIMIT, childKey);
1171 [ + - + - ]: 4008 : metadata.hdKeypath = "m/0'/0'/" + ToString(hd_chain.nExternalChainCounter) + "'";
1172 [ + - ]: 2004 : metadata.key_origin.path.push_back(0 | BIP32_HARDENED_KEY_LIMIT);
1173 [ + - ]: 2004 : metadata.key_origin.path.push_back(0 | BIP32_HARDENED_KEY_LIMIT);
1174 [ + - ]: 2004 : metadata.key_origin.path.push_back(hd_chain.nExternalChainCounter | BIP32_HARDENED_KEY_LIMIT);
1175 : 2004 : hd_chain.nExternalChainCounter++;
1176 : : }
1177 [ + - + - : 2004 : } while (HaveKey(childKey.key.GetPubKey().GetID()));
+ - - + ]
1178 [ + - ]: 2004 : secret = childKey.key;
1179 : 2004 : metadata.hd_seed_id = hd_chain.seed_id;
1180 [ + - + - ]: 2004 : CKeyID master_id = masterKey.key.GetPubKey().GetID();
1181 : 2004 : std::copy(master_id.begin(), master_id.begin() + 4, metadata.key_origin.fingerprint);
1182 : 2004 : metadata.has_key_origin = true;
1183 : : // update the chain model in the database
1184 [ + - + - : 2004 : if (hd_chain.seed_id == m_hd_chain.seed_id && !batch.WriteHDChain(hd_chain))
+ - ]
1185 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": writing HD chain model failed");
1186 : 2004 : }
1187 : :
1188 : 4037 : void LegacyDataSPKM::LoadKeyPool(int64_t nIndex, const CKeyPool &keypool)
1189 : : {
1190 : 4037 : LOCK(cs_KeyStore);
1191 [ - + ]: 4037 : if (keypool.m_pre_split) {
1192 [ # # ]: 0 : set_pre_split_keypool.insert(nIndex);
1193 [ + + ]: 4037 : } else if (keypool.fInternal) {
1194 [ + - ]: 21 : setInternalKeyPool.insert(nIndex);
1195 : : } else {
1196 [ + - ]: 4016 : setExternalKeyPool.insert(nIndex);
1197 : : }
1198 [ + + ]: 4037 : m_max_keypool_index = std::max(m_max_keypool_index, nIndex);
1199 [ + - + - ]: 4037 : m_pool_key_to_index[keypool.vchPubKey.GetID()] = nIndex;
1200 : :
1201 : : // If no metadata exists yet, create a default with the pool key's
1202 : : // creation time. Note that this may be overwritten by actually
1203 : : // stored metadata for that key later, which is fine.
1204 [ + - ]: 4037 : CKeyID keyid = keypool.vchPubKey.GetID();
1205 [ - + ]: 4037 : if (mapKeyMetadata.count(keyid) == 0)
1206 [ # # ]: 0 : mapKeyMetadata[keyid] = CKeyMetadata(keypool.nTime);
1207 : 4037 : }
1208 : :
1209 : 10 : bool LegacyScriptPubKeyMan::CanGenerateKeys() const
1210 : : {
1211 : : // A wallet can generate keys if it has an HD seed (IsHDEnabled) or it is a non-HD wallet (pre FEATURE_HD)
1212 : 10 : LOCK(cs_KeyStore);
1213 [ + - + + : 12 : return IsHDEnabled() || !m_storage.CanSupportFeature(FEATURE_HD);
+ - + + +
- ]
1214 : 10 : }
1215 : :
1216 : 3 : CPubKey LegacyScriptPubKeyMan::GenerateNewSeed()
1217 : : {
1218 [ - + ]: 3 : assert(!m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
1219 : 3 : CKey key = GenerateRandomKey();
1220 [ + - ]: 3 : return DeriveNewSeed(key);
1221 : 3 : }
1222 : :
1223 : 3 : CPubKey LegacyScriptPubKeyMan::DeriveNewSeed(const CKey& key)
1224 : : {
1225 : 3 : int64_t nCreationTime = GetTime();
1226 : 3 : CKeyMetadata metadata(nCreationTime);
1227 : :
1228 : : // calculate the seed
1229 [ + - ]: 3 : CPubKey seed = key.GetPubKey();
1230 [ + - - + ]: 3 : assert(key.VerifyPubKey(seed));
1231 : :
1232 : : // set the hd keypath to "s" -> Seed, refers the seed to itself
1233 [ + - ]: 3 : metadata.hdKeypath = "s";
1234 : 3 : metadata.has_key_origin = false;
1235 [ + - ]: 3 : metadata.hd_seed_id = seed.GetID();
1236 : :
1237 : 3 : {
1238 [ + - ]: 3 : LOCK(cs_KeyStore);
1239 : :
1240 : : // mem store the metadata
1241 [ + - + - : 3 : mapKeyMetadata[seed.GetID()] = metadata;
+ - ]
1242 : :
1243 : : // write the key&metadata to the database
1244 [ + - - + ]: 3 : if (!AddKeyPubKey(key, seed))
1245 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": AddKeyPubKey failed");
1246 : 0 : }
1247 : :
1248 : 3 : return seed;
1249 : 3 : }
1250 : :
1251 : 3 : void LegacyScriptPubKeyMan::SetHDSeed(const CPubKey& seed)
1252 : : {
1253 : 3 : LOCK(cs_KeyStore);
1254 : : // store the keyid (hash160) together with
1255 : : // the child index counter in the database
1256 : : // as a hdchain object
1257 : 3 : CHDChain newHdChain;
1258 [ + - + - ]: 3 : newHdChain.nVersion = m_storage.CanSupportFeature(FEATURE_HD_SPLIT) ? CHDChain::VERSION_HD_CHAIN_SPLIT : CHDChain::VERSION_HD_BASE;
1259 [ + - ]: 3 : newHdChain.seed_id = seed.GetID();
1260 [ + - ]: 3 : AddHDChain(newHdChain);
1261 [ + - ]: 3 : NotifyCanGetAddressesChanged();
1262 [ + - + - ]: 3 : WalletBatch batch(m_storage.GetDatabase());
1263 [ + - ]: 3 : m_storage.UnsetBlankWalletFlag(batch);
1264 [ + - ]: 6 : }
1265 : :
1266 : : /**
1267 : : * Mark old keypool keys as used,
1268 : : * and generate all new keys
1269 : : */
1270 : 3 : bool LegacyScriptPubKeyMan::NewKeyPool()
1271 : : {
1272 [ + - ]: 3 : if (m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
1273 : : return false;
1274 : : }
1275 : 3 : {
1276 : 3 : LOCK(cs_KeyStore);
1277 [ + - + - ]: 3 : WalletBatch batch(m_storage.GetDatabase());
1278 : :
1279 [ - + ]: 3 : for (const int64_t nIndex : setInternalKeyPool) {
1280 [ # # ]: 0 : batch.ErasePool(nIndex);
1281 : : }
1282 : 3 : setInternalKeyPool.clear();
1283 : :
1284 [ + + ]: 1002 : for (const int64_t nIndex : setExternalKeyPool) {
1285 [ + - ]: 999 : batch.ErasePool(nIndex);
1286 : : }
1287 : 3 : setExternalKeyPool.clear();
1288 : :
1289 [ - + ]: 3 : for (const int64_t nIndex : set_pre_split_keypool) {
1290 [ # # ]: 0 : batch.ErasePool(nIndex);
1291 : : }
1292 : 3 : set_pre_split_keypool.clear();
1293 : :
1294 : 3 : m_pool_key_to_index.clear();
1295 : :
1296 [ + - - + ]: 3 : if (!TopUp()) {
1297 : 0 : return false;
1298 : : }
1299 [ + - ]: 3 : WalletLogPrintf("LegacyScriptPubKeyMan::NewKeyPool rewrote keypool\n");
1300 [ - - + - ]: 3 : }
1301 : 3 : return true;
1302 : : }
1303 : :
1304 : 6 : bool LegacyScriptPubKeyMan::TopUp(unsigned int kpSize)
1305 : : {
1306 [ + + ]: 6 : if (!CanGenerateKeys()) {
1307 : : return false;
1308 : : }
1309 : :
1310 : 4 : WalletBatch batch(m_storage.GetDatabase());
1311 [ + - + - ]: 4 : if (!batch.TxnBegin()) return false;
1312 [ + - + - ]: 4 : if (!TopUpChain(batch, m_hd_chain, kpSize)) {
1313 : : return false;
1314 : : }
1315 [ + - + + ]: 5 : for (auto& [chain_id, chain] : m_inactive_hd_chains) {
1316 [ + - + - ]: 1 : if (!TopUpChain(batch, chain, kpSize)) {
1317 : : return false;
1318 : : }
1319 : : }
1320 [ + - - + : 4 : if (!batch.TxnCommit()) throw std::runtime_error(strprintf("Error during keypool top up. Cannot commit changes for wallet %s", m_storage.GetDisplayName()));
- - - - -
- ]
1321 [ + - ]: 4 : NotifyCanGetAddressesChanged();
1322 : : // Note: Unlike with DescriptorSPKM, LegacySPKM does not need to call
1323 : : // m_storage.TopUpCallback() as we do not know what new scripts the LegacySPKM is
1324 : : // watching for. CWallet's scriptPubKey cache is not used for LegacySPKMs.
1325 : : return true;
1326 : 4 : }
1327 : :
1328 : 5 : bool LegacyScriptPubKeyMan::TopUpChain(WalletBatch& batch, CHDChain& chain, unsigned int kpSize)
1329 : : {
1330 : 5 : LOCK(cs_KeyStore);
1331 : :
1332 [ + - + - ]: 5 : if (m_storage.IsLocked()) return false;
1333 : :
1334 : : // Top up key pool
1335 : 5 : unsigned int nTargetSize;
1336 [ + - ]: 5 : if (kpSize > 0) {
1337 : : nTargetSize = kpSize;
1338 : : } else {
1339 : 5 : nTargetSize = m_keypool_size;
1340 : : }
1341 [ + - ]: 5 : int64_t target = std::max((int64_t) nTargetSize, int64_t{1});
1342 : :
1343 : : // count amount of available keys (internal, external)
1344 : : // make sure the keypool of external and internal keys fits the user selected target (-keypool)
1345 : 5 : int64_t missingExternal;
1346 : 5 : int64_t missingInternal;
1347 [ + + ]: 5 : if (chain == m_hd_chain) {
1348 [ + - ]: 4 : missingExternal = std::max(target - (int64_t)setExternalKeyPool.size(), int64_t{0});
1349 [ + - ]: 8 : missingInternal = std::max(target - (int64_t)setInternalKeyPool.size(), int64_t{0});
1350 : : } else {
1351 [ + - ]: 1 : missingExternal = std::max(target - (chain.nExternalChainCounter - chain.m_next_external_index), int64_t{0});
1352 [ + - ]: 2 : missingInternal = std::max(target - (chain.nInternalChainCounter - chain.m_next_internal_index), int64_t{0});
1353 : : }
1354 : :
1355 [ + - + - : 5 : if (!IsHDEnabled() || !m_storage.CanSupportFeature(FEATURE_HD_SPLIT)) {
+ - + - ]
1356 : : // don't create extra internal keys
1357 : 5 : missingInternal = 0;
1358 : : }
1359 : 5 : bool internal = false;
1360 [ + + ]: 2009 : for (int64_t i = missingInternal + missingExternal; i--;) {
1361 [ - + ]: 2004 : if (i < missingInternal) {
1362 : 0 : internal = true;
1363 : : }
1364 : :
1365 [ + - ]: 2004 : CPubKey pubkey(GenerateNewKey(batch, chain, internal));
1366 [ + - ]: 2004 : if (chain == m_hd_chain) {
1367 [ + - ]: 2004 : AddKeypoolPubkeyWithDB(pubkey, internal, batch);
1368 : : }
1369 : : }
1370 [ + + ]: 5 : if (missingInternal + missingExternal > 0) {
1371 [ + - ]: 3 : if (chain == m_hd_chain) {
1372 [ + - ]: 3 : 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());
1373 : : } else {
1374 [ # # # # ]: 0 : WalletLogPrintf("inactive seed with id %s added %d external keys, %d internal keys\n", HexStr(chain.seed_id), missingExternal, missingInternal);
1375 : : }
1376 : : }
1377 : : return true;
1378 : 5 : }
1379 : :
1380 : 2004 : void LegacyScriptPubKeyMan::AddKeypoolPubkeyWithDB(const CPubKey& pubkey, const bool internal, WalletBatch& batch)
1381 : : {
1382 : 2004 : LOCK(cs_KeyStore);
1383 [ - + ]: 2004 : assert(m_max_keypool_index < std::numeric_limits<int64_t>::max()); // How in the hell did you use so many keys?
1384 : 2004 : int64_t index = ++m_max_keypool_index;
1385 [ + - + - : 2004 : if (!batch.WritePool(index, CKeyPool(pubkey, internal))) {
- + ]
1386 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": writing imported pubkey failed");
1387 : : }
1388 [ - + ]: 2004 : if (internal) {
1389 [ # # ]: 0 : setInternalKeyPool.insert(index);
1390 : : } else {
1391 [ + - ]: 2004 : setExternalKeyPool.insert(index);
1392 : : }
1393 [ + - + - : 2004 : m_pool_key_to_index[pubkey.GetID()] = index;
+ - ]
1394 : 2004 : }
1395 : :
1396 : 1 : void LegacyScriptPubKeyMan::KeepDestination(int64_t nIndex, const OutputType& type)
1397 : : {
1398 [ - + ]: 1 : assert(type != OutputType::BECH32M);
1399 : : // Remove from key pool
1400 : 1 : WalletBatch batch(m_storage.GetDatabase());
1401 [ + - ]: 1 : batch.ErasePool(nIndex);
1402 [ + - ]: 1 : CPubKey pubkey;
1403 [ + - + - ]: 1 : bool have_pk = GetPubKey(m_index_to_reserved_key.at(nIndex), pubkey);
1404 [ - + ]: 1 : assert(have_pk);
1405 [ + - ]: 1 : LearnRelatedScripts(pubkey, type);
1406 : 1 : m_index_to_reserved_key.erase(nIndex);
1407 [ + - ]: 1 : WalletLogPrintf("keypool keep %d\n", nIndex);
1408 : 1 : }
1409 : :
1410 : 0 : void LegacyScriptPubKeyMan::ReturnDestination(int64_t nIndex, bool fInternal, const CTxDestination&)
1411 : : {
1412 : : // Return to key pool
1413 : 0 : {
1414 : 0 : LOCK(cs_KeyStore);
1415 [ # # ]: 0 : if (fInternal) {
1416 [ # # ]: 0 : setInternalKeyPool.insert(nIndex);
1417 [ # # ]: 0 : } else if (!set_pre_split_keypool.empty()) {
1418 [ # # ]: 0 : set_pre_split_keypool.insert(nIndex);
1419 : : } else {
1420 [ # # ]: 0 : setExternalKeyPool.insert(nIndex);
1421 : : }
1422 [ # # ]: 0 : CKeyID& pubkey_id = m_index_to_reserved_key.at(nIndex);
1423 [ # # ]: 0 : m_pool_key_to_index[pubkey_id] = nIndex;
1424 : 0 : m_index_to_reserved_key.erase(nIndex);
1425 [ # # ]: 0 : NotifyCanGetAddressesChanged();
1426 : 0 : }
1427 : 0 : WalletLogPrintf("keypool return %d\n", nIndex);
1428 : 0 : }
1429 : :
1430 : 2 : bool LegacyScriptPubKeyMan::GetKeyFromPool(CPubKey& result, const OutputType type)
1431 : : {
1432 [ - + ]: 2 : assert(type != OutputType::BECH32M);
1433 [ + + ]: 2 : if (!CanGetAddresses(/*internal=*/ false)) {
1434 : : return false;
1435 : : }
1436 : :
1437 : 1 : CKeyPool keypool;
1438 : 1 : {
1439 : 1 : LOCK(cs_KeyStore);
1440 : 1 : int64_t nIndex;
1441 [ + - - + : 1 : if (!ReserveKeyFromKeyPool(nIndex, keypool, /*fRequestedInternal=*/ false) && !m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
- - - - ]
1442 [ # # # # ]: 0 : if (m_storage.IsLocked()) return false;
1443 [ # # # # ]: 0 : WalletBatch batch(m_storage.GetDatabase());
1444 [ # # ]: 0 : result = GenerateNewKey(batch, m_hd_chain, /*internal=*/ false);
1445 : 0 : return true;
1446 : 0 : }
1447 [ + - ]: 1 : KeepDestination(nIndex, type);
1448 [ + - ]: 1 : result = keypool.vchPubKey;
1449 : 0 : }
1450 : 1 : return true;
1451 : : }
1452 : :
1453 : 1 : bool LegacyScriptPubKeyMan::ReserveKeyFromKeyPool(int64_t& nIndex, CKeyPool& keypool, bool fRequestedInternal)
1454 : : {
1455 : 1 : nIndex = -1;
1456 : 1 : keypool.vchPubKey = CPubKey();
1457 : 1 : {
1458 : 1 : LOCK(cs_KeyStore);
1459 : :
1460 : 1 : bool fReturningInternal = fRequestedInternal;
1461 [ + - + - : 1 : fReturningInternal &= (IsHDEnabled() && m_storage.CanSupportFeature(FEATURE_HD_SPLIT)) || m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS);
+ - + - +
- - + ]
1462 [ + - ]: 1 : bool use_split_keypool = set_pre_split_keypool.empty();
1463 [ + - - + ]: 1 : std::set<int64_t>& setKeyPool = use_split_keypool ? (fReturningInternal ? setInternalKeyPool : setExternalKeyPool) : set_pre_split_keypool;
1464 : :
1465 : : // Get the oldest key
1466 [ - + ]: 1 : if (setKeyPool.empty()) {
1467 [ # # ]: 0 : return false;
1468 : : }
1469 : :
1470 [ + - + - ]: 1 : WalletBatch batch(m_storage.GetDatabase());
1471 : :
1472 : 1 : auto it = setKeyPool.begin();
1473 : 1 : nIndex = *it;
1474 : 1 : setKeyPool.erase(it);
1475 [ + - - + ]: 1 : if (!batch.ReadPool(nIndex, keypool)) {
1476 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": read failed");
1477 : : }
1478 [ + - ]: 1 : CPubKey pk;
1479 [ + - + - : 1 : if (!GetPubKey(keypool.vchPubKey.GetID(), pk)) {
- + ]
1480 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": unknown key in key pool");
1481 : : }
1482 : : // If the key was pre-split keypool, we don't care about what type it is
1483 [ + - - + ]: 1 : if (use_split_keypool && keypool.fInternal != fReturningInternal) {
1484 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": keypool entry misclassified");
1485 : : }
1486 [ - + ]: 1 : if (!keypool.vchPubKey.IsValid()) {
1487 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": keypool entry invalid");
1488 : : }
1489 : :
1490 [ - + ]: 1 : assert(m_index_to_reserved_key.count(nIndex) == 0);
1491 [ + - + - ]: 1 : m_index_to_reserved_key[nIndex] = keypool.vchPubKey.GetID();
1492 [ + - ]: 1 : m_pool_key_to_index.erase(keypool.vchPubKey.GetID());
1493 [ + - ]: 1 : WalletLogPrintf("keypool reserve %d\n", nIndex);
1494 [ + - ]: 1 : }
1495 : 1 : NotifyCanGetAddressesChanged();
1496 : 1 : return true;
1497 : : }
1498 : :
1499 : 2 : void LegacyScriptPubKeyMan::LearnRelatedScripts(const CPubKey& key, OutputType type)
1500 : : {
1501 [ - + ]: 2 : assert(type != OutputType::BECH32M);
1502 [ + - - + ]: 2 : if (key.IsCompressed() && (type == OutputType::P2SH_SEGWIT || type == OutputType::BECH32)) {
1503 [ # # ]: 0 : CTxDestination witdest = WitnessV0KeyHash(key.GetID());
1504 [ # # ]: 0 : CScript witprog = GetScriptForDestination(witdest);
1505 : : // Make sure the resulting program is solvable.
1506 [ # # ]: 0 : const auto desc = InferDescriptor(witprog, *this);
1507 [ # # # # : 0 : assert(desc && desc->IsSolvable());
# # ]
1508 [ # # ]: 0 : AddCScript(witprog);
1509 : 0 : }
1510 : 2 : }
1511 : :
1512 : 0 : void LegacyScriptPubKeyMan::LearnAllRelatedScripts(const CPubKey& key)
1513 : : {
1514 : : // OutputType::P2SH_SEGWIT always adds all necessary scripts for all types.
1515 : 0 : LearnRelatedScripts(key, OutputType::P2SH_SEGWIT);
1516 : 0 : }
1517 : :
1518 : 0 : std::vector<CKeyPool> LegacyScriptPubKeyMan::MarkReserveKeysAsUsed(int64_t keypool_id)
1519 : : {
1520 : 0 : AssertLockHeld(cs_KeyStore);
1521 : 0 : bool internal = setInternalKeyPool.count(keypool_id);
1522 [ # # # # : 0 : if (!internal) assert(setExternalKeyPool.count(keypool_id) || set_pre_split_keypool.count(keypool_id));
# # ]
1523 [ # # ]: 0 : std::set<int64_t> *setKeyPool = internal ? &setInternalKeyPool : (set_pre_split_keypool.empty() ? &setExternalKeyPool : &set_pre_split_keypool);
1524 [ # # ]: 0 : auto it = setKeyPool->begin();
1525 : :
1526 : 0 : std::vector<CKeyPool> result;
1527 [ # # # # ]: 0 : WalletBatch batch(m_storage.GetDatabase());
1528 : 0 : while (it != std::end(*setKeyPool)) {
1529 [ # # ]: 0 : const int64_t& index = *(it);
1530 [ # # ]: 0 : if (index > keypool_id) break; // set*KeyPool is ordered
1531 : :
1532 [ # # ]: 0 : CKeyPool keypool;
1533 [ # # # # ]: 0 : if (batch.ReadPool(index, keypool)) { //TODO: This should be unnecessary
1534 [ # # ]: 0 : m_pool_key_to_index.erase(keypool.vchPubKey.GetID());
1535 : : }
1536 [ # # ]: 0 : LearnAllRelatedScripts(keypool.vchPubKey);
1537 [ # # ]: 0 : batch.ErasePool(index);
1538 [ # # ]: 0 : WalletLogPrintf("keypool index %d removed\n", index);
1539 : 0 : it = setKeyPool->erase(it);
1540 [ # # # # ]: 0 : result.push_back(std::move(keypool));
1541 : : }
1542 : :
1543 : 0 : return result;
1544 : 0 : }
1545 : :
1546 : 4 : std::vector<CKeyID> GetAffectedKeys(const CScript& spk, const SigningProvider& provider)
1547 : : {
1548 : 4 : std::vector<CScript> dummy;
1549 : 4 : FlatSigningProvider out;
1550 [ + - + - ]: 4 : InferDescriptor(spk, provider)->Expand(0, DUMMY_SIGNING_PROVIDER, dummy, out);
1551 : 4 : std::vector<CKeyID> ret;
1552 [ + - ]: 4 : ret.reserve(out.pubkeys.size());
1553 [ - + ]: 4 : for (const auto& entry : out.pubkeys) {
1554 [ # # ]: 0 : ret.push_back(entry.first);
1555 : : }
1556 : 4 : return ret;
1557 : 4 : }
1558 : :
1559 : 0 : void LegacyScriptPubKeyMan::MarkPreSplitKeys()
1560 : : {
1561 : 0 : WalletBatch batch(m_storage.GetDatabase());
1562 [ # # ]: 0 : for (auto it = setExternalKeyPool.begin(); it != setExternalKeyPool.end();) {
1563 [ # # ]: 0 : int64_t index = *it;
1564 [ # # ]: 0 : CKeyPool keypool;
1565 [ # # # # ]: 0 : if (!batch.ReadPool(index, keypool)) {
1566 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": read keypool entry failed");
1567 : : }
1568 : 0 : keypool.m_pre_split = true;
1569 [ # # # # ]: 0 : if (!batch.WritePool(index, keypool)) {
1570 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": writing modified keypool entry failed");
1571 : : }
1572 [ # # ]: 0 : set_pre_split_keypool.insert(index);
1573 : 0 : it = setExternalKeyPool.erase(it);
1574 : : }
1575 : 0 : }
1576 : :
1577 : 23 : bool LegacyScriptPubKeyMan::AddCScript(const CScript& redeemScript)
1578 : : {
1579 : 23 : WalletBatch batch(m_storage.GetDatabase());
1580 [ + - ]: 23 : return AddCScriptWithDB(batch, redeemScript);
1581 : 23 : }
1582 : :
1583 : 23 : bool LegacyScriptPubKeyMan::AddCScriptWithDB(WalletBatch& batch, const CScript& redeemScript)
1584 : : {
1585 [ + - ]: 23 : if (!FillableSigningProvider::AddCScript(redeemScript))
1586 : : return false;
1587 [ + - ]: 23 : if (batch.WriteCScript(Hash160(redeemScript), redeemScript)) {
1588 : 23 : m_storage.UnsetBlankWalletFlag(batch);
1589 : 23 : return true;
1590 : : }
1591 : : return false;
1592 : : }
1593 : :
1594 : 0 : bool LegacyScriptPubKeyMan::AddKeyOriginWithDB(WalletBatch& batch, const CPubKey& pubkey, const KeyOriginInfo& info)
1595 : : {
1596 : 0 : LOCK(cs_KeyStore);
1597 [ # # # # ]: 0 : std::copy(info.fingerprint, info.fingerprint + 4, mapKeyMetadata[pubkey.GetID()].key_origin.fingerprint);
1598 [ # # # # : 0 : mapKeyMetadata[pubkey.GetID()].key_origin.path = info.path;
# # ]
1599 [ # # # # ]: 0 : mapKeyMetadata[pubkey.GetID()].has_key_origin = true;
1600 [ # # # # : 0 : mapKeyMetadata[pubkey.GetID()].hdKeypath = WriteHDKeypath(info.path, /*apostrophe=*/true);
# # ]
1601 [ # # # # : 0 : return batch.WriteKeyMetadata(mapKeyMetadata[pubkey.GetID()], pubkey, true);
# # # # ]
1602 : 0 : }
1603 : :
1604 : 3 : bool LegacyScriptPubKeyMan::ImportScripts(const std::set<CScript> scripts, int64_t timestamp)
1605 : : {
1606 : 3 : WalletBatch batch(m_storage.GetDatabase());
1607 [ + + ]: 4 : for (const auto& entry : scripts) {
1608 [ + - ]: 1 : CScriptID id(entry);
1609 [ + - + - ]: 1 : if (HaveCScript(id)) {
1610 [ + - + - : 2 : WalletLogPrintf("Already have script %s, skipping\n", HexStr(entry));
+ - ]
1611 : 1 : continue;
1612 : : }
1613 [ # # # # ]: 0 : if (!AddCScriptWithDB(batch, entry)) {
1614 : : return false;
1615 : : }
1616 : :
1617 [ # # ]: 0 : if (timestamp > 0) {
1618 [ # # # # ]: 0 : m_script_metadata[CScriptID(entry)].nCreateTime = timestamp;
1619 : : }
1620 : : }
1621 [ + + ]: 3 : if (timestamp > 0) {
1622 [ + - ]: 2 : UpdateTimeFirstKey(timestamp);
1623 : : }
1624 : :
1625 : : return true;
1626 : 3 : }
1627 : :
1628 : 3 : bool LegacyScriptPubKeyMan::ImportPrivKeys(const std::map<CKeyID, CKey>& privkey_map, const int64_t timestamp)
1629 : : {
1630 : 3 : WalletBatch batch(m_storage.GetDatabase());
1631 [ + + ]: 4 : for (const auto& entry : privkey_map) {
1632 : 1 : const CKey& key = entry.second;
1633 [ + - ]: 1 : CPubKey pubkey = key.GetPubKey();
1634 : 1 : const CKeyID& id = entry.first;
1635 [ + - - + ]: 1 : assert(key.VerifyPubKey(pubkey));
1636 : : // Skip if we already have the key
1637 [ + - - + ]: 1 : if (HaveKey(id)) {
1638 [ # # # # ]: 0 : WalletLogPrintf("Already have key with pubkey %s, skipping\n", HexStr(pubkey));
1639 : 0 : continue;
1640 : : }
1641 [ + - ]: 1 : mapKeyMetadata[id].nCreateTime = timestamp;
1642 : : // If the private key is not present in the wallet, insert it.
1643 [ + - + - ]: 1 : if (!AddKeyPubKeyWithDB(batch, key, pubkey)) {
1644 : : return false;
1645 : : }
1646 [ + - ]: 1 : UpdateTimeFirstKey(timestamp);
1647 : : }
1648 : : return true;
1649 : 3 : }
1650 : :
1651 : 2 : bool LegacyScriptPubKeyMan::ImportPubKeys(const std::vector<std::pair<CKeyID, bool>>& ordered_pubkeys, const std::map<CKeyID, CPubKey>& pubkey_map, const std::map<CKeyID, std::pair<CPubKey, KeyOriginInfo>>& key_origins, const bool add_keypool, const int64_t timestamp)
1652 : : {
1653 : 2 : WalletBatch batch(m_storage.GetDatabase());
1654 [ - + ]: 2 : for (const auto& entry : key_origins) {
1655 [ # # ]: 0 : AddKeyOriginWithDB(batch, entry.second.first, entry.second.second);
1656 : : }
1657 [ - + ]: 2 : for (const auto& [id, internal] : ordered_pubkeys) {
1658 : 0 : auto entry = pubkey_map.find(id);
1659 [ # # ]: 0 : if (entry == pubkey_map.end()) {
1660 : 0 : continue;
1661 : : }
1662 [ # # ]: 0 : const CPubKey& pubkey = entry->second;
1663 [ # # ]: 0 : CPubKey temp;
1664 [ # # # # ]: 0 : if (GetPubKey(id, temp)) {
1665 : : // Already have pubkey, skipping
1666 [ # # # # ]: 0 : WalletLogPrintf("Already have pubkey %s, skipping\n", HexStr(temp));
1667 : 0 : continue;
1668 : : }
1669 [ # # # # : 0 : if (!AddWatchOnlyWithDB(batch, GetScriptForRawPubKey(pubkey), timestamp)) {
# # ]
1670 : : return false;
1671 : : }
1672 [ # # ]: 0 : mapKeyMetadata[id].nCreateTime = timestamp;
1673 : :
1674 : : // Add to keypool only works with pubkeys
1675 [ # # ]: 0 : if (add_keypool) {
1676 [ # # ]: 0 : AddKeypoolPubkeyWithDB(pubkey, internal, batch);
1677 [ # # ]: 0 : NotifyCanGetAddressesChanged();
1678 : : }
1679 : : }
1680 : : return true;
1681 : 2 : }
1682 : :
1683 : 2 : bool LegacyScriptPubKeyMan::ImportScriptPubKeys(const std::set<CScript>& script_pub_keys, const bool have_solving_data, const int64_t timestamp)
1684 : : {
1685 : 2 : WalletBatch batch(m_storage.GetDatabase());
1686 [ + + ]: 4 : for (const CScript& script : script_pub_keys) {
1687 [ - + - - : 2 : if (!have_solving_data || !IsMine(script)) { // Always call AddWatchOnly for non-solvable watch-only, so that watch timestamp gets updated
- - ]
1688 [ + - + - ]: 2 : if (!AddWatchOnlyWithDB(batch, script, timestamp)) {
1689 : : return false;
1690 : : }
1691 : : }
1692 : : }
1693 : : return true;
1694 : 2 : }
1695 : :
1696 : 1 : std::set<CKeyID> LegacyScriptPubKeyMan::GetKeys() const
1697 : : {
1698 : 1 : LOCK(cs_KeyStore);
1699 [ + - + - ]: 1 : if (!m_storage.HasEncryptionKeys()) {
1700 [ + - ]: 1 : return FillableSigningProvider::GetKeys();
1701 : : }
1702 : 0 : std::set<CKeyID> set_address;
1703 [ # # ]: 0 : for (const auto& mi : mapCryptedKeys) {
1704 [ # # ]: 0 : set_address.insert(mi.first);
1705 : : }
1706 : 0 : return set_address;
1707 : 1 : }
1708 : :
1709 : 60 : std::unordered_set<CScript, SaltedSipHasher> LegacyDataSPKM::GetScriptPubKeys() const
1710 : : {
1711 : 60 : LOCK(cs_KeyStore);
1712 [ + - ]: 60 : std::unordered_set<CScript, SaltedSipHasher> spks;
1713 : :
1714 : : // All keys have at least P2PK and P2PKH
1715 [ + + ]: 197 : for (const auto& key_pair : mapKeys) {
1716 [ + - ]: 137 : const CPubKey& pub = key_pair.second.GetPubKey();
1717 [ + - ]: 274 : spks.insert(GetScriptForRawPubKey(pub));
1718 [ + - + - ]: 274 : spks.insert(GetScriptForDestination(PKHash(pub)));
1719 : : }
1720 [ + + ]: 66 : for (const auto& key_pair : mapCryptedKeys) {
1721 : 6 : const CPubKey& pub = key_pair.second.first;
1722 [ + - ]: 12 : spks.insert(GetScriptForRawPubKey(pub));
1723 [ + - + - ]: 12 : spks.insert(GetScriptForDestination(PKHash(pub)));
1724 : : }
1725 : :
1726 : : // For every script in mapScript, only the ISMINE_SPENDABLE ones are being tracked.
1727 : : // The watchonly ones will be in setWatchOnly which we deal with later
1728 : : // For all keys, if they have segwit scripts, those scripts will end up in mapScripts
1729 [ + + ]: 237 : for (const auto& script_pair : mapScripts) {
1730 : 177 : const CScript& script = script_pair.second;
1731 [ + - + + ]: 177 : if (IsMine(script) == ISMINE_SPENDABLE) {
1732 : : // Add ScriptHash for scripts that are not already P2SH
1733 [ + - + + ]: 141 : if (!script.IsPayToScriptHash()) {
1734 [ + - + - ]: 278 : spks.insert(GetScriptForDestination(ScriptHash(script)));
1735 : : }
1736 : : // For segwit scripts, we only consider them spendable if we have the segwit spk
1737 : 141 : int wit_ver = -1;
1738 : 141 : std::vector<unsigned char> witprog;
1739 [ + - + + : 141 : if (script.IsWitnessProgram(wit_ver, witprog) && wit_ver == 0) {
+ - ]
1740 [ + - ]: 135 : spks.insert(script);
1741 : : }
1742 : 141 : } else {
1743 : : // Multisigs are special. They don't show up as ISMINE_SPENDABLE unless they are in a P2SH
1744 : : // So check the P2SH of a multisig to see if we should insert it
1745 : 36 : std::vector<std::vector<unsigned char>> sols;
1746 [ + - ]: 36 : TxoutType type = Solver(script, sols);
1747 [ + + ]: 36 : if (type == TxoutType::MULTISIG) {
1748 [ + - + - ]: 13 : CScript ms_spk = GetScriptForDestination(ScriptHash(script));
1749 [ + - + + ]: 13 : if (IsMine(ms_spk) != ISMINE_NO) {
1750 [ + - ]: 8 : spks.insert(ms_spk);
1751 : : }
1752 : 13 : }
1753 : 36 : }
1754 : : }
1755 : :
1756 : : // All watchonly scripts are raw
1757 [ + + ]: 92 : for (const CScript& script : setWatchOnly) {
1758 : : // As the legacy wallet allowed to import any script, we need to verify the validity here.
1759 : : // LegacyScriptPubKeyMan::IsMine() return 'ISMINE_NO' for invalid or not watched scripts (IsMineResult::INVALID or IsMineResult::NO).
1760 : : // e.g. a "sh(sh(pkh()))" which legacy wallets allowed to import!.
1761 [ + - + + : 32 : if (IsMine(script) != ISMINE_NO) spks.insert(script);
+ - ]
1762 : : }
1763 : :
1764 [ + - ]: 60 : return spks;
1765 : 60 : }
1766 : :
1767 : 22 : std::unordered_set<CScript, SaltedSipHasher> LegacyDataSPKM::GetNotMineScriptPubKeys() const
1768 : : {
1769 : 22 : LOCK(cs_KeyStore);
1770 [ + - ]: 22 : std::unordered_set<CScript, SaltedSipHasher> spks;
1771 [ + + ]: 53 : for (const CScript& script : setWatchOnly) {
1772 [ + - + + : 31 : if (IsMine(script) == ISMINE_NO) spks.insert(script);
+ - ]
1773 : : }
1774 [ + - ]: 22 : return spks;
1775 : 22 : }
1776 : :
1777 : 23 : std::optional<MigrationData> LegacyDataSPKM::MigrateToDescriptor()
1778 : : {
1779 : 23 : LOCK(cs_KeyStore);
1780 [ + - - + ]: 23 : if (m_storage.IsLocked()) {
1781 : 0 : return std::nullopt;
1782 : : }
1783 : :
1784 : 23 : MigrationData out;
1785 : :
1786 [ + - ]: 23 : std::unordered_set<CScript, SaltedSipHasher> spks{GetScriptPubKeys()};
1787 : :
1788 : : // Get all key ids
1789 : 23 : std::set<CKeyID> keyids;
1790 [ + + ]: 121 : for (const auto& key_pair : mapKeys) {
1791 [ + - ]: 98 : keyids.insert(key_pair.first);
1792 : : }
1793 [ + + ]: 29 : for (const auto& key_pair : mapCryptedKeys) {
1794 [ + - ]: 6 : keyids.insert(key_pair.first);
1795 : : }
1796 : :
1797 : : // Get key metadata and figure out which keys don't have a seed
1798 : : // Note that we do not ignore the seeds themselves because they are considered IsMine!
1799 [ + + ]: 127 : for (auto keyid_it = keyids.begin(); keyid_it != keyids.end();) {
1800 : 104 : const CKeyID& keyid = *keyid_it;
1801 : 104 : const auto& it = mapKeyMetadata.find(keyid);
1802 [ + - ]: 104 : if (it != mapKeyMetadata.end()) {
1803 [ + + ]: 104 : const CKeyMetadata& meta = it->second;
1804 [ + + - + ]: 104 : if (meta.hdKeypath == "s" || meta.hdKeypath == "m") {
1805 : 20 : keyid_it++;
1806 : 20 : continue;
1807 : : }
1808 [ + + + + : 84 : if (!meta.hd_seed_id.IsNull() && (m_hd_chain.seed_id == meta.hd_seed_id || m_inactive_hd_chains.count(meta.hd_seed_id) > 0)) {
+ - + - ]
1809 : 83 : keyid_it = keyids.erase(keyid_it);
1810 : 83 : continue;
1811 : : }
1812 : : }
1813 : 1 : keyid_it++;
1814 : : }
1815 : :
1816 [ + - + - ]: 23 : WalletBatch batch(m_storage.GetDatabase());
1817 [ + - - + ]: 23 : if (!batch.TxnBegin()) {
1818 [ # # ]: 0 : LogPrintf("Error generating descriptors for migration, cannot initialize db transaction\n");
1819 : 0 : return std::nullopt;
1820 : : }
1821 : :
1822 : : // keyids is now all non-HD keys. Each key will have its own combo descriptor
1823 [ + + ]: 44 : for (const CKeyID& keyid : keyids) {
1824 : 21 : CKey key;
1825 [ + - - + ]: 21 : if (!GetKey(keyid, key)) {
1826 : 0 : assert(false);
1827 : : }
1828 : :
1829 : : // Get birthdate from key meta
1830 : 21 : uint64_t creation_time = 0;
1831 : 21 : const auto& it = mapKeyMetadata.find(keyid);
1832 [ + - ]: 21 : if (it != mapKeyMetadata.end()) {
1833 : 21 : creation_time = it->second.nCreateTime;
1834 : : }
1835 : :
1836 : : // Get the key origin
1837 : : // Maybe this doesn't matter because floating keys here shouldn't have origins
1838 [ + - ]: 21 : KeyOriginInfo info;
1839 [ + - ]: 21 : bool has_info = GetKeyOrigin(keyid, info);
1840 [ + - + - : 105 : std::string origin_str = has_info ? "[" + HexStr(info.fingerprint) + FormatHDKeypath(info.path) + "]" : "";
+ - + - +
- + - - -
+ - + - +
- - - - -
- - - - ]
1841 : :
1842 : : // Construct the combo descriptor
1843 [ + - + - : 42 : std::string desc_str = "combo(" + origin_str + HexStr(key.GetPubKey()) + ")";
+ - + - ]
1844 : 21 : FlatSigningProvider keys;
1845 [ + - ]: 21 : std::string error;
1846 [ + - ]: 21 : std::vector<std::unique_ptr<Descriptor>> descs = Parse(desc_str, keys, error, false);
1847 [ + - ]: 21 : CHECK_NONFATAL(descs.size() == 1); // It shouldn't be possible to have an invalid or multipath descriptor
1848 [ + - + - : 21 : WalletDescriptor w_desc(std::move(descs.at(0)), creation_time, 0, 0, 0);
+ - ]
1849 : :
1850 : : // Make the DescriptorScriptPubKeyMan and get the scriptPubKeys
1851 [ + - ]: 21 : auto desc_spk_man = std::make_unique<DescriptorScriptPubKeyMan>(m_storage, w_desc, /*keypool_size=*/0);
1852 [ + - + - : 63 : WITH_LOCK(desc_spk_man->cs_desc_man, desc_spk_man->AddDescriptorKeyWithDB(batch, key, key.GetPubKey()));
+ - ]
1853 [ + - ]: 21 : desc_spk_man->TopUpWithDB(batch);
1854 [ + - ]: 21 : auto desc_spks = desc_spk_man->GetScriptPubKeys();
1855 : :
1856 : : // Remove the scriptPubKeys from our current set
1857 [ + + ]: 105 : for (const CScript& spk : desc_spks) {
1858 [ + - ]: 84 : size_t erased = spks.erase(spk);
1859 [ - + ]: 84 : assert(erased == 1);
1860 [ + - - + ]: 84 : assert(IsMine(spk) == ISMINE_SPENDABLE);
1861 : : }
1862 : :
1863 [ + - ]: 21 : out.desc_spkms.push_back(std::move(desc_spk_man));
1864 : 21 : }
1865 : :
1866 : : // Handle HD keys by using the CHDChains
1867 : 23 : std::vector<CHDChain> chains;
1868 [ + - ]: 23 : chains.push_back(m_hd_chain);
1869 [ + + ]: 25 : for (const auto& chain_pair : m_inactive_hd_chains) {
1870 [ + - ]: 2 : chains.push_back(chain_pair.second);
1871 : : }
1872 [ + + ]: 48 : for (const CHDChain& chain : chains) {
1873 [ + + ]: 75 : for (int i = 0; i < 2; ++i) {
1874 : : // Skip if doing internal chain and split chain is not supported
1875 [ + + + + : 50 : if (chain.seed_id.IsNull() || (i == 1 && !m_storage.CanSupportFeature(FEATURE_HD_SPLIT))) {
+ - - + ]
1876 : 10 : continue;
1877 : : }
1878 : : // Get the master xprv
1879 : 40 : CKey seed_key;
1880 [ + - - + ]: 40 : if (!GetKey(chain.seed_id, seed_key)) {
1881 : 0 : assert(false);
1882 : : }
1883 [ + - ]: 40 : CExtKey master_key;
1884 [ + - + - ]: 80 : master_key.SetSeed(seed_key);
1885 : :
1886 : : // Make the combo descriptor
1887 [ + - + - ]: 40 : std::string xpub = EncodeExtPubKey(master_key.Neuter());
1888 [ + - + - : 120 : std::string desc_str = "combo(" + xpub + "/0h/" + ToString(i) + "h/*h)";
+ - ]
1889 : 40 : FlatSigningProvider keys;
1890 [ + - ]: 40 : std::string error;
1891 [ + - ]: 40 : std::vector<std::unique_ptr<Descriptor>> descs = Parse(desc_str, keys, error, false);
1892 [ + - ]: 40 : CHECK_NONFATAL(descs.size() == 1); // It shouldn't be possible to have an invalid or multipath descriptor
1893 [ + + ]: 40 : uint32_t chain_counter = std::max((i == 1 ? chain.nInternalChainCounter : chain.nExternalChainCounter), (uint32_t)0);
1894 [ + - + - : 40 : WalletDescriptor w_desc(std::move(descs.at(0)), 0, 0, chain_counter, 0);
+ - ]
1895 : :
1896 : : // Make the DescriptorScriptPubKeyMan and get the scriptPubKeys
1897 [ + - ]: 40 : auto desc_spk_man = std::make_unique<DescriptorScriptPubKeyMan>(m_storage, w_desc, /*keypool_size=*/0);
1898 [ + - + - : 120 : WITH_LOCK(desc_spk_man->cs_desc_man, desc_spk_man->AddDescriptorKeyWithDB(batch, master_key.key, master_key.key.GetPubKey()));
+ - ]
1899 [ + - ]: 40 : desc_spk_man->TopUpWithDB(batch);
1900 [ + - ]: 40 : auto desc_spks = desc_spk_man->GetScriptPubKeys();
1901 : :
1902 : : // Remove the scriptPubKeys from our current set
1903 [ + + ]: 372 : for (const CScript& spk : desc_spks) {
1904 [ + - ]: 332 : size_t erased = spks.erase(spk);
1905 [ - + ]: 332 : assert(erased == 1);
1906 [ + - - + ]: 332 : assert(IsMine(spk) == ISMINE_SPENDABLE);
1907 : : }
1908 : :
1909 [ + - ]: 40 : out.desc_spkms.push_back(std::move(desc_spk_man));
1910 : 40 : }
1911 : : }
1912 : : // Add the current master seed to the migration data
1913 [ + + ]: 23 : if (!m_hd_chain.seed_id.IsNull()) {
1914 : 18 : CKey seed_key;
1915 [ + - - + ]: 18 : if (!GetKey(m_hd_chain.seed_id, seed_key)) {
1916 : 0 : assert(false);
1917 : : }
1918 [ + - + - ]: 36 : out.master_key.SetSeed(seed_key);
1919 : 18 : }
1920 : :
1921 : : // Handle the rest of the scriptPubKeys which must be imports and may not have all info
1922 [ + + ]: 57 : for (auto it = spks.begin(); it != spks.end();) {
1923 [ + - ]: 34 : const CScript& spk = *it;
1924 : :
1925 : : // Get birthdate from script meta
1926 : 34 : uint64_t creation_time = 0;
1927 [ + - ]: 34 : const auto& mit = m_script_metadata.find(CScriptID(spk));
1928 [ + + ]: 34 : if (mit != m_script_metadata.end()) {
1929 : 31 : creation_time = mit->second.nCreateTime;
1930 : : }
1931 : :
1932 : : // InferDescriptor as that will get us all the solving info if it is there
1933 [ + - + - ]: 34 : std::unique_ptr<Descriptor> desc = InferDescriptor(spk, *GetSolvingProvider(spk));
1934 : : // Get the private keys for this descriptor
1935 : 34 : std::vector<CScript> scripts;
1936 : 34 : FlatSigningProvider keys;
1937 [ + - - + ]: 34 : if (!desc->Expand(0, DUMMY_SIGNING_PROVIDER, scripts, keys)) {
1938 : 0 : assert(false);
1939 : : }
1940 : 34 : std::set<CKeyID> privkeyids;
1941 [ + + ]: 65 : for (const auto& key_orig_pair : keys.origins) {
1942 [ + - ]: 31 : privkeyids.insert(key_orig_pair.first);
1943 : : }
1944 : :
1945 : 34 : std::vector<CScript> desc_spks;
1946 : :
1947 : : // Make the descriptor string with private keys
1948 [ + - ]: 34 : std::string desc_str;
1949 [ + - ]: 34 : bool watchonly = !desc->ToPrivateString(*this, desc_str);
1950 [ + + + - : 34 : if (watchonly && !m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
+ + ]
1951 [ + - + - ]: 25 : out.watch_descs.emplace_back(desc->ToString(), creation_time);
1952 : :
1953 : : // Get the scriptPubKeys without writing this to the wallet
1954 : 25 : FlatSigningProvider provider;
1955 [ + - ]: 25 : desc->Expand(0, provider, desc_spks, provider);
1956 : 25 : } else {
1957 : : // Make the DescriptorScriptPubKeyMan and get the scriptPubKeys
1958 [ + - + - ]: 9 : WalletDescriptor w_desc(std::move(desc), creation_time, 0, 0, 0);
1959 [ + - ]: 9 : auto desc_spk_man = std::make_unique<DescriptorScriptPubKeyMan>(m_storage, w_desc, /*keypool_size=*/0);
1960 [ + + ]: 24 : for (const auto& keyid : privkeyids) {
1961 : 15 : CKey key;
1962 [ + - + + ]: 15 : if (!GetKey(keyid, key)) {
1963 : 6 : continue;
1964 : : }
1965 [ + - + - : 27 : WITH_LOCK(desc_spk_man->cs_desc_man, desc_spk_man->AddDescriptorKeyWithDB(batch, key, key.GetPubKey()));
+ - ]
1966 : 15 : }
1967 [ + - ]: 9 : desc_spk_man->TopUpWithDB(batch);
1968 [ + - ]: 9 : auto desc_spks_set = desc_spk_man->GetScriptPubKeys();
1969 [ + - ]: 9 : desc_spks.insert(desc_spks.end(), desc_spks_set.begin(), desc_spks_set.end());
1970 : :
1971 [ + - ]: 9 : out.desc_spkms.push_back(std::move(desc_spk_man));
1972 : 9 : }
1973 : :
1974 : : // Remove the scriptPubKeys from our current set
1975 [ + + ]: 68 : for (const CScript& desc_spk : desc_spks) {
1976 [ + - ]: 34 : auto del_it = spks.find(desc_spk);
1977 [ - + ]: 34 : assert(del_it != spks.end());
1978 [ + - - + ]: 34 : assert(IsMine(desc_spk) != ISMINE_NO);
1979 : 34 : it = spks.erase(del_it);
1980 : : }
1981 : 34 : }
1982 : :
1983 : : // Multisigs are special. They don't show up as ISMINE_SPENDABLE unless they are in a P2SH
1984 : : // So we have to check if any of our scripts are a multisig and if so, add the P2SH
1985 [ + + ]: 148 : for (const auto& script_pair : mapScripts) {
1986 : 125 : const CScript script = script_pair.second;
1987 : :
1988 : : // Get birthdate from script meta
1989 : 125 : uint64_t creation_time = 0;
1990 [ + - ]: 125 : const auto& it = m_script_metadata.find(CScriptID(script));
1991 [ + + ]: 125 : if (it != m_script_metadata.end()) {
1992 : 11 : creation_time = it->second.nCreateTime;
1993 : : }
1994 : :
1995 : 125 : std::vector<std::vector<unsigned char>> sols;
1996 [ + - ]: 125 : TxoutType type = Solver(script, sols);
1997 [ + + ]: 125 : if (type == TxoutType::MULTISIG) {
1998 [ + - + - ]: 5 : CScript sh_spk = GetScriptForDestination(ScriptHash(script));
1999 [ + - ]: 5 : CTxDestination witdest = WitnessV0ScriptHash(script);
2000 [ + - ]: 5 : CScript witprog = GetScriptForDestination(witdest);
2001 [ + - + - ]: 5 : CScript sh_wsh_spk = GetScriptForDestination(ScriptHash(witprog));
2002 : :
2003 : : // We only want the multisigs that we have not already seen, i.e. they are not watchonly and not spendable
2004 : : // For P2SH, a multisig is not ISMINE_NO when:
2005 : : // * All keys are in the wallet
2006 : : // * The multisig itself is watch only
2007 : : // * The P2SH is watch only
2008 : : // For P2SH-P2WSH, if the script is in the wallet, then it will have the same conditions as P2SH.
2009 : : // For P2WSH, a multisig is not ISMINE_NO when, other than the P2SH conditions:
2010 : : // * The P2WSH script is in the wallet and it is being watched
2011 [ + - ]: 5 : std::vector<std::vector<unsigned char>> keys(sols.begin() + 1, sols.begin() + sols.size() - 1);
2012 [ + - + - : 5 : if (HaveWatchOnly(sh_spk) || HaveWatchOnly(script) || HaveKeys(keys, *this) || (HaveCScript(CScriptID(witprog)) && HaveWatchOnly(witprog))) {
+ - + - +
- + + + -
+ - + - +
- + + ]
2013 : : // The above emulates IsMine for these 3 scriptPubKeys, so double check that by running IsMine
2014 [ + - + + : 2 : assert(IsMine(sh_spk) != ISMINE_NO || IsMine(witprog) != ISMINE_NO || IsMine(sh_wsh_spk) != ISMINE_NO);
+ - - + -
- - - ]
2015 : 2 : continue;
2016 : : }
2017 [ + - + - : 3 : assert(IsMine(sh_spk) == ISMINE_NO && IsMine(witprog) == ISMINE_NO && IsMine(sh_wsh_spk) == ISMINE_NO);
+ - + - +
- - + ]
2018 : :
2019 [ + - + - ]: 3 : std::unique_ptr<Descriptor> sh_desc = InferDescriptor(sh_spk, *GetSolvingProvider(sh_spk));
2020 [ + - + - ]: 3 : out.solvable_descs.emplace_back(sh_desc->ToString(), creation_time);
2021 : :
2022 [ + - ]: 3 : const auto desc = InferDescriptor(witprog, *this);
2023 [ + - + - ]: 3 : if (desc->IsSolvable()) {
2024 [ + - + - ]: 3 : std::unique_ptr<Descriptor> wsh_desc = InferDescriptor(witprog, *GetSolvingProvider(witprog));
2025 [ + - + - ]: 3 : out.solvable_descs.emplace_back(wsh_desc->ToString(), creation_time);
2026 [ + - + - ]: 3 : std::unique_ptr<Descriptor> sh_wsh_desc = InferDescriptor(sh_wsh_spk, *GetSolvingProvider(sh_wsh_spk));
2027 [ + - + - ]: 3 : out.solvable_descs.emplace_back(sh_wsh_desc->ToString(), creation_time);
2028 : 3 : }
2029 : 5 : }
2030 : 125 : }
2031 : :
2032 : : // Make sure that we have accounted for all scriptPubKeys
2033 [ - + ]: 23 : assert(spks.size() == 0);
2034 : :
2035 : : // Finalize transaction
2036 [ + - - + ]: 23 : if (!batch.TxnCommit()) {
2037 [ # # ]: 0 : LogPrintf("Error generating descriptors for migration, cannot commit db transaction\n");
2038 : 0 : return std::nullopt;
2039 : : }
2040 : :
2041 : 23 : return out;
2042 : 69 : }
2043 : :
2044 : 3 : bool LegacyDataSPKM::DeleteRecords()
2045 : : {
2046 [ + - + - ]: 3 : return RunWithinTxn(m_storage.GetDatabase(), /*process_desc=*/"delete legacy records", [&](WalletBatch& batch){
2047 : 3 : return DeleteRecordsWithDB(batch);
2048 : 3 : });
2049 : : }
2050 : :
2051 : 25 : bool LegacyDataSPKM::DeleteRecordsWithDB(WalletBatch& batch)
2052 : : {
2053 : 25 : LOCK(cs_KeyStore);
2054 [ + - + - ]: 25 : return batch.EraseRecords(DBKeys::LEGACY_TYPES);
2055 : 25 : }
2056 : :
2057 : 18157 : util::Result<CTxDestination> DescriptorScriptPubKeyMan::GetNewDestination(const OutputType type)
2058 : : {
2059 : : // Returns true if this descriptor supports getting new addresses. Conditions where we may be unable to fetch them (e.g. locked) are caught later
2060 [ - + ]: 18157 : if (!CanGetAddresses()) {
2061 : 0 : return util::Error{_("No addresses available")};
2062 : : }
2063 : 18157 : {
2064 : 18157 : LOCK(cs_desc_man);
2065 [ + - - + ]: 18157 : assert(m_wallet_descriptor.descriptor->IsSingleType()); // This is a combo descriptor which should not be an active descriptor
2066 [ + - ]: 18157 : std::optional<OutputType> desc_addr_type = m_wallet_descriptor.descriptor->GetOutputType();
2067 [ - + ]: 18157 : assert(desc_addr_type);
2068 [ - + ]: 18157 : if (type != *desc_addr_type) {
2069 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": Types are inconsistent. Stored type does not match type of newly generated address");
2070 : : }
2071 : :
2072 [ + - ]: 18157 : TopUp();
2073 : :
2074 : : // Get the scriptPubKey from the descriptor
2075 : 18157 : FlatSigningProvider out_keys;
2076 : 18157 : std::vector<CScript> scripts_temp;
2077 [ - + - - : 18157 : if (m_wallet_descriptor.range_end <= m_max_cached_index && !TopUp(1)) {
- - ]
2078 : : // We can't generate anymore keys
2079 [ # # ]: 0 : return util::Error{_("Error: Keypool ran out, please call keypoolrefill first")};
2080 : : }
2081 [ + - + + ]: 18157 : if (!m_wallet_descriptor.descriptor->ExpandFromCache(m_wallet_descriptor.next_index, m_wallet_descriptor.cache, scripts_temp, out_keys)) {
2082 : : // We can't generate anymore keys
2083 [ + - ]: 24 : return util::Error{_("Error: Keypool ran out, please call keypoolrefill first")};
2084 : : }
2085 : :
2086 : 18149 : CTxDestination dest;
2087 [ + - - + ]: 18149 : if (!ExtractDestination(scripts_temp[0], dest)) {
2088 [ # # ]: 0 : return util::Error{_("Error: Cannot extract destination from the generated scriptpubkey")}; // shouldn't happen
2089 : : }
2090 : 18149 : m_wallet_descriptor.next_index++;
2091 [ + - + - : 18149 : WalletBatch(m_storage.GetDatabase()).WriteDescriptor(GetID(), m_wallet_descriptor);
+ - + - ]
2092 : 18149 : return dest;
2093 [ + - ]: 36314 : }
2094 : : }
2095 : :
2096 : 765385 : isminetype DescriptorScriptPubKeyMan::IsMine(const CScript& script) const
2097 : : {
2098 : 765385 : LOCK(cs_desc_man);
2099 [ + + ]: 765385 : if (m_map_script_pub_keys.count(script) > 0) {
2100 : 765358 : return ISMINE_SPENDABLE;
2101 : : }
2102 : : return ISMINE_NO;
2103 : 765385 : }
2104 : :
2105 : 874 : bool DescriptorScriptPubKeyMan::CheckDecryptionKey(const CKeyingMaterial& master_key)
2106 : : {
2107 : 874 : LOCK(cs_desc_man);
2108 [ + - ]: 874 : if (!m_map_keys.empty()) {
2109 : : return false;
2110 : : }
2111 : :
2112 : 874 : bool keyPass = m_map_crypted_keys.empty(); // Always pass when there are no encrypted keys
2113 : 874 : bool keyFail = false;
2114 [ + + ]: 1089 : for (const auto& mi : m_map_crypted_keys) {
2115 : 736 : const CPubKey &pubkey = mi.second.first;
2116 : 736 : const std::vector<unsigned char> &crypted_secret = mi.second.second;
2117 : 736 : CKey key;
2118 [ + - + - ]: 736 : if (!DecryptKey(master_key, crypted_secret, pubkey, key)) {
2119 : : keyFail = true;
2120 : : break;
2121 : : }
2122 : 736 : keyPass = true;
2123 [ + + ]: 736 : if (m_decryption_thoroughly_checked)
2124 : : break;
2125 : 736 : }
2126 [ - + ]: 874 : if (keyPass && keyFail) {
2127 [ # # ]: 0 : LogPrintf("The wallet is probably corrupted: Some keys decrypt but not all.\n");
2128 [ # # ]: 0 : throw std::runtime_error("Error unlocking wallet: some keys decrypt but not all. Your wallet file may be corrupt.");
2129 : : }
2130 [ + - ]: 874 : if (keyFail || !keyPass) {
2131 : : return false;
2132 : : }
2133 : 874 : m_decryption_thoroughly_checked = true;
2134 : 874 : return true;
2135 : 874 : }
2136 : :
2137 : 103 : bool DescriptorScriptPubKeyMan::Encrypt(const CKeyingMaterial& master_key, WalletBatch* batch)
2138 : : {
2139 : 103 : LOCK(cs_desc_man);
2140 [ + - ]: 103 : if (!m_map_crypted_keys.empty()) {
2141 : : return false;
2142 : : }
2143 : :
2144 [ + + ]: 206 : for (const KeyMap::value_type& key_in : m_map_keys)
2145 : : {
2146 : 103 : const CKey &key = key_in.second;
2147 [ + - ]: 103 : CPubKey pubkey = key.GetPubKey();
2148 [ + - + - : 309 : CKeyingMaterial secret{UCharCast(key.begin()), UCharCast(key.end())};
+ - ]
2149 : 103 : std::vector<unsigned char> crypted_secret;
2150 [ + - + - : 103 : if (!EncryptSecret(master_key, secret, pubkey.GetHash(), crypted_secret)) {
- + ]
2151 : 0 : return false;
2152 : : }
2153 [ + - + - : 206 : m_map_crypted_keys[pubkey.GetID()] = make_pair(pubkey, crypted_secret);
+ - ]
2154 [ + - + - ]: 103 : batch->WriteCryptedDescriptorKey(GetID(), pubkey, crypted_secret);
2155 : 103 : }
2156 : 103 : m_map_keys.clear();
2157 : 103 : return true;
2158 : 103 : }
2159 : :
2160 : 1897 : util::Result<CTxDestination> DescriptorScriptPubKeyMan::GetReservedDestination(const OutputType type, bool internal, int64_t& index, CKeyPool& keypool)
2161 : : {
2162 : 1897 : LOCK(cs_desc_man);
2163 [ + - ]: 1897 : auto op_dest = GetNewDestination(type);
2164 : 1897 : index = m_wallet_descriptor.next_index - 1;
2165 [ + - ]: 1897 : return op_dest;
2166 : 1897 : }
2167 : :
2168 : 83 : void DescriptorScriptPubKeyMan::ReturnDestination(int64_t index, bool internal, const CTxDestination& addr)
2169 : : {
2170 : 83 : LOCK(cs_desc_man);
2171 : : // Only return when the index was the most recent
2172 [ + - ]: 83 : if (m_wallet_descriptor.next_index - 1 == index) {
2173 : 83 : m_wallet_descriptor.next_index--;
2174 : : }
2175 [ + - + - : 83 : WalletBatch(m_storage.GetDatabase()).WriteDescriptor(GetID(), m_wallet_descriptor);
+ - + - ]
2176 [ + - ]: 83 : NotifyCanGetAddressesChanged();
2177 : 83 : }
2178 : :
2179 : 84847 : std::map<CKeyID, CKey> DescriptorScriptPubKeyMan::GetKeys() const
2180 : : {
2181 : 84847 : AssertLockHeld(cs_desc_man);
2182 [ + + + + ]: 84847 : if (m_storage.HasEncryptionKeys() && !m_storage.IsLocked()) {
2183 : 2261 : KeyMap keys;
2184 [ + + ]: 4522 : for (const auto& key_pair : m_map_crypted_keys) {
2185 : 2261 : const CPubKey& pubkey = key_pair.second.first;
2186 : 2261 : const std::vector<unsigned char>& crypted_secret = key_pair.second.second;
2187 : 2261 : CKey key;
2188 [ + - + - ]: 2261 : m_storage.WithEncryptionKey([&](const CKeyingMaterial& encryption_key) {
2189 : 2261 : return DecryptKey(encryption_key, crypted_secret, pubkey, key);
2190 : : });
2191 [ + - + - : 2261 : keys[pubkey.GetID()] = key;
+ - ]
2192 : 2261 : }
2193 : : return keys;
2194 : 0 : }
2195 : 82586 : return m_map_keys;
2196 : : }
2197 : :
2198 : 225 : bool DescriptorScriptPubKeyMan::HasPrivKey(const CKeyID& keyid) const
2199 : : {
2200 : 225 : AssertLockHeld(cs_desc_man);
2201 [ + + + + ]: 225 : return m_map_keys.contains(keyid) || m_map_crypted_keys.contains(keyid);
2202 : : }
2203 : :
2204 : 72 : std::optional<CKey> DescriptorScriptPubKeyMan::GetKey(const CKeyID& keyid) const
2205 : : {
2206 : 72 : AssertLockHeld(cs_desc_man);
2207 [ + + + - ]: 72 : if (m_storage.HasEncryptionKeys() && !m_storage.IsLocked()) {
2208 : 9 : const auto& it = m_map_crypted_keys.find(keyid);
2209 [ - + ]: 9 : if (it == m_map_crypted_keys.end()) {
2210 : 0 : return std::nullopt;
2211 : : }
2212 [ + - ]: 9 : const std::vector<unsigned char>& crypted_secret = it->second.second;
2213 : 9 : CKey key;
2214 [ + - + - : 18 : if (!Assume(m_storage.WithEncryptionKey([&](const CKeyingMaterial& encryption_key) {
- + ]
2215 : : return DecryptKey(encryption_key, crypted_secret, it->second.first, key);
2216 : : }))) {
2217 : 0 : return std::nullopt;
2218 : : }
2219 : 9 : return key;
2220 : 9 : }
2221 : 63 : const auto& it = m_map_keys.find(keyid);
2222 [ + + ]: 63 : if (it == m_map_keys.end()) {
2223 : 1 : return std::nullopt;
2224 : : }
2225 : 62 : return it->second;
2226 : : }
2227 : :
2228 : 69829 : bool DescriptorScriptPubKeyMan::TopUp(unsigned int size)
2229 : : {
2230 : 69829 : WalletBatch batch(m_storage.GetDatabase());
2231 [ + - + + ]: 69829 : if (!batch.TxnBegin()) return false;
2232 [ + - ]: 69828 : bool res = TopUpWithDB(batch, size);
2233 [ + - - + : 69828 : if (!batch.TxnCommit()) throw std::runtime_error(strprintf("Error during descriptors keypool top up. Cannot commit changes for wallet %s", m_storage.GetDisplayName()));
- - - - -
- ]
2234 : : return res;
2235 : 69829 : }
2236 : :
2237 : 72772 : bool DescriptorScriptPubKeyMan::TopUpWithDB(WalletBatch& batch, unsigned int size)
2238 : : {
2239 : 72772 : LOCK(cs_desc_man);
2240 [ + + ]: 72772 : std::set<CScript> new_spks;
2241 : 72772 : unsigned int target_size;
2242 [ + + ]: 72772 : if (size > 0) {
2243 : : target_size = size;
2244 : : } else {
2245 : 72699 : target_size = m_keypool_size;
2246 : : }
2247 : :
2248 : : // Calculate the new range_end
2249 [ + + ]: 72772 : int32_t new_range_end = std::max(m_wallet_descriptor.next_index + (int32_t)target_size, m_wallet_descriptor.range_end);
2250 : :
2251 : : // If the descriptor is not ranged, we actually just want to fill the first cache item
2252 [ + - + + ]: 72772 : if (!m_wallet_descriptor.descriptor->IsRange()) {
2253 : 13143 : new_range_end = 1;
2254 : 13143 : m_wallet_descriptor.range_end = 1;
2255 : 13143 : m_wallet_descriptor.range_start = 0;
2256 : : }
2257 : :
2258 : 72772 : FlatSigningProvider provider;
2259 [ + - ]: 145544 : provider.keys = GetKeys();
2260 : :
2261 [ + - ]: 72772 : uint256 id = GetID();
2262 [ + + ]: 506243 : for (int32_t i = m_max_cached_index + 1; i < new_range_end; ++i) {
2263 : 433578 : FlatSigningProvider out_keys;
2264 : 433578 : std::vector<CScript> scripts_temp;
2265 : 433578 : DescriptorCache temp_cache;
2266 : : // Maybe we have a cached xpub and we can expand from the cache first
2267 [ + - + + ]: 433578 : if (!m_wallet_descriptor.descriptor->ExpandFromCache(i, m_wallet_descriptor.cache, scripts_temp, out_keys)) {
2268 [ + - + + ]: 14263 : if (!m_wallet_descriptor.descriptor->Expand(i, provider, scripts_temp, out_keys, &temp_cache)) return false;
2269 : : }
2270 : : // Add all of the scriptPubKeys to the scriptPubKey set
2271 [ + - ]: 433471 : new_spks.insert(scripts_temp.begin(), scripts_temp.end());
2272 [ + + ]: 867809 : for (const CScript& script : scripts_temp) {
2273 [ + - ]: 434338 : m_map_script_pub_keys[script] = i;
2274 : : }
2275 [ + + ]: 850578 : for (const auto& pk_pair : out_keys.pubkeys) {
2276 : 417107 : const CPubKey& pubkey = pk_pair.second;
2277 [ + + ]: 417107 : if (m_map_pubkeys.count(pubkey) != 0) {
2278 : : // We don't need to give an error here.
2279 : : // 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
2280 : 5588 : continue;
2281 : : }
2282 [ + - ]: 411519 : m_map_pubkeys[pubkey] = i;
2283 : : }
2284 : : // Merge and write the cache
2285 [ + - ]: 433471 : DescriptorCache new_items = m_wallet_descriptor.cache.MergeAndDiff(temp_cache);
2286 [ + - - + ]: 433471 : if (!batch.WriteDescriptorCacheItems(id, new_items)) {
2287 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": writing cache items failed");
2288 : : }
2289 : 433471 : m_max_cached_index++;
2290 : 433578 : }
2291 : 72665 : m_wallet_descriptor.range_end = new_range_end;
2292 [ + - + - ]: 72665 : batch.WriteDescriptor(GetID(), m_wallet_descriptor);
2293 : :
2294 : : // By this point, the cache size should be the size of the entire range
2295 [ - + ]: 72665 : assert(m_wallet_descriptor.range_end - 1 == m_max_cached_index);
2296 : :
2297 [ + - ]: 72665 : m_storage.TopUpCallback(new_spks, this);
2298 [ + - ]: 72665 : NotifyCanGetAddressesChanged();
2299 : : return true;
2300 [ + - ]: 145544 : }
2301 : :
2302 : 46429 : std::vector<WalletDestination> DescriptorScriptPubKeyMan::MarkUnusedAddresses(const CScript& script)
2303 : : {
2304 : 46429 : LOCK(cs_desc_man);
2305 : 46429 : std::vector<WalletDestination> result;
2306 [ + - + - ]: 46429 : if (IsMine(script)) {
2307 [ + - ]: 46429 : int32_t index = m_map_script_pub_keys[script];
2308 [ + + ]: 46429 : if (index >= m_wallet_descriptor.next_index) {
2309 [ + - ]: 523 : WalletLogPrintf("%s: Detected a used keypool item at index %d, mark all keypool items up to this item as used\n", __func__, index);
2310 [ + - ]: 523 : auto out_keys = std::make_unique<FlatSigningProvider>();
2311 : 523 : std::vector<CScript> scripts_temp;
2312 [ + + ]: 28932 : while (index >= m_wallet_descriptor.next_index) {
2313 [ + - - + ]: 28409 : if (!m_wallet_descriptor.descriptor->ExpandFromCache(m_wallet_descriptor.next_index, m_wallet_descriptor.cache, scripts_temp, *out_keys)) {
2314 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": Unable to expand descriptor from cache");
2315 : : }
2316 : 28409 : CTxDestination dest;
2317 [ + - ]: 28409 : ExtractDestination(scripts_temp[0], dest);
2318 : 28409 : result.push_back({dest, std::nullopt});
2319 : 28409 : m_wallet_descriptor.next_index++;
2320 : 28409 : }
2321 [ + - ]: 1046 : }
2322 [ + - + + ]: 46429 : if (!TopUp()) {
2323 [ + - ]: 1 : WalletLogPrintf("%s: Topping up keypool failed (locked wallet)\n", __func__);
2324 : : }
2325 : : }
2326 : :
2327 [ + - ]: 46429 : return result;
2328 [ + - + - ]: 103247 : }
2329 : :
2330 : 505 : void DescriptorScriptPubKeyMan::AddDescriptorKey(const CKey& key, const CPubKey &pubkey)
2331 : : {
2332 : 505 : LOCK(cs_desc_man);
2333 [ + - + - ]: 505 : WalletBatch batch(m_storage.GetDatabase());
2334 [ + - - + ]: 505 : if (!AddDescriptorKeyWithDB(batch, key, pubkey)) {
2335 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": writing descriptor private key failed");
2336 : : }
2337 [ + - ]: 1010 : }
2338 : :
2339 : 3441 : bool DescriptorScriptPubKeyMan::AddDescriptorKeyWithDB(WalletBatch& batch, const CKey& key, const CPubKey &pubkey)
2340 : : {
2341 : 3441 : AssertLockHeld(cs_desc_man);
2342 [ - + ]: 3441 : assert(!m_storage.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
2343 : :
2344 : : // Check if provided key already exists
2345 [ + + - + ]: 6875 : if (m_map_keys.find(pubkey.GetID()) != m_map_keys.end() ||
2346 [ - + ]: 3434 : m_map_crypted_keys.find(pubkey.GetID()) != m_map_crypted_keys.end()) {
2347 : 7 : return true;
2348 : : }
2349 : :
2350 [ + + ]: 3434 : if (m_storage.HasEncryptionKeys()) {
2351 [ + - ]: 162 : if (m_storage.IsLocked()) {
2352 : : return false;
2353 : : }
2354 : :
2355 : 162 : std::vector<unsigned char> crypted_secret;
2356 [ + - + - : 486 : CKeyingMaterial secret{UCharCast(key.begin()), UCharCast(key.end())};
+ - ]
2357 [ + - + - : 162 : if (!m_storage.WithEncryptionKey([&](const CKeyingMaterial& encryption_key) {
+ - ]
2358 : 162 : return EncryptSecret(encryption_key, secret, pubkey.GetHash(), crypted_secret);
2359 : : })) {
2360 : : return false;
2361 : : }
2362 : :
2363 [ + - + - : 324 : m_map_crypted_keys[pubkey.GetID()] = make_pair(pubkey, crypted_secret);
+ - ]
2364 [ + - + - ]: 162 : return batch.WriteCryptedDescriptorKey(GetID(), pubkey, crypted_secret);
2365 : 162 : } else {
2366 : 3272 : m_map_keys[pubkey.GetID()] = key;
2367 [ + - + - ]: 3272 : return batch.WriteDescriptorKey(GetID(), pubkey, key.GetPrivKey());
2368 : : }
2369 : : }
2370 : :
2371 : 2866 : bool DescriptorScriptPubKeyMan::SetupDescriptorGeneration(WalletBatch& batch, const CExtKey& master_key, OutputType addr_type, bool internal)
2372 : : {
2373 : 2866 : LOCK(cs_desc_man);
2374 [ + - - + ]: 2866 : assert(m_storage.IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS));
2375 : :
2376 : : // Ignore when there is already a descriptor
2377 [ + - ]: 2866 : if (m_wallet_descriptor.descriptor) {
2378 : : return false;
2379 : : }
2380 : :
2381 [ + - + - ]: 2866 : m_wallet_descriptor = GenerateWalletDescriptor(master_key.Neuter(), addr_type, internal);
2382 : :
2383 : : // Store the master private key, and descriptor
2384 [ + - + - : 2866 : if (!AddDescriptorKeyWithDB(batch, master_key.key, master_key.key.GetPubKey())) {
- + ]
2385 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": writing descriptor master private key failed");
2386 : : }
2387 [ + - + - : 2866 : if (!batch.WriteDescriptor(GetID(), m_wallet_descriptor)) {
- + ]
2388 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": writing descriptor failed");
2389 : : }
2390 : :
2391 : : // TopUp
2392 [ + - ]: 2866 : TopUpWithDB(batch);
2393 : :
2394 [ + - ]: 2866 : m_storage.UnsetBlankWalletFlag(batch);
2395 : : return true;
2396 : 2866 : }
2397 : :
2398 : 77 : bool DescriptorScriptPubKeyMan::IsHDEnabled() const
2399 : : {
2400 : 77 : LOCK(cs_desc_man);
2401 [ + - + - ]: 77 : return m_wallet_descriptor.descriptor->IsRange();
2402 : 77 : }
2403 : :
2404 : 28488 : bool DescriptorScriptPubKeyMan::CanGetAddresses(bool internal) const
2405 : : {
2406 : : // We can only give out addresses from descriptors that are single type (not combo), ranged,
2407 : : // and either have cached keys or can generate more keys (ignoring encryption)
2408 : 28488 : LOCK(cs_desc_man);
2409 [ + - + - ]: 56976 : return m_wallet_descriptor.descriptor->IsSingleType() &&
2410 [ + - + - : 56976 : m_wallet_descriptor.descriptor->IsRange() &&
+ + ]
2411 [ + - - + : 56976 : (HavePrivateKeys() || m_wallet_descriptor.next_index < m_wallet_descriptor.range_end);
+ - ]
2412 : 28488 : }
2413 : :
2414 : 325092 : bool DescriptorScriptPubKeyMan::HavePrivateKeys() const
2415 : : {
2416 : 325092 : LOCK(cs_desc_man);
2417 [ + + + + : 354003 : return m_map_keys.size() > 0 || m_map_crypted_keys.size() > 0;
+ - ]
2418 : 325092 : }
2419 : :
2420 : 0 : bool DescriptorScriptPubKeyMan::HaveCryptedKeys() const
2421 : : {
2422 : 0 : LOCK(cs_desc_man);
2423 [ # # ]: 0 : return !m_map_crypted_keys.empty();
2424 : 0 : }
2425 : :
2426 : 4151 : std::optional<int64_t> DescriptorScriptPubKeyMan::GetOldestKeyPoolTime() const
2427 : : {
2428 : : // This is only used for getwalletinfo output and isn't relevant to descriptor wallets.
2429 : 4151 : return std::nullopt;
2430 : : }
2431 : :
2432 : :
2433 : 8953 : unsigned int DescriptorScriptPubKeyMan::GetKeyPoolSize() const
2434 : : {
2435 : 8953 : LOCK(cs_desc_man);
2436 [ + - ]: 8953 : return m_wallet_descriptor.range_end - m_wallet_descriptor.next_index;
2437 : 8953 : }
2438 : :
2439 : 10352 : int64_t DescriptorScriptPubKeyMan::GetTimeFirstKey() const
2440 : : {
2441 : 10352 : LOCK(cs_desc_man);
2442 [ + - ]: 10352 : return m_wallet_descriptor.creation_time;
2443 : 10352 : }
2444 : :
2445 : 398115 : std::unique_ptr<FlatSigningProvider> DescriptorScriptPubKeyMan::GetSigningProvider(const CScript& script, bool include_private) const
2446 : : {
2447 : 398115 : LOCK(cs_desc_man);
2448 : :
2449 : : // Find the index of the script
2450 : 398115 : auto it = m_map_script_pub_keys.find(script);
2451 [ + + ]: 398115 : if (it == m_map_script_pub_keys.end()) {
2452 : 101929 : return nullptr;
2453 : : }
2454 [ + - ]: 296186 : int32_t index = it->second;
2455 : :
2456 [ + - ]: 296186 : return GetSigningProvider(index, include_private);
2457 : 398115 : }
2458 : :
2459 : 16617 : std::unique_ptr<FlatSigningProvider> DescriptorScriptPubKeyMan::GetSigningProvider(const CPubKey& pubkey) const
2460 : : {
2461 : 16617 : LOCK(cs_desc_man);
2462 : :
2463 : : // Find index of the pubkey
2464 : 16617 : auto it = m_map_pubkeys.find(pubkey);
2465 [ + + ]: 16617 : if (it == m_map_pubkeys.end()) {
2466 : 16205 : return nullptr;
2467 : : }
2468 [ + - ]: 412 : int32_t index = it->second;
2469 : :
2470 : : // Always try to get the signing provider with private keys. This function should only be called during signing anyways
2471 [ + - ]: 412 : std::unique_ptr<FlatSigningProvider> out = GetSigningProvider(index, true);
2472 [ + - + - : 412 : if (!out->HaveKey(pubkey.GetID())) {
+ + ]
2473 : 151 : return nullptr;
2474 : : }
2475 : 261 : return out;
2476 : 17029 : }
2477 : :
2478 : 296598 : std::unique_ptr<FlatSigningProvider> DescriptorScriptPubKeyMan::GetSigningProvider(int32_t index, bool include_private) const
2479 : : {
2480 : 296598 : AssertLockHeld(cs_desc_man);
2481 : :
2482 : 296598 : std::unique_ptr<FlatSigningProvider> out_keys = std::make_unique<FlatSigningProvider>();
2483 : :
2484 : : // Fetch SigningProvider from cache to avoid re-deriving
2485 : 296598 : auto it = m_map_signing_providers.find(index);
2486 [ + + ]: 296598 : if (it != m_map_signing_providers.end()) {
2487 [ + - + - ]: 280657 : out_keys->Merge(FlatSigningProvider{it->second});
2488 : : } else {
2489 : : // Get the scripts, keys, and key origins for this script
2490 : 15941 : std::vector<CScript> scripts_temp;
2491 [ + - - + ]: 15941 : if (!m_wallet_descriptor.descriptor->ExpandFromCache(index, m_wallet_descriptor.cache, scripts_temp, *out_keys)) return nullptr;
2492 : :
2493 : : // Cache SigningProvider so we don't need to re-derive if we need this SigningProvider again
2494 [ + - + - ]: 15941 : m_map_signing_providers[index] = *out_keys;
2495 : 15941 : }
2496 : :
2497 [ + - + + : 296598 : if (HavePrivateKeys() && include_private) {
+ + ]
2498 : 10824 : FlatSigningProvider master_provider;
2499 [ + - ]: 21648 : master_provider.keys = GetKeys();
2500 [ + - ]: 10824 : m_wallet_descriptor.descriptor->ExpandPrivate(index, master_provider, *out_keys);
2501 : 10824 : }
2502 : :
2503 : 296598 : return out_keys;
2504 : 296598 : }
2505 : :
2506 : 347352 : std::unique_ptr<SigningProvider> DescriptorScriptPubKeyMan::GetSolvingProvider(const CScript& script) const
2507 : : {
2508 [ - + ]: 347352 : return GetSigningProvider(script, false);
2509 : : }
2510 : :
2511 : 366078 : bool DescriptorScriptPubKeyMan::CanProvide(const CScript& script, SignatureData& sigdata)
2512 : : {
2513 : 366078 : return IsMine(script);
2514 : : }
2515 : :
2516 : 16164 : bool DescriptorScriptPubKeyMan::SignTransaction(CMutableTransaction& tx, const std::map<COutPoint, Coin>& coins, int sighash, std::map<int, bilingual_str>& input_errors) const
2517 : : {
2518 : 16164 : std::unique_ptr<FlatSigningProvider> keys = std::make_unique<FlatSigningProvider>();
2519 [ + + ]: 48941 : for (const auto& coin_pair : coins) {
2520 [ + - ]: 32777 : std::unique_ptr<FlatSigningProvider> coin_keys = GetSigningProvider(coin_pair.second.out.scriptPubKey, true);
2521 [ + + ]: 32777 : if (!coin_keys) {
2522 : 23674 : continue;
2523 : : }
2524 [ + - ]: 9103 : keys->Merge(std::move(*coin_keys));
2525 : 32777 : }
2526 : :
2527 [ + - + - ]: 16164 : return ::SignTransaction(tx, keys.get(), coins, sighash, input_errors);
2528 : 16164 : }
2529 : :
2530 : 9 : SigningResult DescriptorScriptPubKeyMan::SignMessage(const std::string& message, const PKHash& pkhash, std::string& str_sig) const
2531 : : {
2532 [ + - + - ]: 18 : std::unique_ptr<FlatSigningProvider> keys = GetSigningProvider(GetScriptForDestination(pkhash), true);
2533 [ + - ]: 9 : if (!keys) {
2534 : : return SigningResult::PRIVATE_KEY_NOT_AVAILABLE;
2535 : : }
2536 : :
2537 : 9 : CKey key;
2538 [ + - + - : 9 : if (!keys->GetKey(ToKeyID(pkhash), key)) {
+ - ]
2539 : : return SigningResult::PRIVATE_KEY_NOT_AVAILABLE;
2540 : : }
2541 : :
2542 [ + - - + ]: 9 : if (!MessageSign(key, message, str_sig)) {
2543 : 0 : return SigningResult::SIGNING_FAILED;
2544 : : }
2545 : : return SigningResult::OK;
2546 : 18 : }
2547 : :
2548 : 5576 : std::optional<PSBTError> DescriptorScriptPubKeyMan::FillPSBT(PartiallySignedTransaction& psbtx, const PrecomputedTransactionData& txdata, int sighash_type, bool sign, bool bip32derivs, int* n_signed, bool finalize) const
2549 : : {
2550 [ + - ]: 5576 : if (n_signed) {
2551 : 5576 : *n_signed = 0;
2552 : : }
2553 [ + + ]: 29600 : for (unsigned int i = 0; i < psbtx.tx->vin.size(); ++i) {
2554 : 24025 : const CTxIn& txin = psbtx.tx->vin[i];
2555 : 24025 : PSBTInput& input = psbtx.inputs.at(i);
2556 : :
2557 [ + + ]: 24025 : if (PSBTInputSigned(input)) {
2558 : 6487 : continue;
2559 : : }
2560 : :
2561 : : // Get the Sighash type
2562 [ + + + + : 17538 : if (sign && input.sighash_type != std::nullopt && *input.sighash_type != sighash_type) {
- + ]
2563 : 0 : return PSBTError::SIGHASH_MISMATCH;
2564 : : }
2565 : :
2566 : : // Get the scriptPubKey to know which SigningProvider to use
2567 : 17538 : CScript script;
2568 [ + + ]: 17538 : if (!input.witness_utxo.IsNull()) {
2569 : 12445 : script = input.witness_utxo.scriptPubKey;
2570 [ + + ]: 5093 : } else if (input.non_witness_utxo) {
2571 [ + + ]: 4896 : if (txin.prevout.n >= input.non_witness_utxo->vout.size()) {
2572 : 1 : return PSBTError::MISSING_INPUTS;
2573 : : }
2574 : 4895 : script = input.non_witness_utxo->vout[txin.prevout.n].scriptPubKey;
2575 : : } else {
2576 : : // There's no UTXO so we can just skip this now
2577 : 197 : continue;
2578 : : }
2579 : :
2580 [ + - ]: 17340 : std::unique_ptr<FlatSigningProvider> keys = std::make_unique<FlatSigningProvider>();
2581 [ + - ]: 17340 : std::unique_ptr<FlatSigningProvider> script_keys = GetSigningProvider(script, /*include_private=*/sign);
2582 [ + + ]: 17340 : if (script_keys) {
2583 [ + - ]: 2763 : keys->Merge(std::move(*script_keys));
2584 : : } else {
2585 : : // Maybe there are pubkeys listed that we can sign for
2586 : 14577 : std::vector<CPubKey> pubkeys;
2587 [ + - ]: 14577 : pubkeys.reserve(input.hd_keypaths.size() + 2);
2588 : :
2589 : : // ECDSA Pubkeys
2590 [ + - + + ]: 25032 : for (const auto& [pk, _] : input.hd_keypaths) {
2591 [ + - ]: 10455 : pubkeys.push_back(pk);
2592 : : }
2593 : :
2594 : : // Taproot output pubkey
2595 : 14577 : std::vector<std::vector<unsigned char>> sols;
2596 [ + - + + ]: 14577 : if (Solver(script, sols) == TxoutType::WITNESS_V1_TAPROOT) {
2597 [ + - ]: 990 : sols[0].insert(sols[0].begin(), 0x02);
2598 [ + - ]: 990 : pubkeys.emplace_back(sols[0]);
2599 [ + - ]: 990 : sols[0][0] = 0x03;
2600 [ + - ]: 990 : pubkeys.emplace_back(sols[0]);
2601 : : }
2602 : :
2603 : : // Taproot pubkeys
2604 [ + + ]: 16667 : for (const auto& pk_pair : input.m_tap_bip32_paths) {
2605 : 2090 : const XOnlyPubKey& pubkey = pk_pair.first;
2606 [ + + ]: 6270 : for (unsigned char prefix : {0x02, 0x03}) {
2607 : 4180 : unsigned char b[33] = {prefix};
2608 : 4180 : std::copy(pubkey.begin(), pubkey.end(), b + 1);
2609 : 4180 : CPubKey fullpubkey;
2610 : 4180 : fullpubkey.Set(b, b + 33);
2611 [ + - ]: 4180 : pubkeys.push_back(fullpubkey);
2612 : : }
2613 : : }
2614 : :
2615 [ + + ]: 31192 : for (const auto& pubkey : pubkeys) {
2616 [ + - ]: 16615 : std::unique_ptr<FlatSigningProvider> pk_keys = GetSigningProvider(pubkey);
2617 [ + + ]: 16615 : if (pk_keys) {
2618 [ + - ]: 260 : keys->Merge(std::move(*pk_keys));
2619 : : }
2620 : 16615 : }
2621 : 14577 : }
2622 : :
2623 [ + - ]: 17340 : SignPSBTInput(HidingSigningProvider(keys.get(), /*hide_secret=*/!sign, /*hide_origin=*/!bip32derivs), psbtx, i, &txdata, sighash_type, nullptr, finalize);
2624 : :
2625 [ + - ]: 17340 : bool signed_one = PSBTInputSigned(input);
2626 [ + - + + ]: 17340 : if (n_signed && (signed_one || !sign)) {
2627 : : // If sign is false, we assume that we _could_ sign if we get here. This
2628 : : // will never have false negatives; it is hard to tell under what i
2629 : : // circumstances it could have false positives.
2630 : 12836 : (*n_signed)++;
2631 : : }
2632 [ + - ]: 34878 : }
2633 : :
2634 : : // Fill in the bip32 keypaths and redeemscripts for the outputs so that hardware wallets can identify change
2635 [ + + ]: 70069 : for (unsigned int i = 0; i < psbtx.tx->vout.size(); ++i) {
2636 : 65310 : std::unique_ptr<SigningProvider> keys = GetSolvingProvider(psbtx.tx->vout.at(i).scriptPubKey);
2637 [ + + ]: 64494 : if (!keys) {
2638 : 63678 : continue;
2639 : : }
2640 [ + - ]: 816 : UpdatePSBTOutput(HidingSigningProvider(keys.get(), /*hide_secret=*/true, /*hide_origin=*/!bip32derivs), psbtx, i);
2641 : 64494 : }
2642 : :
2643 : 5575 : return {};
2644 : : }
2645 : :
2646 : 637 : std::unique_ptr<CKeyMetadata> DescriptorScriptPubKeyMan::GetMetadata(const CTxDestination& dest) const
2647 : : {
2648 [ + - ]: 637 : std::unique_ptr<SigningProvider> provider = GetSigningProvider(GetScriptForDestination(dest));
2649 [ + - ]: 637 : if (provider) {
2650 [ + - ]: 637 : KeyOriginInfo orig;
2651 [ + - ]: 637 : CKeyID key_id = GetKeyForDestination(*provider, dest);
2652 [ + - + + ]: 637 : if (provider->GetKeyOrigin(key_id, orig)) {
2653 [ + - ]: 558 : LOCK(cs_desc_man);
2654 [ + - ]: 558 : std::unique_ptr<CKeyMetadata> meta = std::make_unique<CKeyMetadata>();
2655 [ + - ]: 558 : meta->key_origin = orig;
2656 [ + - ]: 558 : meta->has_key_origin = true;
2657 : 558 : meta->nCreateTime = m_wallet_descriptor.creation_time;
2658 [ + - ]: 558 : return meta;
2659 : 558 : }
2660 : 637 : }
2661 : 79 : return nullptr;
2662 : 637 : }
2663 : :
2664 : 177473 : uint256 DescriptorScriptPubKeyMan::GetID() const
2665 : : {
2666 : 177473 : LOCK(cs_desc_man);
2667 [ + - ]: 177473 : return m_wallet_descriptor.id;
2668 : 177473 : }
2669 : :
2670 : 2226 : void DescriptorScriptPubKeyMan::SetCache(const DescriptorCache& cache)
2671 : : {
2672 : 2226 : LOCK(cs_desc_man);
2673 [ + - ]: 2226 : std::set<CScript> new_spks;
2674 [ + - ]: 2226 : m_wallet_descriptor.cache = cache;
2675 [ + + ]: 58967 : for (int32_t i = m_wallet_descriptor.range_start; i < m_wallet_descriptor.range_end; ++i) {
2676 : 56741 : FlatSigningProvider out_keys;
2677 : 56741 : std::vector<CScript> scripts_temp;
2678 [ + - - + ]: 56741 : if (!m_wallet_descriptor.descriptor->ExpandFromCache(i, m_wallet_descriptor.cache, scripts_temp, out_keys)) {
2679 [ # # ]: 0 : throw std::runtime_error("Error: Unable to expand wallet descriptor from cache");
2680 : : }
2681 : : // Add all of the scriptPubKeys to the scriptPubKey set
2682 [ + - ]: 56741 : new_spks.insert(scripts_temp.begin(), scripts_temp.end());
2683 [ + + ]: 114166 : for (const CScript& script : scripts_temp) {
2684 [ - + ]: 57425 : if (m_map_script_pub_keys.count(script) != 0) {
2685 [ # # # # : 0 : throw std::runtime_error(strprintf("Error: Already loaded script at index %d as being at index %d", i, m_map_script_pub_keys[script]));
# # ]
2686 : : }
2687 [ + - ]: 57425 : m_map_script_pub_keys[script] = i;
2688 : : }
2689 [ + + ]: 111439 : for (const auto& pk_pair : out_keys.pubkeys) {
2690 : 54698 : const CPubKey& pubkey = pk_pair.second;
2691 [ - + ]: 54698 : if (m_map_pubkeys.count(pubkey) != 0) {
2692 : : // We don't need to give an error here.
2693 : : // 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
2694 : 0 : continue;
2695 : : }
2696 [ + - ]: 54698 : m_map_pubkeys[pubkey] = i;
2697 : : }
2698 : 56741 : m_max_cached_index++;
2699 : 56741 : }
2700 : : // Make sure the wallet knows about our new spks
2701 [ + - ]: 2226 : m_storage.TopUpCallback(new_spks, this);
2702 [ + - ]: 4452 : }
2703 : :
2704 : 1931 : bool DescriptorScriptPubKeyMan::AddKey(const CKeyID& key_id, const CKey& key)
2705 : : {
2706 : 1931 : LOCK(cs_desc_man);
2707 [ + - + - ]: 1931 : m_map_keys[key_id] = key;
2708 [ + - ]: 1931 : return true;
2709 : 1931 : }
2710 : :
2711 : 231 : bool DescriptorScriptPubKeyMan::AddCryptedKey(const CKeyID& key_id, const CPubKey& pubkey, const std::vector<unsigned char>& crypted_key)
2712 : : {
2713 : 231 : LOCK(cs_desc_man);
2714 [ + - ]: 231 : if (!m_map_keys.empty()) {
2715 : : return false;
2716 : : }
2717 : :
2718 [ + - + - ]: 462 : m_map_crypted_keys[key_id] = make_pair(pubkey, crypted_key);
2719 : 231 : return true;
2720 : 231 : }
2721 : :
2722 : 6252 : bool DescriptorScriptPubKeyMan::HasWalletDescriptor(const WalletDescriptor& desc) const
2723 : : {
2724 : 6252 : LOCK(cs_desc_man);
2725 [ + - + - : 12390 : return !m_wallet_descriptor.id.IsNull() && !desc.id.IsNull() && m_wallet_descriptor.id == desc.id;
+ + + - ]
2726 : 6252 : }
2727 : :
2728 : 699 : void DescriptorScriptPubKeyMan::WriteDescriptor()
2729 : : {
2730 : 699 : LOCK(cs_desc_man);
2731 [ + - + - ]: 699 : WalletBatch batch(m_storage.GetDatabase());
2732 [ + - + - : 699 : if (!batch.WriteDescriptor(GetID(), m_wallet_descriptor)) {
- + ]
2733 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": writing descriptor failed");
2734 : : }
2735 [ + - ]: 1398 : }
2736 : :
2737 : 55368 : WalletDescriptor DescriptorScriptPubKeyMan::GetWalletDescriptor() const
2738 : : {
2739 : 55368 : return m_wallet_descriptor;
2740 : : }
2741 : :
2742 : 403 : std::unordered_set<CScript, SaltedSipHasher> DescriptorScriptPubKeyMan::GetScriptPubKeys() const
2743 : : {
2744 : 403 : return GetScriptPubKeys(0);
2745 : : }
2746 : :
2747 : 528 : std::unordered_set<CScript, SaltedSipHasher> DescriptorScriptPubKeyMan::GetScriptPubKeys(int32_t minimum_index) const
2748 : : {
2749 : 528 : LOCK(cs_desc_man);
2750 [ + - ]: 528 : std::unordered_set<CScript, SaltedSipHasher> script_pub_keys;
2751 [ + - ]: 528 : script_pub_keys.reserve(m_map_script_pub_keys.size());
2752 : :
2753 [ + + + + ]: 37057 : for (auto const& [script_pub_key, index] : m_map_script_pub_keys) {
2754 [ + + + - ]: 36529 : if (index >= minimum_index) script_pub_keys.insert(script_pub_key);
2755 : : }
2756 [ + - ]: 528 : return script_pub_keys;
2757 : 528 : }
2758 : :
2759 : 4968 : int32_t DescriptorScriptPubKeyMan::GetEndRange() const
2760 : : {
2761 : 4968 : return m_max_cached_index + 1;
2762 : : }
2763 : :
2764 : 1093 : bool DescriptorScriptPubKeyMan::GetDescriptorString(std::string& out, const bool priv) const
2765 : : {
2766 : 1093 : LOCK(cs_desc_man);
2767 : :
2768 : 1093 : FlatSigningProvider provider;
2769 [ + - ]: 2186 : provider.keys = GetKeys();
2770 : :
2771 [ + + ]: 1093 : if (priv) {
2772 : : // For the private version, always return the master key to avoid
2773 : : // exposing child private keys. The risk implications of exposing child
2774 : : // private keys together with the parent xpub may be non-obvious for users.
2775 [ + - ]: 48 : return m_wallet_descriptor.descriptor->ToPrivateString(provider, out);
2776 : : }
2777 : :
2778 [ + - ]: 1045 : return m_wallet_descriptor.descriptor->ToNormalizedString(provider, out, &m_wallet_descriptor.cache);
2779 [ + - ]: 2186 : }
2780 : :
2781 : 1181 : void DescriptorScriptPubKeyMan::UpgradeDescriptorCache()
2782 : : {
2783 : 1181 : LOCK(cs_desc_man);
2784 [ + - + - : 1181 : if (m_storage.IsLocked() || m_storage.IsWalletFlagSet(WALLET_FLAG_LAST_HARDENED_XPUB_CACHED)) {
+ - - + ]
2785 : 0 : return;
2786 : : }
2787 : :
2788 : : // Skip if we have the last hardened xpub cache
2789 [ + - + + ]: 1181 : if (m_wallet_descriptor.cache.GetCachedLastHardenedExtPubKeys().size() > 0) {
2790 : : return;
2791 : : }
2792 : :
2793 : : // Expand the descriptor
2794 : 158 : FlatSigningProvider provider;
2795 [ + - ]: 316 : provider.keys = GetKeys();
2796 : 158 : FlatSigningProvider out_keys;
2797 : 158 : std::vector<CScript> scripts_temp;
2798 : 158 : DescriptorCache temp_cache;
2799 [ + - - + ]: 158 : if (!m_wallet_descriptor.descriptor->Expand(0, provider, scripts_temp, out_keys, &temp_cache)){
2800 [ # # ]: 0 : throw std::runtime_error("Unable to expand descriptor");
2801 : : }
2802 : :
2803 : : // Cache the last hardened xpubs
2804 [ + - ]: 158 : DescriptorCache diff = m_wallet_descriptor.cache.MergeAndDiff(temp_cache);
2805 [ + - + - : 316 : if (!WalletBatch(m_storage.GetDatabase()).WriteDescriptorCacheItems(GetID(), diff)) {
+ - + - -
+ ]
2806 [ # # # # ]: 0 : throw std::runtime_error(std::string(__func__) + ": writing cache items failed");
2807 : : }
2808 [ + - ]: 1339 : }
2809 : :
2810 : 27 : void DescriptorScriptPubKeyMan::UpdateWalletDescriptor(WalletDescriptor& descriptor)
2811 : : {
2812 : 27 : LOCK(cs_desc_man);
2813 [ + - ]: 27 : std::string error;
2814 [ + - - + ]: 27 : if (!CanUpdateToWalletDescriptor(descriptor, error)) {
2815 [ # # # # : 0 : throw std::runtime_error(std::string(__func__) + ": " + error);
# # ]
2816 : : }
2817 : :
2818 : 27 : m_map_pubkeys.clear();
2819 : 27 : m_map_script_pub_keys.clear();
2820 : 27 : m_max_cached_index = -1;
2821 [ + - ]: 27 : m_wallet_descriptor = descriptor;
2822 : :
2823 [ + - ]: 27 : NotifyFirstKeyTimeChanged(this, m_wallet_descriptor.creation_time);
2824 [ + - ]: 54 : }
2825 : :
2826 : 57 : bool DescriptorScriptPubKeyMan::CanUpdateToWalletDescriptor(const WalletDescriptor& descriptor, std::string& error)
2827 : : {
2828 : 57 : LOCK(cs_desc_man);
2829 [ + - - + ]: 57 : if (!HasWalletDescriptor(descriptor)) {
2830 [ - - + - ]: 57 : error = "can only update matching descriptor";
2831 : : return false;
2832 : : }
2833 : :
2834 [ + + ]: 57 : if (descriptor.range_start > m_wallet_descriptor.range_start ||
2835 [ + + ]: 55 : descriptor.range_end < m_wallet_descriptor.range_end) {
2836 : : // Use inclusive range for error
2837 : 6 : error = strprintf("new range must include current range = [%d,%d]",
2838 : 3 : m_wallet_descriptor.range_start,
2839 [ + - ]: 3 : m_wallet_descriptor.range_end - 1);
2840 : 3 : return false;
2841 : : }
2842 : :
2843 : : return true;
2844 : 57 : }
2845 : : } // namespace wallet
|
