scriptpubkeyman.h

Go to the documentation of this file.

// Copyright (c) 2019 The Bitcoin Core developers
// Copyright (c) 2020-2021 The PIVX Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef PIVX_WALLET_SCRIPTPUBKEYMAN_H
#define PIVX_WALLET_SCRIPTPUBKEYMAN_H
 
#include "wallet/hdchain.h"
#include "wallet/wallet.h"
#include "wallet/walletdb.h"
 
static const unsigned int DEFAULT_KEYPOOL_SIZE = 100;
static const uint32_t BIP32_HARDENED_KEY_LIMIT = 0x80000000;
 
/*
 * A class implementing ScriptPubKeyMan manages some (or all) scriptPubKeys used in a wallet.
 * It contains the scripts and keys related to the scriptPubKeys it manages.
 * A ScriptPubKeyMan will be able to give out scriptPubKeys to be used, as well as marking
 * when a scriptPubKey has been used. It also handles when and how to store a scriptPubKey
 * and its related scripts and keys, including encryption.
 */
class ScriptPubKeyMan {
 
public:
    explicit ScriptPubKeyMan(CWallet* parent) : wallet(parent) {}
    ~ScriptPubKeyMan() {};
 
    /* Set the HD chain model (chain child index counters) */
    void SetHDChain(CHDChain& chain, bool memonly);
    const CHDChain& GetHDChain() const { return hdChain; }
 
    bool SetupGeneration(bool newKeypool = true, bool force = false, bool memOnly = false);
 
    bool Upgrade(const int prev_version, std::string& error);
 
    /* Returns true if the wallet can generate new keys */
    bool CanGenerateKeys();
 
    /* True is HD wallet is enabled */
    bool IsHDEnabled() const;
 
    /* Return the oldest key time */
    int64_t GetOldestKeyPoolTime();
 
    /* Count external keypool available keys */
    size_t KeypoolCountExternalKeys();
 
    /* Key pool size */
    unsigned int GetKeyPoolSize() const;
 
    /* Staking key pool size */
    unsigned int GetStakingKeyPoolSize() const;
 
    /* Whether the wallet has or not keys in the pool */
    bool CanGetAddresses(const uint8_t& type = HDChain::ChangeType::EXTERNAL);
 
    /* Generates a new HD seed (will not be activated) */
    CPubKey GenerateNewSeed();
 
    /* Derives a new HD seed (will not be activated) */
    CPubKey DeriveNewSeed(const CKey& key);
 
    /* 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
      caller must ensure the current wallet version is correct before calling
      this function). */
    void SetHDSeed(const CPubKey& key, bool force = false, bool memOnly = false);
 
    void LoadKeyPool(int64_t nIndex, const CKeyPool &keypool);
    bool NewKeyPool();
    void MarkPreSplitKeys();
 
    bool TopUp(unsigned int size = 0);
 
    void MarkUnusedAddresses(const CScript& script);
 
    void UpdateTimeFirstKey(int64_t nCreateTime);
    CPubKey GenerateNewKey(WalletBatch& batch, const uint8_t& type = HDChain::ChangeType::EXTERNAL);
 
 
    bool GetKeyFromPool(CPubKey &key, const uint8_t& changeType = HDChain::ChangeType::EXTERNAL);
    bool GetReservedKey(const uint8_t& changeType, int64_t& index, CKeyPool& keypool);
 
    const std::map<CKeyID, int64_t>& GetAllReserveKeys() const { return m_pool_key_to_index; }
    bool ReserveKeyFromKeyPool(int64_t& nIndex, CKeyPool& keypool, const uint8_t& type = HDChain::ChangeType::EXTERNAL);
 
    void KeepDestination(int64_t index);
    void ReturnDestination(int64_t index, const uint8_t& type, const CTxDestination&);
 
    // TODO: This is public for now but shouldn't be here.
    std::set<int64_t> set_pre_split_keypool;
 
private:
    /* Parent wallet */
    CWallet* wallet{nullptr};
    /* the HD chain data model (external/internal chain counters) */
    CHDChain hdChain;
 
    /* TODO: This has not been implemented yet.. */
    WalletBatch *encrypted_batch = nullptr;
 
    // Key pool maps
    std::set<int64_t> setInternalKeyPool;
    std::set<int64_t> setExternalKeyPool;
    std::set<int64_t> setStakingKeyPool;
    int64_t m_max_keypool_index = 0;
    std::map<CKeyID, int64_t> m_pool_key_to_index;
    // Tracks keypool indexes to CKeyIDs of keys that have been taken out of the keypool but may be returned to it
    std::map<int64_t, CKeyID> m_index_to_reserved_key;
 
    /* */
    bool AddKeyPubKeyInner(const CKey& key, const CPubKey &pubkey);
 
    bool AddKeyPubKeyWithDB(WalletBatch &batch,const CKey& key, const CPubKey &pubkey);
    /* Complete me */
    void AddKeypoolPubkeyWithDB(const CPubKey& pubkey, const uint8_t& type, WalletBatch& batch);
    void GeneratePool(WalletBatch& batch, int64_t targetSize, const uint8_t& type);
 
    /* HD derive new child key (on internal or external chain) */
    void DeriveNewChildKey(WalletBatch &batch, CKeyMetadata& metadata, CKey& secret, const uint8_t& type = HDChain::ChangeType::EXTERNAL);
 
    void MarkReserveKeysAsUsed(int64_t keypool_id);
};
 
 
#endif // PIVX_WALLET_SCRIPTPUBKEYMAN_H