wallet.h
No OneTemporary
Actions

Size

26 KB

Subscribers

None

wallet.h
View Options

	// Copyright (c) 2009-2010 Satoshi Nakamoto
	// Copyright (c) 2009-2013 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 "core.h"
	#include "crypter.h"
	#include "key.h"
	#include "keystore.h"
	#include "main.h"
	#include "ui_interface.h"
	#include "util.h"
	#include "walletdb.h"

	#include <algorithm>
	#include <map>
	#include <set>
	#include <stdexcept>
	#include <stdint.h>
	#include <string>
	#include <utility>
	#include <vector>

	// Settings
	extern int64_t nTransactionFee;

	class CAccountingEntry;
	class CCoinControl;
	class COutput;
	class CReserveKey;
	class CScript;
	class CWalletTx;

	/** (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_t 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);
	)
	};

	/** Address book data */
	class CAddressBookData
	{
	public:
	std::string name;
	std::string purpose;

	CAddressBookData()
	{
	purpose = "unknown";
	}

	typedef std::map<std::string, std::string> StringMap;
	StringMap destdata;
	};

	/** 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, public CWalletInterface
	{
	private:
	bool SelectCoins(int64_t nTargetValue, std::set<std::pair<const CWalletTx,unsigned int> >& setCoinsRet, int64_t& 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;

	int64_t nNextResend;
	int64_t nLastResend;

	public:
	/// Main wallet lock.
	/// This lock protects all the fields added by CWallet
	/// except for:
	/// fFileBacked (immutable after instantiation)
	/// strWalletFile (immutable after instantiation)
	mutable CCriticalSection cs_wallet;

	bool fFileBacked;
	std::string strWalletFile;

	std::set<int64_t> setKeyPool;
	std::map<CKeyID, CKeyMetadata> mapKeyMetadata;

	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;
	nNextResend = 0;
	nLastResend = 0;
	}
	CWallet(std::string strWalletFileIn)
	{
	nWalletVersion = FEATURE_BASE;
	nWalletMaxVersion = FEATURE_BASE;
	strWalletFile = strWalletFileIn;
	fFileBacked = true;
	nMasterKeyMaxID = 0;
	pwalletdbEncryption = NULL;
	nOrderPosNext = 0;
	nNextResend = 0;
	nLastResend = 0;
	}

	std::map<uint256, CWalletTx> mapWallet;
	int64_t nOrderPosNext;
	std::map<uint256, int> mapRequestCount;

	std::map<CTxDestination, CAddressBookData> mapAddressBook;

	CPubKey vchDefaultKey;

	std::set<COutPoint> setLockedCoins;

	int64_t nTimeFirstKey;

	// check whether we are allowed to upgrade (or already support) to the named feature
	bool CanSupportFeature(enum WalletFeature wf) { AssertLockHeld(cs_wallet); return nWalletMaxVersion >= wf; }

	void AvailableCoins(std::vector<COutput>& vCoins, bool fOnlyConfirmed=true, const CCoinControl *coinControl = NULL) const;
	bool SelectCoinsMinConf(int64_t nTargetValue, int nConfMine, int nConfTheirs, std::vector<COutput> vCoins, std::set<std::pair<const CWalletTx*,unsigned int> >& setCoinsRet, int64_t& 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); }
	// Load metadata (used by LoadWallet)
	bool LoadKeyMetadata(const CPubKey &pubkey, const CKeyMetadata &metadata);

	bool LoadMinVersion(int nVersion) { AssertLockHeld(cs_wallet); 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); }

	/// Adds a destination data tuple to the store, and saves it to disk
	bool AddDestData(const CTxDestination &dest, const std::string &key, const std::string &value);
	/// Erases a destination data tuple in the store and on disk
	bool EraseDestData(const CTxDestination &dest, const std::string &key);
	/// Adds a destination data tuple to the store, without saving it to disk
	bool LoadDestData(const CTxDestination &dest, const std::string &key, const std::string &value);
	/// Look up a destination data tuple in the store, return true if found false otherwise
	bool GetDestData(const CTxDestination &dest, const std::string &key, std::string *value) const;

	bool Unlock(const SecureString& strWalletPassphrase);
	bool ChangeWalletPassphrase(const SecureString& strOldWalletPassphrase, const SecureString& strNewWalletPassphrase);
	bool EncryptWallet(const SecureString& strWalletPassphrase);

	void GetKeyBirthTimes(std::map<CKeyID, int64_t> &mapKeyBirth) const;

	/** Increment the next transaction order id
	@return next transaction order id
	*/
	int64_t IncOrderPosNext(CWalletDB *pwalletdb = NULL);

	typedef std::pair<CWalletTx, CAccountingEntry> TxPair;
	typedef std::multimap<int64_t, 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);
	void SyncTransaction(const uint256 &hash, const CTransaction& tx, const CBlock* pblock);
	bool AddToWalletIfInvolvingMe(const uint256 &hash, const CTransaction& tx, const CBlock* pblock, bool fUpdate);
	void EraseFromWallet(const uint256 &hash);
	void WalletUpdateSpent(const CTransaction& prevout);
	int ScanForWalletTransactions(CBlockIndex* pindexStart, bool fUpdate = false);
	void ReacceptWalletTransactions();
	void ResendWalletTransactions();
	int64_t GetBalance() const;
	int64_t GetUnconfirmedBalance() const;
	int64_t GetImmatureBalance() const;
	bool CreateTransaction(const std::vector<std::pair<CScript, int64_t> >& vecSend,
	CWalletTx& wtxNew, CReserveKey& reservekey, int64_t& nFeeRet, std::string& strFailReason, const CCoinControl *coinControl = NULL);
	bool CreateTransaction(CScript scriptPubKey, int64_t nValue,
	CWalletTx& wtxNew, CReserveKey& reservekey, int64_t& nFeeRet, std::string& strFailReason, const CCoinControl *coinControl = NULL);
	bool CommitTransaction(CWalletTx& wtxNew, CReserveKey& reservekey);
	std::string SendMoney(CScript scriptPubKey, int64_t nValue, CWalletTx& wtxNew);
	std::string SendMoneyToDestination(const CTxDestination &address, int64_t nValue, CWalletTx& wtxNew);

	bool NewKeyPool();
	bool TopUpKeyPool(unsigned int kpSize = 0);
	int64_t AddReserveKey(const CKeyPool& keypool);
	void ReserveKeyFromKeyPool(int64_t& nIndex, CKeyPool& keypool);
	void KeepKey(int64_t nIndex);
	void ReturnKey(int64_t nIndex);
	bool GetKeyFromPool(CPubKey &key);
	int64_t GetOldestKeyPoolTime();
	void GetAllReserveKeys(std::set<CKeyID>& setAddress) const;

	std::set< std::set<CTxDestination> > GetAddressGroupings();
	std::map<CTxDestination, int64_t> GetAddressBalances();

	std::set<CTxDestination> GetAccountAddresses(std::string strAccount) const;

	bool IsMine(const CTxIn& txin) const;
	int64_t GetDebit(const CTxIn& txin) const;
	bool IsMine(const CTxOut& txout) const
	{
	return ::IsMine(*this, txout.scriptPubKey);
	}
	int64_t 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_t 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))
	return true;
	return false;
	}
	bool IsFromMe(const CTransaction& tx) const
	{
	return (GetDebit(tx) > 0);
	}
	int64_t GetDebit(const CTransaction& tx) const
	{
	int64_t 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_t GetCredit(const CTransaction& tx) const
	{
	int64_t 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_t GetChange(const CTransaction& tx) const
	{
	int64_t 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 SetAddressBook(const CTxDestination& address, const std::string& strName, const std::string& purpose);

	bool DelAddressBook(const CTxDestination& address);

	void UpdatedTransaction(const uint256 &hashTx);

	void Inventory(const uint256 &hash)
	{
	{
	LOCK(cs_wallet);
	std::map<uint256, int>::iterator mi = mapRequestCount.find(hash);
	if (mi != mapRequestCount.end())
	(*mi).second++;
	}
	}

	unsigned int GetKeyPoolSize()
	{
	AssertLockHeld(cs_wallet); // setKeyPool
	return setKeyPool.size();
	}

	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() { AssertLockHeld(cs_wallet); 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,
	const std::string &purpose,
	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_t 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_t& 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_t& 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_t 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_t nDebitCached;
	mutable int64_t nCreditCached;
	mutable int64_t nImmatureCreditCached;
	mutable int64_t nAvailableCreditCached;
	mutable int64_t 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_t GetDebit() const
	{
	if (vin.empty())
	return 0;
	if (fDebitCached)
	return nDebitCached;
	nDebitCached = pwallet->GetDebit(*this);
	fDebitCached = true;
	return nDebitCached;
	}

	int64_t 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_t 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_t 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_t 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_t GetChange() const
	{
	if (fChangeCached)
	return nChangeCached;
	nChangeCached = pwallet->GetChange(*this);
	fChangeCached = true;
	return nChangeCached;
	}

	void GetAmounts(std::list<std::pair<CTxDestination, int64_t> >& listReceived,
	std::list<std::pair<CTxDestination, int64_t> >& listSent, int64_t& nFee, std::string& strSentAccount) const;

	void GetAccountAmounts(const std::string& strAccount, int64_t& nReceived,
	int64_t& nSent, int64_t& nFee) const;

	bool IsFromMe() const
	{
	return (GetDebit() > 0);
	}

	bool IsConfirmed() const
	{
	// Quick answer in most cases
	if (!IsFinalTx(*this))
	return false;
	if (GetDepthInMainChain() >= 1)
	return true;
	if (!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 (!IsFinalTx(*ptx))
	return false;
	if (ptx->GetDepthInMainChain() >= 1)
	continue;
	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_t GetTxTime() const;
	int GetRequestCount() const;

	void AddSupportingTransactions();
	bool AcceptWalletTransaction();
	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
	{
	LogPrintf("%s\n", ToString().c_str());
	}
	};




	/** Private key that includes an expiration date in case it never gets used. */
	class CWalletKey
	{
	public:
	CPrivKey vchPrivKey;
	int64_t nTimeCreated;
	int64_t 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_t 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_t nCreditDebit;
	int64_t nTime;
	std::string strOtherAccount;
	std::string strComment;
	mapValue_t mapValue;
	int64_t nOrderPos; // position in ordered transaction list
	uint64_t 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;
	};

	#endif

File Metadata

Mime Type: text/x-c++
Expires: Sat, Nov 23, 10:04 (22 h, 43 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 4526666
Default Alt Text: wallet.h (26 KB)

wallet.hNo OneTemporaryActions

wallet.hView Options

File Metadata

Event Timeline

wallet.h
No OneTemporary
Actions

wallet.h
View Options