Differential D7147 Diff 22791 src/wallet/scriptpubkeyman.h

Changeset View

Standalone View

src/wallet/scriptpubkeyman.h

Show First 20 Lines • Show All 153 Lines • ▼ Show 20 Lines

public:		public:
ScriptPubKeyMan(WalletStorage &storage) : m_storage(storage) {}		ScriptPubKeyMan(WalletStorage &storage) : m_storage(storage) {}
};		};

class LegacyScriptPubKeyMan : public ScriptPubKeyMan,		class LegacyScriptPubKeyMan : public ScriptPubKeyMan,
public FillableSigningProvider {		public FillableSigningProvider {
private:		private:
using CryptedKeyMap =
std::map<CKeyID, std::pair<CPubKey, std::vector<uint8_t>>>;
using WatchOnlySet = std::set<CScript>;		using WatchOnlySet = std::set<CScript>;
using WatchKeyMap = std::map<CKeyID, CPubKey>;		using WatchKeyMap = std::map<CKeyID, CPubKey>;

//! will encrypt previously unencrypted keys		WalletBatch *encrypted_batch GUARDED_BY(cs_wallet) = nullptr;
bool EncryptKeys(CKeyingMaterial &vMasterKeyIn);
		using CryptedKeyMap =
		std::map<CKeyID, std::pair<CPubKey, std::vector<uint8_t>>>;

CryptedKeyMap mapCryptedKeys GUARDED_BY(cs_KeyStore);		CryptedKeyMap mapCryptedKeys GUARDED_BY(cs_KeyStore);
WatchOnlySet setWatchOnly GUARDED_BY(cs_KeyStore);		WatchOnlySet setWatchOnly GUARDED_BY(cs_KeyStore);
WatchKeyMap mapWatchKeys GUARDED_BY(cs_KeyStore);		WatchKeyMap mapWatchKeys GUARDED_BY(cs_KeyStore);

		int64_t nTimeFirstKey GUARDED_BY(cs_wallet) = 0;

		bool AddKeyPubKeyInner(const CKey &key, const CPubKey &pubkey);
bool AddCryptedKeyInner(const CPubKey &vchPubKey,		bool AddCryptedKeyInner(const CPubKey &vchPubKey,
const std::vector<uint8_t> &vchCryptedSecret);		const std::vector<uint8_t> &vchCryptedSecret);
bool AddKeyPubKeyInner(const CKey &key, const CPubKey &pubkey);

WalletBatch *encrypted_batch GUARDED_BY(cs_wallet) = nullptr;

/* the HD chain data model (external chain counters) */
CHDChain hdChain;

/* HD derive new child key (on internal or external chain) */
void DeriveNewChildKey(WalletBatch &batch, CKeyMetadata &metadata,
CKey &secret, bool internal = false)
EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

std::set<int64_t> setInternalKeyPool GUARDED_BY(cs_wallet);
std::set<int64_t> setExternalKeyPool GUARDED_BY(cs_wallet);
std::set<int64_t> set_pre_split_keypool GUARDED_BY(cs_wallet);
int64_t m_max_keypool_index GUARDED_BY(cs_wallet) = 0;
std::map<CKeyID, int64_t> m_pool_key_to_index;

int64_t nTimeFirstKey GUARDED_BY(cs_wallet) = 0;

/**		/**
* Private version of AddWatchOnly method which does not accept a		* Private version of AddWatchOnly method which does not accept a
* timestamp, and which will reset the wallet's nTimeFirstKey value to 1 if		* timestamp, and which will reset the wallet's nTimeFirstKey value to 1 if
* the watch key did not previously have a timestamp associated with it.		* the watch key did not previously have a timestamp associated with it.
* Because this is an inherited virtual method, it is accessible despite		* Because this is an inherited virtual method, it is accessible despite
* being marked private, but it is marked private anyway to encourage use		* being marked private, but it is marked private anyway to encourage use
* of the other AddWatchOnly which accepts a timestamp and sets		* of the other AddWatchOnly which accepts a timestamp and sets
* nTimeFirstKey more intelligently for more efficient rescans.		* nTimeFirstKey more intelligently for more efficient rescans.
*/		*/
bool AddWatchOnly(const CScript &dest) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);		bool AddWatchOnly(const CScript &dest) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
bool AddWatchOnlyWithDB(WalletBatch &batch, const CScript &dest)		bool AddWatchOnlyWithDB(WalletBatch &batch, const CScript &dest)
EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);		EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
bool AddWatchOnlyInMem(const CScript &dest);		bool AddWatchOnlyInMem(const CScript &dest);
		//! Adds a watch-only address to the store, and saves it to disk.
/** Add a KeyOriginInfo to the wallet */		bool AddWatchOnlyWithDB(WalletBatch &batch, const CScript &dest,
bool AddKeyOriginWithDB(WalletBatch &batch, const CPubKey &pubkey,		int64_t create_time)
const KeyOriginInfo &info);		EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

//! Adds a key to the store, and saves it to disk.		//! Adds a key to the store, and saves it to disk.
bool AddKeyPubKeyWithDB(WalletBatch &batch, const CKey &key,		bool AddKeyPubKeyWithDB(WalletBatch &batch, const CKey &key,
const CPubKey &pubkey)		const CPubKey &pubkey)
EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);		EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

//! Adds a watch-only address to the store, and saves it to disk.
bool AddWatchOnlyWithDB(WalletBatch &batch, const CScript &dest,
int64_t create_time)
EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

void AddKeypoolPubkeyWithDB(const CPubKey &pubkey, const bool internal,		void AddKeypoolPubkeyWithDB(const CPubKey &pubkey, const bool internal,
WalletBatch &batch);		WalletBatch &batch);

//! Adds a script to the store and saves it to disk		//! Adds a script to the store and saves it to disk
bool AddCScriptWithDB(WalletBatch &batch, const CScript &script);		bool AddCScriptWithDB(WalletBatch &batch, const CScript &script);

public:		/** Add a KeyOriginInfo to the wallet */
		bool AddKeyOriginWithDB(WalletBatch &batch, const CPubKey &pubkey,
		const KeyOriginInfo &info);

		/* the HD chain data model (external chain counters) */
		CHDChain hdChain;

		/* HD derive new child key (on internal or external chain) */
		void DeriveNewChildKey(WalletBatch &batch, CKeyMetadata &metadata,
		CKey &secret, bool internal = false)
		EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

		std::set<int64_t> setInternalKeyPool GUARDED_BY(cs_wallet);
		std::set<int64_t> setExternalKeyPool GUARDED_BY(cs_wallet);
		std::set<int64_t> set_pre_split_keypool GUARDED_BY(cs_wallet);
		int64_t m_max_keypool_index GUARDED_BY(cs_wallet) = 0;
		std::map<CKeyID, int64_t> m_pool_key_to_index;

//! Fetches a key from the keypool		//! Fetches a key from the keypool
bool GetKeyFromPool(CPubKey &key, bool internal = false);		bool GetKeyFromPool(CPubKey &key, bool internal = false);
void LoadKeyPool(int64_t nIndex, const CKeyPool &keypool)
EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);		/**
void MarkPreSplitKeys() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);		* Reserves a key from the keypool and sets nIndex to its index
		*
		* @param[out] nIndex the index of the key in keypool
		* @param[out] keypool the keypool the key was drawn from, which could be
		* the the pre-split pool if present, or the internal or external pool
		* @param fRequestedInternal true if the caller would like the key drawn
		* from the internal keypool, false if external is preferred
		*
		* @return true if succeeded, false if failed due to empty keypool
		* @throws std::runtime_error if keypool read failed, key was invalid,
		* was not found in the wallet, or was misclassified in the internal
		* or external keypool
		*/
		bool ReserveKeyFromKeyPool(int64_t &nIndex, CKeyPool &keypool,
		bool fRequestedInternal);

		void KeepKey(int64_t nIndex);
		void ReturnKey(int64_t nIndex, bool fInternal, const CPubKey &pubkey);

		public:
		bool GetNewDestination(const OutputType type, const std::string label,
		CTxDestination &dest, std::string &error);
		isminetype IsMine(const CScript &script) const;

		//! will encrypt previously unencrypted keys
		bool EncryptKeys(CKeyingMaterial &vMasterKeyIn);
		void UpgradeKeyMetadata() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

		bool IsHDEnabled() const;

		int64_t GetOldestKeyPoolTime();
		size_t KeypoolCountExternalKeys() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

		/* Returns true if the wallet can give out new addresses. This means it has
		* keys in the keypool or can generate new keys */
		jasonbcoxUnsubmitted Not Done Inline Actions Nit: comment styling jasonbcox: Nit: comment styling
		bool CanGetAddresses(bool internal = false);

// Map from Key ID to key metadata.		// Map from Key ID to key metadata.
std::map<CKeyID, CKeyMetadata> mapKeyMetadata GUARDED_BY(cs_wallet);		std::map<CKeyID, CKeyMetadata> mapKeyMetadata GUARDED_BY(cs_wallet);

// Map from Script ID to key metadata (for watch-only keys).		// Map from Script ID to key metadata (for watch-only keys).
std::map<CScriptID, CKeyMetadata> m_script_metadata GUARDED_BY(cs_wallet);		std::map<CScriptID, CKeyMetadata> m_script_metadata GUARDED_BY(cs_wallet);

/**
* keystore implementation
* Generate a new key
*/
CPubKey GenerateNewKey(WalletBatch &batch, bool internal = false)
EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
//! Adds a key to the store, and saves it to disk.		//! Adds a key to the store, and saves it to disk.
bool AddKeyPubKey(const CKey &key, const CPubKey &pubkey) override		bool AddKeyPubKey(const CKey &key, const CPubKey &pubkey) override
EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);		EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
//! Adds a key to the store, without saving it to disk (used by LoadWallet)		//! Adds a key to the store, without saving it to disk (used by LoadWallet)
bool LoadKey(const CKey &key, const CPubKey &pubkey) {		bool LoadKey(const CKey &key, const CPubKey &pubkey) {
return AddKeyPubKeyInner(key, pubkey);		return AddKeyPubKeyInner(key, pubkey);
}		}
//! Load metadata (used by LoadWallet)
void LoadKeyMetadata(const CKeyID &keyID, const CKeyMetadata &metadata)
EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
void LoadScriptMetadata(const CScriptID &script_id,
const CKeyMetadata &metadata)
EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
//! Upgrade stored CKeyMetadata objects to store key origin info as
//! KeyOriginInfo
void UpgradeKeyMetadata() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
void UpdateTimeFirstKey(int64_t nCreateTime)
EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

//! Adds an encrypted key to the store, and saves it to disk.		//! Adds an encrypted key to the store, and saves it to disk.
bool AddCryptedKey(const CPubKey &vchPubKey,		bool AddCryptedKey(const CPubKey &vchPubKey,
const std::vector<uint8_t> &vchCryptedSecret);		const std::vector<uint8_t> &vchCryptedSecret);
//! Adds an encrypted key to the store, without saving it to disk (used by		//! Adds an encrypted key to the store, without saving it to disk (used by
//! LoadWallet)		//! LoadWallet)
bool LoadCryptedKey(const CPubKey &vchPubKey,		bool LoadCryptedKey(const CPubKey &vchPubKey,
const std::vector<uint8_t> &vchCryptedSecret);		const std::vector<uint8_t> &vchCryptedSecret);
bool GetKey(const CKeyID &address, CKey &keyOut) const override;		void UpdateTimeFirstKey(int64_t nCreateTime)
bool GetPubKey(const CKeyID &address, CPubKey &vchPubKeyOut) const override;		EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
bool HaveKey(const CKeyID &address) const override;		//! Adds a CScript to the store
std::set<CKeyID> GetKeys() const override;
bool AddCScript(const CScript &redeemScript) override;
bool LoadCScript(const CScript &redeemScript);		bool LoadCScript(const CScript &redeemScript);
		//! Load metadata (used by LoadWallet)
//! Adds a watch-only address to the store, and saves it to disk.		void LoadKeyMetadata(const CKeyID &keyID, const CKeyMetadata &metadata)
bool AddWatchOnly(const CScript &dest, int64_t nCreateTime)
EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);		EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
bool RemoveWatchOnly(const CScript &dest)		void LoadScriptMetadata(const CScriptID &script_id,
		const CKeyMetadata &metadata)
EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);		EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
		//! Generate a new key
		CPubKey GenerateNewKey(WalletBatch &batch, bool internal = false)
		EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

		/* Set the HD chain model (chain child index counters) */
		void SetHDChain(const CHDChain &chain, bool memonly);
		const CHDChain &GetHDChain() const { return hdChain; }

//! Adds a watch-only address to the store, without saving it to disk (used		//! Adds a watch-only address to the store, without saving it to disk (used
//! by LoadWallet)		//! by LoadWallet)
bool LoadWatchOnly(const CScript &dest);		bool LoadWatchOnly(const CScript &dest);
//! Returns whether the watch-only script is in the wallet		//! Returns whether the watch-only script is in the wallet
bool HaveWatchOnly(const CScript &dest) const;		bool HaveWatchOnly(const CScript &dest) const;
//! Returns whether there are any watch-only things in the wallet		//! Returns whether there are any watch-only things in the wallet
bool HaveWatchOnly() const;		bool HaveWatchOnly() const;
		//! Remove a watch only script from the keystore
		bool RemoveWatchOnly(const CScript &dest)
		EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
		bool AddWatchOnly(const CScript &dest, int64_t nCreateTime)
		EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

//! Fetches a pubkey from mapWatchKeys if it exists there		//! Fetches a pubkey from mapWatchKeys if it exists there
bool GetWatchPubKey(const CKeyID &address, CPubKey &pubkey_out) const;		bool GetWatchPubKey(const CKeyID &address, CPubKey &pubkey_out) const;

		bool HaveKey(const CKeyID &address) const override;
		bool GetKey(const CKeyID &address, CKey &keyOut) const override;
		bool GetPubKey(const CKeyID &address, CPubKey &vchPubKeyOut) const override;
		bool AddCScript(const CScript &redeemScript) override;
		bool GetKeyOrigin(const CKeyID &keyid, KeyOriginInfo &info) const override;

		//! Load a keypool entry
		void LoadKeyPool(int64_t nIndex, const CKeyPool &keypool)
		EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
		bool TopUpKeyPool(unsigned int kpSize = 0);
		bool NewKeyPool();
		void MarkPreSplitKeys() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

bool ImportScripts(const std::set<CScript> scripts, int64_t timestamp)		bool ImportScripts(const std::set<CScript> scripts, int64_t timestamp)
EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);		EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
bool ImportPrivKeys(const std::map<CKeyID, CKey> &privkey_map,		bool ImportPrivKeys(const std::map<CKeyID, CKey> &privkey_map,
const int64_t timestamp)		const int64_t timestamp)
EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);		EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
bool ImportPubKeys(		bool ImportPubKeys(
const std::vector<CKeyID> &ordered_pubkeys,		const std::vector<CKeyID> &ordered_pubkeys,
const std::map<CKeyID, CPubKey> &pubkey_map,		const std::map<CKeyID, CPubKey> &pubkey_map,
const std::map<CKeyID, std::pair<CPubKey, KeyOriginInfo>> &key_origins,		const std::map<CKeyID, std::pair<CPubKey, KeyOriginInfo>> &key_origins,
const bool add_keypool, const bool internal, const int64_t timestamp)		const bool add_keypool, const bool internal, const int64_t timestamp)
EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);		EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
bool ImportScriptPubKeys(const std::string &label,		bool ImportScriptPubKeys(const std::string &label,
const std::set<CScript> &script_pub_keys,		const std::set<CScript> &script_pub_keys,
const bool have_solving_data,		const bool have_solving_data,
const bool apply_label, const int64_t timestamp)		const bool apply_label, const int64_t timestamp)
EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);		EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

bool NewKeyPool();
size_t KeypoolCountExternalKeys() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
bool TopUpKeyPool(unsigned int kpSize = 0);

/**
* Reserves a key from the keypool and sets nIndex to its index
*
* @param[out] nIndex the index of the key in keypool
* @param[out] keypool the keypool the key was drawn from, which could be
* the the pre-split pool if present, or the internal or external pool
* @param fRequestedInternal true if the caller would like the key drawn
* from the internal keypool, false if external is preferred
*
* @return true if succeeded, false if failed due to empty keypool
* @throws std::runtime_error if keypool read failed, key was invalid,
* was not found in the wallet, or was misclassified in the internal
* or external keypool
*/
bool ReserveKeyFromKeyPool(int64_t &nIndex, CKeyPool &keypool,
bool fRequestedInternal);
void KeepKey(int64_t nIndex);
void ReturnKey(int64_t nIndex, bool fInternal, const CPubKey &pubkey);
int64_t GetOldestKeyPoolTime();
/**
* Marks all keys in the keypool up to and including reserve_key as used.
*/
void MarkReserveKeysAsUsed(int64_t keypool_id)
EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
const std::map<CKeyID, int64_t> &GetAllReserveKeys() const {
return m_pool_key_to_index;
}
bool GetNewDestination(const OutputType type, const std::string label,
CTxDestination &dest, std::string &error);

isminetype IsMine(const CScript &script) const;

/* Set the HD chain model (chain child index counters) */
void SetHDChain(const CHDChain &chain, bool memonly);
const CHDChain &GetHDChain() const { return hdChain; }

/* Returns true if HD is enabled */
bool IsHDEnabled() const;

/* Returns true if the wallet can generate new keys */		/* Returns true if the wallet can generate new keys */
bool CanGenerateKeys();		bool CanGenerateKeys();

/* Returns true if the wallet can give out new addresses. This means it has
* keys in the keypool or can generate new keys */
bool CanGetAddresses(bool internal = false);

/* Generates a new HD seed (will not be activated) */		/* Generates a new HD seed (will not be activated) */
CPubKey GenerateNewSeed();		CPubKey GenerateNewSeed();

/* Derives a new HD seed (will not be activated) */		/* Derives a new HD seed (will not be activated) */
CPubKey DeriveNewSeed(const CKey &key);		CPubKey DeriveNewSeed(const CKey &key);

/* Set the current HD seed (will reset the chain child index counters)		/* Set the current HD seed (will reset the chain child index counters)
Sets the seed's version based on the current wallet version (so the		Sets the seed's version based on the current wallet version (so the
Show All 10 Lines	public:
void LearnRelatedScripts(const CPubKey &key, OutputType);		void LearnRelatedScripts(const CPubKey &key, OutputType);

/**		/**
* Same as LearnRelatedScripts, but when the OutputType is not known (and		* Same as LearnRelatedScripts, but when the OutputType is not known (and
* could be anything).		* could be anything).
*/		*/
void LearnAllRelatedScripts(const CPubKey &key);		void LearnAllRelatedScripts(const CPubKey &key);

/** Implement lookup of key origin information through wallet key metadata.		/**
		* Marks all keys in the keypool up to and including reserve_key as used.
*/		*/
bool GetKeyOrigin(const CKeyID &keyid, KeyOriginInfo &info) const override;		void MarkReserveKeysAsUsed(int64_t keypool_id)
		EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
		const std::map<CKeyID, int64_t> &GetAllReserveKeys() const {
		return m_pool_key_to_index;
		}

		std::set<CKeyID> GetKeys() const override;
// Temporary CWallet accessors and aliases.		// Temporary CWallet accessors and aliases.
friend class CWallet;		friend class CWallet;
friend class ReserveDestination;		friend class ReserveDestination;
LegacyScriptPubKeyMan(CWallet &wallet);		LegacyScriptPubKeyMan(CWallet &wallet);
bool SetCrypted();		bool SetCrypted();
bool IsCrypted() const;		bool IsCrypted() const;
void NotifyWatchonlyChanged(bool fHaveWatchOnly) const;		void NotifyWatchonlyChanged(bool fHaveWatchOnly) const;
void NotifyCanGetAddressesChanged() const;		void NotifyCanGetAddressesChanged() const;
Show All 11 Lines