src/walletdb.h

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2012 The Bitcoin developers
   3 // Distributed under the MIT/X11 software license, see the accompanying
   4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   5 #ifndef BITCOIN_WALLETDB_H
   6 #define BITCOIN_WALLETDB_H
   7
   8 #include "db.h"
   9 #include "base58.h"
  10 #include "keystore.h"
  11
  12 class CKeyPool;
  13 class CAccount;
  14 class CAccountingEntry;
  15
  16 /** Error statuses for the wallet database */
  17 enum DBErrors
  18 {
  19     DB_LOAD_OK,
  20     DB_CORRUPT,
  21     DB_NONCRITICAL_ERROR,
  22     DB_TOO_NEW,
  23     DB_LOAD_FAIL,
  24     DB_NEED_REWRITE
  25 };
  26
  27 class CKeyMetadata
  28 {
  29 public:
  30     static const int CURRENT_VERSION=1;
  31     int nVersion;
  32     int64 nCreateTime; // 0 means unknown
  33
  34     CKeyMetadata()
  35     {
  36         SetNull();
  37     }
  38     CKeyMetadata(int64 nCreateTime_)
  39     {
  40         nVersion = CKeyMetadata::CURRENT_VERSION;
  41         nCreateTime = nCreateTime_;
  42     }
  43
  44     IMPLEMENT_SERIALIZE
  45     (
  46         READWRITE(this->nVersion);
  47         nVersion = this->nVersion;
  48         READWRITE(nCreateTime);
  49     )
  50
  51     void SetNull()
  52     {
  53         nVersion = CKeyMetadata::CURRENT_VERSION;
  54         nCreateTime = 0;
  55     }
  56 };
  57
  58
  59 /** Access to the wallet database (wallet.dat) */
  60 class CWalletDB : public CDB
  61 {
  62 public:
  63     CWalletDB(std::string strFilename, const char* pszMode="r+") : CDB(strFilename.c_str(), pszMode)
  64     {
  65     }
  66 private:
  67     CWalletDB(const CWalletDB&);
  68     void operator=(const CWalletDB&);
  69 public:
  70     bool WriteName(const std::string& strAddress, const std::string& strName);
  71
  72     bool EraseName(const std::string& strAddress);
  73
  74     bool WriteTx(uint256 hash, const CWalletTx& wtx)
  75     {
  76         nWalletDBUpdated++;
  77         return Write(std::make_pair(std::string("tx"), hash), wtx);
  78     }
  79
  80     bool EraseTx(uint256 hash)
  81     {
  82         nWalletDBUpdated++;
  83         return Erase(std::make_pair(std::string("tx"), hash));
  84     }
  85
  86     bool WriteKey(const CPubKey& vchPubKey, const CPrivKey& vchPrivKey, const CKeyMetadata &keyMeta)
  87     {
  88         nWalletDBUpdated++;
  89
  90         if(!Write(std::make_pair(std::string("keymeta"), vchPubKey), keyMeta))
  91             return false;
  92
  93         return Write(std::make_pair(std::string("key"), vchPubKey.Raw()), vchPrivKey, false);
  94     }
  95
  96     bool WriteCryptedKey(const CPubKey& vchPubKey, const std::vector<unsigned char>& vchCryptedSecret, const CKeyMetadata &keyMeta)
  97     {
  98         nWalletDBUpdated++;
  99         bool fEraseUnencryptedKey = true;
 100
 101         if(!Write(std::make_pair(std::string("keymeta"), vchPubKey), keyMeta))
 102             return false;
 103
 104         if (!Write(std::make_pair(std::string("ckey"), vchPubKey.Raw()), vchCryptedSecret, false))
 105             return false;
 106         if (fEraseUnencryptedKey)
 107         {
 108             Erase(std::make_pair(std::string("key"), vchPubKey.Raw()));
 109             Erase(std::make_pair(std::string("wkey"), vchPubKey.Raw()));
 110         }
 111         return true;
 112     }
 113
 114     bool WriteMasterKey(unsigned int nID, const CMasterKey& kMasterKey)
 115     {
 116         nWalletDBUpdated++;
 117         return Write(std::make_pair(std::string("mkey"), nID), kMasterKey, true);
 118     }
 119
 120     bool WriteCScript(const uint160& hash, const CScript& redeemScript)
 121     {
 122         nWalletDBUpdated++;
 123         return Write(std::make_pair(std::string("cscript"), hash), redeemScript, false);
 124     }
 125
 126     bool WriteWatchOnly(const CScript &dest)
 127     {
 128         nWalletDBUpdated++;
 129         return Write(std::make_pair(std::string("watchs"), dest), '1');
 130     }
 131
 132     bool WriteBestBlock(const CBlockLocator& locator)
 133     {
 134         nWalletDBUpdated++;
 135         return Write(std::string("bestblock"), locator);
 136     }
 137
 138     bool ReadBestBlock(CBlockLocator& locator)
 139     {
 140         return Read(std::string("bestblock"), locator);
 141     }
 142
 143     bool WriteOrderPosNext(int64 nOrderPosNext)
 144     {
 145         nWalletDBUpdated++;
 146         return Write(std::string("orderposnext"), nOrderPosNext);
 147     }
 148
 149     bool WriteDefaultKey(const CPubKey& vchPubKey)
 150     {
 151         nWalletDBUpdated++;
 152         return Write(std::string("defaultkey"), vchPubKey.Raw());
 153     }
 154
 155     bool ReadPool(int64 nPool, CKeyPool& keypool)
 156     {
 157         return Read(std::make_pair(std::string("pool"), nPool), keypool);
 158     }
 159
 160     bool WritePool(int64 nPool, const CKeyPool& keypool)
 161     {
 162         nWalletDBUpdated++;
 163         return Write(std::make_pair(std::string("pool"), nPool), keypool);
 164     }
 165
 166     bool ErasePool(int64 nPool)
 167     {
 168         nWalletDBUpdated++;
 169         return Erase(std::make_pair(std::string("pool"), nPool));
 170     }
 171
 172     // Settings are no longer stored in wallet.dat; these are
 173     // used only for backwards compatibility:
 174     template<typename T>
 175     bool ReadSetting(const std::string& strKey, T& value)
 176     {
 177         return Read(std::make_pair(std::string("setting"), strKey), value);
 178     }
 179     template<typename T>
 180     bool WriteSetting(const std::string& strKey, const T& value)
 181     {
 182         nWalletDBUpdated++;
 183         return Write(std::make_pair(std::string("setting"), strKey), value);
 184     }
 185     bool EraseSetting(const std::string& strKey)
 186     {
 187         nWalletDBUpdated++;
 188         return Erase(std::make_pair(std::string("setting"), strKey));
 189     }
 190
 191     bool WriteMinVersion(int nVersion)
 192     {
 193         return Write(std::string("minversion"), nVersion);
 194     }
 195
 196     bool ReadAccount(const std::string& strAccount, CAccount& account);
 197     bool WriteAccount(const std::string& strAccount, const CAccount& account);
 198 private:
 199     bool WriteAccountingEntry(const uint64 nAccEntryNum, const CAccountingEntry& acentry);
 200 public:
 201     bool WriteAccountingEntry(const CAccountingEntry& acentry);
 202     int64 GetAccountCreditDebit(const std::string& strAccount);
 203     void ListAccountCreditDebit(const std::string& strAccount, std::list<CAccountingEntry>& acentries);
 204
 205     DBErrors ReorderTransactions(CWallet*);
 206     DBErrors LoadWallet(CWallet* pwallet);
 207     static bool Recover(CDBEnv& dbenv, std::string filename, bool fOnlyKeys);
 208     static bool Recover(CDBEnv& dbenv, std::string filename);
 209 };
 210
 211 #endif // BITCOIN_WALLETDB_H