text: // Copyright (c) 2009-2017 Satoshi Nakamoto
  // Copyright (c) 2009-2017 The Bitcoin Developers
  // Copyright (c) 2014-2017 The Dash Core Developers
  // Copyright (c) 2017 Credits Developers
  // Distributed under the MIT/X11 software license, see the accompanying
  // file COPYING or http://www.opensource.org/licenses/mit-license.php.
  
  #ifndef CREDITS_WALLET_WALLETDB_H
  #define CREDITS_WALLET_WALLETDB_H
  
  #include "amount.h"
  #include "wallet/db.h"
  #include "hdchain.h"
  #include "key.h"
  
  #include <list>
  #include <stdint.h>
  #include <string>
  #include <utility>
  #include <vector>
  
  static const bool DEFAULT_FLUSHWALLET = true;
  
  class CAccount;
  class CAccountingEntry;
  class CKeyPool;
  class CMasterKey;
  class CScript;
  class CWallet;
  class CWalletTx;
  class uint160;
  class uint256;
  
  struct CBlockLocator;
  
  /** Error statuses for the wallet database */
  enum DBErrors
  {
      DB_LOAD_OK,
      DB_CORRUPT,
      DB_NONCRITICAL_ERROR,
      DB_TOO_NEW,
      DB_LOAD_FAIL,
      DB_NEED_REWRITE
  };
  
  class CKeyMetadata
  {
  public:
      static const int CURRENT_VERSION=1;        
      int nVersion;
      int64_t nCreateTime; // 0 means unknown
  
      CKeyMetadata()
      {
          SetNull();
      }
      CKeyMetadata(int64_t nCreateTime_)
      {
          SetNull();
          nCreateTime = nCreateTime_;
      }
  
      ADD_SERIALIZE_METHODS;
  
      template <typename Stream, typename Operation>
      inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
          READWRITE(this->nVersion);
          nVersion = this->nVersion;
          READWRITE(nCreateTime);
      }
  
      void SetNull()
      {
          nVersion = CKeyMetadata::CURRENT_VERSION;
          nCreateTime = 0;
      }
  };
  
  /** Access to the wallet database (wallet.dat) */
  class CWalletDB : public CDB
  {
  public:
      CWalletDB(const std::string& strFilename, const char* pszMode = "r+", bool fFlushOnClose = true) : CDB(strFilename, pszMode, fFlushOnClose)
      {
      }
  
      bool WriteName(const std::string& strAddress, const std::string& strName);
      bool EraseName(const std::string& strAddress);
  
      bool WritePurpose(const std::string& strAddress, const std::string& purpose);
      bool ErasePurpose(const std::string& strAddress);
  
      bool WriteTx(uint256 hash, const CWalletTx& wtx);
      bool EraseTx(uint256 hash);
  
      bool WriteKey(const CPubKey& vchPubKey, const CPrivKey& vchPrivKey, const CKeyMetadata &keyMeta);
      bool WriteCryptedKey(const CPubKey& vchPubKey, const std::vector<unsigned char>& vchCryptedSecret, const CKeyMetadata &keyMeta);
      bool WriteMasterKey(unsigned int nID, const CMasterKey& kMasterKey);
  
      bool WriteCScript(const uint160& hash, const CScript& redeemScript);
  
      bool WriteWatchOnly(const CScript &script);
      bool EraseWatchOnly(const CScript &script);
  
      bool WriteBestBlock(const CBlockLocator& locator);
      bool ReadBestBlock(CBlockLocator& locator);
  
      bool WriteOrderPosNext(int64_t nOrderPosNext);
  
      bool WriteDefaultKey(const CPubKey& vchPubKey);
  
      bool ReadPool(int64_t nPool, CKeyPool& keypool);
      bool WritePool(int64_t nPool, const CKeyPool& keypool);
      bool ErasePool(int64_t nPool);
  
      bool WriteMinVersion(int nVersion);
  
      /// This writes directly to the database, and will not update the CWallet's cached accounting entries!
      /// Use wallet.AddAccountingEntry instead, to write *and* update its caches.
      bool WriteAccountingEntry_Backend(const CAccountingEntry& acentry);
      bool ReadAccount(const std::string& strAccount, CAccount& account);
      bool WriteAccount(const std::string& strAccount, const CAccount& account);
  
      /// Write destination data key,value tuple to database
      bool WriteDestData(const std::string &address, const std::string &key, const std::string &value);
      /// Erase destination data tuple from wallet database
      bool EraseDestData(const std::string &address, const std::string &key);
  
      CAmount GetAccountCreditDebit(const std::string& strAccount);
      void ListAccountCreditDebit(const std::string& strAccount, std::list<CAccountingEntry>& acentries);
  
      DBErrors ReorderTransactions(CWallet* pwallet);
      DBErrors LoadWallet(CWallet* pwallet);
      DBErrors FindWalletTx(CWallet* pwallet, std::vector<uint256>& vTxHash, std::vector<CWalletTx>& vWtx);
      DBErrors ZapWalletTx(CWallet* pwallet, std::vector<CWalletTx>& vWtx);
      static bool Recover(CDBEnv& dbenv, const std::string& filename, bool fOnlyKeys);
      static bool Recover(CDBEnv& dbenv, const std::string& filename);
  
      //! write the hdchain model (external chain child index counter)
      bool WriteHDChain(const CHDChain& chain);
      bool WriteCryptedHDChain(const CHDChain& chain);
      bool WriteHDPubKey(const CHDPubKey& hdPubKey, const CKeyMetadata& keyMeta);
  
  private:
      CWalletDB(const CWalletDB&);
      void operator=(const CWalletDB&);
  
      bool WriteAccountingEntry(const uint64_t nAccEntryNum, const CAccountingEntry& acentry);
  };
  
  bool BackupWallet(const CWallet& wallet, const std::string& strDest);
  void ThreadFlushWalletDB(const std::string& strFile);
  
  bool AutoBackupWallet (CWallet* wallet, std::string strWalletFile, std::string& strBackupWarning, std::string& strBackupError);
  
  #endif // CREDITS_WALLET_WALLETDB_H
  