-
-
Save bitmxittz/abf6a4de52af8c142fc65755f1997a52 to your computer and use it in GitHub Desktop.
Bitmxittz Source
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
source files |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// Copyright (c) 2009-2010 Satoshi Nakamoto | |
// Copyright (c) 2009-2014 The Bitcoin developers | |
// Distributed under the MIT/X11 software license, see the accompanying | |
// file COPYING or http://www.opensource.org/licenses/mit-license.php. | |
#ifndef BITCOIN_WALLET_H | |
#define BITCOIN_WALLET_H | |
#include <string> | |
#include <vector> | |
#include <stdlib.h> | |
#include "main.h" | |
#include "key.h" | |
#include "keystore.h" | |
#include "script.h" | |
#include "ui_interface.h" | |
#include "util.h" | |
#include "walletdb.h" | |
extern bool bSpendZeroConfChange; | |
class CAccountingEntry; | |
class CWalletTx; | |
class CReserveKey; | |
class COutput; | |
class CCoinControl; | |
/** (client) version numbers for particular wallet features */ | |
enum WalletFeature | |
{ | |
FEATURE_BASE = 10500, // the earliest version new wallets supports (only useful for getinfo's clientversion output) | |
FEATURE_WALLETCRYPT = 40000, // wallet encryption | |
FEATURE_COMPRPUBKEY = 60000, // compressed public keys | |
FEATURE_LATEST = 60000 | |
}; | |
/** A key pool entry */ | |
class CKeyPool | |
{ | |
public: | |
int64 nTime; | |
CPubKey vchPubKey; | |
CKeyPool() | |
{ | |
nTime = GetTime(); | |
} | |
CKeyPool(const CPubKey& vchPubKeyIn) | |
{ | |
nTime = GetTime(); | |
vchPubKey = vchPubKeyIn; | |
} | |
IMPLEMENT_SERIALIZE | |
( | |
if (!(nType & SER_GETHASH)) | |
READWRITE(nVersion); | |
READWRITE(nTime); | |
READWRITE(vchPubKey); | |
) | |
}; | |
/** A CWallet is an extension of a keystore, which also maintains a set of transactions and balances, | |
* and provides the ability to create new transactions. | |
*/ | |
class CWallet : public CCryptoKeyStore | |
{ | |
private: | |
bool SelectCoins(int64 nTargetValue, std::set<std::pair<const CWalletTx*,unsigned int> >& setCoinsRet, int64& nValueRet, const CCoinControl *coinControl=NULL) const; | |
CWalletDB *pwalletdbEncryption; | |
// the current wallet version: clients below this version are not able to load the wallet | |
int nWalletVersion; | |
// the maximum wallet format version: memory-only variable that specifies to what version this wallet may be upgraded | |
int nWalletMaxVersion; | |
public: | |
mutable CCriticalSection cs_wallet; | |
bool fFileBacked; | |
std::string strWalletFile; | |
std::set<int64> setKeyPool; | |
typedef std::map<unsigned int, CMasterKey> MasterKeyMap; | |
MasterKeyMap mapMasterKeys; | |
unsigned int nMasterKeyMaxID; | |
CWallet() | |
{ | |
nWalletVersion = FEATURE_BASE; | |
nWalletMaxVersion = FEATURE_BASE; | |
fFileBacked = false; | |
nMasterKeyMaxID = 0; | |
pwalletdbEncryption = NULL; | |
nOrderPosNext = 0; | |
} | |
CWallet(std::string strWalletFileIn) | |
{ | |
nWalletVersion = FEATURE_BASE; | |
nWalletMaxVersion = FEATURE_BASE; | |
strWalletFile = strWalletFileIn; | |
fFileBacked = true; | |
nMasterKeyMaxID = 0; | |
pwalletdbEncryption = NULL; | |
nOrderPosNext = 0; | |
} | |
std::map<uint256, CWalletTx> mapWallet; | |
int64 nOrderPosNext; | |
std::map<uint256, int> mapRequestCount; | |
std::map<CTxDestination, std::string> mapAddressBook; | |
CPubKey vchDefaultKey; | |
std::set<COutPoint> setLockedCoins; | |
// check whether we are allowed to upgrade (or already support) to the named feature | |
bool CanSupportFeature(enum WalletFeature wf) { return nWalletMaxVersion >= wf; } | |
void AvailableCoins(std::vector<COutput>& vCoins, bool fOnlyConfirmed=true, const CCoinControl *coinControl=NULL) const; | |
bool SelectCoinsMinConf(int64 nTargetValue, int nConfMine, int nConfTheirs, std::vector<COutput> vCoins, std::set<std::pair<const CWalletTx*,unsigned int> >& setCoinsRet, int64& nValueRet) const; | |
bool IsLockedCoin(uint256 hash, unsigned int n) const; | |
void LockCoin(COutPoint& output); | |
void UnlockCoin(COutPoint& output); | |
void UnlockAllCoins(); | |
void ListLockedCoins(std::vector<COutPoint>& vOutpts); | |
// keystore implementation | |
// Generate a new key | |
CPubKey GenerateNewKey(); | |
// Adds a key to the store, and saves it to disk. | |
bool AddKeyPubKey(const CKey& key, const CPubKey &pubkey); | |
// Adds a key to the store, without saving it to disk (used by LoadWallet) | |
bool LoadKey(const CKey& key, const CPubKey &pubkey) { return CCryptoKeyStore::AddKeyPubKey(key, pubkey); } | |
bool LoadMinVersion(int nVersion) { nWalletVersion = nVersion; nWalletMaxVersion = std::max(nWalletMaxVersion, nVersion); return true; } | |
// Adds an encrypted key to the store, and saves it to disk. | |
bool AddCryptedKey(const CPubKey &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret); | |
// Adds an encrypted key to the store, without saving it to disk (used by LoadWallet) | |
bool LoadCryptedKey(const CPubKey &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret); | |
bool AddCScript(const CScript& redeemScript); | |
bool LoadCScript(const CScript& redeemScript) { return CCryptoKeyStore::AddCScript(redeemScript); } | |
bool Unlock(const SecureString& strWalletPassphrase); | |
bool ChangeWalletPassphrase(const SecureString& strOldWalletPassphrase, const SecureString& strNewWalletPassphrase); | |
bool EncryptWallet(const SecureString& strWalletPassphrase); | |
/** Increment the next transaction order id | |
@return next transaction order id | |
*/ | |
int64 IncOrderPosNext(CWalletDB *pwalletdb = NULL); | |
typedef std::pair<CWalletTx*, CAccountingEntry*> TxPair; | |
typedef std::multimap<int64, TxPair > TxItems; | |
/** Get the wallet's activity log | |
@return multimap of ordered transactions and accounting entries | |
@warning Returned pointers are *only* valid within the scope of passed acentries | |
*/ | |
TxItems OrderedTxItems(std::list<CAccountingEntry>& acentries, std::string strAccount = ""); | |
void MarkDirty(); | |
bool AddToWallet(const CWalletTx& wtxIn); | |
bool AddToWalletIfInvolvingMe(const uint256 &hash, const CTransaction& tx, const CBlock* pblock, bool fUpdate = false, bool fFindBlock = false); | |
bool EraseFromWallet(uint256 hash); | |
void WalletUpdateSpent(const CTransaction& prevout); | |
int ScanForWalletTransactions(CBlockIndex* pindexStart, bool fUpdate = false); | |
void ReacceptWalletTransactions(); | |
void ResendWalletTransactions(); | |
int64 GetBalance() const; | |
int64 GetUnconfirmedBalance() const; | |
int64 GetImmatureBalance() const; | |
bool CreateTransaction(const std::vector<std::pair<CScript, int64> >& vecSend, | |
CWalletTx& wtxNew, CReserveKey& reservekey, int64& nFeeRet, std::string& strFailReason, const CCoinControl *coinControl=NULL); | |
bool CreateTransaction(CScript scriptPubKey, int64 nValue, | |
CWalletTx& wtxNew, CReserveKey& reservekey, int64& nFeeRet, std::string& strFailReason, const CCoinControl *coinControl=NULL); | |
bool CommitTransaction(CWalletTx& wtxNew, CReserveKey& reservekey); | |
std::string SendMoney(CScript scriptPubKey, int64 nValue, CWalletTx& wtxNew, bool fAskFee=false); | |
std::string SendMoneyToDestination(const CTxDestination &address, int64 nValue, CWalletTx& wtxNew, bool fAskFee=false); | |
bool NewKeyPool(); | |
bool TopUpKeyPool(); | |
int64 AddReserveKey(const CKeyPool& keypool); | |
void ReserveKeyFromKeyPool(int64& nIndex, CKeyPool& keypool); | |
void KeepKey(int64 nIndex); | |
void ReturnKey(int64 nIndex); | |
bool GetKeyFromPool(CPubKey &key, bool fAllowReuse=true); | |
int64 GetOldestKeyPoolTime(); | |
void GetAllReserveKeys(std::set<CKeyID>& setAddress); | |
std::set< std::set<CTxDestination> > GetAddressGroupings(); | |
std::map<CTxDestination, int64> GetAddressBalances(); | |
bool IsMine(const CTxIn& txin) const; | |
int64 GetDebit(const CTxIn& txin) const; | |
bool IsMine(const CTxOut& txout) const | |
{ | |
return ::IsMine(*this, txout.scriptPubKey); | |
} | |
int64 GetCredit(const CTxOut& txout) const | |
{ | |
if (!MoneyRange(txout.nValue)) | |
throw std::runtime_error("CWallet::GetCredit() : value out of range"); | |
return (IsMine(txout) ? txout.nValue : 0); | |
} | |
bool IsChange(const CTxOut& txout) const; | |
int64 GetChange(const CTxOut& txout) const | |
{ | |
if (!MoneyRange(txout.nValue)) | |
throw std::runtime_error("CWallet::GetChange() : value out of range"); | |
return (IsChange(txout) ? txout.nValue : 0); | |
} | |
bool IsMine(const CTransaction& tx) const | |
{ | |
BOOST_FOREACH(const CTxOut& txout, tx.vout) | |
if (IsMine(txout) && txout.nValue >= nMinimumInputValue) | |
return true; | |
return false; | |
} | |
bool IsFromMe(const CTransaction& tx) const | |
{ | |
return (GetDebit(tx) > 0); | |
} | |
int64 GetDebit(const CTransaction& tx) const | |
{ | |
int64 nDebit = 0; | |
BOOST_FOREACH(const CTxIn& txin, tx.vin) | |
{ | |
nDebit += GetDebit(txin); | |
if (!MoneyRange(nDebit)) | |
throw std::runtime_error("CWallet::GetDebit() : value out of range"); | |
} | |
return nDebit; | |
} | |
int64 GetCredit(const CTransaction& tx) const | |
{ | |
int64 nCredit = 0; | |
BOOST_FOREACH(const CTxOut& txout, tx.vout) | |
{ | |
nCredit += GetCredit(txout); | |
if (!MoneyRange(nCredit)) | |
throw std::runtime_error("CWallet::GetCredit() : value out of range"); | |
} | |
return nCredit; | |
} | |
int64 GetChange(const CTransaction& tx) const | |
{ | |
int64 nChange = 0; | |
BOOST_FOREACH(const CTxOut& txout, tx.vout) | |
{ | |
nChange += GetChange(txout); | |
if (!MoneyRange(nChange)) | |
throw std::runtime_error("CWallet::GetChange() : value out of range"); | |
} | |
return nChange; | |
} | |
void SetBestChain(const CBlockLocator& loc); | |
DBErrors LoadWallet(bool& fFirstRunRet); | |
bool SetAddressBookName(const CTxDestination& address, const std::string& strName); | |
bool DelAddressBookName(const CTxDestination& address); | |
void UpdatedTransaction(const uint256 &hashTx); | |
void PrintWallet(const CBlock& block); | |
void Inventory(const uint256 &hash) | |
{ | |
{ | |
LOCK(cs_wallet); | |
std::map<uint256, int>::iterator mi = mapRequestCount.find(hash); | |
if (mi != mapRequestCount.end()) | |
(*mi).second++; | |
} | |
} | |
int GetKeyPoolSize() | |
{ | |
return setKeyPool.size(); | |
} | |
bool GetTransaction(const uint256 &hashTx, CWalletTx& wtx); | |
bool SetDefaultKey(const CPubKey &vchPubKey); | |
// signify that a particular wallet feature is now used. this may change nWalletVersion and nWalletMaxVersion if those are lower | |
bool SetMinVersion(enum WalletFeature, CWalletDB* pwalletdbIn = NULL, bool fExplicit = false); | |
// change which version we're allowed to upgrade to (note that this does not immediately imply upgrading to that format) | |
bool SetMaxVersion(int nVersion); | |
// get the current wallet format (the oldest client version guaranteed to understand this wallet) | |
int GetVersion() { return nWalletVersion; } | |
/** Address book entry changed. | |
* @note called with lock cs_wallet held. | |
*/ | |
boost::signals2::signal<void (CWallet *wallet, const CTxDestination &address, const std::string &label, bool isMine, ChangeType status)> NotifyAddressBookChanged; | |
/** Wallet transaction added, removed or updated. | |
* @note called with lock cs_wallet held. | |
*/ | |
boost::signals2::signal<void (CWallet *wallet, const uint256 &hashTx, ChangeType status)> NotifyTransactionChanged; | |
}; | |
/** A key allocated from the key pool. */ | |
class CReserveKey | |
{ | |
protected: | |
CWallet* pwallet; | |
int64 nIndex; | |
CPubKey vchPubKey; | |
public: | |
CReserveKey(CWallet* pwalletIn) | |
{ | |
nIndex = -1; | |
pwallet = pwalletIn; | |
} | |
~CReserveKey() | |
{ | |
ReturnKey(); | |
} | |
void ReturnKey(); | |
bool GetReservedKey(CPubKey &pubkey); | |
void KeepKey(); | |
}; | |
typedef std::map<std::string, std::string> mapValue_t; | |
static void ReadOrderPos(int64& nOrderPos, mapValue_t& mapValue) | |
{ | |
if (!mapValue.count("n")) | |
{ | |
nOrderPos = -1; // TODO: calculate elsewhere | |
return; | |
} | |
nOrderPos = atoi64(mapValue["n"].c_str()); | |
} | |
static void WriteOrderPos(const int64& nOrderPos, mapValue_t& mapValue) | |
{ | |
if (nOrderPos == -1) | |
return; | |
mapValue["n"] = i64tostr(nOrderPos); | |
} | |
/** A transaction with a bunch of additional info that only the owner cares about. | |
* It includes any unrecorded transactions needed to link it back to the block chain. | |
*/ | |
class CWalletTx : public CMerkleTx | |
{ | |
private: | |
const CWallet* pwallet; | |
public: | |
std::vector<CMerkleTx> vtxPrev; | |
mapValue_t mapValue; | |
std::vector<std::pair<std::string, std::string> > vOrderForm; | |
unsigned int fTimeReceivedIsTxTime; | |
unsigned int nTimeReceived; // time received by this node | |
unsigned int nTimeSmart; | |
char fFromMe; | |
std::string strFromAccount; | |
std::vector<char> vfSpent; // which outputs are already spent | |
int64 nOrderPos; // position in ordered transaction list | |
// memory only | |
mutable bool fDebitCached; | |
mutable bool fCreditCached; | |
mutable bool fImmatureCreditCached; | |
mutable bool fAvailableCreditCached; | |
mutable bool fChangeCached; | |
mutable int64 nDebitCached; | |
mutable int64 nCreditCached; | |
mutable int64 nImmatureCreditCached; | |
mutable int64 nAvailableCreditCached; | |
mutable int64 nChangeCached; | |
CWalletTx() | |
{ | |
Init(NULL); | |
} | |
CWalletTx(const CWallet* pwalletIn) | |
{ | |
Init(pwalletIn); | |
} | |
CWalletTx(const CWallet* pwalletIn, const CMerkleTx& txIn) : CMerkleTx(txIn) | |
{ | |
Init(pwalletIn); | |
} | |
CWalletTx(const CWallet* pwalletIn, const CTransaction& txIn) : CMerkleTx(txIn) | |
{ | |
Init(pwalletIn); | |
} | |
void Init(const CWallet* pwalletIn) | |
{ | |
pwallet = pwalletIn; | |
vtxPrev.clear(); | |
mapValue.clear(); | |
vOrderForm.clear(); | |
fTimeReceivedIsTxTime = false; | |
nTimeReceived = 0; | |
nTimeSmart = 0; | |
fFromMe = false; | |
strFromAccount.clear(); | |
vfSpent.clear(); | |
fDebitCached = false; | |
fCreditCached = false; | |
fImmatureCreditCached = false; | |
fAvailableCreditCached = false; | |
fChangeCached = false; | |
nDebitCached = 0; | |
nCreditCached = 0; | |
nImmatureCreditCached = 0; | |
nAvailableCreditCached = 0; | |
nChangeCached = 0; | |
nOrderPos = -1; | |
} | |
IMPLEMENT_SERIALIZE | |
( | |
CWalletTx* pthis = const_cast<CWalletTx*>(this); | |
if (fRead) | |
pthis->Init(NULL); | |
char fSpent = false; | |
if (!fRead) | |
{ | |
pthis->mapValue["fromaccount"] = pthis->strFromAccount; | |
std::string str; | |
BOOST_FOREACH(char f, vfSpent) | |
{ | |
str += (f ? '1' : '0'); | |
if (f) | |
fSpent = true; | |
} | |
pthis->mapValue["spent"] = str; | |
WriteOrderPos(pthis->nOrderPos, pthis->mapValue); | |
if (nTimeSmart) | |
pthis->mapValue["timesmart"] = strprintf("%u", nTimeSmart); | |
} | |
nSerSize += SerReadWrite(s, *(CMerkleTx*)this, nType, nVersion,ser_action); | |
READWRITE(vtxPrev); | |
READWRITE(mapValue); | |
READWRITE(vOrderForm); | |
READWRITE(fTimeReceivedIsTxTime); | |
READWRITE(nTimeReceived); | |
READWRITE(fFromMe); | |
READWRITE(fSpent); | |
if (fRead) | |
{ | |
pthis->strFromAccount = pthis->mapValue["fromaccount"]; | |
if (mapValue.count("spent")) | |
BOOST_FOREACH(char c, pthis->mapValue["spent"]) | |
pthis->vfSpent.push_back(c != '0'); | |
else | |
pthis->vfSpent.assign(vout.size(), fSpent); | |
ReadOrderPos(pthis->nOrderPos, pthis->mapValue); | |
pthis->nTimeSmart = mapValue.count("timesmart") ? (unsigned int)atoi64(pthis->mapValue["timesmart"]) : 0; | |
} | |
pthis->mapValue.erase("fromaccount"); | |
pthis->mapValue.erase("version"); | |
pthis->mapValue.erase("spent"); | |
pthis->mapValue.erase("n"); | |
pthis->mapValue.erase("timesmart"); | |
) | |
// marks certain txout's as spent | |
// returns true if any update took place | |
bool UpdateSpent(const std::vector<char>& vfNewSpent) | |
{ | |
bool fReturn = false; | |
for (unsigned int i = 0; i < vfNewSpent.size(); i++) | |
{ | |
if (i == vfSpent.size()) | |
break; | |
if (vfNewSpent[i] && !vfSpent[i]) | |
{ | |
vfSpent[i] = true; | |
fReturn = true; | |
fAvailableCreditCached = false; | |
} | |
} | |
return fReturn; | |
} | |
// make sure balances are recalculated | |
void MarkDirty() | |
{ | |
fCreditCached = false; | |
fAvailableCreditCached = false; | |
fDebitCached = false; | |
fChangeCached = false; | |
} | |
void BindWallet(CWallet *pwalletIn) | |
{ | |
pwallet = pwalletIn; | |
MarkDirty(); | |
} | |
void MarkSpent(unsigned int nOut) | |
{ | |
if (nOut >= vout.size()) | |
throw std::runtime_error("CWalletTx::MarkSpent() : nOut out of range"); | |
vfSpent.resize(vout.size()); | |
if (!vfSpent[nOut]) | |
{ | |
vfSpent[nOut] = true; | |
fAvailableCreditCached = false; | |
} | |
} | |
bool IsSpent(unsigned int nOut) const | |
{ | |
if (nOut >= vout.size()) | |
throw std::runtime_error("CWalletTx::IsSpent() : nOut out of range"); | |
if (nOut >= vfSpent.size()) | |
return false; | |
return (!!vfSpent[nOut]); | |
} | |
int64 GetDebit() const | |
{ | |
if (vin.empty()) | |
return 0; | |
if (fDebitCached) | |
return nDebitCached; | |
nDebitCached = pwallet->GetDebit(*this); | |
fDebitCached = true; | |
return nDebitCached; | |
} | |
int64 GetCredit(bool fUseCache=true) const | |
{ | |
// Must wait until coinbase is safely deep enough in the chain before valuing it | |
if (IsCoinBase() && GetBlocksToMaturity() > 0) | |
return 0; | |
// GetBalance can assume transactions in mapWallet won't change | |
if (fUseCache && fCreditCached) | |
return nCreditCached; | |
nCreditCached = pwallet->GetCredit(*this); | |
fCreditCached = true; | |
return nCreditCached; | |
} | |
int64 GetImmatureCredit(bool fUseCache=true) const | |
{ | |
if (IsCoinBase() && GetBlocksToMaturity() > 0 && IsInMainChain()) | |
{ | |
if (fUseCache && fImmatureCreditCached) | |
return nImmatureCreditCached; | |
nImmatureCreditCached = pwallet->GetCredit(*this); | |
fImmatureCreditCached = true; | |
return nImmatureCreditCached; | |
} | |
return 0; | |
} | |
int64 GetAvailableCredit(bool fUseCache=true) const | |
{ | |
// Must wait until coinbase is safely deep enough in the chain before valuing it | |
if (IsCoinBase() && GetBlocksToMaturity() > 0) | |
return 0; | |
if (fUseCache && fAvailableCreditCached) | |
return nAvailableCreditCached; | |
int64 nCredit = 0; | |
for (unsigned int i = 0; i < vout.size(); i++) | |
{ | |
if (!IsSpent(i)) | |
{ | |
const CTxOut &txout = vout[i]; | |
nCredit += pwallet->GetCredit(txout); | |
if (!MoneyRange(nCredit)) | |
throw std::runtime_error("CWalletTx::GetAvailableCredit() : value out of range"); | |
} | |
} | |
nAvailableCreditCached = nCredit; | |
fAvailableCreditCached = true; | |
return nCredit; | |
} | |
int64 GetChange() const | |
{ | |
if (fChangeCached) | |
return nChangeCached; | |
nChangeCached = pwallet->GetChange(*this); | |
fChangeCached = true; | |
return nChangeCached; | |
} | |
void GetAmounts(std::list<std::pair<CTxDestination, int64> >& listReceived, | |
std::list<std::pair<CTxDestination, int64> >& listSent, int64& nFee, std::string& strSentAccount) const; | |
void GetAccountAmounts(const std::string& strAccount, int64& nReceived, | |
int64& nSent, int64& nFee) const; | |
bool IsFromMe() const | |
{ | |
return (GetDebit() > 0); | |
} | |
bool IsConfirmed() const | |
{ | |
// Quick answer in most cases | |
if (!IsFinal()) | |
return false; | |
int nDepth = GetDepthInMainChain(); | |
if (nDepth >= 1) | |
return true; | |
if (nDepth < 0) | |
return false; | |
if (!bSpendZeroConfChange || !IsFromMe()) // using wtx's cached debit | |
return false; | |
// If no confirmations but it's from us, we can still | |
// consider it confirmed if all dependencies are confirmed | |
std::map<uint256, const CMerkleTx*> mapPrev; | |
std::vector<const CMerkleTx*> vWorkQueue; | |
vWorkQueue.reserve(vtxPrev.size()+1); | |
vWorkQueue.push_back(this); | |
for (unsigned int i = 0; i < vWorkQueue.size(); i++) | |
{ | |
const CMerkleTx* ptx = vWorkQueue[i]; | |
if (!ptx->IsFinal()) | |
return false; | |
int nPDepth = ptx->GetDepthInMainChain(); | |
if (nPDepth >= 1) | |
continue; | |
if (nPDepth < 0) | |
return false; | |
if (!pwallet->IsFromMe(*ptx)) | |
return false; | |
if (mapPrev.empty()) | |
{ | |
BOOST_FOREACH(const CMerkleTx& tx, vtxPrev) | |
mapPrev[tx.GetHash()] = &tx; | |
} | |
BOOST_FOREACH(const CTxIn& txin, ptx->vin) | |
{ | |
if (!mapPrev.count(txin.prevout.hash)) | |
return false; | |
vWorkQueue.push_back(mapPrev[txin.prevout.hash]); | |
} | |
} | |
return true; | |
} | |
bool WriteToDisk(); | |
int64 GetTxTime() const; | |
int GetRequestCount() const; | |
void AddSupportingTransactions(); | |
bool AcceptWalletTransaction(bool fCheckInputs=true); | |
void RelayWalletTransaction(); | |
}; | |
class COutput | |
{ | |
public: | |
const CWalletTx *tx; | |
int i; | |
int nDepth; | |
COutput(const CWalletTx *txIn, int iIn, int nDepthIn) | |
{ | |
tx = txIn; i = iIn; nDepth = nDepthIn; | |
} | |
std::string ToString() const | |
{ | |
return strprintf("COutput(%s, %d, %d) [%s]", tx->GetHash().ToString().c_str(), i, nDepth, FormatMoney(tx->vout[i].nValue).c_str()); | |
} | |
void print() const | |
{ | |
printf("%s\n", ToString().c_str()); | |
} | |
}; | |
/** Private key that includes an expiration date in case it never gets used. */ | |
class CWalletKey | |
{ | |
public: | |
CPrivKey vchPrivKey; | |
int64 nTimeCreated; | |
int64 nTimeExpires; | |
std::string strComment; | |
//// todo: add something to note what created it (user, getnewaddress, change) | |
//// maybe should have a map<string, string> property map | |
CWalletKey(int64 nExpires=0) | |
{ | |
nTimeCreated = (nExpires ? GetTime() : 0); | |
nTimeExpires = nExpires; | |
} | |
IMPLEMENT_SERIALIZE | |
( | |
if (!(nType & SER_GETHASH)) | |
READWRITE(nVersion); | |
READWRITE(vchPrivKey); | |
READWRITE(nTimeCreated); | |
READWRITE(nTimeExpires); | |
READWRITE(strComment); | |
) | |
}; | |
/** Account information. | |
* Stored in wallet with key "acc"+string account name. | |
*/ | |
class CAccount | |
{ | |
public: | |
CPubKey vchPubKey; | |
CAccount() | |
{ | |
SetNull(); | |
} | |
void SetNull() | |
{ | |
vchPubKey = CPubKey(); | |
} | |
IMPLEMENT_SERIALIZE | |
( | |
if (!(nType & SER_GETHASH)) | |
READWRITE(nVersion); | |
READWRITE(vchPubKey); | |
) | |
}; | |
/** Internal transfers. | |
* Database key is acentry<account><counter>. | |
*/ | |
class CAccountingEntry | |
{ | |
public: | |
std::string strAccount; | |
int64 nCreditDebit; | |
int64 nTime; | |
std::string strOtherAccount; | |
std::string strComment; | |
mapValue_t mapValue; | |
int64 nOrderPos; // position in ordered transaction list | |
uint64 nEntryNo; | |
CAccountingEntry() | |
{ | |
SetNull(); | |
} | |
void SetNull() | |
{ | |
nCreditDebit = 0; | |
nTime = 0; | |
strAccount.clear(); | |
strOtherAccount.clear(); | |
strComment.clear(); | |
nOrderPos = -1; | |
} | |
IMPLEMENT_SERIALIZE | |
( | |
CAccountingEntry& me = *const_cast<CAccountingEntry*>(this); | |
if (!(nType & SER_GETHASH)) | |
READWRITE(nVersion); | |
// Note: strAccount is serialized as part of the key, not here. | |
READWRITE(nCreditDebit); | |
READWRITE(nTime); | |
READWRITE(strOtherAccount); | |
if (!fRead) | |
{ | |
WriteOrderPos(nOrderPos, me.mapValue); | |
if (!(mapValue.empty() && _ssExtra.empty())) | |
{ | |
CDataStream ss(nType, nVersion); | |
ss.insert(ss.begin(), '\0'); | |
ss << mapValue; | |
ss.insert(ss.end(), _ssExtra.begin(), _ssExtra.end()); | |
me.strComment.append(ss.str()); | |
} | |
} | |
READWRITE(strComment); | |
size_t nSepPos = strComment.find("\0", 0, 1); | |
if (fRead) | |
{ | |
me.mapValue.clear(); | |
if (std::string::npos != nSepPos) | |
{ | |
CDataStream ss(std::vector<char>(strComment.begin() + nSepPos + 1, strComment.end()), nType, nVersion); | |
ss >> me.mapValue; | |
me._ssExtra = std::vector<char>(ss.begin(), ss.end()); | |
} | |
ReadOrderPos(me.nOrderPos, me.mapValue); | |
} | |
if (std::string::npos != nSepPos) | |
me.strComment.erase(nSepPos); | |
me.mapValue.erase("n"); | |
) | |
private: | |
std::vector<char> _ssExtra; | |
}; | |
bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut); | |
#endif |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// Copyright (c) 2009-2010 Satoshi Nakamoto | |
// Copyright (c) 2009-2012 The Bitcoin developers | |
// Distributed under the MIT/X11 software license, see the accompanying | |
// file COPYING or http://www.opensource.org/licenses/mit-license.php. | |
#include "walletdb.h" | |
#include "wallet.h" | |
#include <boost/version.hpp> | |
#include <boost/filesystem.hpp> | |
using namespace std; | |
using namespace boost; | |
static uint64 nAccountingEntryNumber = 0; | |
// | |
// CWalletDB | |
// | |
bool CWalletDB::WriteName(const string& strAddress, const string& strName) | |
{ | |
nWalletDBUpdated++; | |
return Write(make_pair(string("name"), strAddress), strName); | |
} | |
bool CWalletDB::EraseName(const string& strAddress) | |
{ | |
// This should only be used for sending addresses, never for receiving addresses, | |
// receiving addresses must always have an address book entry if they're not change return. | |
nWalletDBUpdated++; | |
return Erase(make_pair(string("name"), strAddress)); | |
} | |
bool CWalletDB::ReadAccount(const string& strAccount, CAccount& account) | |
{ | |
account.SetNull(); | |
return Read(make_pair(string("acc"), strAccount), account); | |
} | |
bool CWalletDB::WriteAccount(const string& strAccount, const CAccount& account) | |
{ | |
return Write(make_pair(string("acc"), strAccount), account); | |
} | |
bool CWalletDB::WriteAccountingEntry(const uint64 nAccEntryNum, const CAccountingEntry& acentry) | |
{ | |
return Write(boost::make_tuple(string("acentry"), acentry.strAccount, nAccEntryNum), acentry); | |
} | |
bool CWalletDB::WriteAccountingEntry(const CAccountingEntry& acentry) | |
{ | |
return WriteAccountingEntry(++nAccountingEntryNumber, acentry); | |
} | |
int64 CWalletDB::GetAccountCreditDebit(const string& strAccount) | |
{ | |
list<CAccountingEntry> entries; | |
ListAccountCreditDebit(strAccount, entries); | |
int64 nCreditDebit = 0; | |
BOOST_FOREACH (const CAccountingEntry& entry, entries) | |
nCreditDebit += entry.nCreditDebit; | |
return nCreditDebit; | |
} | |
void CWalletDB::ListAccountCreditDebit(const string& strAccount, list<CAccountingEntry>& entries) | |
{ | |
bool fAllAccounts = (strAccount == "*"); | |
Dbc* pcursor = GetCursor(); | |
if (!pcursor) | |
throw runtime_error("CWalletDB::ListAccountCreditDebit() : cannot create DB cursor"); | |
unsigned int fFlags = DB_SET_RANGE; | |
loop | |
{ | |
// Read next record | |
CDataStream ssKey(SER_DISK, CLIENT_VERSION); | |
if (fFlags == DB_SET_RANGE) | |
ssKey << boost::make_tuple(string("acentry"), (fAllAccounts? string("") : strAccount), uint64(0)); | |
CDataStream ssValue(SER_DISK, CLIENT_VERSION); | |
int ret = ReadAtCursor(pcursor, ssKey, ssValue, fFlags); | |
fFlags = DB_NEXT; | |
if (ret == DB_NOTFOUND) | |
break; | |
else if (ret != 0) | |
{ | |
pcursor->close(); | |
throw runtime_error("CWalletDB::ListAccountCreditDebit() : error scanning DB"); | |
} | |
// Unserialize | |
string strType; | |
ssKey >> strType; | |
if (strType != "acentry") | |
break; | |
CAccountingEntry acentry; | |
ssKey >> acentry.strAccount; | |
if (!fAllAccounts && acentry.strAccount != strAccount) | |
break; | |
ssValue >> acentry; | |
ssKey >> acentry.nEntryNo; | |
entries.push_back(acentry); | |
} | |
pcursor->close(); | |
} | |
DBErrors | |
CWalletDB::ReorderTransactions(CWallet* pwallet) | |
{ | |
LOCK(pwallet->cs_wallet); | |
// Old wallets didn't have any defined order for transactions | |
// Probably a bad idea to change the output of this | |
// First: get all CWalletTx and CAccountingEntry into a sorted-by-time multimap. | |
typedef pair<CWalletTx*, CAccountingEntry*> TxPair; | |
typedef multimap<int64, TxPair > TxItems; | |
TxItems txByTime; | |
for (map<uint256, CWalletTx>::iterator it = pwallet->mapWallet.begin(); it != pwallet->mapWallet.end(); ++it) | |
{ | |
CWalletTx* wtx = &((*it).second); | |
txByTime.insert(make_pair(wtx->nTimeReceived, TxPair(wtx, (CAccountingEntry*)0))); | |
} | |
list<CAccountingEntry> acentries; | |
ListAccountCreditDebit("", acentries); | |
BOOST_FOREACH(CAccountingEntry& entry, acentries) | |
{ | |
txByTime.insert(make_pair(entry.nTime, TxPair((CWalletTx*)0, &entry))); | |
} | |
int64& nOrderPosNext = pwallet->nOrderPosNext; | |
nOrderPosNext = 0; | |
std::vector<int64> nOrderPosOffsets; | |
for (TxItems::iterator it = txByTime.begin(); it != txByTime.end(); ++it) | |
{ | |
CWalletTx *const pwtx = (*it).second.first; | |
CAccountingEntry *const pacentry = (*it).second.second; | |
int64& nOrderPos = (pwtx != 0) ? pwtx->nOrderPos : pacentry->nOrderPos; | |
if (nOrderPos == -1) | |
{ | |
nOrderPos = nOrderPosNext++; | |
nOrderPosOffsets.push_back(nOrderPos); | |
if (pacentry) | |
// Have to write accounting regardless, since we don't keep it in memory | |
if (!WriteAccountingEntry(pacentry->nEntryNo, *pacentry)) | |
return DB_LOAD_FAIL; | |
} | |
else | |
{ | |
int64 nOrderPosOff = 0; | |
BOOST_FOREACH(const int64& nOffsetStart, nOrderPosOffsets) | |
{ | |
if (nOrderPos >= nOffsetStart) | |
++nOrderPosOff; | |
} | |
nOrderPos += nOrderPosOff; | |
nOrderPosNext = std::max(nOrderPosNext, nOrderPos + 1); | |
if (!nOrderPosOff) | |
continue; | |
// Since we're changing the order, write it back | |
if (pwtx) | |
{ | |
if (!WriteTx(pwtx->GetHash(), *pwtx)) | |
return DB_LOAD_FAIL; | |
} | |
else | |
if (!WriteAccountingEntry(pacentry->nEntryNo, *pacentry)) | |
return DB_LOAD_FAIL; | |
} | |
} | |
return DB_LOAD_OK; | |
} | |
bool | |
ReadKeyValue(CWallet* pwallet, CDataStream& ssKey, CDataStream& ssValue, | |
int& nFileVersion, vector<uint256>& vWalletUpgrade, | |
bool& fIsEncrypted, bool& fAnyUnordered, string& strType, string& strErr) | |
{ | |
try { | |
// Unserialize | |
// Taking advantage of the fact that pair serialization | |
// is just the two items serialized one after the other | |
ssKey >> strType; | |
if (strType == "name") | |
{ | |
string strAddress; | |
ssKey >> strAddress; | |
ssValue >> pwallet->mapAddressBook[CBitcoinAddress(strAddress).Get()]; | |
} | |
else if (strType == "tx") | |
{ | |
uint256 hash; | |
ssKey >> hash; | |
CWalletTx wtx; | |
ssValue >> wtx; | |
CValidationState state; | |
if (wtx.CheckTransaction(state) && (wtx.GetHash() == hash) && state.IsValid()) | |
wtx.BindWallet(pwallet); | |
else | |
return false; | |
// Undo serialize changes in 31600 | |
if (31404 <= wtx.fTimeReceivedIsTxTime && wtx.fTimeReceivedIsTxTime <= 31703) | |
{ | |
if (!ssValue.empty()) | |
{ | |
char fTmp; | |
char fUnused; | |
ssValue >> fTmp >> fUnused >> wtx.strFromAccount; | |
strErr = strprintf("LoadWallet() upgrading tx ver=%d %d '%s' %s", | |
wtx.fTimeReceivedIsTxTime, fTmp, wtx.strFromAccount.c_str(), hash.ToString().c_str()); | |
wtx.fTimeReceivedIsTxTime = fTmp; | |
} | |
else | |
{ | |
strErr = strprintf("LoadWallet() repairing tx ver=%d %s", wtx.fTimeReceivedIsTxTime, hash.ToString().c_str()); | |
wtx.fTimeReceivedIsTxTime = 0; | |
} | |
vWalletUpgrade.push_back(hash); | |
} | |
if (wtx.nOrderPos == -1) | |
fAnyUnordered = true; | |
pwallet->mapWallet[hash] = wtx; | |
//// debug print | |
//printf("LoadWallet %s\n", wtx.GetHash().ToString().c_str()); | |
//printf(" %12"PRI64d" %s %s %s\n", | |
// wtx.vout[0].nValue, | |
// DateTimeStrFormat("%Y-%m-%d %H:%M:%S", wtx.GetBlockTime()).c_str(), | |
// wtx.hashBlock.ToString().c_str(), | |
// wtx.mapValue["message"].c_str()); | |
} | |
else if (strType == "acentry") | |
{ | |
string strAccount; | |
ssKey >> strAccount; | |
uint64 nNumber; | |
ssKey >> nNumber; | |
if (nNumber > nAccountingEntryNumber) | |
nAccountingEntryNumber = nNumber; | |
if (!fAnyUnordered) | |
{ | |
CAccountingEntry acentry; | |
ssValue >> acentry; | |
if (acentry.nOrderPos == -1) | |
fAnyUnordered = true; | |
} | |
} | |
else if (strType == "key" || strType == "wkey") | |
{ | |
CPubKey vchPubKey; | |
ssKey >> vchPubKey; | |
if (!vchPubKey.IsValid()) | |
{ | |
strErr = "Error reading wallet database: CPubKey corrupt"; | |
return false; | |
} | |
CKey key; | |
CPrivKey pkey; | |
if (strType == "key") | |
ssValue >> pkey; | |
else { | |
CWalletKey wkey; | |
ssValue >> wkey; | |
pkey = wkey.vchPrivKey; | |
} | |
if (!key.SetPrivKey(pkey, vchPubKey.IsCompressed())) | |
{ | |
strErr = "Error reading wallet database: CPrivKey corrupt"; | |
return false; | |
} | |
if (key.GetPubKey() != vchPubKey) | |
{ | |
strErr = "Error reading wallet database: CPrivKey pubkey inconsistency"; | |
return false; | |
} | |
if (!pwallet->LoadKey(key, vchPubKey)) | |
{ | |
strErr = "Error reading wallet database: LoadKey failed"; | |
return false; | |
} | |
} | |
else if (strType == "mkey") | |
{ | |
unsigned int nID; | |
ssKey >> nID; | |
CMasterKey kMasterKey; | |
ssValue >> kMasterKey; | |
if(pwallet->mapMasterKeys.count(nID) != 0) | |
{ | |
strErr = strprintf("Error reading wallet database: duplicate CMasterKey id %u", nID); | |
return false; | |
} | |
pwallet->mapMasterKeys[nID] = kMasterKey; | |
if (pwallet->nMasterKeyMaxID < nID) | |
pwallet->nMasterKeyMaxID = nID; | |
} | |
else if (strType == "ckey") | |
{ | |
vector<unsigned char> vchPubKey; | |
ssKey >> vchPubKey; | |
vector<unsigned char> vchPrivKey; | |
ssValue >> vchPrivKey; | |
if (!pwallet->LoadCryptedKey(vchPubKey, vchPrivKey)) | |
{ | |
strErr = "Error reading wallet database: LoadCryptedKey failed"; | |
return false; | |
} | |
fIsEncrypted = true; | |
} | |
else if (strType == "defaultkey") | |
{ | |
ssValue >> pwallet->vchDefaultKey; | |
} | |
else if (strType == "pool") | |
{ | |
int64 nIndex; | |
ssKey >> nIndex; | |
pwallet->setKeyPool.insert(nIndex); | |
} | |
else if (strType == "version") | |
{ | |
ssValue >> nFileVersion; | |
if (nFileVersion == 10300) | |
nFileVersion = 300; | |
} | |
else if (strType == "cscript") | |
{ | |
uint160 hash; | |
ssKey >> hash; | |
CScript script; | |
ssValue >> script; | |
if (!pwallet->LoadCScript(script)) | |
{ | |
strErr = "Error reading wallet database: LoadCScript failed"; | |
return false; | |
} | |
} | |
else if (strType == "orderposnext") | |
{ | |
ssValue >> pwallet->nOrderPosNext; | |
} | |
} catch (...) | |
{ | |
return false; | |
} | |
return true; | |
} | |
static bool IsKeyType(string strType) | |
{ | |
return (strType== "key" || strType == "wkey" || | |
strType == "mkey" || strType == "ckey"); | |
} | |
DBErrors CWalletDB::LoadWallet(CWallet* pwallet) | |
{ | |
pwallet->vchDefaultKey = CPubKey(); | |
int nFileVersion = 0; | |
vector<uint256> vWalletUpgrade; | |
bool fIsEncrypted = false; | |
bool fAnyUnordered = false; | |
bool fNoncriticalErrors = false; | |
DBErrors result = DB_LOAD_OK; | |
try { | |
LOCK(pwallet->cs_wallet); | |
int nMinVersion = 0; | |
if (Read((string)"minversion", nMinVersion)) | |
{ | |
if (nMinVersion > CLIENT_VERSION) | |
return DB_TOO_NEW; | |
pwallet->LoadMinVersion(nMinVersion); | |
} | |
// Get cursor | |
Dbc* pcursor = GetCursor(); | |
if (!pcursor) | |
{ | |
printf("Error getting wallet database cursor\n"); | |
return DB_CORRUPT; | |
} | |
loop | |
{ | |
// Read next record | |
CDataStream ssKey(SER_DISK, CLIENT_VERSION); | |
CDataStream ssValue(SER_DISK, CLIENT_VERSION); | |
int ret = ReadAtCursor(pcursor, ssKey, ssValue); | |
if (ret == DB_NOTFOUND) | |
break; | |
else if (ret != 0) | |
{ | |
printf("Error reading next record from wallet database\n"); | |
return DB_CORRUPT; | |
} | |
// Try to be tolerant of single corrupt records: | |
string strType, strErr; | |
if (!ReadKeyValue(pwallet, ssKey, ssValue, nFileVersion, | |
vWalletUpgrade, fIsEncrypted, fAnyUnordered, strType, strErr)) | |
{ | |
// losing keys is considered a catastrophic error, anything else | |
// we assume the user can live with: | |
if (IsKeyType(strType)) | |
result = DB_CORRUPT; | |
else | |
{ | |
// Leave other errors alone, if we try to fix them we might make things worse. | |
fNoncriticalErrors = true; // ... but do warn the user there is something wrong. | |
if (strType == "tx") | |
// Rescan if there is a bad transaction record: | |
SoftSetBoolArg("-rescan", true); | |
} | |
} | |
if (!strErr.empty()) | |
printf("%s\n", strErr.c_str()); | |
} | |
pcursor->close(); | |
} | |
catch (boost::thread_interrupted) { | |
throw; | |
} | |
catch (...) { | |
result = DB_CORRUPT; | |
} | |
if (fNoncriticalErrors && result == DB_LOAD_OK) | |
result = DB_NONCRITICAL_ERROR; | |
// Any wallet corruption at all: skip any rewriting or | |
// upgrading, we don't want to make it worse. | |
if (result != DB_LOAD_OK) | |
return result; | |
printf("nFileVersion = %d\n", nFileVersion); | |
BOOST_FOREACH(uint256 hash, vWalletUpgrade) | |
WriteTx(hash, pwallet->mapWallet[hash]); | |
// Rewrite encrypted wallets of versions 0.4.0 and 0.5.0rc: | |
if (fIsEncrypted && (nFileVersion == 40000 || nFileVersion == 50000)) | |
return DB_NEED_REWRITE; | |
if (nFileVersion < CLIENT_VERSION) // Update | |
WriteVersion(CLIENT_VERSION); | |
if (fAnyUnordered) | |
result = ReorderTransactions(pwallet); | |
return result; | |
} | |
void ThreadFlushWalletDB(const string& strFile) | |
{ | |
// Make this thread recognisable as the wallet flushing thread | |
RenameThread("bitcoin-wallet"); | |
static bool fOneThread; | |
if (fOneThread) | |
return; | |
fOneThread = true; | |
if (!GetBoolArg("-flushwallet", true)) | |
return; | |
unsigned int nLastSeen = nWalletDBUpdated; | |
unsigned int nLastFlushed = nWalletDBUpdated; | |
int64 nLastWalletUpdate = GetTime(); | |
while (true) | |
{ | |
MilliSleep(500); | |
if (nLastSeen != nWalletDBUpdated) | |
{ | |
nLastSeen = nWalletDBUpdated; | |
nLastWalletUpdate = GetTime(); | |
} | |
if (nLastFlushed != nWalletDBUpdated && GetTime() - nLastWalletUpdate >= 2) | |
{ | |
TRY_LOCK(bitdb.cs_db,lockDb); | |
if (lockDb) | |
{ | |
// Don't do this if any databases are in use | |
int nRefCount = 0; | |
map<string, int>::iterator mi = bitdb.mapFileUseCount.begin(); | |
while (mi != bitdb.mapFileUseCount.end()) | |
{ | |
nRefCount += (*mi).second; | |
mi++; | |
} | |
if (nRefCount == 0) | |
{ | |
boost::this_thread::interruption_point(); | |
map<string, int>::iterator mi = bitdb.mapFileUseCount.find(strFile); | |
if (mi != bitdb.mapFileUseCount.end()) | |
{ | |
printf("Flushing wallet.dat\n"); | |
nLastFlushed = nWalletDBUpdated; | |
int64 nStart = GetTimeMillis(); | |
// Flush wallet.dat so it's self contained | |
bitdb.CloseDb(strFile); | |
bitdb.CheckpointLSN(strFile); | |
bitdb.mapFileUseCount.erase(mi++); | |
printf("Flushed wallet.dat %"PRI64d"ms\n", GetTimeMillis() - nStart); | |
} | |
} | |
} | |
} | |
} | |
} | |
bool BackupWallet(const CWallet& wallet, const string& strDest) | |
{ | |
if (!wallet.fFileBacked) | |
return false; | |
while (true) | |
{ | |
{ | |
LOCK(bitdb.cs_db); | |
if (!bitdb.mapFileUseCount.count(wallet.strWalletFile) || bitdb.mapFileUseCount[wallet.strWalletFile] == 0) | |
{ | |
// Flush log data to the dat file | |
bitdb.CloseDb(wallet.strWalletFile); | |
bitdb.CheckpointLSN(wallet.strWalletFile); | |
bitdb.mapFileUseCount.erase(wallet.strWalletFile); | |
// Copy wallet.dat | |
filesystem::path pathSrc = GetDataDir() / wallet.strWalletFile; | |
filesystem::path pathDest(strDest); | |
if (filesystem::is_directory(pathDest)) | |
pathDest /= wallet.strWalletFile; | |
try { | |
#if BOOST_VERSION >= 104000 | |
filesystem::copy_file(pathSrc, pathDest, filesystem::copy_option::overwrite_if_exists); | |
#else | |
filesystem::copy_file(pathSrc, pathDest); | |
#endif | |
printf("copied wallet.dat to %s\n", pathDest.string().c_str()); | |
return true; | |
} catch(const filesystem::filesystem_error &e) { | |
printf("error copying wallet.dat to %s - %s\n", pathDest.string().c_str(), e.what()); | |
return false; | |
} | |
} | |
} | |
MilliSleep(100); | |
} | |
return false; | |
} | |
// | |
// Try to (very carefully!) recover wallet.dat if there is a problem. | |
// | |
bool CWalletDB::Recover(CDBEnv& dbenv, std::string filename, bool fOnlyKeys) | |
{ | |
// Recovery procedure: | |
// move wallet.dat to wallet.timestamp.bak | |
// Call Salvage with fAggressive=true to | |
// get as much data as possible. | |
// Rewrite salvaged data to wallet.dat | |
// Set -rescan so any missing transactions will be | |
// found. | |
int64 now = GetTime(); | |
std::string newFilename = strprintf("wallet.%"PRI64d".bak", now); | |
int result = dbenv.dbenv.dbrename(NULL, filename.c_str(), NULL, | |
newFilename.c_str(), DB_AUTO_COMMIT); | |
if (result == 0) | |
printf("Renamed %s to %s\n", filename.c_str(), newFilename.c_str()); | |
else | |
{ | |
printf("Failed to rename %s to %s\n", filename.c_str(), newFilename.c_str()); | |
return false; | |
} | |
std::vector<CDBEnv::KeyValPair> salvagedData; | |
bool allOK = dbenv.Salvage(newFilename, true, salvagedData); | |
if (salvagedData.empty()) | |
{ | |
printf("Salvage(aggressive) found no records in %s.\n", newFilename.c_str()); | |
return false; | |
} | |
printf("Salvage(aggressive) found %"PRIszu" records\n", salvagedData.size()); | |
bool fSuccess = allOK; | |
Db* pdbCopy = new Db(&dbenv.dbenv, 0); | |
int ret = pdbCopy->open(NULL, // Txn pointer | |
filename.c_str(), // Filename | |
"main", // Logical db name | |
DB_BTREE, // Database type | |
DB_CREATE, // Flags | |
0); | |
if (ret > 0) | |
{ | |
printf("Cannot create database file %s\n", filename.c_str()); | |
return false; | |
} | |
CWallet dummyWallet; | |
int nFileVersion = 0; | |
vector<uint256> vWalletUpgrade; | |
bool fIsEncrypted = false; | |
bool fAnyUnordered = false; | |
DbTxn* ptxn = dbenv.TxnBegin(); | |
BOOST_FOREACH(CDBEnv::KeyValPair& row, salvagedData) | |
{ | |
if (fOnlyKeys) | |
{ | |
CDataStream ssKey(row.first, SER_DISK, CLIENT_VERSION); | |
CDataStream ssValue(row.second, SER_DISK, CLIENT_VERSION); | |
string strType, strErr; | |
bool fReadOK = ReadKeyValue(&dummyWallet, ssKey, ssValue, | |
nFileVersion, vWalletUpgrade, | |
fIsEncrypted, fAnyUnordered, | |
strType, strErr); | |
if (!IsKeyType(strType)) | |
continue; | |
if (!fReadOK) | |
{ | |
printf("WARNING: CWalletDB::Recover skipping %s: %s\n", strType.c_str(), strErr.c_str()); | |
continue; | |
} | |
} | |
Dbt datKey(&row.first[0], row.first.size()); | |
Dbt datValue(&row.second[0], row.second.size()); | |
int ret2 = pdbCopy->put(ptxn, &datKey, &datValue, DB_NOOVERWRITE); | |
if (ret2 > 0) | |
fSuccess = false; | |
} | |
ptxn->commit(0); | |
pdbCopy->close(0); | |
delete pdbCopy; | |
return fSuccess; | |
} | |
bool CWalletDB::Recover(CDBEnv& dbenv, std::string filename) | |
{ | |
return CWalletDB::Recover(dbenv, filename, false); | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// Copyright (c) 2009-2010 Satoshi Nakamoto | |
// Copyright (c) 2009-2012 The Bitcoin developers | |
// Distributed under the MIT/X11 software license, see the accompanying | |
// file COPYING or http://www.opensource.org/licenses/mit-license.php. | |
#ifndef BITCOIN_WALLETDB_H | |
#define BITCOIN_WALLETDB_H | |
#include "db.h" | |
#include "base58.h" | |
class CKeyPool; | |
class CAccount; | |
class CAccountingEntry; | |
/** 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 | |
}; | |
/** Access to the wallet database (wallet.dat) */ | |
class CWalletDB : public CDB | |
{ | |
public: | |
CWalletDB(std::string strFilename, const char* pszMode="r+") : CDB(strFilename.c_str(), pszMode) | |
{ | |
} | |
private: | |
CWalletDB(const CWalletDB&); | |
void operator=(const CWalletDB&); | |
public: | |
bool WriteName(const std::string& strAddress, const std::string& strName); | |
bool EraseName(const std::string& strAddress); | |
bool WriteTx(uint256 hash, const CWalletTx& wtx) | |
{ | |
nWalletDBUpdated++; | |
return Write(std::make_pair(std::string("tx"), hash), wtx); | |
} | |
bool EraseTx(uint256 hash) | |
{ | |
nWalletDBUpdated++; | |
return Erase(std::make_pair(std::string("tx"), hash)); | |
} | |
bool WriteKey(const CPubKey& vchPubKey, const CPrivKey& vchPrivKey) | |
{ | |
nWalletDBUpdated++; | |
return Write(std::make_pair(std::string("key"), vchPubKey), vchPrivKey, false); | |
} | |
bool WriteCryptedKey(const CPubKey& vchPubKey, const std::vector<unsigned char>& vchCryptedSecret, bool fEraseUnencryptedKey = true) | |
{ | |
nWalletDBUpdated++; | |
if (!Write(std::make_pair(std::string("ckey"), vchPubKey), vchCryptedSecret, false)) | |
return false; | |
if (fEraseUnencryptedKey) | |
{ | |
Erase(std::make_pair(std::string("key"), vchPubKey)); | |
Erase(std::make_pair(std::string("wkey"), vchPubKey)); | |
} | |
return true; | |
} | |
bool WriteMasterKey(unsigned int nID, const CMasterKey& kMasterKey) | |
{ | |
nWalletDBUpdated++; | |
return Write(std::make_pair(std::string("mkey"), nID), kMasterKey, true); | |
} | |
bool WriteCScript(const uint160& hash, const CScript& redeemScript) | |
{ | |
nWalletDBUpdated++; | |
return Write(std::make_pair(std::string("cscript"), hash), redeemScript, false); | |
} | |
bool WriteBestBlock(const CBlockLocator& locator) | |
{ | |
nWalletDBUpdated++; | |
return Write(std::string("bestblock"), locator); | |
} | |
bool ReadBestBlock(CBlockLocator& locator) | |
{ | |
return Read(std::string("bestblock"), locator); | |
} | |
bool WriteOrderPosNext(int64 nOrderPosNext) | |
{ | |
nWalletDBUpdated++; | |
return Write(std::string("orderposnext"), nOrderPosNext); | |
} | |
bool WriteDefaultKey(const CPubKey& vchPubKey) | |
{ | |
nWalletDBUpdated++; | |
return Write(std::string("defaultkey"), vchPubKey); | |
} | |
bool ReadPool(int64 nPool, CKeyPool& keypool) | |
{ | |
return Read(std::make_pair(std::string("pool"), nPool), keypool); | |
} | |
bool WritePool(int64 nPool, const CKeyPool& keypool) | |
{ | |
nWalletDBUpdated++; | |
return Write(std::make_pair(std::string("pool"), nPool), keypool); | |
} | |
bool ErasePool(int64 nPool) | |
{ | |
nWalletDBUpdated++; | |
return Erase(std::make_pair(std::string("pool"), nPool)); | |
} | |
// Settings are no longer stored in wallet.dat; these are | |
// used only for backwards compatibility: | |
template<typename T> | |
bool ReadSetting(const std::string& strKey, T& value) | |
{ | |
return Read(std::make_pair(std::string("setting"), strKey), value); | |
} | |
template<typename T> | |
bool WriteSetting(const std::string& strKey, const T& value) | |
{ | |
nWalletDBUpdated++; | |
return Write(std::make_pair(std::string("setting"), strKey), value); | |
} | |
bool EraseSetting(const std::string& strKey) | |
{ | |
nWalletDBUpdated++; | |
return Erase(std::make_pair(std::string("setting"), strKey)); | |
} | |
bool WriteMinVersion(int nVersion) | |
{ | |
return Write(std::string("minversion"), nVersion); | |
} | |
bool ReadAccount(const std::string& strAccount, CAccount& account); | |
bool WriteAccount(const std::string& strAccount, const CAccount& account); | |
private: | |
bool WriteAccountingEntry(const uint64 nAccEntryNum, const CAccountingEntry& acentry); | |
public: | |
bool WriteAccountingEntry(const CAccountingEntry& acentry); | |
int64 GetAccountCreditDebit(const std::string& strAccount); | |
void ListAccountCreditDebit(const std::string& strAccount, std::list<CAccountingEntry>& acentries); | |
DBErrors ReorderTransactions(CWallet*); | |
DBErrors LoadWallet(CWallet* pwallet); | |
static bool Recover(CDBEnv& dbenv, std::string filename, bool fOnlyKeys); | |
static bool Recover(CDBEnv& dbenv, std::string filename); | |
}; | |
#endif // BITCOIN_WALLETDB_H |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment