251    std::optional<MigrationData> MigrateToDescriptor();
252    /** Delete the legacy wallet records from disk. */
253    bool DeleteRecordsWithDB(WalletBatch& batch);
254};
255
256/** SigningProvider wrapper for LegacyDataSPKM that does not provide private keys. */
257class LegacySigningProvider : public SigningProvider
258{
259private:
260    const LegacyDataSPKM& m_spk_man;
261public:
262    explicit LegacySigningProvider(const LegacyDataSPKM& spk_man) : m_spk_man(spk_man) {}
263
264    bool GetCScript(const CScriptID &scriptid, CScript& script) const override { return m_spk_man.GetCScript(scriptid, script); }
265    bool HaveCScript(const CScriptID &scriptid) const override { return m_spk_man.HaveCScript(scriptid); }
266    bool GetPubKey(const CKeyID &address, CPubKey& pubkey) const override { return m_spk_man.GetPubKey(address, pubkey); }
267    bool GetKey(const CKeyID &address, CKey& key) const override { return false; }
268    bool HaveKey(const CKeyID &address) const override { return false; }
269    bool GetKeyOrigin(const CKeyID& keyid, KeyOriginInfo& info) const override { return m_spk_man.GetKeyOrigin(keyid, info); }
270};
271
272class DescriptorScriptPubKeyMan : public ScriptPubKeyMan
273{
274private:
275    using ScriptPubKeyMap = std::map<CScript, int32_t>; // Map of scripts to descriptor range index
276    using PubKeyMap = std::map<CPubKey, int32_t>; // Map of pubkeys involved in scripts to descriptor range index
277
278    ScriptPubKeyMap m_map_script_pub_keys GUARDED_BY(cs_desc_man);
279    PubKeyMap m_map_pubkeys GUARDED_BY(cs_desc_man);
280    int32_t m_max_cached_index = -1;
281
282    KeyMap m_map_keys GUARDED_BY(cs_desc_man);
283    CryptedKeyMap m_map_crypted_keys GUARDED_BY(cs_desc_man);
284
285    //! keeps track of whether Unlock has run a thorough check before
286    bool m_decryption_thoroughly_checked = false;
287
288    //! Number of pre-generated keys/scripts (part of the look-ahead process, used to detect payments)
289    int64_t m_keypool_size GUARDED_BY(cs_desc_man){DEFAULT_KEYPOOL_SIZE};
290
291    /** Map of a session id to MuSig2 secnonce
292     *
293     * Stores MuSig2 secnonces while the MuSig2 signing session is still ongoing.
294     * Note that these secnonces must not be reused. In order to avoid being tricked into
295     * reusing a nonce, this map is held only in memory and must not be written to disk.
296     * The side effect is that signing sessions cannot persist across restarts, but this
297     * must be done in order to prevent nonce reuse.
298     *
299     * The session id is an arbitrary value set by the signer in order for the signing logic
300     * to find ongoing signing sessions, see MuSig2SessionID.
301     */
302    mutable std::map<uint256, MuSig2SecNonce> m_musig2_secnonces;
303
304    const uint256 m_id;
305
306    bool AddDescriptorKeyWithDB(WalletBatch& batch, const CKey& key, const CPubKey &pubkey) EXCLUSIVE_LOCKS_REQUIRED(cs_desc_man);
307
308    KeyMap GetKeys() const EXCLUSIVE_LOCKS_REQUIRED(cs_desc_man);
309
310    // Cached FlatSigningProviders to avoid regenerating them each time they are needed.
311    mutable std::map<int32_t, FlatSigningProvider> m_map_signing_providers;
312    // Fetch the SigningProvider for the given script and optionally include private keys
313    std::unique_ptr<FlatSigningProvider> GetSigningProvider(const CScript& script, bool include_private = false) const;
314    // Fetch the SigningProvider for a given index and optionally include private keys. Called by the above functions.
315    std::unique_ptr<FlatSigningProvider> GetSigningProvider(int32_t index, bool include_private = false) const EXCLUSIVE_LOCKS_REQUIRED(cs_desc_man);
316
317    void Load();
318
319    void UpdateWithSigningProvider(WalletBatch& batch, const FlatSigningProvider& signing_provider) EXCLUSIVE_LOCKS_REQUIRED(cs_desc_man);
320
321protected:
322    //! Create a DescriptorScriptPubKeyMan from existing data (i.e. during loading)
323    DescriptorScriptPubKeyMan(WalletStorage& storage, const uint256& id, WalletDescriptor& descriptor, int64_t keypool_size, const KeyMap& keys, const CryptedKeyMap& ckeys);
324
325    //! Create a new DescriptorScriptPubKeyMan from a descriptor (e.g. from an import, newly generated)
326    DescriptorScriptPubKeyMan(WalletStorage& storage, WalletDescriptor& descriptor, int64_t keypool_size)
327        : ScriptPubKeyMan(storage),
328        m_keypool_size(keypool_size),
329        m_id(CompatDescriptorHash(*descriptor.descriptor)),
330        m_wallet_descriptor(descriptor)
331    {}
332
333    WalletDescriptor m_wallet_descriptor GUARDED_BY(cs_desc_man);
334    void IncIndex() EXCLUSIVE_LOCKS_REQUIRED(cs_desc_man);
335    void DecIndex() EXCLUSIVE_LOCKS_REQUIRED(cs_desc_man);
336    void SetRangeEnd(int32_t end) EXCLUSIVE_LOCKS_REQUIRED(cs_desc_man);
337
338    //! Same as 'TopUp' but designed for use within a batch transaction context
339    bool TopUpWithDB(WalletBatch& batch, unsigned int size = 0);
340
341public:
342    static std::unique_ptr<DescriptorScriptPubKeyMan> LoadFromStorage(WalletStorage& storage, const uint256& id, WalletDescriptor& descriptor, int64_t keypool_size, const KeyMap& keys, const CryptedKeyMap& ckeys);
343    static std::unique_ptr<DescriptorScriptPubKeyMan> CreateFromImport(WalletStorage& storage, WalletDescriptor& descriptor, int64_t keypool_size, const FlatSigningProvider& provider);
344    static std::unique_ptr<DescriptorScriptPubKeyMan> CreateFromMigration(WalletStorage& storage, WalletBatch& batch, WalletDescriptor& descriptor, int64_t keypool_size, const FlatSigningProvider& provider);
345    static std::unique_ptr<DescriptorScriptPubKeyMan> GenerateNewSingleSig(WalletStorage& storage, WalletBatch& batch, int64_t keypool_size, const CExtKey& master_key, OutputType addr_type, bool internal);
346
347    mutable RecursiveMutex cs_desc_man;
348
349    util::Result<CTxDestination> GetNewDestination(OutputType type) override;
350    bool IsMine(const CScript& script) const override;
351
352    bool CheckDecryptionKey(const CKeyingMaterial& master_key) override;
353    bool Encrypt(const CKeyingMaterial& master_key, WalletBatch* batch) override;
354
355    util::Result<CTxDestination> GetReservedDestination(OutputType type, bool internal, int64_t& index) override;
356    void ReturnDestination(int64_t index, bool internal, const CTxDestination& addr) override;
357
358    // Tops up the descriptor cache and m_map_script_pub_keys. The cache is stored in the wallet file
359    // and is used to expand the descriptor in GetNewDestination. Descriptor wallets rely more on
360    // ephemeral data than legacy wallets. For wallets using unhardened derivation
361    // (with or without private keys), the "keypool" is a single xpub.
362    bool TopUp(unsigned int size = 0) override;
363
364    std::vector<WalletDestination> MarkUnusedAddresses(const CScript& script) override;
365
366    bool IsHDEnabled() const override;
367
368    bool HavePrivateKeys() const override;
369    bool HasPrivKey(const CKeyID& keyid) const EXCLUSIVE_LOCKS_REQUIRED(cs_desc_man);
370    //! Retrieve the particular key if it is available. Returns nullopt if the key is not in the wallet, or if the wallet is locked.
371    std::optional<CKey> GetKey(const CKeyID& keyid) const EXCLUSIVE_LOCKS_REQUIRED(cs_desc_man);
372    bool HaveCryptedKeys() const override;
373
374    unsigned int GetKeyPoolSize() const override;
375
376    int64_t GetTimeFirstKey() const override;
377
378    std::unique_ptr<CKeyMetadata> GetMetadata(const CTxDestination& dest) const override;
379
380    bool CanGetAddresses(bool internal = false) const override;
381
382    std::unique_ptr<SigningProvider> GetSolvingProvider(const CScript& script) const override;
383
384    bool CanProvide(const CScript& script, SignatureData& sigdata) override;
385
386    // Fetch the SigningProvider for the given pubkey and always include private keys. This should only be called by signing code.
387    std::unique_ptr<FlatSigningProvider> GetSigningProvider(const CPubKey& pubkey) const;
388
389    bool SignTransaction(CMutableTransaction& tx, const std::map<COutPoint, Coin>& coins, int sighash, std::map<int, bilingual_str>& input_errors) const override;
390    SigningResult SignMessage(const std::string& message, const PKHash& pkhash, std::string& str_sig) const override;
391    std::optional<common::PSBTError> FillPSBT(PartiallySignedTransaction& psbt, const PrecomputedTransactionData& txdata, const common::PSBTFillOptions& options, int* n_signed = nullptr) const override;
392
393    uint256 GetID() const override;
394
395    bool HasWalletDescriptor(const WalletDescriptor& desc) const;
396    util::Result<void> UpdateWalletDescriptor(WalletDescriptor& descriptor, const FlatSigningProvider& provider);
397    bool CanUpdateToWalletDescriptor(const WalletDescriptor& descriptor, std::string& error);
398    void WriteDescriptor();
399
400    WalletDescriptor GetWalletDescriptor() const EXCLUSIVE_LOCKS_REQUIRED(cs_desc_man);
401    std::unordered_set<CScript, SaltedSipHasher> GetScriptPubKeys() const override;
402    std::unordered_set<CScript, SaltedSipHasher> GetScriptPubKeys(int32_t minimum_index) const;
403    int32_t GetEndRange() const;
404
405    [[nodiscard]] bool GetDescriptorString(std::string& out, bool priv) const;
406
407    void UpgradeDescriptorCache();
408};
409
410/** struct containing information needed for migrating legacy wallets to descriptor wallets */
411struct MigrationData
412{
413    CExtKey master_key;
414    std::vector<std::pair<std::string, int64_t>> watch_descs;
415    std::vector<std::pair<std::string, int64_t>> solvable_descs;
416    std::vector<std::unique_ptr<DescriptorScriptPubKeyMan>> desc_spkms;
417    std::shared_ptr<CWallet> watchonly_wallet{nullptr};
418    std::shared_ptr<CWallet> solvable_wallet{nullptr};
419};
420
421} // namespace wallet
422
423#endif // BITCOIN_WALLET_SCRIPTPUBKEYMAN_H
424