src/wallet/walletdb.h

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2015 The Bitcoin Core developers
   3 // Distributed under the MIT software license, see the accompanying
   4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   5
   6 #ifndef BITCOIN_WALLET_WALLETDB_H
   7 #define BITCOIN_WALLET_WALLETDB_H
   8
   9 #include "amount.h"
  10 #include "primitives/transaction.h"
  11 #include "wallet/db.h"
  12 #include "key.h"
  13
  14 #include <list>
  15 #include <stdint.h>
  16 #include <string>
  17 #include <utility>
  18 #include <vector>
  19
  20 static const bool DEFAULT_FLUSHWALLET = true;
  21
  22 class CAccount;
  23 class CAccountingEntry;
  24 struct CBlockLocator;
  25 class CKeyPool;
  26 class CMasterKey;
  27 class CScript;
  28 class CWallet;
  29 class CWalletTx;
  30 class uint160;
  31 class uint256;
  32
  33 /** Error statuses for the wallet database */
  34 enum DBErrors
  35 {
  36     DB_LOAD_OK,
  37     DB_CORRUPT,
  38     DB_NONCRITICAL_ERROR,
  39     DB_TOO_NEW,
  40     DB_LOAD_FAIL,
  41     DB_NEED_REWRITE
  42 };
  43
  44 /* simple HD chain data model */
  45 class CHDChain
  46 {
  47 public:
  48     uint32_t nExternalChainCounter;
  49     CKeyID masterKeyID; //!< master key hash160
  50
  51     static const int CURRENT_VERSION = 1;
  52     int nVersion;
  53
  54     CHDChain() { SetNull(); }
  55     ADD_SERIALIZE_METHODS;
  56     template <typename Stream, typename Operation>
  57     inline void SerializationOp(Stream& s, Operation ser_action)
  58     {
  59         READWRITE(this->nVersion);
  60         READWRITE(nExternalChainCounter);
  61         READWRITE(masterKeyID);
  62     }
  63
  64     void SetNull()
  65     {
  66         nVersion = CHDChain::CURRENT_VERSION;
  67         nExternalChainCounter = 0;
  68         masterKeyID.SetNull();
  69     }
  70 };
  71
  72 class CKeyMetadata
  73 {
  74 public:
  75     static const int VERSION_BASIC=1;
  76     static const int VERSION_WITH_HDDATA=10;
  77     static const int CURRENT_VERSION=VERSION_WITH_HDDATA;
  78     int nVersion;
  79     int64_t nCreateTime; // 0 means unknown
  80     std::string hdKeypath; //optional HD/bip32 keypath
  81     CKeyID hdMasterKeyID; //id of the HD masterkey used to derive this key
  82
  83     CKeyMetadata()
  84     {
  85         SetNull();
  86     }
  87     CKeyMetadata(int64_t nCreateTime_)
  88     {
  89         SetNull();
  90         nCreateTime = nCreateTime_;
  91     }
  92
  93     ADD_SERIALIZE_METHODS;
  94
  95     template <typename Stream, typename Operation>
  96     inline void SerializationOp(Stream& s, Operation ser_action) {
  97         READWRITE(this->nVersion);
  98         READWRITE(nCreateTime);
  99         if (this->nVersion >= VERSION_WITH_HDDATA)
 100         {
 101             READWRITE(hdKeypath);
 102             READWRITE(hdMasterKeyID);
 103         }
 104     }
 105
 106     void SetNull()
 107     {
 108         nVersion = CKeyMetadata::CURRENT_VERSION;
 109         nCreateTime = 0;
 110         hdKeypath.clear();
 111         hdMasterKeyID.SetNull();
 112     }
 113 };
 114
 115 /** Access to the wallet database */
 116 class CWalletDB : public CDB
 117 {
 118 public:
 119     CWalletDB(const std::string& strFilename, const char* pszMode = "r+", bool fFlushOnClose = true) : CDB(strFilename, pszMode, fFlushOnClose)
 120     {
 121     }
 122
 123     bool WriteName(const std::string& strAddress, const std::string& strName);
 124     bool EraseName(const std::string& strAddress);
 125
 126     bool WritePurpose(const std::string& strAddress, const std::string& purpose);
 127     bool ErasePurpose(const std::string& strAddress);
 128
 129     bool WriteTx(const CWalletTx& wtx);
 130     bool EraseTx(uint256 hash);
 131
 132     bool WriteKey(const CPubKey& vchPubKey, const CPrivKey& vchPrivKey, const CKeyMetadata &keyMeta);
 133     bool WriteCryptedKey(const CPubKey& vchPubKey, const std::vector<unsigned char>& vchCryptedSecret, const CKeyMetadata &keyMeta);
 134     bool WriteMasterKey(unsigned int nID, const CMasterKey& kMasterKey);
 135
 136     bool WriteCScript(const uint160& hash, const CScript& redeemScript);
 137
 138     bool WriteWatchOnly(const CScript &script);
 139     bool EraseWatchOnly(const CScript &script);
 140
 141     bool WriteBestBlock(const CBlockLocator& locator);
 142     bool ReadBestBlock(CBlockLocator& locator);
 143
 144     bool WriteOrderPosNext(int64_t nOrderPosNext);
 145
 146     bool WriteDefaultKey(const CPubKey& vchPubKey);
 147
 148     bool ReadPool(int64_t nPool, CKeyPool& keypool);
 149     bool WritePool(int64_t nPool, const CKeyPool& keypool);
 150     bool ErasePool(int64_t nPool);
 151
 152     bool WriteMinVersion(int nVersion);
 153
 154     /// This writes directly to the database, and will not update the CWallet's cached accounting entries!
 155     /// Use wallet.AddAccountingEntry instead, to write *and* update its caches.
 156     bool WriteAccountingEntry(const uint64_t nAccEntryNum, const CAccountingEntry& acentry);
 157     bool WriteAccountingEntry_Backend(const CAccountingEntry& acentry);
 158     bool ReadAccount(const std::string& strAccount, CAccount& account);
 159     bool WriteAccount(const std::string& strAccount, const CAccount& account);
 160
 161     /// Write destination data key,value tuple to database
 162     bool WriteDestData(const std::string &address, const std::string &key, const std::string &value);
 163     /// Erase destination data tuple from wallet database
 164     bool EraseDestData(const std::string &address, const std::string &key);
 165
 166     CAmount GetAccountCreditDebit(const std::string& strAccount);
 167     void ListAccountCreditDebit(const std::string& strAccount, std::list<CAccountingEntry>& acentries);
 168
 169     DBErrors LoadWallet(CWallet* pwallet);
 170     DBErrors FindWalletTx(CWallet* pwallet, std::vector<uint256>& vTxHash, std::vector<CWalletTx>& vWtx);
 171     DBErrors ZapWalletTx(CWallet* pwallet, std::vector<CWalletTx>& vWtx);
 172     DBErrors ZapSelectTx(CWallet* pwallet, std::vector<uint256>& vHashIn, std::vector<uint256>& vHashOut);
 173     static bool Recover(CDBEnv& dbenv, const std::string& filename, bool fOnlyKeys);
 174     static bool Recover(CDBEnv& dbenv, const std::string& filename);
 175
 176     //! write the hdchain model (external chain child index counter)
 177     bool WriteHDChain(const CHDChain& chain);
 178
 179 private:
 180     CWalletDB(const CWalletDB&);
 181     void operator=(const CWalletDB&);
 182
 183 };
 184
 185 void ThreadFlushWalletDB(const std::string& strFile);
 186
 187 #endif // BITCOIN_WALLET_WALLETDB_H