Bitcoin Core 29.99.0
P2P Digital Currency
scriptpubkeyman.h
Go to the documentation of this file.
1// Copyright (c) 2019-present The Bitcoin Core developers
2// Distributed under the MIT software license, see the accompanying
3// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5#ifndef BITCOIN_WALLET_SCRIPTPUBKEYMAN_H
6#define BITCOIN_WALLET_SCRIPTPUBKEYMAN_H
7
8#include <addresstype.h>
9#include <common/messages.h>
10#include <common/signmessage.h>
11#include <common/types.h>
12#include <logging.h>
13#include <node/types.h>
14#include <psbt.h>
15#include <script/descriptor.h>
16#include <script/script.h>
18#include <util/result.h>
19#include <util/time.h>
20#include <wallet/crypter.h>
21#include <wallet/types.h>
22#include <wallet/walletdb.h>
23#include <wallet/walletutil.h>
24
25#include <boost/signals2/signal.hpp>
26
27#include <functional>
28#include <optional>
29#include <unordered_map>
30
31enum class OutputType;
32
33namespace wallet {
34struct MigrationData;
35class ScriptPubKeyMan;
36
37// Wallet storage things that ScriptPubKeyMans need in order to be able to store things to the wallet database.
38// It provides access to things that are part of the entire wallet and not specific to a ScriptPubKeyMan such as
39// wallet flags, wallet version, encryption keys, encryption status, and the database itself. This allows a
40// ScriptPubKeyMan to have callbacks into CWallet without causing a circular dependency.
41// WalletStorage should be the same for all ScriptPubKeyMans of a wallet.
43{
44public:
45 virtual ~WalletStorage() = default;
46 virtual std::string LogName() const = 0;
47 virtual WalletDatabase& GetDatabase() const = 0;
48 virtual bool IsWalletFlagSet(uint64_t) const = 0;
51 virtual bool WithEncryptionKey(std::function<bool (const CKeyingMaterial&)> cb) const = 0;
52 virtual bool HasEncryptionKeys() const = 0;
53 virtual bool IsLocked() const = 0;
55 virtual void TopUpCallback(const std::set<CScript>&, ScriptPubKeyMan*) = 0;
56};
57
59static constexpr int64_t UNKNOWN_TIME = std::numeric_limits<int64_t>::max();
60
62static const unsigned int DEFAULT_KEYPOOL_SIZE = 1000;
63
64std::vector<CKeyID> GetAffectedKeys(const CScript& spk, const SigningProvider& provider);
65
67{
69 std::optional<bool> internal;
70};
71
72/*
73 * A class implementing ScriptPubKeyMan manages some (or all) scriptPubKeys used in a wallet.
74 * It contains the scripts and keys related to the scriptPubKeys it manages.
75 * A ScriptPubKeyMan will be able to give out scriptPubKeys to be used, as well as marking
76 * when a scriptPubKey has been used. It also handles when and how to store a scriptPubKey
77 * and its related scripts and keys, including encryption.
78 */
80{
81protected:
83
84public:
85 explicit ScriptPubKeyMan(WalletStorage& storage) : m_storage(storage) {}
86 virtual ~ScriptPubKeyMan() = default;
87 virtual util::Result<CTxDestination> GetNewDestination(const OutputType type) { return util::Error{Untranslated("Not supported")}; }
88 virtual bool IsMine(const CScript& script) const { return false; }
89
91 virtual bool CheckDecryptionKey(const CKeyingMaterial& master_key) { return false; }
92 virtual bool Encrypt(const CKeyingMaterial& master_key, WalletBatch* batch) { return false; }
93
94 virtual util::Result<CTxDestination> GetReservedDestination(const OutputType type, bool internal, int64_t& index) { return util::Error{Untranslated("Not supported")}; }
95 virtual void KeepDestination(int64_t index, const OutputType& type) {}
96 virtual void ReturnDestination(int64_t index, bool internal, const CTxDestination& addr) {}
97
102 virtual bool TopUp(unsigned int size = 0) { return false; }
103
111 virtual std::vector<WalletDestination> MarkUnusedAddresses(const CScript& script) { return {}; }
112
113 /* Returns true if HD is enabled */
114 virtual bool IsHDEnabled() const { return false; }
115
116 /* Returns true if the wallet can give out new addresses. This means it has keys in the keypool or can generate new keys */
117 virtual bool CanGetAddresses(bool internal = false) const { return false; }
118
119 virtual bool HavePrivateKeys() const { return false; }
120 virtual bool HaveCryptedKeys() const { return false; }
121
123 virtual void RewriteDB() {}
124
125 virtual unsigned int GetKeyPoolSize() const { return 0; }
126
127 virtual int64_t GetTimeFirstKey() const { return 0; }
128
129 virtual std::unique_ptr<CKeyMetadata> GetMetadata(const CTxDestination& dest) const { return nullptr; }
130
131 virtual std::unique_ptr<SigningProvider> GetSolvingProvider(const CScript& script) const { return nullptr; }
132
136 virtual bool CanProvide(const CScript& script, SignatureData& sigdata) { return false; }
137
139 virtual bool SignTransaction(CMutableTransaction& tx, const std::map<COutPoint, Coin>& coins, int sighash, std::map<int, bilingual_str>& input_errors) const { return false; }
141 virtual SigningResult SignMessage(const std::string& message, const PKHash& pkhash, std::string& str_sig) const { return SigningResult::SIGNING_FAILED; };
143 virtual std::optional<common::PSBTError> FillPSBT(PartiallySignedTransaction& psbt, const PrecomputedTransactionData& txdata, std::optional<int> sighash_type = std::nullopt, bool sign = true, bool bip32derivs = false, int* n_signed = nullptr, bool finalize = true) const { return common::PSBTError::UNSUPPORTED; }
144
145 virtual uint256 GetID() const { return uint256(); }
146
148 virtual std::unordered_set<CScript, SaltedSipHasher> GetScriptPubKeys() const { return {}; };
149
151 template <typename... Params>
152 void WalletLogPrintf(util::ConstevalFormatString<sizeof...(Params)> wallet_fmt, const Params&... params) const
153 {
154 LogInfo("[%s] %s", m_storage.LogName(), tfm::format(wallet_fmt, params...));
155 };
156
158 boost::signals2::signal<void ()> NotifyCanGetAddressesChanged;
159
161 boost::signals2::signal<void (const ScriptPubKeyMan* spkm, int64_t new_birth_time)> NotifyFirstKeyTimeChanged;
162};
163
165static const std::unordered_set<OutputType> LEGACY_OUTPUT_TYPES {
169};
170
171// Manages the data for a LegacyScriptPubKeyMan.
172// This is the minimum necessary to load a legacy wallet so that it can be migrated.
174{
175private:
176 using WatchOnlySet = std::set<CScript>;
177 using WatchKeyMap = std::map<CKeyID, CPubKey>;
178 using CryptedKeyMap = std::map<CKeyID, std::pair<CPubKey, std::vector<unsigned char>>>;
179
183
184 /* the HD chain data model (external chain counters) */
186 std::unordered_map<CKeyID, CHDChain, SaltedSipHasher> m_inactive_hd_chains;
187
190
191 bool AddWatchOnlyInMem(const CScript &dest);
192 virtual bool AddKeyPubKeyInner(const CKey& key, const CPubKey &pubkey);
193 bool AddCryptedKeyInner(const CPubKey &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret);
194
195 // Helper function to retrieve a conservative superset of all output scripts that may be relevant to this LegacyDataSPKM.
196 // It may include scripts that are invalid or not actually watched by this LegacyDataSPKM.
197 // Used only in migration.
198 std::unordered_set<CScript, SaltedSipHasher> GetCandidateScriptPubKeys() const;
199
200 bool IsMine(const CScript& script) const override;
201 bool CanProvide(const CScript& script, SignatureData& sigdata) override;
202public:
204
205 // Map from Key ID to key metadata.
206 std::map<CKeyID, CKeyMetadata> mapKeyMetadata GUARDED_BY(cs_KeyStore);
207
208 // Map from Script ID to key metadata (for watch-only keys).
209 std::map<CScriptID, CKeyMetadata> m_script_metadata GUARDED_BY(cs_KeyStore);
210
211 // ScriptPubKeyMan overrides
212 bool CheckDecryptionKey(const CKeyingMaterial& master_key) override;
213 std::unordered_set<CScript, SaltedSipHasher> GetScriptPubKeys() const override;
214 std::unique_ptr<SigningProvider> GetSolvingProvider(const CScript& script) const override;
215 uint256 GetID() const override { return uint256::ONE; }
216
217 // FillableSigningProvider overrides
218 bool HaveKey(const CKeyID &address) const override;
219 bool GetKey(const CKeyID &address, CKey& keyOut) const override;
220 bool GetPubKey(const CKeyID &address, CPubKey& vchPubKeyOut) const override;
221 bool GetKeyOrigin(const CKeyID& keyid, KeyOriginInfo& info) const override;
222
224 virtual void LoadKeyMetadata(const CKeyID& keyID, const CKeyMetadata &metadata);
225 virtual void LoadScriptMetadata(const CScriptID& script_id, const CKeyMetadata &metadata);
226
228 bool LoadWatchOnly(const CScript &dest);
230 bool HaveWatchOnly(const CScript &dest) const;
232 bool LoadKey(const CKey& key, const CPubKey &pubkey);
234 bool LoadCryptedKey(const CPubKey &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret, bool checksum_valid);
236 bool LoadCScript(const CScript& redeemScript);
238 void LoadHDChain(const CHDChain& chain);
239 void AddInactiveHDChain(const CHDChain& chain);
240 const CHDChain& GetHDChain() const { return m_hd_chain; }
241
243 bool GetWatchPubKey(const CKeyID &address, CPubKey &pubkey_out) const;
244
249 std::unordered_set<CScript, SaltedSipHasher> GetNotMineScriptPubKeys() const;
250
253 std::optional<MigrationData> MigrateToDescriptor();
255 bool DeleteRecordsWithDB(WalletBatch& batch);
256};
257
260{
261private:
263public:
264 explicit LegacySigningProvider(const LegacyDataSPKM& spk_man) : m_spk_man(spk_man) {}
265
266 bool GetCScript(const CScriptID &scriptid, CScript& script) const override { return m_spk_man.GetCScript(scriptid, script); }
267 bool HaveCScript(const CScriptID &scriptid) const override { return m_spk_man.HaveCScript(scriptid); }
268 bool GetPubKey(const CKeyID &address, CPubKey& pubkey) const override { return m_spk_man.GetPubKey(address, pubkey); }
269 bool GetKey(const CKeyID &address, CKey& key) const override { return false; }
270 bool HaveKey(const CKeyID &address) const override { return false; }
271 bool GetKeyOrigin(const CKeyID& keyid, KeyOriginInfo& info) const override { return m_spk_man.GetKeyOrigin(keyid, info); }
272};
273
275{
276 friend class LegacyDataSPKM;
277private:
278 using ScriptPubKeyMap = std::map<CScript, int32_t>; // Map of scripts to descriptor range index
279 using PubKeyMap = std::map<CPubKey, int32_t>; // Map of pubkeys involved in scripts to descriptor range index
280 using CryptedKeyMap = std::map<CKeyID, std::pair<CPubKey, std::vector<unsigned char>>>;
281 using KeyMap = std::map<CKeyID, CKey>;
282
283 ScriptPubKeyMap m_map_script_pub_keys GUARDED_BY(cs_desc_man);
285 int32_t m_max_cached_index = -1;
286
289
292
295
297
299
300 // Cached FlatSigningProviders to avoid regenerating them each time they are needed.
302 // Fetch the SigningProvider for the given script and optionally include private keys
303 std::unique_ptr<FlatSigningProvider> GetSigningProvider(const CScript& script, bool include_private = false) const;
304 // Fetch the SigningProvider for a given index and optionally include private keys. Called by the above functions.
305 std::unique_ptr<FlatSigningProvider> GetSigningProvider(int32_t index, bool include_private = false) const EXCLUSIVE_LOCKS_REQUIRED(cs_desc_man);
306
307protected:
309
311 bool TopUpWithDB(WalletBatch& batch, unsigned int size = 0);
312
313public:
314 DescriptorScriptPubKeyMan(WalletStorage& storage, WalletDescriptor& descriptor, int64_t keypool_size)
315 : ScriptPubKeyMan(storage),
316 m_keypool_size(keypool_size),
317 m_wallet_descriptor(descriptor)
318 {}
319 DescriptorScriptPubKeyMan(WalletStorage& storage, int64_t keypool_size)
320 : ScriptPubKeyMan(storage),
321 m_keypool_size(keypool_size)
322 {}
323
325
327 bool IsMine(const CScript& script) const override;
328
329 bool CheckDecryptionKey(const CKeyingMaterial& master_key) override;
330 bool Encrypt(const CKeyingMaterial& master_key, WalletBatch* batch) override;
331
332 util::Result<CTxDestination> GetReservedDestination(const OutputType type, bool internal, int64_t& index) override;
333 void ReturnDestination(int64_t index, bool internal, const CTxDestination& addr) override;
334
335 // Tops up the descriptor cache and m_map_script_pub_keys. The cache is stored in the wallet file
336 // and is used to expand the descriptor in GetNewDestination. DescriptorScriptPubKeyMan relies
337 // more on ephemeral data than LegacyScriptPubKeyMan. For wallets using unhardened derivation
338 // (with or without private keys), the "keypool" is a single xpub.
339 bool TopUp(unsigned int size = 0) override;
340
341 std::vector<WalletDestination> MarkUnusedAddresses(const CScript& script) override;
342
343 bool IsHDEnabled() const override;
344
346 bool SetupDescriptorGeneration(WalletBatch& batch, const CExtKey& master_key, OutputType addr_type, bool internal);
347
348 bool HavePrivateKeys() const override;
349 bool HasPrivKey(const CKeyID& keyid) const EXCLUSIVE_LOCKS_REQUIRED(cs_desc_man);
351 std::optional<CKey> GetKey(const CKeyID& keyid) const EXCLUSIVE_LOCKS_REQUIRED(cs_desc_man);
352 bool HaveCryptedKeys() const override;
353
354 unsigned int GetKeyPoolSize() const override;
355
356 int64_t GetTimeFirstKey() const override;
357
358 std::unique_ptr<CKeyMetadata> GetMetadata(const CTxDestination& dest) const override;
359
360 bool CanGetAddresses(bool internal = false) const override;
361
362 std::unique_ptr<SigningProvider> GetSolvingProvider(const CScript& script) const override;
363
364 bool CanProvide(const CScript& script, SignatureData& sigdata) override;
365
366 // Fetch the SigningProvider for the given pubkey and always include private keys. This should only be called by signing code.
367 std::unique_ptr<FlatSigningProvider> GetSigningProvider(const CPubKey& pubkey) const;
368
369 bool SignTransaction(CMutableTransaction& tx, const std::map<COutPoint, Coin>& coins, int sighash, std::map<int, bilingual_str>& input_errors) const override;
370 SigningResult SignMessage(const std::string& message, const PKHash& pkhash, std::string& str_sig) const override;
371 std::optional<common::PSBTError> FillPSBT(PartiallySignedTransaction& psbt, const PrecomputedTransactionData& txdata, std::optional<int> sighash_type = std::nullopt, bool sign = true, bool bip32derivs = false, int* n_signed = nullptr, bool finalize = true) const override;
372
373 uint256 GetID() const override;
374
375 void SetCache(const DescriptorCache& cache);
376
377 bool AddKey(const CKeyID& key_id, const CKey& key);
378 bool AddCryptedKey(const CKeyID& key_id, const CPubKey& pubkey, const std::vector<unsigned char>& crypted_key);
379
380 bool HasWalletDescriptor(const WalletDescriptor& desc) const;
382 bool CanUpdateToWalletDescriptor(const WalletDescriptor& descriptor, std::string& error);
383 void AddDescriptorKey(const CKey& key, const CPubKey &pubkey);
384 void WriteDescriptor();
385
387 std::unordered_set<CScript, SaltedSipHasher> GetScriptPubKeys() const override;
388 std::unordered_set<CScript, SaltedSipHasher> GetScriptPubKeys(int32_t minimum_index) const;
389 int32_t GetEndRange() const;
390
391 [[nodiscard]] bool GetDescriptorString(std::string& out, const bool priv) const;
392
394};
395
398{
400 std::vector<std::pair<std::string, int64_t>> watch_descs;
401 std::vector<std::pair<std::string, int64_t>> solvable_descs;
402 std::vector<std::unique_ptr<DescriptorScriptPubKeyMan>> desc_spkms;
403 std::shared_ptr<CWallet> watchonly_wallet{nullptr};
404 std::shared_ptr<CWallet> solvable_wallet{nullptr};
405};
406
407} // namespace wallet
408
409#endif // BITCOIN_WALLET_SCRIPTPUBKEYMAN_H
std::variant< CNoDestination, PubKeyDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, PayToAnchor, WitnessUnknown > CTxDestination
A txout script categorized into standard templates.
Definition: addresstype.h:143
const CChainParams & Params()
Return the currently selected parameters.
An encapsulated private key.
Definition: key.h:35
A reference to a CKey: the Hash160 of its serialized public key.
Definition: pubkey.h:24
An encapsulated public key.
Definition: pubkey.h:34
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:413
A reference to a CScript: the Hash160 of its serialization.
Definition: script.h:602
Cache for single descriptor's derived extended pubkeys.
Definition: descriptor.h:19
Fillable signing provider that keeps keys in an address->secret map.
virtual bool GetCScript(const CScriptID &hash, CScript &redeemScriptOut) const override
virtual bool HaveCScript(const CScriptID &hash) const override
RecursiveMutex cs_KeyStore
An interface to be implemented by keystores that support signing.
256-bit opaque blob.
Definition: uint256.h:196
static const uint256 ONE
Definition: uint256.h:205
bool IsMine(const CScript &script) const override
KeyMap GetKeys() const EXCLUSIVE_LOCKS_REQUIRED(cs_desc_man)
void SetCache(const DescriptorCache &cache)
std::map< int32_t, FlatSigningProvider > m_map_signing_providers
bool CanProvide(const CScript &script, SignatureData &sigdata) override
Whether this ScriptPubKeyMan can provide a SigningProvider (via GetSolvingProvider) that,...
bool SignTransaction(CMutableTransaction &tx, const std::map< COutPoint, Coin > &coins, int sighash, std::map< int, bilingual_str > &input_errors) const override
Creates new signatures and adds them to the transaction.
std::unordered_set< CScript, SaltedSipHasher > GetScriptPubKeys() const override
Returns a set of all the scriptPubKeys that this ScriptPubKeyMan watches.
WalletDescriptor GetWalletDescriptor() const EXCLUSIVE_LOCKS_REQUIRED(cs_desc_man)
std::map< CScript, int32_t > ScriptPubKeyMap
std::optional< common::PSBTError > FillPSBT(PartiallySignedTransaction &psbt, const PrecomputedTransactionData &txdata, std::optional< int > sighash_type=std::nullopt, bool sign=true, bool bip32derivs=false, int *n_signed=nullptr, bool finalize=true) const override
Adds script and derivation path information to a PSBT, and optionally signs it.
std::optional< CKey > GetKey(const CKeyID &keyid) const EXCLUSIVE_LOCKS_REQUIRED(cs_desc_man)
Retrieve the particular key if it is available. Returns nullopt if the key is not in the wallet,...
bool AddCryptedKey(const CKeyID &key_id, const CPubKey &pubkey, const std::vector< unsigned char > &crypted_key)
bool SetupDescriptorGeneration(WalletBatch &batch, const CExtKey &master_key, OutputType addr_type, bool internal)
Setup descriptors based on the given CExtkey.
bool TopUp(unsigned int size=0) override
Fills internal address pool.
bool m_decryption_thoroughly_checked
keeps track of whether Unlock has run a thorough check before
std::map< CKeyID, CKey > KeyMap
unsigned int GetKeyPoolSize() const override
int64_t GetTimeFirstKey() const override
std::unique_ptr< FlatSigningProvider > GetSigningProvider(const CScript &script, bool include_private=false) const
std::map< CPubKey, int32_t > PubKeyMap
bool CheckDecryptionKey(const CKeyingMaterial &master_key) override
Check that the given decryption key is valid for this ScriptPubKeyMan, i.e. it decrypts all of the ke...
bool CanGetAddresses(bool internal=false) const override
ScriptPubKeyMap m_map_script_pub_keys GUARDED_BY(cs_desc_man)
bool CanUpdateToWalletDescriptor(const WalletDescriptor &descriptor, std::string &error)
bool GetDescriptorString(std::string &out, const bool priv) const
std::unique_ptr< CKeyMetadata > GetMetadata(const CTxDestination &dest) const override
void AddDescriptorKey(const CKey &key, const CPubKey &pubkey)
std::unique_ptr< SigningProvider > GetSolvingProvider(const CScript &script) const override
DescriptorScriptPubKeyMan(WalletStorage &storage, int64_t keypool_size)
int64_t m_keypool_size GUARDED_BY(cs_desc_man)
Number of pre-generated keys/scripts (part of the look-ahead process, used to detect payments)
bool AddKey(const CKeyID &key_id, const CKey &key)
util::Result< CTxDestination > GetReservedDestination(const OutputType type, bool internal, int64_t &index) override
PubKeyMap m_map_pubkeys GUARDED_BY(cs_desc_man)
util::Result< void > UpdateWalletDescriptor(WalletDescriptor &descriptor)
bool TopUpWithDB(WalletBatch &batch, unsigned int size=0)
Same as 'TopUp' but designed for use within a batch transaction context.
void ReturnDestination(int64_t index, bool internal, const CTxDestination &addr) override
std::vector< WalletDestination > MarkUnusedAddresses(const CScript &script) override
Mark unused addresses as being used Affects all keys up to and including the one determined by provid...
CryptedKeyMap m_map_crypted_keys GUARDED_BY(cs_desc_man)
bool AddDescriptorKeyWithDB(WalletBatch &batch, const CKey &key, const CPubKey &pubkey) EXCLUSIVE_LOCKS_REQUIRED(cs_desc_man)
bool HasWalletDescriptor(const WalletDescriptor &desc) const
SigningResult SignMessage(const std::string &message, const PKHash &pkhash, std::string &str_sig) const override
Sign a message with the given script.
util::Result< CTxDestination > GetNewDestination(const OutputType type) override
std::map< CKeyID, std::pair< CPubKey, std::vector< unsigned char > > > CryptedKeyMap
bool HasPrivKey(const CKeyID &keyid) const EXCLUSIVE_LOCKS_REQUIRED(cs_desc_man)
KeyMap m_map_keys GUARDED_BY(cs_desc_man)
bool Encrypt(const CKeyingMaterial &master_key, WalletBatch *batch) override
bool DeleteRecordsWithDB(WalletBatch &batch)
Delete all the records of this LegacyScriptPubKeyMan from disk.
std::set< CScript > WatchOnlySet
WatchKeyMap mapWatchKeys GUARDED_BY(cs_KeyStore)
std::optional< MigrationData > MigrateToDescriptor()
Get the DescriptorScriptPubKeyMans (with private keys) that have the same scriptPubKeys as this Legac...
virtual bool AddKeyPubKeyInner(const CKey &key, const CPubKey &pubkey)
uint256 GetID() const override
std::unordered_set< CScript, SaltedSipHasher > GetCandidateScriptPubKeys() const
virtual void LoadKeyMetadata(const CKeyID &keyID, const CKeyMetadata &metadata)
Load metadata (used by LoadWallet)
bool LoadCryptedKey(const CPubKey &vchPubKey, const std::vector< unsigned char > &vchCryptedSecret, bool checksum_valid)
Adds an encrypted key to the store, without saving it to disk (used by LoadWallet)
WatchOnlySet setWatchOnly GUARDED_BY(cs_KeyStore)
std::map< CKeyID, CKeyMetadata > mapKeyMetadata GUARDED_BY(cs_KeyStore)
void AddInactiveHDChain(const CHDChain &chain)
bool HaveWatchOnly(const CScript &dest) const
Returns whether the watch-only script is in the wallet.
bool fDecryptionThoroughlyChecked
keeps track of whether Unlock has run a thorough check before
bool GetKeyOrigin(const CKeyID &keyid, KeyOriginInfo &info) const override
std::map< CScriptID, CKeyMetadata > m_script_metadata GUARDED_BY(cs_KeyStore)
bool GetPubKey(const CKeyID &address, CPubKey &vchPubKeyOut) const override
const CHDChain & GetHDChain() const
std::unordered_set< CScript, SaltedSipHasher > GetScriptPubKeys() const override
Returns a set of all the scriptPubKeys that this ScriptPubKeyMan watches.
CryptedKeyMap mapCryptedKeys GUARDED_BY(cs_KeyStore)
std::map< CKeyID, CPubKey > WatchKeyMap
std::unordered_set< CScript, SaltedSipHasher > GetNotMineScriptPubKeys() const
Retrieves scripts that were imported by bugs into the legacy spkm and are simply invalid,...
bool LoadKey(const CKey &key, const CPubKey &pubkey)
Adds a key to the store, without saving it to disk (used by LoadWallet)
bool AddWatchOnlyInMem(const CScript &dest)
bool GetWatchPubKey(const CKeyID &address, CPubKey &pubkey_out) const
Fetches a pubkey from mapWatchKeys if it exists there.
bool CheckDecryptionKey(const CKeyingMaterial &master_key) override
Check that the given decryption key is valid for this ScriptPubKeyMan, i.e. it decrypts all of the ke...
std::map< CKeyID, std::pair< CPubKey, std::vector< unsigned char > > > CryptedKeyMap
bool GetKey(const CKeyID &address, CKey &keyOut) const override
bool LoadCScript(const CScript &redeemScript)
Adds a CScript to the store.
bool IsMine(const CScript &script) const override
virtual void LoadScriptMetadata(const CScriptID &script_id, const CKeyMetadata &metadata)
std::unique_ptr< SigningProvider > GetSolvingProvider(const CScript &script) const override
bool CanProvide(const CScript &script, SignatureData &sigdata) override
Whether this ScriptPubKeyMan can provide a SigningProvider (via GetSolvingProvider) that,...
std::unordered_map< CKeyID, CHDChain, SaltedSipHasher > m_inactive_hd_chains
bool AddCryptedKeyInner(const CPubKey &vchPubKey, const std::vector< unsigned char > &vchCryptedSecret)
bool LoadWatchOnly(const CScript &dest)
Adds a watch-only address to the store, without saving it to disk (used by LoadWallet)
bool HaveKey(const CKeyID &address) const override
void LoadHDChain(const CHDChain &chain)
Load a HD chain model (used by LoadWallet)
Wraps a LegacyScriptPubKeyMan so that it can be returned in a new unique_ptr.
const LegacyDataSPKM & m_spk_man
bool HaveKey(const CKeyID &address) const override
bool GetPubKey(const CKeyID &address, CPubKey &pubkey) const override
bool GetKey(const CKeyID &address, CKey &key) const override
bool HaveCScript(const CScriptID &scriptid) const override
bool GetKeyOrigin(const CKeyID &keyid, KeyOriginInfo &info) const override
bool GetCScript(const CScriptID &scriptid, CScript &script) const override
LegacySigningProvider(const LegacyDataSPKM &spk_man)
virtual ~ScriptPubKeyMan()=default
virtual uint256 GetID() const
virtual unsigned int GetKeyPoolSize() const
virtual int64_t GetTimeFirstKey() const
virtual bool TopUp(unsigned int size=0)
Fills internal address pool.
virtual void KeepDestination(int64_t index, const OutputType &type)
virtual void ReturnDestination(int64_t index, bool internal, const CTxDestination &addr)
ScriptPubKeyMan(WalletStorage &storage)
virtual std::unique_ptr< CKeyMetadata > GetMetadata(const CTxDestination &dest) const
virtual std::unordered_set< CScript, SaltedSipHasher > GetScriptPubKeys() const
Returns a set of all the scriptPubKeys that this ScriptPubKeyMan watches.
virtual SigningResult SignMessage(const std::string &message, const PKHash &pkhash, std::string &str_sig) const
Sign a message with the given script.
boost::signals2::signal< void(const ScriptPubKeyMan *spkm, int64_t new_birth_time)> NotifyFirstKeyTimeChanged
Birth time changed.
virtual bool IsMine(const CScript &script) const
virtual void RewriteDB()
The action to do when the DB needs rewrite.
virtual std::optional< common::PSBTError > FillPSBT(PartiallySignedTransaction &psbt, const PrecomputedTransactionData &txdata, std::optional< int > sighash_type=std::nullopt, bool sign=true, bool bip32derivs=false, int *n_signed=nullptr, bool finalize=true) const
Adds script and derivation path information to a PSBT, and optionally signs it.
virtual bool HaveCryptedKeys() const
virtual bool HavePrivateKeys() const
virtual bool Encrypt(const CKeyingMaterial &master_key, WalletBatch *batch)
virtual bool SignTransaction(CMutableTransaction &tx, const std::map< COutPoint, Coin > &coins, int sighash, std::map< int, bilingual_str > &input_errors) const
Creates new signatures and adds them to the transaction.
virtual bool CanProvide(const CScript &script, SignatureData &sigdata)
Whether this ScriptPubKeyMan can provide a SigningProvider (via GetSolvingProvider) that,...
virtual util::Result< CTxDestination > GetReservedDestination(const OutputType type, bool internal, int64_t &index)
virtual util::Result< CTxDestination > GetNewDestination(const OutputType type)
virtual bool CheckDecryptionKey(const CKeyingMaterial &master_key)
Check that the given decryption key is valid for this ScriptPubKeyMan, i.e. it decrypts all of the ke...
boost::signals2::signal< void()> NotifyCanGetAddressesChanged
Keypool has new keys.
virtual std::unique_ptr< SigningProvider > GetSolvingProvider(const CScript &script) const
virtual std::vector< WalletDestination > MarkUnusedAddresses(const CScript &script)
Mark unused addresses as being used Affects all keys up to and including the one determined by provid...
virtual bool IsHDEnabled() const
void WalletLogPrintf(util::ConstevalFormatString< sizeof...(Params)> wallet_fmt, const Params &... params) const
Prepends the wallet name in logging output to ease debugging in multi-wallet use cases.
virtual bool CanGetAddresses(bool internal=false) const
WalletStorage & m_storage
Access to the wallet database.
Definition: walletdb.h:190
An instance of this class represents one database.
Definition: db.h:130
Descriptor with some wallet metadata.
Definition: walletutil.h:64
virtual bool IsWalletFlagSet(uint64_t) const =0
virtual void TopUpCallback(const std::set< CScript > &, ScriptPubKeyMan *)=0
Callback function for after TopUp completes containing any scripts that were added by a SPKMan.
virtual std::string LogName() const =0
virtual WalletDatabase & GetDatabase() const =0
virtual void UnsetBlankWalletFlag(WalletBatch &)=0
virtual bool IsLocked() const =0
virtual ~WalletStorage()=default
virtual bool HasEncryptionKeys() const =0
virtual bool WithEncryptionKey(std::function< bool(const CKeyingMaterial &)> cb) const =0
Pass the encryption key to cb().
is a home for simple enum and struct type definitions that can be used internally by functions in the...
#define LogInfo(...)
Definition: logging.h:356
is a home for simple string functions returning descriptive messages that are used in RPC and GUI int...
static int sign(const secp256k1_context *ctx, struct signer_secrets *signer_secrets, struct signer *signer, const secp256k1_musig_keyagg_cache *cache, const unsigned char *msg32, unsigned char *sig64)
Definition: musig.c:106
void format(std::ostream &out, FormatStringCheck< sizeof...(Args)> fmt, const Args &... args)
Format list of arguments to the stream according to given format string.
Definition: tinyformat.h:1079
std::vector< unsigned char, secure_allocator< unsigned char > > CKeyingMaterial
Definition: crypter.h:63
std::vector< CKeyID > GetAffectedKeys(const CScript &spk, const SigningProvider &provider)
static const unsigned int DEFAULT_KEYPOOL_SIZE
Default for -keypool.
static const std::unordered_set< OutputType > LEGACY_OUTPUT_TYPES
OutputTypes supported by the LegacyScriptPubKeyMan.
static constexpr int64_t UNKNOWN_TIME
Constant representing an unknown spkm creation time.
is a home for public enum and struct type definitions that are used internally by node code,...
OutputType
Definition: outputtype.h:17
SigningResult
Definition: signmessage.h:43
Definition: key.h:227
A mutable version of CTransaction.
Definition: transaction.h:378
A version of CTransaction with the PSBT format.
Definition: psbt.h:1119
A wrapper for a compile-time partially validated format string.
Definition: string.h:92
struct containing information needed for migrating legacy wallets to descriptor wallets
std::vector< std::unique_ptr< DescriptorScriptPubKeyMan > > desc_spkms
std::vector< std::pair< std::string, int64_t > > solvable_descs
std::vector< std::pair< std::string, int64_t > > watch_descs
std::optional< bool > internal
#define EXCLUSIVE_LOCKS_REQUIRED(...)
Definition: threadsafety.h:51
bilingual_str Untranslated(std::string original)
Mark a bilingual_str as untranslated.
Definition: translation.h:82
is a home for public enum and struct type definitions that are used by internally by wallet code,...