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 <musig.h>
13#include <node/types.h>
14#include <psbt.h>
15#include <script/descriptor.h>
16#include <script/script.h>
17#include <script/signingprovider.h>
18#include <util/btcsignals.h>
19#include <util/hasher.h>
20#include <util/log.h>
21#include <util/result.h>
22#include <util/time.h>
23#include <wallet/crypter.h>
24#include <wallet/types.h>
25#include <wallet/walletdb.h>
26#include <wallet/walletutil.h>
27
28#include <functional>
29#include <optional>
30#include <unordered_map>
31#include <unordered_set>
32
33enum class OutputType;
34
35namespace wallet {
36struct MigrationData;
37class ScriptPubKeyMan;
38
39// Wallet storage things that ScriptPubKeyMans need in order to be able to store things to the wallet database.
40// It provides access to things that are part of the entire wallet and not specific to a ScriptPubKeyMan such as
41// wallet flags, wallet version, encryption keys, encryption status, and the database itself. This allows a
42// ScriptPubKeyMan to have callbacks into CWallet without causing a circular dependency.
43// WalletStorage should be the same for all ScriptPubKeyMans of a wallet.
44class WalletStorage
45{
46public:
47    virtual ~WalletStorage() = default;
48    virtual std::string LogName() const = 0;
49    virtual WalletDatabase& GetDatabase() const = 0;
50    virtual bool IsWalletFlagSet(uint64_t) const = 0;
51    virtual void UnsetBlankWalletFlag(WalletBatch&) = 0;
52    //! Pass the encryption key to cb().
53    virtual bool WithEncryptionKey(std::function<bool (const CKeyingMaterial&)> cb) const = 0;
54    virtual bool HasEncryptionKeys() const = 0;
55    virtual bool IsLocked() const = 0;
56    //! Callback function for after TopUp completes containing any scripts that were added by a SPKMan
57    virtual void TopUpCallback(const std::set<CScript>&, ScriptPubKeyMan*) = 0;
58};
59
60//! Constant representing an unknown spkm creation time
61inline constexpr int64_t UNKNOWN_TIME = std::numeric_limits<int64_t>::max();
62
63//! Default for -keypool
64inline constexpr unsigned int DEFAULT_KEYPOOL_SIZE = 1000;
65
66struct WalletDestination
67{
68    CTxDestination dest;
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 */
79class ScriptPubKeyMan
80{
81protected:
82    WalletStorage& m_storage;
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
90    //! Check that the given decryption key is valid for this ScriptPubKeyMan, i.e. it decrypts all of the keys handled by it.
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
98    /** Fills internal address pool. Use within ScriptPubKeyMan implementations should be used sparingly and only
99      * when something from the address pool is removed, excluding GetNewDestination and GetReservedDestination.
100      * External wallet code is primarily responsible for topping up prior to fetching new addresses
101      */
102    virtual bool TopUp(unsigned int size = 0) { return false; }
103
104    /** Mark unused addresses as being used
105     * Affects all keys up to and including the one determined by provided script.
106     *
107     * @param script determines the last key to mark as used
108     *
109     * @return All of the addresses affected
110     */
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
122    virtual unsigned int GetKeyPoolSize() const { return 0; }
123
124    virtual int64_t GetTimeFirstKey() const { return 0; }
125
126    virtual std::unique_ptr<CKeyMetadata> GetMetadata(const CTxDestination& dest) const { return nullptr; }
127
128    virtual std::unique_ptr<SigningProvider> GetSolvingProvider(const CScript& script) const { return nullptr; }
129
130    /** Whether this ScriptPubKeyMan can provide a SigningProvider (via GetSolvingProvider) that, combined with
131      * sigdata, can produce solving data.
132      */
133    virtual bool CanProvide(const CScript& script, SignatureData& sigdata) { return false; }
134
135    /** Creates new signatures and adds them to the transaction. Returns whether all inputs were signed */
136    virtual bool SignTransaction(CMutableTransaction& tx, const std::map<COutPoint, Coin>& coins, int sighash, std::map<int, bilingual_str>& input_errors) const { return false; }
137    /** Sign a message with the given script */
138    virtual SigningResult SignMessage(const std::string& message, const PKHash& pkhash, std::string& str_sig) const { return SigningResult::SIGNING_FAILED; };
139    /** Adds script and derivation path information to a PSBT, and optionally signs it. */
140    virtual std::optional<common::PSBTError> FillPSBT(PartiallySignedTransaction& psbt, const PrecomputedTransactionData& txdata, const common::PSBTFillOptions& options, int* n_signed = nullptr) const { return common::PSBTError::UNSUPPORTED; }
141
142    virtual uint256 GetID() const { return uint256(); }
143
144    /** Returns a set of all the scriptPubKeys that this ScriptPubKeyMan watches */
145    virtual std::unordered_set<CScript, SaltedSipHasher> GetScriptPubKeys() const { return {}; };
146
147    /** Prepends the wallet name in logging output to ease debugging in multi-wallet use cases */
148    template <typename... Params>
149    void WalletLogPrintf(util::ConstevalFormatString<sizeof...(Params)> wallet_fmt, const Params&... params) const
150    {
151        LogInfo("[%s] %s", m_storage.LogName(), tfm::format(wallet_fmt, params...));
152    };
153
154    /** Keypool has new keys */
155    btcsignals::signal<void ()> NotifyCanGetAddressesChanged;
156
157    /** Birth time changed */
158    btcsignals::signal<void (const ScriptPubKeyMan* spkm, int64_t new_birth_time)> NotifyFirstKeyTimeChanged;
159};
160
161/** Output types associated with LegacyDataSPKM. */
162inline const std::unordered_set<OutputType> LEGACY_OUTPUT_TYPES {
163    OutputType::LEGACY,
164    OutputType::P2SH_SEGWIT,
165    OutputType::BECH32,
166};
167
168using KeyMap = std::map<CKeyID, CKey>;
169using CryptedKeyMap = std::map<CKeyID, std::pair<CPubKey, std::vector<unsigned char>>>;
170
171// Manages the minimum data needed to load and migrate a legacy wallet.
172class LegacyDataSPKM : public ScriptPubKeyMan, public FillableSigningProvider
173{
174private:
175    using WatchOnlySet = std::set<CScript>;
176    using WatchKeyMap = std::map<CKeyID, CPubKey>;
177
178    CryptedKeyMap mapCryptedKeys GUARDED_BY(cs_KeyStore);
179    WatchOnlySet setWatchOnly GUARDED_BY(cs_KeyStore);
180    WatchKeyMap mapWatchKeys GUARDED_BY(cs_KeyStore);
181
182    /* the HD chain data model (external chain counters) */
183    CHDChain m_hd_chain;
184    std::unordered_map<CKeyID, CHDChain, SaltedSipHasher> m_inactive_hd_chains;
185
186    //! keeps track of whether Unlock has run a thorough check before
187    bool fDecryptionThoroughlyChecked = true;
188
189    bool AddWatchOnlyInMem(const CScript &dest);
190    virtual bool AddKeyPubKeyInner(const CKey& key, const CPubKey &pubkey);
191    bool AddCryptedKeyInner(const CPubKey &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret);
192
193    // Helper function to retrieve a conservative superset of all output scripts that may be relevant to this LegacyDataSPKM.
194    // It may include scripts that are invalid or not actually watched by this LegacyDataSPKM.
195    // Used only in migration.
196    std::unordered_set<CScript, SaltedSipHasher> GetCandidateScriptPubKeys() const;
197
198    bool IsMine(const CScript& script) const override;
199    bool CanProvide(const CScript& script, SignatureData& sigdata) override;
200public:
201    using ScriptPubKeyMan::ScriptPubKeyMan;
202
203    // Map from Key ID to key metadata.
204    std::map<CKeyID, CKeyMetadata> mapKeyMetadata GUARDED_BY(cs_KeyStore);
205
206    // Map from Script ID to key metadata (for watch-only keys).
207    std::map<CScriptID, CKeyMetadata> m_script_metadata GUARDED_BY(cs_KeyStore);
208
209    // ScriptPubKeyMan overrides
210    bool CheckDecryptionKey(const CKeyingMaterial& master_key) override;
211    std::unordered_set<CScript, SaltedSipHasher> GetScriptPubKeys() const override;
212    std::unique_ptr<SigningProvider> GetSolvingProvider(const CScript& script) const override;
213    uint256 GetID() const override { return uint256::ONE; }
214
215    // FillableSigningProvider overrides
216    bool HaveKey(const CKeyID &address) const override;
217    bool GetKey(const CKeyID &address, CKey& keyOut) const override;
218    bool GetPubKey(const CKeyID &address, CPubKey& vchPubKeyOut) const override;
219    bool GetKeyOrigin(const CKeyID& keyid, KeyOriginInfo& info) const override;
220
221    //! Load metadata (used by LoadWallet)
222    virtual void LoadKeyMetadata(const CKeyID& keyID, const CKeyMetadata &metadata);
223    virtual void LoadScriptMetadata(const CScriptID& script_id, const CKeyMetadata &metadata);
224
225    //! Adds a watch-only address to the store, without saving it to disk (used by LoadWallet)
226    bool LoadWatchOnly(const CScript &dest);
227    //! Returns whether the watch-only script is in the wallet
228    bool HaveWatchOnly(const CScript &dest) const;
229    //! Adds a key to the store, without saving it to disk (used by LoadWallet)
230    bool LoadKey(const CKey& key, const CPubKey &pubkey);
231    //! Adds an encrypted key to the store, without saving it to disk (used by LoadWallet)
232    bool LoadCryptedKey(const CPubKey &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret, bool checksum_valid);
233    //! Adds a CScript to the store
234    bool LoadCScript(const CScript& redeemScript);
235    //! Load a HD chain model (used by LoadWallet)
236    void LoadHDChain(const CHDChain& chain);
237    void AddInactiveHDChain(const CHDChain& chain);
238    const CHDChain& GetHDChain() const { return m_hd_chain; }
239
240    //! Fetches a pubkey from mapWatchKeys if it exists there
241    bool GetWatchPubKey(const CKeyID &address, CPubKey &pubkey_out) const;
242
243    /**
244     * Retrieves scripts that were imported by bugs into the legacy spkm and are
245     * simply invalid, such as a sh(sh(pkh())) script, or not watched.
246     */
247    std::unordered_set<CScript, SaltedSipHasher> GetNotMineScriptPubKeys() const;
248
249    /** Get the DescriptorScriptPubKeyMans (with private keys) that have the same scriptPubKeys as this LegacyDataSPKM.
250     * Does not modify this LegacyDataSPKM. */