No OneTemporary
Actions

Size

159 KB

Subscribers

None

View Options

	diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
	index 4b6d98025d..a76085de30 100644
	--- a/src/wallet/wallet.cpp
	+++ b/src/wallet/wallet.cpp
	@@ -1,3562 +1,3565 @@
	// Copyright (c) 2009-2010 Satoshi Nakamoto
	// Copyright (c) 2009-2015 The Bitcoin Core developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include "wallet/wallet.h"

	#include "base58.h"
	#include "checkpoints.h"
	#include "chain.h"
	#include "coincontrol.h"
	#include "consensus/consensus.h"
	#include "consensus/validation.h"
	#include "key.h"
	#include "keystore.h"
	#include "main.h"
	#include "net.h"
	#include "policy/policy.h"
	#include "primitives/block.h"
	#include "primitives/transaction.h"
	#include "script/script.h"
	#include "script/sign.h"
	#include "timedata.h"
	#include "txmempool.h"
	#include "util.h"
	#include "ui_interface.h"
	#include "utilmoneystr.h"

	#include <assert.h>

	#include <boost/algorithm/string/replace.hpp>
	#include <boost/filesystem.hpp>
	#include <boost/thread.hpp>

	using namespace std;

	CWallet* pwalletMain = NULL;
	/** Transaction fee set by the user */
	CFeeRate payTxFee(DEFAULT_TRANSACTION_FEE);
	unsigned int nTxConfirmTarget = DEFAULT_TX_CONFIRM_TARGET;
	bool bSpendZeroConfChange = DEFAULT_SPEND_ZEROCONF_CHANGE;
	bool fSendFreeTransactions = DEFAULT_SEND_FREE_TRANSACTIONS;

	const char * DEFAULT_WALLET_DAT = "wallet.dat";
	const uint32_t BIP32_HARDENED_KEY_LIMIT = 0x80000000;

	/**
	* Fees smaller than this (in satoshi) are considered zero fee (for transaction creation)
	* Override with -mintxfee
	*/
	CFeeRate CWallet::minTxFee = CFeeRate(DEFAULT_TRANSACTION_MINFEE);
	/**
	* If fee estimation does not have enough data to provide estimates, use this fee instead.
	* Has no effect if not using fee estimation
	* Override with -fallbackfee
	*/
	CFeeRate CWallet::fallbackFee = CFeeRate(DEFAULT_FALLBACK_FEE);

	const uint256 CMerkleTx::ABANDON_HASH(uint256S("0000000000000000000000000000000000000000000000000000000000000001"));

	/** @defgroup mapWallet
	*
	* @{
	*/

	struct CompareValueOnly
	{
	bool operator()(const pair<CAmount, pair<const CWalletTx*, unsigned int> >& t1,
	const pair<CAmount, pair<const CWalletTx*, unsigned int> >& t2) const
	{
	return t1.first < t2.first;
	}
	};

	std::string COutput::ToString() const
	{
	return strprintf("COutput(%s, %d, %d) [%s]", tx->GetHash().ToString(), i, nDepth, FormatMoney(tx->vout[i].nValue));
	}

	const CWalletTx* CWallet::GetWalletTx(const uint256& hash) const
	{
	LOCK(cs_wallet);
	std::map<uint256, CWalletTx>::const_iterator it = mapWallet.find(hash);
	if (it == mapWallet.end())
	return NULL;
	return &(it->second);
	}

	CPubKey CWallet::GenerateNewKey()
	{
	AssertLockHeld(cs_wallet); // mapKeyMetadata
	bool fCompressed = CanSupportFeature(FEATURE_COMPRPUBKEY); // default to compressed public keys if we want 0.6.0 wallets

	CKey secret;

	// Create new metadata
	int64_t nCreationTime = GetTime();
	CKeyMetadata metadata(nCreationTime);

	// use HD key derivation if HD was enabled during wallet creation
	if (!hdChain.masterKeyID.IsNull()) {
	// for now we use a fixed keypath scheme of m/0'/0'/k
	CKey key; //master key seed (256bit)
	CExtKey masterKey; //hd master key
	CExtKey accountKey; //key at m/0'
	CExtKey externalChainChildKey; //key at m/0'/0'
	CExtKey childKey; //key at m/0'/0'/<n>'

	// try to get the master key
	if (!GetKey(hdChain.masterKeyID, key))
	throw std::runtime_error("CWallet::GenerateNewKey(): Master key not found");

	masterKey.SetMaster(key.begin(), key.size());

	// derive m/0'
	// use hardened derivation (child keys >= 0x80000000 are hardened after bip32)
	masterKey.Derive(accountKey, BIP32_HARDENED_KEY_LIMIT);

	// derive m/0'/0'
	accountKey.Derive(externalChainChildKey, BIP32_HARDENED_KEY_LIMIT);

	// derive child key at next index, skip keys already known to the wallet
	do
	{
	// always derive hardened keys
	// childIndex \| BIP32_HARDENED_KEY_LIMIT = derive childIndex in hardened child-index-range
	// example: 1 \| BIP32_HARDENED_KEY_LIMIT == 0x80000001 == 2147483649
	externalChainChildKey.Derive(childKey, hdChain.nExternalChainCounter \| BIP32_HARDENED_KEY_LIMIT);
	metadata.hdKeypath = "m/0'/0'/"+std::to_string(hdChain.nExternalChainCounter)+"'";
	metadata.hdMasterKeyID = hdChain.masterKeyID;
	// increment childkey index
	hdChain.nExternalChainCounter++;
	} while(HaveKey(childKey.key.GetPubKey().GetID()));
	secret = childKey.key;

	// update the chain model in the database
	if (!CWalletDB(strWalletFile).WriteHDChain(hdChain))
	throw std::runtime_error("CWallet::GenerateNewKey(): Writing HD chain model failed");
	} else {
	secret.MakeNewKey(fCompressed);
	}

	// Compressed public keys were introduced in version 0.6.0
	if (fCompressed)
	SetMinVersion(FEATURE_COMPRPUBKEY);

	CPubKey pubkey = secret.GetPubKey();
	assert(secret.VerifyPubKey(pubkey));

	mapKeyMetadata[pubkey.GetID()] = metadata;
	if (!nTimeFirstKey \|\| nCreationTime < nTimeFirstKey)
	nTimeFirstKey = nCreationTime;

	if (!AddKeyPubKey(secret, pubkey))
	throw std::runtime_error("CWallet::GenerateNewKey(): AddKey failed");
	return pubkey;
	}

	bool CWallet::AddKeyPubKey(const CKey& secret, const CPubKey &pubkey)
	{
	AssertLockHeld(cs_wallet); // mapKeyMetadata
	if (!CCryptoKeyStore::AddKeyPubKey(secret, pubkey))
	return false;

	// check if we need to remove from watch-only
	CScript script;
	script = GetScriptForDestination(pubkey.GetID());
	if (HaveWatchOnly(script))
	RemoveWatchOnly(script);
	script = GetScriptForRawPubKey(pubkey);
	if (HaveWatchOnly(script))
	RemoveWatchOnly(script);

	if (!fFileBacked)
	return true;
	if (!IsCrypted()) {
	return CWalletDB(strWalletFile).WriteKey(pubkey,
	secret.GetPrivKey(),
	mapKeyMetadata[pubkey.GetID()]);
	}
	return true;
	}

	bool CWallet::AddCryptedKey(const CPubKey &vchPubKey,
	const vector<unsigned char> &vchCryptedSecret)
	{
	if (!CCryptoKeyStore::AddCryptedKey(vchPubKey, vchCryptedSecret))
	return false;
	if (!fFileBacked)
	return true;
	{
	LOCK(cs_wallet);
	if (pwalletdbEncryption)
	return pwalletdbEncryption->WriteCryptedKey(vchPubKey,
	vchCryptedSecret,
	mapKeyMetadata[vchPubKey.GetID()]);
	else
	return CWalletDB(strWalletFile).WriteCryptedKey(vchPubKey,
	vchCryptedSecret,
	mapKeyMetadata[vchPubKey.GetID()]);
	}
	return false;
	}

	bool CWallet::LoadKeyMetadata(const CPubKey &pubkey, const CKeyMetadata &meta)
	{
	AssertLockHeld(cs_wallet); // mapKeyMetadata
	if (meta.nCreateTime && (!nTimeFirstKey \|\| meta.nCreateTime < nTimeFirstKey))
	nTimeFirstKey = meta.nCreateTime;

	mapKeyMetadata[pubkey.GetID()] = meta;
	return true;
	}

	bool CWallet::LoadCryptedKey(const CPubKey &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret)
	{
	return CCryptoKeyStore::AddCryptedKey(vchPubKey, vchCryptedSecret);
	}

	bool CWallet::AddCScript(const CScript& redeemScript)
	{
	if (!CCryptoKeyStore::AddCScript(redeemScript))
	return false;
	if (!fFileBacked)
	return true;
	return CWalletDB(strWalletFile).WriteCScript(Hash160(redeemScript), redeemScript);
	}

	bool CWallet::LoadCScript(const CScript& redeemScript)
	{
	/* A sanity check was added in pull #3843 to avoid adding redeemScripts
	* that never can be redeemed. However, old wallets may still contain
	* these. Do not add them to the wallet and warn. */
	if (redeemScript.size() > MAX_SCRIPT_ELEMENT_SIZE)
	{
	std::string strAddr = CBitcoinAddress(CScriptID(redeemScript)).ToString();
	LogPrintf("%s: Warning: This wallet contains a redeemScript of size %i which exceeds maximum size %i thus can never be redeemed. Do not use address %s.\n",
	__func__, redeemScript.size(), MAX_SCRIPT_ELEMENT_SIZE, strAddr);
	return true;
	}

	return CCryptoKeyStore::AddCScript(redeemScript);
	}

	bool CWallet::AddWatchOnly(const CScript &dest)
	{
	if (!CCryptoKeyStore::AddWatchOnly(dest))
	return false;
	nTimeFirstKey = 1; // No birthday information for watch-only keys.
	NotifyWatchonlyChanged(true);
	if (!fFileBacked)
	return true;
	return CWalletDB(strWalletFile).WriteWatchOnly(dest);
	}

	bool CWallet::RemoveWatchOnly(const CScript &dest)
	{
	AssertLockHeld(cs_wallet);
	if (!CCryptoKeyStore::RemoveWatchOnly(dest))
	return false;
	if (!HaveWatchOnly())
	NotifyWatchonlyChanged(false);
	if (fFileBacked)
	if (!CWalletDB(strWalletFile).EraseWatchOnly(dest))
	return false;

	return true;
	}

	bool CWallet::LoadWatchOnly(const CScript &dest)
	{
	return CCryptoKeyStore::AddWatchOnly(dest);
	}

	bool CWallet::Unlock(const SecureString& strWalletPassphrase)
	{
	CCrypter crypter;
	CKeyingMaterial vMasterKey;

	{
	LOCK(cs_wallet);
	BOOST_FOREACH(const MasterKeyMap::value_type& pMasterKey, mapMasterKeys)
	{
	if(!crypter.SetKeyFromPassphrase(strWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
	return false;
	if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, vMasterKey))
	continue; // try another master key
	if (CCryptoKeyStore::Unlock(vMasterKey))
	return true;
	}
	}
	return false;
	}

	bool CWallet::ChangeWalletPassphrase(const SecureString& strOldWalletPassphrase, const SecureString& strNewWalletPassphrase)
	{
	bool fWasLocked = IsLocked();

	{
	LOCK(cs_wallet);
	Lock();

	CCrypter crypter;
	CKeyingMaterial vMasterKey;
	BOOST_FOREACH(MasterKeyMap::value_type& pMasterKey, mapMasterKeys)
	{
	if(!crypter.SetKeyFromPassphrase(strOldWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
	return false;
	if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, vMasterKey))
	return false;
	if (CCryptoKeyStore::Unlock(vMasterKey))
	{
	int64_t nStartTime = GetTimeMillis();
	crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod);
	pMasterKey.second.nDeriveIterations = pMasterKey.second.nDeriveIterations * (100 / ((double)(GetTimeMillis() - nStartTime)));

	nStartTime = GetTimeMillis();
	crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod);
	pMasterKey.second.nDeriveIterations = (pMasterKey.second.nDeriveIterations + pMasterKey.second.nDeriveIterations * 100 / ((double)(GetTimeMillis() - nStartTime))) / 2;

	if (pMasterKey.second.nDeriveIterations < 25000)
	pMasterKey.second.nDeriveIterations = 25000;

	LogPrintf("Wallet passphrase changed to an nDeriveIterations of %i\n", pMasterKey.second.nDeriveIterations);

	if (!crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
	return false;
	if (!crypter.Encrypt(vMasterKey, pMasterKey.second.vchCryptedKey))
	return false;
	CWalletDB(strWalletFile).WriteMasterKey(pMasterKey.first, pMasterKey.second);
	if (fWasLocked)
	Lock();
	return true;
	}
	}
	}

	return false;
	}

	void CWallet::SetBestChain(const CBlockLocator& loc)
	{
	CWalletDB walletdb(strWalletFile);
	walletdb.WriteBestBlock(loc);
	}

	bool CWallet::SetMinVersion(enum WalletFeature nVersion, CWalletDB* pwalletdbIn, bool fExplicit)
	{
	LOCK(cs_wallet); // nWalletVersion
	if (nWalletVersion >= nVersion)
	return true;

	// when doing an explicit upgrade, if we pass the max version permitted, upgrade all the way
	if (fExplicit && nVersion > nWalletMaxVersion)
	nVersion = FEATURE_LATEST;

	nWalletVersion = nVersion;

	if (nVersion > nWalletMaxVersion)
	nWalletMaxVersion = nVersion;

	if (fFileBacked)
	{
	CWalletDB* pwalletdb = pwalletdbIn ? pwalletdbIn : new CWalletDB(strWalletFile);
	if (nWalletVersion > 40000)
	pwalletdb->WriteMinVersion(nWalletVersion);
	if (!pwalletdbIn)
	delete pwalletdb;
	}

	return true;
	}

	bool CWallet::SetMaxVersion(int nVersion)
	{
	LOCK(cs_wallet); // nWalletVersion, nWalletMaxVersion
	// cannot downgrade below current version
	if (nWalletVersion > nVersion)
	return false;

	nWalletMaxVersion = nVersion;

	return true;
	}

	set<uint256> CWallet::GetConflicts(const uint256& txid) const
	{
	set<uint256> result;
	AssertLockHeld(cs_wallet);

	std::map<uint256, CWalletTx>::const_iterator it = mapWallet.find(txid);
	if (it == mapWallet.end())
	return result;
	const CWalletTx& wtx = it->second;

	std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range;

	BOOST_FOREACH(const CTxIn& txin, wtx.vin)
	{
	if (mapTxSpends.count(txin.prevout) <= 1)
	continue; // No conflict if zero or one spends
	range = mapTxSpends.equal_range(txin.prevout);
	for (TxSpends::const_iterator it = range.first; it != range.second; ++it)
	result.insert(it->second);
	}
	return result;
	}

	void CWallet::Flush(bool shutdown)
	{
	bitdb.Flush(shutdown);
	}

	bool CWallet::Verify()
	{
	LogPrintf("Using BerkeleyDB version %s\n", DbEnv::version(0, 0, 0));
	std::string walletFile = GetArg("-wallet", DEFAULT_WALLET_DAT);

	LogPrintf("Using wallet %s\n", walletFile);
	uiInterface.InitMessage(_("Verifying wallet..."));

	// Wallet file must be a plain filename without a directory
	if (walletFile != boost::filesystem::basename(walletFile) + boost::filesystem::extension(walletFile))
	return InitError(strprintf(_("Wallet %s resides outside data directory %s"), walletFile, GetDataDir().string()));

	if (!bitdb.Open(GetDataDir()))
	{
	// try moving the database env out of the way
	boost::filesystem::path pathDatabase = GetDataDir() / "database";
	boost::filesystem::path pathDatabaseBak = GetDataDir() / strprintf("database.%d.bak", GetTime());
	try {
	boost::filesystem::rename(pathDatabase, pathDatabaseBak);
	LogPrintf("Moved old %s to %s. Retrying.\n", pathDatabase.string(), pathDatabaseBak.string());
	} catch (const boost::filesystem::filesystem_error&) {
	// failure is ok (well, not really, but it's not worse than what we started with)
	}

	// try again
	if (!bitdb.Open(GetDataDir())) {
	// if it still fails, it probably means we can't even create the database env
	return InitError(strprintf(_("Error initializing wallet database environment %s!"), GetDataDir()));
	}
	}

	if (GetBoolArg("-salvagewallet", false))
	{
	// Recover readable keypairs:
	if (!CWalletDB::Recover(bitdb, walletFile, true))
	return false;
	}

	if (boost::filesystem::exists(GetDataDir() / walletFile))
	{
	CDBEnv::VerifyResult r = bitdb.Verify(walletFile, CWalletDB::Recover);
	if (r == CDBEnv::RECOVER_OK)
	{
	InitWarning(strprintf(_("Warning: Wallet file corrupt, data salvaged!"
	" Original %s saved as %s in %s; if"
	" your balance or transactions are incorrect you should"
	" restore from a backup."),
	walletFile, "wallet.{timestamp}.bak", GetDataDir()));
	}
	if (r == CDBEnv::RECOVER_FAIL)
	return InitError(strprintf(_("%s corrupt, salvage failed"), walletFile));
	}

	return true;
	}

	void CWallet::SyncMetaData(pair<TxSpends::iterator, TxSpends::iterator> range)
	{
	// We want all the wallet transactions in range to have the same metadata as
	// the oldest (smallest nOrderPos).
	// So: find smallest nOrderPos:

	int nMinOrderPos = std::numeric_limits<int>::max();
	const CWalletTx* copyFrom = NULL;
	for (TxSpends::iterator it = range.first; it != range.second; ++it)
	{
	const uint256& hash = it->second;
	int n = mapWallet[hash].nOrderPos;
	if (n < nMinOrderPos)
	{
	nMinOrderPos = n;
	copyFrom = &mapWallet[hash];
	}
	}
	// Now copy data from copyFrom to rest:
	for (TxSpends::iterator it = range.first; it != range.second; ++it)
	{
	const uint256& hash = it->second;
	CWalletTx* copyTo = &mapWallet[hash];
	if (copyFrom == copyTo) continue;
	if (!copyFrom->IsEquivalentTo(*copyTo)) continue;
	copyTo->mapValue = copyFrom->mapValue;
	copyTo->vOrderForm = copyFrom->vOrderForm;
	// fTimeReceivedIsTxTime not copied on purpose
	// nTimeReceived not copied on purpose
	copyTo->nTimeSmart = copyFrom->nTimeSmart;
	copyTo->fFromMe = copyFrom->fFromMe;
	copyTo->strFromAccount = copyFrom->strFromAccount;
	// nOrderPos not copied on purpose
	// cached members not copied on purpose
	}
	}

	/**
	* Outpoint is spent if any non-conflicted transaction
	* spends it:
	*/
	bool CWallet::IsSpent(const uint256& hash, unsigned int n) const
	{
	const COutPoint outpoint(hash, n);
	pair<TxSpends::const_iterator, TxSpends::const_iterator> range;
	range = mapTxSpends.equal_range(outpoint);

	for (TxSpends::const_iterator it = range.first; it != range.second; ++it)
	{
	const uint256& wtxid = it->second;
	std::map<uint256, CWalletTx>::const_iterator mit = mapWallet.find(wtxid);
	if (mit != mapWallet.end()) {
	int depth = mit->second.GetDepthInMainChain();
	if (depth > 0 \|\| (depth == 0 && !mit->second.isAbandoned()))
	return true; // Spent
	}
	}
	return false;
	}

	void CWallet::AddToSpends(const COutPoint& outpoint, const uint256& wtxid)
	{
	mapTxSpends.insert(make_pair(outpoint, wtxid));

	pair<TxSpends::iterator, TxSpends::iterator> range;
	range = mapTxSpends.equal_range(outpoint);
	SyncMetaData(range);
	}


	void CWallet::AddToSpends(const uint256& wtxid)
	{
	assert(mapWallet.count(wtxid));
	CWalletTx& thisTx = mapWallet[wtxid];
	if (thisTx.IsCoinBase()) // Coinbases don't spend anything!
	return;

	BOOST_FOREACH(const CTxIn& txin, thisTx.vin)
	AddToSpends(txin.prevout, wtxid);
	}

	bool CWallet::EncryptWallet(const SecureString& strWalletPassphrase)
	{
	if (IsCrypted())
	return false;

	CKeyingMaterial vMasterKey;

	vMasterKey.resize(WALLET_CRYPTO_KEY_SIZE);
	GetStrongRandBytes(&vMasterKey[0], WALLET_CRYPTO_KEY_SIZE);

	CMasterKey kMasterKey;

	kMasterKey.vchSalt.resize(WALLET_CRYPTO_SALT_SIZE);
	GetStrongRandBytes(&kMasterKey.vchSalt[0], WALLET_CRYPTO_SALT_SIZE);

	CCrypter crypter;
	int64_t nStartTime = GetTimeMillis();
	crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, 25000, kMasterKey.nDerivationMethod);
	kMasterKey.nDeriveIterations = 2500000 / ((double)(GetTimeMillis() - nStartTime));

	nStartTime = GetTimeMillis();
	crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, kMasterKey.nDeriveIterations, kMasterKey.nDerivationMethod);
	kMasterKey.nDeriveIterations = (kMasterKey.nDeriveIterations + kMasterKey.nDeriveIterations * 100 / ((double)(GetTimeMillis() - nStartTime))) / 2;

	if (kMasterKey.nDeriveIterations < 25000)
	kMasterKey.nDeriveIterations = 25000;

	LogPrintf("Encrypting Wallet with an nDeriveIterations of %i\n", kMasterKey.nDeriveIterations);

	if (!crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, kMasterKey.nDeriveIterations, kMasterKey.nDerivationMethod))
	return false;
	if (!crypter.Encrypt(vMasterKey, kMasterKey.vchCryptedKey))
	return false;

	{
	LOCK(cs_wallet);
	mapMasterKeys[++nMasterKeyMaxID] = kMasterKey;
	if (fFileBacked)
	{
	assert(!pwalletdbEncryption);
	pwalletdbEncryption = new CWalletDB(strWalletFile);
	if (!pwalletdbEncryption->TxnBegin()) {
	delete pwalletdbEncryption;
	pwalletdbEncryption = NULL;
	return false;
	}
	pwalletdbEncryption->WriteMasterKey(nMasterKeyMaxID, kMasterKey);
	}

	if (!EncryptKeys(vMasterKey))
	{
	if (fFileBacked) {
	pwalletdbEncryption->TxnAbort();
	delete pwalletdbEncryption;
	}
	// We now probably have half of our keys encrypted in memory, and half not...
	// die and let the user reload the unencrypted wallet.
	assert(false);
	}

	// Encryption was introduced in version 0.4.0
	SetMinVersion(FEATURE_WALLETCRYPT, pwalletdbEncryption, true);

	if (fFileBacked)
	{
	if (!pwalletdbEncryption->TxnCommit()) {
	delete pwalletdbEncryption;
	// We now have keys encrypted in memory, but not on disk...
	// die to avoid confusion and let the user reload the unencrypted wallet.
	assert(false);
	}

	delete pwalletdbEncryption;
	pwalletdbEncryption = NULL;
	}

	Lock();
	Unlock(strWalletPassphrase);
	NewKeyPool();
	Lock();

	// Need to completely rewrite the wallet file; if we don't, bdb might keep
	// bits of the unencrypted private key in slack space in the database file.
	CDB::Rewrite(strWalletFile);

	}
	NotifyStatusChanged(this);

	return true;
	}

	int64_t CWallet::IncOrderPosNext(CWalletDB *pwalletdb)
	{
	AssertLockHeld(cs_wallet); // nOrderPosNext
	int64_t nRet = nOrderPosNext++;
	if (pwalletdb) {
	pwalletdb->WriteOrderPosNext(nOrderPosNext);
	} else {
	CWalletDB(strWalletFile).WriteOrderPosNext(nOrderPosNext);
	}
	return nRet;
	}

	bool CWallet::AccountMove(std::string strFrom, std::string strTo, CAmount nAmount, std::string strComment)
	{
	CWalletDB walletdb(strWalletFile);
	if (!walletdb.TxnBegin())
	return false;

	int64_t nNow = GetAdjustedTime();

	// Debit
	CAccountingEntry debit;
	debit.nOrderPos = IncOrderPosNext(&walletdb);
	debit.strAccount = strFrom;
	debit.nCreditDebit = -nAmount;
	debit.nTime = nNow;
	debit.strOtherAccount = strTo;
	debit.strComment = strComment;
	AddAccountingEntry(debit, walletdb);

	// Credit
	CAccountingEntry credit;
	credit.nOrderPos = IncOrderPosNext(&walletdb);
	credit.strAccount = strTo;
	credit.nCreditDebit = nAmount;
	credit.nTime = nNow;
	credit.strOtherAccount = strFrom;
	credit.strComment = strComment;
	AddAccountingEntry(credit, walletdb);

	if (!walletdb.TxnCommit())
	return false;

	return true;
	}

	bool CWallet::GetAccountPubkey(CPubKey &pubKey, std::string strAccount, bool bForceNew)
	{
	CWalletDB walletdb(strWalletFile);

	CAccount account;
	walletdb.ReadAccount(strAccount, account);

	if (!bForceNew) {
	if (!account.vchPubKey.IsValid())
	bForceNew = true;
	else {
	// Check if the current key has been used
	CScript scriptPubKey = GetScriptForDestination(account.vchPubKey.GetID());
	for (map<uint256, CWalletTx>::iterator it = mapWallet.begin();
	it != mapWallet.end() && account.vchPubKey.IsValid();
	++it)
	BOOST_FOREACH(const CTxOut& txout, (*it).second.vout)
	if (txout.scriptPubKey == scriptPubKey) {
	bForceNew = true;
	break;
	}
	}
	}

	// Generate a new key
	if (bForceNew) {
	if (!GetKeyFromPool(account.vchPubKey))
	return false;

	SetAddressBook(account.vchPubKey.GetID(), strAccount, "receive");
	walletdb.WriteAccount(strAccount, account);
	}

	pubKey = account.vchPubKey;

	return true;
	}

	void CWallet::MarkDirty()
	{
	{
	LOCK(cs_wallet);
	BOOST_FOREACH(PAIRTYPE(const uint256, CWalletTx)& item, mapWallet)
	item.second.MarkDirty();
	}
	}

	bool CWallet::AddToWallet(const CWalletTx& wtxIn, bool fFromLoadWallet, CWalletDB* pwalletdb)
	{
	uint256 hash = wtxIn.GetHash();

	if (fFromLoadWallet)
	{
	mapWallet[hash] = wtxIn;
	CWalletTx& wtx = mapWallet[hash];
	wtx.BindWallet(this);
	wtxOrdered.insert(make_pair(wtx.nOrderPos, TxPair(&wtx, (CAccountingEntry*)0)));
	AddToSpends(hash);
	BOOST_FOREACH(const CTxIn& txin, wtx.vin) {
	if (mapWallet.count(txin.prevout.hash)) {
	CWalletTx& prevtx = mapWallet[txin.prevout.hash];
	if (prevtx.nIndex == -1 && !prevtx.hashUnset()) {
	MarkConflicted(prevtx.hashBlock, wtx.GetHash());
	}
	}
	}
	}
	else
	{
	LOCK(cs_wallet);
	// Inserts only if not already there, returns tx inserted or tx found
	pair<map<uint256, CWalletTx>::iterator, bool> ret = mapWallet.insert(make_pair(hash, wtxIn));
	CWalletTx& wtx = (*ret.first).second;
	wtx.BindWallet(this);
	bool fInsertedNew = ret.second;
	if (fInsertedNew)
	{
	wtx.nTimeReceived = GetAdjustedTime();
	wtx.nOrderPos = IncOrderPosNext(pwalletdb);
	wtxOrdered.insert(make_pair(wtx.nOrderPos, TxPair(&wtx, (CAccountingEntry*)0)));

	wtx.nTimeSmart = wtx.nTimeReceived;
	if (!wtxIn.hashUnset())
	{
	if (mapBlockIndex.count(wtxIn.hashBlock))
	{
	int64_t latestNow = wtx.nTimeReceived;
	int64_t latestEntry = 0;
	{
	// Tolerate times up to the last timestamp in the wallet not more than 5 minutes into the future
	int64_t latestTolerated = latestNow + 300;
	const TxItems & txOrdered = wtxOrdered;
	for (TxItems::const_reverse_iterator it = txOrdered.rbegin(); it != txOrdered.rend(); ++it)
	{
	CWalletTx const pwtx = (it).second.first;
	if (pwtx == &wtx)
	continue;
	CAccountingEntry const pacentry = (it).second.second;
	int64_t nSmartTime;
	if (pwtx)
	{
	nSmartTime = pwtx->nTimeSmart;
	if (!nSmartTime)
	nSmartTime = pwtx->nTimeReceived;
	}
	else
	nSmartTime = pacentry->nTime;
	if (nSmartTime <= latestTolerated)
	{
	latestEntry = nSmartTime;
	if (nSmartTime > latestNow)
	latestNow = nSmartTime;
	break;
	}
	}
	}

	int64_t blocktime = mapBlockIndex[wtxIn.hashBlock]->GetBlockTime();
	wtx.nTimeSmart = std::max(latestEntry, std::min(blocktime, latestNow));
	}
	else
	LogPrintf("AddToWallet(): found %s in block %s not in index\n",
	wtxIn.GetHash().ToString(),
	wtxIn.hashBlock.ToString());
	}
	AddToSpends(hash);
	}

	bool fUpdated = false;
	if (!fInsertedNew)
	{
	// Merge
	if (!wtxIn.hashUnset() && wtxIn.hashBlock != wtx.hashBlock)
	{
	wtx.hashBlock = wtxIn.hashBlock;
	fUpdated = true;
	}
	// If no longer abandoned, update
	if (wtxIn.hashBlock.IsNull() && wtx.isAbandoned())
	{
	wtx.hashBlock = wtxIn.hashBlock;
	fUpdated = true;
	}
	if (wtxIn.nIndex != -1 && (wtxIn.nIndex != wtx.nIndex))
	{
	wtx.nIndex = wtxIn.nIndex;
	fUpdated = true;
	}
	if (wtxIn.fFromMe && wtxIn.fFromMe != wtx.fFromMe)
	{
	wtx.fFromMe = wtxIn.fFromMe;
	fUpdated = true;
	}
	}

	//// debug print
	LogPrintf("AddToWallet %s %s%s\n", wtxIn.GetHash().ToString(), (fInsertedNew ? "new" : ""), (fUpdated ? "update" : ""));

	// Write to disk
	if (fInsertedNew \|\| fUpdated)
	if (!pwalletdb->WriteTx(wtx))
	return false;

	// Break debit/credit balance caches:
	wtx.MarkDirty();

	// Notify UI of new or updated transaction
	NotifyTransactionChanged(this, hash, fInsertedNew ? CT_NEW : CT_UPDATED);

	// notify an external script when a wallet transaction comes in or is updated
	std::string strCmd = GetArg("-walletnotify", "");

	if ( !strCmd.empty())
	{
	boost::replace_all(strCmd, "%s", wtxIn.GetHash().GetHex());
	boost::thread t(runCommand, strCmd); // thread runs free
	}

	}
	return true;
	}

	/**
	* Add a transaction to the wallet, or update it.
	* pblock is optional, but should be provided if the transaction is known to be in a block.
	* If fUpdate is true, existing transactions will be updated.
	*/
	bool CWallet::AddToWalletIfInvolvingMe(const CTransaction& tx, const CBlock* pblock, bool fUpdate)
	{
	{
	AssertLockHeld(cs_wallet);

	if (pblock) {
	BOOST_FOREACH(const CTxIn& txin, tx.vin) {
	std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range = mapTxSpends.equal_range(txin.prevout);
	while (range.first != range.second) {
	if (range.first->second != tx.GetHash()) {
	LogPrintf("Transaction %s (in block %s) conflicts with wallet transaction %s (both spend %s:%i)\n", tx.GetHash().ToString(), pblock->GetHash().ToString(), range.first->second.ToString(), range.first->first.hash.ToString(), range.first->first.n);
	MarkConflicted(pblock->GetHash(), range.first->second);
	}
	range.first++;
	}
	}
	}

	bool fExisted = mapWallet.count(tx.GetHash()) != 0;
	if (fExisted && !fUpdate) return false;
	if (fExisted \|\| IsMine(tx) \|\| IsFromMe(tx))
	{
	CWalletTx wtx(this,tx);

	// Get merkle branch if transaction was found in a block
	if (pblock)
	wtx.SetMerkleBranch(*pblock);

	// Do not flush the wallet here for performance reasons
	// this is safe, as in case of a crash, we rescan the necessary blocks on startup through our SetBestChain-mechanism
	CWalletDB walletdb(strWalletFile, "r+", false);

	return AddToWallet(wtx, false, &walletdb);
	}
	}
	return false;
	}

	bool CWallet::AbandonTransaction(const uint256& hashTx)
	{
	LOCK2(cs_main, cs_wallet);

	// Do not flush the wallet here for performance reasons
	CWalletDB walletdb(strWalletFile, "r+", false);

	std::set<uint256> todo;
	std::set<uint256> done;

	// Can't mark abandoned if confirmed or in mempool
	assert(mapWallet.count(hashTx));
	CWalletTx& origtx = mapWallet[hashTx];
	if (origtx.GetDepthInMainChain() > 0 \|\| origtx.InMempool()) {
	return false;
	}

	todo.insert(hashTx);

	while (!todo.empty()) {
	uint256 now = *todo.begin();
	todo.erase(now);
	done.insert(now);
	assert(mapWallet.count(now));
	CWalletTx& wtx = mapWallet[now];
	int currentconfirm = wtx.GetDepthInMainChain();
	// If the orig tx was not in block, none of its spends can be
	assert(currentconfirm <= 0);
	// if (currentconfirm < 0) {Tx and spends are already conflicted, no need to abandon}
	if (currentconfirm == 0 && !wtx.isAbandoned()) {
	// If the orig tx was not in block/mempool, none of its spends can be in mempool
	assert(!wtx.InMempool());
	wtx.nIndex = -1;
	wtx.setAbandoned();
	wtx.MarkDirty();
	walletdb.WriteTx(wtx);
	NotifyTransactionChanged(this, wtx.GetHash(), CT_UPDATED);
	// Iterate over all its outputs, and mark transactions in the wallet that spend them abandoned too
	TxSpends::const_iterator iter = mapTxSpends.lower_bound(COutPoint(hashTx, 0));
	while (iter != mapTxSpends.end() && iter->first.hash == now) {
	if (!done.count(iter->second)) {
	todo.insert(iter->second);
	}
	iter++;
	}
	// If a transaction changes 'conflicted' state, that changes the balance
	// available of the outputs it spends. So force those to be recomputed
	BOOST_FOREACH(const CTxIn& txin, wtx.vin)
	{
	if (mapWallet.count(txin.prevout.hash))
	mapWallet[txin.prevout.hash].MarkDirty();
	}
	}
	}

	return true;
	}

	void CWallet::MarkConflicted(const uint256& hashBlock, const uint256& hashTx)
	{
	LOCK2(cs_main, cs_wallet);

	int conflictconfirms = 0;
	if (mapBlockIndex.count(hashBlock)) {
	CBlockIndex* pindex = mapBlockIndex[hashBlock];
	if (chainActive.Contains(pindex)) {
	conflictconfirms = -(chainActive.Height() - pindex->nHeight + 1);
	}
	}
	// If number of conflict confirms cannot be determined, this means
	// that the block is still unknown or not yet part of the main chain,
	// for example when loading the wallet during a reindex. Do nothing in that
	// case.
	if (conflictconfirms >= 0)
	return;

	// Do not flush the wallet here for performance reasons
	CWalletDB walletdb(strWalletFile, "r+", false);

	std::set<uint256> todo;
	std::set<uint256> done;

	todo.insert(hashTx);

	while (!todo.empty()) {
	uint256 now = *todo.begin();
	todo.erase(now);
	done.insert(now);
	assert(mapWallet.count(now));
	CWalletTx& wtx = mapWallet[now];
	int currentconfirm = wtx.GetDepthInMainChain();
	if (conflictconfirms < currentconfirm) {
	// Block is 'more conflicted' than current confirm; update.
	// Mark transaction as conflicted with this block.
	wtx.nIndex = -1;
	wtx.hashBlock = hashBlock;
	wtx.MarkDirty();
	walletdb.WriteTx(wtx);
	// Iterate over all its outputs, and mark transactions in the wallet that spend them conflicted too
	TxSpends::const_iterator iter = mapTxSpends.lower_bound(COutPoint(now, 0));
	while (iter != mapTxSpends.end() && iter->first.hash == now) {
	if (!done.count(iter->second)) {
	todo.insert(iter->second);
	}
	iter++;
	}
	// If a transaction changes 'conflicted' state, that changes the balance
	// available of the outputs it spends. So force those to be recomputed
	BOOST_FOREACH(const CTxIn& txin, wtx.vin)
	{
	if (mapWallet.count(txin.prevout.hash))
	mapWallet[txin.prevout.hash].MarkDirty();
	}
	}
	}
	}

	void CWallet::SyncTransaction(const CTransaction& tx, const CBlockIndex pindex, const CBlock pblock)
	{
	LOCK2(cs_main, cs_wallet);

	if (!AddToWalletIfInvolvingMe(tx, pblock, true))
	return; // Not one of ours

	// If a transaction changes 'conflicted' state, that changes the balance
	// available of the outputs it spends. So force those to be
	// recomputed, also:
	BOOST_FOREACH(const CTxIn& txin, tx.vin)
	{
	if (mapWallet.count(txin.prevout.hash))
	mapWallet[txin.prevout.hash].MarkDirty();
	}
	}


	isminetype CWallet::IsMine(const CTxIn &txin) const
	{
	{
	LOCK(cs_wallet);
	map<uint256, CWalletTx>::const_iterator mi = mapWallet.find(txin.prevout.hash);
	if (mi != mapWallet.end())
	{
	const CWalletTx& prev = (*mi).second;
	if (txin.prevout.n < prev.vout.size())
	return IsMine(prev.vout[txin.prevout.n]);
	}
	}
	return ISMINE_NO;
	}

	CAmount CWallet::GetDebit(const CTxIn &txin, const isminefilter& filter) const
	{
	{
	LOCK(cs_wallet);
	map<uint256, CWalletTx>::const_iterator mi = mapWallet.find(txin.prevout.hash);
	if (mi != mapWallet.end())
	{
	const CWalletTx& prev = (*mi).second;
	if (txin.prevout.n < prev.vout.size())
	if (IsMine(prev.vout[txin.prevout.n]) & filter)
	return prev.vout[txin.prevout.n].nValue;
	}
	}
	return 0;
	}

	isminetype CWallet::IsMine(const CTxOut& txout) const
	{
	return ::IsMine(*this, txout.scriptPubKey);
	}

	CAmount CWallet::GetCredit(const CTxOut& txout, const isminefilter& filter) const
	{
	if (!MoneyRange(txout.nValue))
	throw std::runtime_error("CWallet::GetCredit(): value out of range");
	return ((IsMine(txout) & filter) ? txout.nValue : 0);
	}

	bool CWallet::IsChange(const CTxOut& txout) const
	{
	// TODO: fix handling of 'change' outputs. The assumption is that any
	// payment to a script that is ours, but is not in the address book
	// is change. That assumption is likely to break when we implement multisignature
	// wallets that return change back into a multi-signature-protected address;
	// a better way of identifying which outputs are 'the send' and which are
	// 'the change' will need to be implemented (maybe extend CWalletTx to remember
	// which output, if any, was change).
	if (::IsMine(*this, txout.scriptPubKey))
	{
	CTxDestination address;
	if (!ExtractDestination(txout.scriptPubKey, address))
	return true;

	LOCK(cs_wallet);
	if (!mapAddressBook.count(address))
	return true;
	}
	return false;
	}

	CAmount CWallet::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 CWallet::IsMine(const CTransaction& tx) const
	{
	BOOST_FOREACH(const CTxOut& txout, tx.vout)
	if (IsMine(txout))
	return true;
	return false;
	}

	bool CWallet::IsFromMe(const CTransaction& tx) const
	{
	return (GetDebit(tx, ISMINE_ALL) > 0);
	}

	CAmount CWallet::GetDebit(const CTransaction& tx, const isminefilter& filter) const
	{
	CAmount nDebit = 0;
	BOOST_FOREACH(const CTxIn& txin, tx.vin)
	{
	nDebit += GetDebit(txin, filter);
	if (!MoneyRange(nDebit))
	throw std::runtime_error("CWallet::GetDebit(): value out of range");
	}
	return nDebit;
	}

	CAmount CWallet::GetCredit(const CTransaction& tx, const isminefilter& filter) const
	{
	CAmount nCredit = 0;
	BOOST_FOREACH(const CTxOut& txout, tx.vout)
	{
	nCredit += GetCredit(txout, filter);
	if (!MoneyRange(nCredit))
	throw std::runtime_error("CWallet::GetCredit(): value out of range");
	}
	return nCredit;
	}

	CAmount CWallet::GetChange(const CTransaction& tx) const
	{
	CAmount 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;
	}

	bool CWallet::SetHDMasterKey(const CKey& key)
	{
	LOCK(cs_wallet);

	// store the key as normal "key"/"ckey" object
	// in the database
	// key metadata is not required
	CPubKey pubkey = key.GetPubKey();
	if (!AddKeyPubKey(key, pubkey))
	throw std::runtime_error("CWallet::GenerateNewKey(): AddKey failed");

	// store the keyid (hash160) together with
	// the child index counter in the database
	// as a hdchain object
	CHDChain newHdChain;
	newHdChain.masterKeyID = pubkey.GetID();
	SetHDChain(newHdChain, false);

	return true;
	}

	bool CWallet::SetHDChain(const CHDChain& chain, bool memonly)
	{
	LOCK(cs_wallet);
	if (!memonly && !CWalletDB(strWalletFile).WriteHDChain(chain))
	throw runtime_error("AddHDChain(): writing chain failed");

	hdChain = chain;
	return true;
	}

	int64_t CWalletTx::GetTxTime() const
	{
	int64_t n = nTimeSmart;
	return n ? n : nTimeReceived;
	}

	int CWalletTx::GetRequestCount() const
	{
	// Returns -1 if it wasn't being tracked
	int nRequests = -1;
	{
	LOCK(pwallet->cs_wallet);
	if (IsCoinBase())
	{
	// Generated block
	if (!hashUnset())
	{
	map<uint256, int>::const_iterator mi = pwallet->mapRequestCount.find(hashBlock);
	if (mi != pwallet->mapRequestCount.end())
	nRequests = (*mi).second;
	}
	}
	else
	{
	// Did anyone request this transaction?
	map<uint256, int>::const_iterator mi = pwallet->mapRequestCount.find(GetHash());
	if (mi != pwallet->mapRequestCount.end())
	{
	nRequests = (*mi).second;

	// How about the block it's in?
	if (nRequests == 0 && !hashUnset())
	{
	map<uint256, int>::const_iterator mi = pwallet->mapRequestCount.find(hashBlock);
	if (mi != pwallet->mapRequestCount.end())
	nRequests = (*mi).second;
	else
	nRequests = 1; // If it's in someone else's block it must have got out
	}
	}
	}
	}
	return nRequests;
	}

	void CWalletTx::GetAmounts(list<COutputEntry>& listReceived,
	list<COutputEntry>& listSent, CAmount& nFee, string& strSentAccount, const isminefilter& filter) const
	{
	nFee = 0;
	listReceived.clear();
	listSent.clear();
	strSentAccount = strFromAccount;

	// Compute fee:
	CAmount nDebit = GetDebit(filter);
	if (nDebit > 0) // debit>0 means we signed/sent this transaction
	{
	CAmount nValueOut = GetValueOut();
	nFee = nDebit - nValueOut;
	}

	// Sent/received.
	for (unsigned int i = 0; i < vout.size(); ++i)
	{
	const CTxOut& txout = vout[i];
	isminetype fIsMine = pwallet->IsMine(txout);
	// Only need to handle txouts if AT LEAST one of these is true:
	// 1) they debit from us (sent)
	// 2) the output is to us (received)
	if (nDebit > 0)
	{
	// Don't report 'change' txouts
	if (pwallet->IsChange(txout))
	continue;
	}
	else if (!(fIsMine & filter))
	continue;

	// In either case, we need to get the destination address
	CTxDestination address;

	if (!ExtractDestination(txout.scriptPubKey, address) && !txout.scriptPubKey.IsUnspendable())
	{
	LogPrintf("CWalletTx::GetAmounts: Unknown transaction type found, txid %s\n",
	this->GetHash().ToString());
	address = CNoDestination();
	}

	COutputEntry output = {address, txout.nValue, (int)i};

	// If we are debited by the transaction, add the output as a "sent" entry
	if (nDebit > 0)
	listSent.push_back(output);

	// If we are receiving the output, add it as a "received" entry
	if (fIsMine & filter)
	listReceived.push_back(output);
	}

	}

	void CWalletTx::GetAccountAmounts(const string& strAccount, CAmount& nReceived,
	CAmount& nSent, CAmount& nFee, const isminefilter& filter) const
	{
	nReceived = nSent = nFee = 0;

	CAmount allFee;
	string strSentAccount;
	list<COutputEntry> listReceived;
	list<COutputEntry> listSent;
	GetAmounts(listReceived, listSent, allFee, strSentAccount, filter);

	if (strAccount == strSentAccount)
	{
	BOOST_FOREACH(const COutputEntry& s, listSent)
	nSent += s.amount;
	nFee = allFee;
	}
	{
	LOCK(pwallet->cs_wallet);
	BOOST_FOREACH(const COutputEntry& r, listReceived)
	{
	if (pwallet->mapAddressBook.count(r.destination))
	{
	map<CTxDestination, CAddressBookData>::const_iterator mi = pwallet->mapAddressBook.find(r.destination);
	if (mi != pwallet->mapAddressBook.end() && (*mi).second.name == strAccount)
	nReceived += r.amount;
	}
	else if (strAccount.empty())
	{
	nReceived += r.amount;
	}
	}
	}
	}

	/**
	* Scan the block chain (starting in pindexStart) for transactions
	* from or to us. If fUpdate is true, found transactions that already
	* exist in the wallet will be updated.
	*/
	int CWallet::ScanForWalletTransactions(CBlockIndex* pindexStart, bool fUpdate)
	{
	int ret = 0;
	int64_t nNow = GetTime();
	const CChainParams& chainParams = Params();

	CBlockIndex* pindex = pindexStart;
	{
	LOCK2(cs_main, cs_wallet);

	// no need to read and scan block, if block was created before
	// our wallet birthday (as adjusted for block time variability)
	while (pindex && nTimeFirstKey && (pindex->GetBlockTime() < (nTimeFirstKey - 7200)))
	pindex = chainActive.Next(pindex);

	ShowProgress(_("Rescanning..."), 0); // show rescan progress in GUI as dialog or on splashscreen, if -rescan on startup
	double dProgressStart = Checkpoints::GuessVerificationProgress(chainParams.Checkpoints(), pindex, false);
	double dProgressTip = Checkpoints::GuessVerificationProgress(chainParams.Checkpoints(), chainActive.Tip(), false);
	while (pindex)
	{
	if (pindex->nHeight % 100 == 0 && dProgressTip - dProgressStart > 0.0)
	ShowProgress(_("Rescanning..."), std::max(1, std::min(99, (int)((Checkpoints::GuessVerificationProgress(chainParams.Checkpoints(), pindex, false) - dProgressStart) / (dProgressTip - dProgressStart) * 100))));

	CBlock block;
	ReadBlockFromDisk(block, pindex, Params().GetConsensus());
	BOOST_FOREACH(CTransaction& tx, block.vtx)
	{
	if (AddToWalletIfInvolvingMe(tx, &block, fUpdate))
	ret++;
	}
	pindex = chainActive.Next(pindex);
	if (GetTime() >= nNow + 60) {
	nNow = GetTime();
	LogPrintf("Still rescanning. At block %d. Progress=%f\n", pindex->nHeight, Checkpoints::GuessVerificationProgress(chainParams.Checkpoints(), pindex));
	}
	}
	ShowProgress(_("Rescanning..."), 100); // hide progress dialog in GUI
	}
	return ret;
	}

	void CWallet::ReacceptWalletTransactions()
	{
	// If transactions aren't being broadcasted, don't let them into local mempool either
	if (!fBroadcastTransactions)
	return;
	LOCK2(cs_main, cs_wallet);
	std::map<int64_t, CWalletTx*> mapSorted;

	// Sort pending wallet transactions based on their initial wallet insertion order
	BOOST_FOREACH(PAIRTYPE(const uint256, CWalletTx)& item, mapWallet)
	{
	const uint256& wtxid = item.first;
	CWalletTx& wtx = item.second;
	assert(wtx.GetHash() == wtxid);

	int nDepth = wtx.GetDepthInMainChain();

	if (!wtx.IsCoinBase() && (nDepth == 0 && !wtx.isAbandoned())) {
	mapSorted.insert(std::make_pair(wtx.nOrderPos, &wtx));
	}
	}

	// Try to add wallet transactions to memory pool
	BOOST_FOREACH(PAIRTYPE(const int64_t, CWalletTx*)& item, mapSorted)
	{
	CWalletTx& wtx = *(item.second);

	LOCK(mempool.cs);
	wtx.AcceptToMemoryPool(false, maxTxFee);
	}
	}

	bool CWalletTx::RelayWalletTransaction()
	{
	assert(pwallet->GetBroadcastTransactions());
	if (!IsCoinBase())
	{
	if (GetDepthInMainChain() == 0 && !isAbandoned() && InMempool()) {
	LogPrintf("Relaying wtx %s\n", GetHash().ToString());
	RelayTransaction((CTransaction)*this);
	return true;
	}
	}
	return false;
	}

	set<uint256> CWalletTx::GetConflicts() const
	{
	set<uint256> result;
	if (pwallet != NULL)
	{
	uint256 myHash = GetHash();
	result = pwallet->GetConflicts(myHash);
	result.erase(myHash);
	}
	return result;
	}

	CAmount CWalletTx::GetDebit(const isminefilter& filter) const
	{
	if (vin.empty())
	return 0;

	CAmount debit = 0;
	if(filter & ISMINE_SPENDABLE)
	{
	if (fDebitCached)
	debit += nDebitCached;
	else
	{
	nDebitCached = pwallet->GetDebit(*this, ISMINE_SPENDABLE);
	fDebitCached = true;
	debit += nDebitCached;
	}
	}
	if(filter & ISMINE_WATCH_ONLY)
	{
	if(fWatchDebitCached)
	debit += nWatchDebitCached;
	else
	{
	nWatchDebitCached = pwallet->GetDebit(*this, ISMINE_WATCH_ONLY);
	fWatchDebitCached = true;
	debit += nWatchDebitCached;
	}
	}
	return debit;
	}

	CAmount CWalletTx::GetCredit(const isminefilter& filter) const
	{
	// Must wait until coinbase is safely deep enough in the chain before valuing it
	if (IsCoinBase() && GetBlocksToMaturity() > 0)
	return 0;

	int64_t credit = 0;
	if (filter & ISMINE_SPENDABLE)
	{
	// GetBalance can assume transactions in mapWallet won't change
	if (fCreditCached)
	credit += nCreditCached;
	else
	{
	nCreditCached = pwallet->GetCredit(*this, ISMINE_SPENDABLE);
	fCreditCached = true;
	credit += nCreditCached;
	}
	}
	if (filter & ISMINE_WATCH_ONLY)
	{
	if (fWatchCreditCached)
	credit += nWatchCreditCached;
	else
	{
	nWatchCreditCached = pwallet->GetCredit(*this, ISMINE_WATCH_ONLY);
	fWatchCreditCached = true;
	credit += nWatchCreditCached;
	}
	}
	return credit;
	}

	CAmount CWalletTx::GetImmatureCredit(bool fUseCache) const
	{
	if (IsCoinBase() && GetBlocksToMaturity() > 0 && IsInMainChain())
	{
	if (fUseCache && fImmatureCreditCached)
	return nImmatureCreditCached;
	nImmatureCreditCached = pwallet->GetCredit(*this, ISMINE_SPENDABLE);
	fImmatureCreditCached = true;
	return nImmatureCreditCached;
	}

	return 0;
	}

	CAmount CWalletTx::GetAvailableCredit(bool fUseCache) const
	{
	if (pwallet == 0)
	return 0;

	// 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;

	CAmount nCredit = 0;
	uint256 hashTx = GetHash();
	for (unsigned int i = 0; i < vout.size(); i++)
	{
	if (!pwallet->IsSpent(hashTx, i))
	{
	const CTxOut &txout = vout[i];
	nCredit += pwallet->GetCredit(txout, ISMINE_SPENDABLE);
	if (!MoneyRange(nCredit))
	throw std::runtime_error("CWalletTx::GetAvailableCredit() : value out of range");
	}
	}

	nAvailableCreditCached = nCredit;
	fAvailableCreditCached = true;
	return nCredit;
	}

	CAmount CWalletTx::GetImmatureWatchOnlyCredit(const bool& fUseCache) const
	{
	if (IsCoinBase() && GetBlocksToMaturity() > 0 && IsInMainChain())
	{
	if (fUseCache && fImmatureWatchCreditCached)
	return nImmatureWatchCreditCached;
	nImmatureWatchCreditCached = pwallet->GetCredit(*this, ISMINE_WATCH_ONLY);
	fImmatureWatchCreditCached = true;
	return nImmatureWatchCreditCached;
	}

	return 0;
	}

	CAmount CWalletTx::GetAvailableWatchOnlyCredit(const bool& fUseCache) const
	{
	if (pwallet == 0)
	return 0;

	// Must wait until coinbase is safely deep enough in the chain before valuing it
	if (IsCoinBase() && GetBlocksToMaturity() > 0)
	return 0;

	if (fUseCache && fAvailableWatchCreditCached)
	return nAvailableWatchCreditCached;

	CAmount nCredit = 0;
	for (unsigned int i = 0; i < vout.size(); i++)
	{
	if (!pwallet->IsSpent(GetHash(), i))
	{
	const CTxOut &txout = vout[i];
	nCredit += pwallet->GetCredit(txout, ISMINE_WATCH_ONLY);
	if (!MoneyRange(nCredit))
	throw std::runtime_error("CWalletTx::GetAvailableCredit() : value out of range");
	}
	}

	nAvailableWatchCreditCached = nCredit;
	fAvailableWatchCreditCached = true;
	return nCredit;
	}

	CAmount CWalletTx::GetChange() const
	{
	if (fChangeCached)
	return nChangeCached;
	nChangeCached = pwallet->GetChange(*this);
	fChangeCached = true;
	return nChangeCached;
	}

	bool CWalletTx::InMempool() const
	{
	LOCK(mempool.cs);
	if (mempool.exists(GetHash())) {
	return true;
	}
	return false;
	}

	bool CWalletTx::IsTrusted() const
	{
	// Quick answer in most cases
	if (!CheckFinalTx(*this))
	return false;
	int nDepth = GetDepthInMainChain();
	if (nDepth >= 1)
	return true;
	if (nDepth < 0)
	return false;
	if (!bSpendZeroConfChange \|\| !IsFromMe(ISMINE_ALL)) // using wtx's cached debit
	return false;

	// Don't trust unconfirmed transactions from us unless they are in the mempool.
	if (!InMempool())
	return false;

	// Trusted if all inputs are from us and are in the mempool:
	BOOST_FOREACH(const CTxIn& txin, vin)
	{
	// Transactions not sent by us: not trusted
	const CWalletTx* parent = pwallet->GetWalletTx(txin.prevout.hash);
	if (parent == NULL)
	return false;
	const CTxOut& parentOut = parent->vout[txin.prevout.n];
	if (pwallet->IsMine(parentOut) != ISMINE_SPENDABLE)
	return false;
	}
	return true;
	}

	bool CWalletTx::IsEquivalentTo(const CWalletTx& tx) const
	{
	CMutableTransaction tx1 = *this;
	CMutableTransaction tx2 = tx;
	for (unsigned int i = 0; i < tx1.vin.size(); i++) tx1.vin[i].scriptSig = CScript();
	for (unsigned int i = 0; i < tx2.vin.size(); i++) tx2.vin[i].scriptSig = CScript();
	return CTransaction(tx1) == CTransaction(tx2);
	}

	std::vector<uint256> CWallet::ResendWalletTransactionsBefore(int64_t nTime)
	{
	std::vector<uint256> result;

	LOCK(cs_wallet);
	// Sort them in chronological order
	multimap<unsigned int, CWalletTx*> mapSorted;
	BOOST_FOREACH(PAIRTYPE(const uint256, CWalletTx)& item, mapWallet)
	{
	CWalletTx& wtx = item.second;
	// Don't rebroadcast if newer than nTime:
	if (wtx.nTimeReceived > nTime)
	continue;
	mapSorted.insert(make_pair(wtx.nTimeReceived, &wtx));
	}
	BOOST_FOREACH(PAIRTYPE(const unsigned int, CWalletTx*)& item, mapSorted)
	{
	CWalletTx& wtx = *item.second;
	if (wtx.RelayWalletTransaction())
	result.push_back(wtx.GetHash());
	}
	return result;
	}

	void CWallet::ResendWalletTransactions(int64_t nBestBlockTime)
	{
	// Do this infrequently and randomly to avoid giving away
	// that these are our transactions.
	if (GetTime() < nNextResend \|\| !fBroadcastTransactions)
	return;
	bool fFirst = (nNextResend == 0);
	nNextResend = GetTime() + GetRand(30 * 60);
	if (fFirst)
	return;

	// Only do it if there's been a new block since last time
	if (nBestBlockTime < nLastResend)
	return;
	nLastResend = GetTime();

	// Rebroadcast unconfirmed txes older than 5 minutes before the last
	// block was found:
	std::vector<uint256> relayed = ResendWalletTransactionsBefore(nBestBlockTime-5*60);
	if (!relayed.empty())
	LogPrintf("%s: rebroadcast %u unconfirmed transactions\n", __func__, relayed.size());
	}

	/** @} */ // end of mapWallet




	/** @defgroup Actions
	*
	* @{
	*/


	CAmount CWallet::GetBalance() const
	{
	CAmount nTotal = 0;
	{
	LOCK2(cs_main, cs_wallet);
	for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
	{
	const CWalletTx* pcoin = &(*it).second;
	if (pcoin->IsTrusted())
	nTotal += pcoin->GetAvailableCredit();
	}
	}

	return nTotal;
	}

	CAmount CWallet::GetUnconfirmedBalance() const
	{
	CAmount nTotal = 0;
	{
	LOCK2(cs_main, cs_wallet);
	for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
	{
	const CWalletTx* pcoin = &(*it).second;
	if (!pcoin->IsTrusted() && pcoin->GetDepthInMainChain() == 0 && pcoin->InMempool())
	nTotal += pcoin->GetAvailableCredit();
	}
	}
	return nTotal;
	}

	CAmount CWallet::GetImmatureBalance() const
	{
	CAmount nTotal = 0;
	{
	LOCK2(cs_main, cs_wallet);
	for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
	{
	const CWalletTx* pcoin = &(*it).second;
	nTotal += pcoin->GetImmatureCredit();
	}
	}
	return nTotal;
	}

	CAmount CWallet::GetWatchOnlyBalance() const
	{
	CAmount nTotal = 0;
	{
	LOCK2(cs_main, cs_wallet);
	for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
	{
	const CWalletTx* pcoin = &(*it).second;
	if (pcoin->IsTrusted())
	nTotal += pcoin->GetAvailableWatchOnlyCredit();
	}
	}

	return nTotal;
	}

	CAmount CWallet::GetUnconfirmedWatchOnlyBalance() const
	{
	CAmount nTotal = 0;
	{
	LOCK2(cs_main, cs_wallet);
	for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
	{
	const CWalletTx* pcoin = &(*it).second;
	if (!pcoin->IsTrusted() && pcoin->GetDepthInMainChain() == 0 && pcoin->InMempool())
	nTotal += pcoin->GetAvailableWatchOnlyCredit();
	}
	}
	return nTotal;
	}

	CAmount CWallet::GetImmatureWatchOnlyBalance() const
	{
	CAmount nTotal = 0;
	{
	LOCK2(cs_main, cs_wallet);
	for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
	{
	const CWalletTx* pcoin = &(*it).second;
	nTotal += pcoin->GetImmatureWatchOnlyCredit();
	}
	}
	return nTotal;
	}

	void CWallet::AvailableCoins(vector<COutput>& vCoins, bool fOnlyConfirmed, const CCoinControl *coinControl, bool fIncludeZeroValue) const
	{
	vCoins.clear();

	{
	LOCK2(cs_main, cs_wallet);
	for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
	{
	const uint256& wtxid = it->first;
	const CWalletTx* pcoin = &(*it).second;

	if (!CheckFinalTx(*pcoin))
	continue;

	if (fOnlyConfirmed && !pcoin->IsTrusted())
	continue;

	if (pcoin->IsCoinBase() && pcoin->GetBlocksToMaturity() > 0)
	continue;

	int nDepth = pcoin->GetDepthInMainChain();
	if (nDepth < 0)
	continue;

	// We should not consider coins which aren't at least in our mempool
	// It's possible for these to be conflicted via ancestors which we may never be able to detect
	if (nDepth == 0 && !pcoin->InMempool())
	continue;

	for (unsigned int i = 0; i < pcoin->vout.size(); i++) {
	isminetype mine = IsMine(pcoin->vout[i]);
	if (!(IsSpent(wtxid, i)) && mine != ISMINE_NO &&
	!IsLockedCoin((*it).first, i) && (pcoin->vout[i].nValue > 0 \|\| fIncludeZeroValue) &&
	(!coinControl \|\| !coinControl->HasSelected() \|\| coinControl->fAllowOtherInputs \|\| coinControl->IsSelected(COutPoint((*it).first, i))))
	vCoins.push_back(COutput(pcoin, i, nDepth,
	((mine & ISMINE_SPENDABLE) != ISMINE_NO) \|\|
	(coinControl && coinControl->fAllowWatchOnly && (mine & ISMINE_WATCH_SOLVABLE) != ISMINE_NO),
	(mine & (ISMINE_SPENDABLE \| ISMINE_WATCH_SOLVABLE)) != ISMINE_NO));
	}
	}
	}
	}

	static void ApproximateBestSubset(vector<pair<CAmount, pair<const CWalletTx*,unsigned int> > >vValue, const CAmount& nTotalLower, const CAmount& nTargetValue,
	vector<char>& vfBest, CAmount& nBest, int iterations = 1000)
	{
	vector<char> vfIncluded;

	vfBest.assign(vValue.size(), true);
	nBest = nTotalLower;

	seed_insecure_rand();

	for (int nRep = 0; nRep < iterations && nBest != nTargetValue; nRep++)
	{
	vfIncluded.assign(vValue.size(), false);
	CAmount nTotal = 0;
	bool fReachedTarget = false;
	for (int nPass = 0; nPass < 2 && !fReachedTarget; nPass++)
	{
	for (unsigned int i = 0; i < vValue.size(); i++)
	{
	//The solver here uses a randomized algorithm,
	//the randomness serves no real security purpose but is just
	//needed to prevent degenerate behavior and it is important
	//that the rng is fast. We do not use a constant random sequence,
	//because there may be some privacy improvement by making
	//the selection random.
	if (nPass == 0 ? insecure_rand()&1 : !vfIncluded[i])
	{
	nTotal += vValue[i].first;
	vfIncluded[i] = true;
	if (nTotal >= nTargetValue)
	{
	fReachedTarget = true;
	if (nTotal < nBest)
	{
	nBest = nTotal;
	vfBest = vfIncluded;
	}
	nTotal -= vValue[i].first;
	vfIncluded[i] = false;
	}
	}
	}
	}
	}
	}

	bool CWallet::SelectCoinsMinConf(const CAmount& nTargetValue, int nConfMine, int nConfTheirs, vector<COutput> vCoins,
	set<pair<const CWalletTx*,unsigned int> >& setCoinsRet, CAmount& nValueRet) const
	{
	setCoinsRet.clear();
	nValueRet = 0;

	// List of values less than target
	pair<CAmount, pair<const CWalletTx*,unsigned int> > coinLowestLarger;
	coinLowestLarger.first = std::numeric_limits<CAmount>::max();
	coinLowestLarger.second.first = NULL;
	vector<pair<CAmount, pair<const CWalletTx*,unsigned int> > > vValue;
	CAmount nTotalLower = 0;

	random_shuffle(vCoins.begin(), vCoins.end(), GetRandInt);

	BOOST_FOREACH(const COutput &output, vCoins)
	{
	if (!output.fSpendable)
	continue;

	const CWalletTx *pcoin = output.tx;

	if (output.nDepth < (pcoin->IsFromMe(ISMINE_ALL) ? nConfMine : nConfTheirs))
	continue;

	int i = output.i;
	CAmount n = pcoin->vout[i].nValue;

	pair<CAmount,pair<const CWalletTx*,unsigned int> > coin = make_pair(n,make_pair(pcoin, i));

	if (n == nTargetValue)
	{
	setCoinsRet.insert(coin.second);
	nValueRet += coin.first;
	return true;
	}
	else if (n < nTargetValue + MIN_CHANGE)
	{
	vValue.push_back(coin);
	nTotalLower += n;
	}
	else if (n < coinLowestLarger.first)
	{
	coinLowestLarger = coin;
	}
	}

	if (nTotalLower == nTargetValue)
	{
	for (unsigned int i = 0; i < vValue.size(); ++i)
	{
	setCoinsRet.insert(vValue[i].second);
	nValueRet += vValue[i].first;
	}
	return true;
	}

	if (nTotalLower < nTargetValue)
	{
	if (coinLowestLarger.second.first == NULL)
	return false;
	setCoinsRet.insert(coinLowestLarger.second);
	nValueRet += coinLowestLarger.first;
	return true;
	}

	// Solve subset sum by stochastic approximation
	std::sort(vValue.begin(), vValue.end(), CompareValueOnly());
	std::reverse(vValue.begin(), vValue.end());
	vector<char> vfBest;
	CAmount nBest;

	ApproximateBestSubset(vValue, nTotalLower, nTargetValue, vfBest, nBest);
	if (nBest != nTargetValue && nTotalLower >= nTargetValue + MIN_CHANGE)
	ApproximateBestSubset(vValue, nTotalLower, nTargetValue + MIN_CHANGE, vfBest, nBest);

	// If we have a bigger coin and (either the stochastic approximation didn't find a good solution,
	// or the next bigger coin is closer), return the bigger coin
	if (coinLowestLarger.second.first &&
	((nBest != nTargetValue && nBest < nTargetValue + MIN_CHANGE) \|\| coinLowestLarger.first <= nBest))
	{
	setCoinsRet.insert(coinLowestLarger.second);
	nValueRet += coinLowestLarger.first;
	}
	else {
	for (unsigned int i = 0; i < vValue.size(); i++)
	if (vfBest[i])
	{
	setCoinsRet.insert(vValue[i].second);
	nValueRet += vValue[i].first;
	}

	LogPrint("selectcoins", "SelectCoins() best subset: ");
	for (unsigned int i = 0; i < vValue.size(); i++)
	if (vfBest[i])
	LogPrint("selectcoins", "%s ", FormatMoney(vValue[i].first));
	LogPrint("selectcoins", "total %s\n", FormatMoney(nBest));
	}

	return true;
	}

	bool CWallet::SelectCoins(const vector<COutput>& vAvailableCoins, const CAmount& nTargetValue, set<pair<const CWalletTx,unsigned int> >& setCoinsRet, CAmount& nValueRet, const CCoinControl coinControl) const
	{
	vector<COutput> vCoins(vAvailableCoins);

	// coin control -> return all selected outputs (we want all selected to go into the transaction for sure)
	if (coinControl && coinControl->HasSelected() && !coinControl->fAllowOtherInputs)
	{
	BOOST_FOREACH(const COutput& out, vCoins)
	{
	if (!out.fSpendable)
	continue;
	nValueRet += out.tx->vout[out.i].nValue;
	setCoinsRet.insert(make_pair(out.tx, out.i));
	}
	return (nValueRet >= nTargetValue);
	}

	// calculate value from preset inputs and store them
	set<pair<const CWalletTx*, uint32_t> > setPresetCoins;
	CAmount nValueFromPresetInputs = 0;

	std::vector<COutPoint> vPresetInputs;
	if (coinControl)
	coinControl->ListSelected(vPresetInputs);
	BOOST_FOREACH(const COutPoint& outpoint, vPresetInputs)
	{
	map<uint256, CWalletTx>::const_iterator it = mapWallet.find(outpoint.hash);
	if (it != mapWallet.end())
	{
	const CWalletTx* pcoin = &it->second;
	// Clearly invalid input, fail
	if (pcoin->vout.size() <= outpoint.n)
	return false;
	nValueFromPresetInputs += pcoin->vout[outpoint.n].nValue;
	setPresetCoins.insert(make_pair(pcoin, outpoint.n));
	} else
	return false; // TODO: Allow non-wallet inputs
	}

	// remove preset inputs from vCoins
	for (vector<COutput>::iterator it = vCoins.begin(); it != vCoins.end() && coinControl && coinControl->HasSelected();)
	{
	if (setPresetCoins.count(make_pair(it->tx, it->i)))
	it = vCoins.erase(it);
	else
	++it;
	}

	bool res = nTargetValue <= nValueFromPresetInputs \|\|
	SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, 1, 6, vCoins, setCoinsRet, nValueRet) \|\|
	SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, 1, 1, vCoins, setCoinsRet, nValueRet) \|\|
	(bSpendZeroConfChange && SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, 0, 1, vCoins, setCoinsRet, nValueRet));

	// because SelectCoinsMinConf clears the setCoinsRet, we now add the possible inputs to the coinset
	setCoinsRet.insert(setPresetCoins.begin(), setPresetCoins.end());

	// add preset inputs to the total value selected
	nValueRet += nValueFromPresetInputs;

	return res;
	}

	bool CWallet::FundTransaction(CMutableTransaction& tx, CAmount& nFeeRet, bool overrideEstimatedFeeRate, const CFeeRate& specificFeeRate, int& nChangePosInOut, std::string& strFailReason, bool includeWatching, bool lockUnspents, const CTxDestination& destChange)
	{
	vector<CRecipient> vecSend;

	// Turn the txout set into a CRecipient vector
	BOOST_FOREACH(const CTxOut& txOut, tx.vout)
	{
	CRecipient recipient = {txOut.scriptPubKey, txOut.nValue, false};
	vecSend.push_back(recipient);
	}

	CCoinControl coinControl;
	coinControl.destChange = destChange;
	coinControl.fAllowOtherInputs = true;
	coinControl.fAllowWatchOnly = includeWatching;
	coinControl.fOverrideFeeRate = overrideEstimatedFeeRate;
	coinControl.nFeeRate = specificFeeRate;

	BOOST_FOREACH(const CTxIn& txin, tx.vin)
	coinControl.Select(txin.prevout);

	CReserveKey reservekey(this);
	CWalletTx wtx;
	if (!CreateTransaction(vecSend, wtx, reservekey, nFeeRet, nChangePosInOut, strFailReason, &coinControl, false))
	return false;

	if (nChangePosInOut != -1)
	tx.vout.insert(tx.vout.begin() + nChangePosInOut, wtx.vout[nChangePosInOut]);

	// Add new txins (keeping original txin scriptSig/order)
	BOOST_FOREACH(const CTxIn& txin, wtx.vin)
	{
	if (!coinControl.IsSelected(txin.prevout))
	{
	tx.vin.push_back(txin);

	if (lockUnspents)
	{
	LOCK2(cs_main, cs_wallet);
	LockCoin(txin.prevout);
	}
	}
	}

	return true;
	}

	bool CWallet::CreateTransaction(const vector<CRecipient>& vecSend, CWalletTx& wtxNew, CReserveKey& reservekey, CAmount& nFeeRet,
	int& nChangePosInOut, std::string& strFailReason, const CCoinControl* coinControl, bool sign)
	{
	CAmount nValue = 0;
	int nChangePosRequest = nChangePosInOut;
	unsigned int nSubtractFeeFromAmount = 0;
	BOOST_FOREACH (const CRecipient& recipient, vecSend)
	{
	if (nValue < 0 \|\| recipient.nAmount < 0)
	{
	strFailReason = _("Transaction amounts must be positive");
	return false;
	}
	nValue += recipient.nAmount;

	if (recipient.fSubtractFeeFromAmount)
	nSubtractFeeFromAmount++;
	}
	if (vecSend.empty() \|\| nValue < 0)
	{
	strFailReason = _("Transaction amounts must be positive");
	return false;
	}

	wtxNew.fTimeReceivedIsTxTime = true;
	wtxNew.BindWallet(this);
	CMutableTransaction txNew;

	// Discourage fee sniping.
	//
	// For a large miner the value of the transactions in the best block and
	// the mempool can exceed the cost of deliberately attempting to mine two
	// blocks to orphan the current best block. By setting nLockTime such that
	// only the next block can include the transaction, we discourage this
	// practice as the height restricted and limited blocksize gives miners
	// considering fee sniping fewer options for pulling off this attack.
	//
	// A simple way to think about this is from the wallet's point of view we
	// always want the blockchain to move forward. By setting nLockTime this
	// way we're basically making the statement that we only want this
	// transaction to appear in the next block; we don't want to potentially
	// encourage reorgs by allowing transactions to appear at lower heights
	// than the next block in forks of the best chain.
	//
	// Of course, the subsidy is high enough, and transaction volume low
	// enough, that fee sniping isn't a problem yet, but by implementing a fix
	// now we ensure code won't be written that makes assumptions about
	// nLockTime that preclude a fix later.
	txNew.nLockTime = chainActive.Height();

	// Secondly occasionally randomly pick a nLockTime even further back, so
	// that transactions that are delayed after signing for whatever reason,
	// e.g. high-latency mix networks and some CoinJoin implementations, have
	// better privacy.
	if (GetRandInt(10) == 0)
	txNew.nLockTime = std::max(0, (int)txNew.nLockTime - GetRandInt(100));

	assert(txNew.nLockTime <= (unsigned int)chainActive.Height());
	assert(txNew.nLockTime < LOCKTIME_THRESHOLD);

	{
	LOCK2(cs_main, cs_wallet);
	{
	std::vector<COutput> vAvailableCoins;
	AvailableCoins(vAvailableCoins, true, coinControl);

	nFeeRet = 0;
	// Start with no fee and loop until there is enough fee
	while (true)
	{
	nChangePosInOut = nChangePosRequest;
	txNew.vin.clear();
	txNew.vout.clear();
	wtxNew.fFromMe = true;
	bool fFirst = true;

	CAmount nValueToSelect = nValue;
	if (nSubtractFeeFromAmount == 0)
	nValueToSelect += nFeeRet;
	double dPriority = 0;
	// vouts to the payees
	BOOST_FOREACH (const CRecipient& recipient, vecSend)
	{
	CTxOut txout(recipient.nAmount, recipient.scriptPubKey);

	if (recipient.fSubtractFeeFromAmount)
	{
	txout.nValue -= nFeeRet / nSubtractFeeFromAmount; // Subtract fee equally from each selected recipient

	if (fFirst) // first receiver pays the remainder not divisible by output count
	{
	fFirst = false;
	txout.nValue -= nFeeRet % nSubtractFeeFromAmount;
	}
	}

	if (txout.IsDust(::minRelayTxFee))
	{
	if (recipient.fSubtractFeeFromAmount && nFeeRet > 0)
	{
	if (txout.nValue < 0)
	strFailReason = _("The transaction amount is too small to pay the fee");
	else
	strFailReason = _("The transaction amount is too small to send after the fee has been deducted");
	}
	else
	strFailReason = _("Transaction amount too small");
	return false;
	}
	txNew.vout.push_back(txout);
	}

	// Choose coins to use
	set<pair<const CWalletTx*,unsigned int> > setCoins;
	CAmount nValueIn = 0;
	if (!SelectCoins(vAvailableCoins, nValueToSelect, setCoins, nValueIn, coinControl))
	{
	strFailReason = _("Insufficient funds");
	return false;
	}
	BOOST_FOREACH(PAIRTYPE(const CWalletTx*, unsigned int) pcoin, setCoins)
	{
	CAmount nCredit = pcoin.first->vout[pcoin.second].nValue;
	//The coin age after the next block (depth+1) is used instead of the current,
	//reflecting an assumption the user would accept a bit more delay for
	//a chance at a free transaction.
	//But mempool inputs might still be in the mempool, so their age stays 0
	int age = pcoin.first->GetDepthInMainChain();
	assert(age >= 0);
	if (age != 0)
	age += 1;
	dPriority += (double)nCredit * age;
	}

	const CAmount nChange = nValueIn - nValueToSelect;
	if (nChange > 0)
	{
	// Fill a vout to ourself
	// TODO: pass in scriptChange instead of reservekey so
	// change transaction isn't always pay-to-bitcoin-address
	CScript scriptChange;

	// coin control: send change to custom address
	if (coinControl && !boost::get<CNoDestination>(&coinControl->destChange))
	scriptChange = GetScriptForDestination(coinControl->destChange);

	// no coin control: send change to newly generated address
	else
	{
	// Note: We use a new key here to keep it from being obvious which side is the change.
	// The drawback is that by not reusing a previous key, the change may be lost if a
	// backup is restored, if the backup doesn't have the new private key for the change.
	// If we reused the old key, it would be possible to add code to look for and
	// rediscover unknown transactions that were written with keys of ours to recover
	// post-backup change.

	// Reserve a new key pair from key pool
	CPubKey vchPubKey;
	bool ret;
	ret = reservekey.GetReservedKey(vchPubKey);
	assert(ret); // should never fail, as we just unlocked

	scriptChange = GetScriptForDestination(vchPubKey.GetID());
	}

	CTxOut newTxOut(nChange, scriptChange);

	// We do not move dust-change to fees, because the sender would end up paying more than requested.
	// This would be against the purpose of the all-inclusive feature.
	// So instead we raise the change and deduct from the recipient.
	if (nSubtractFeeFromAmount > 0 && newTxOut.IsDust(::minRelayTxFee))
	{
	CAmount nDust = newTxOut.GetDustThreshold(::minRelayTxFee) - newTxOut.nValue;
	newTxOut.nValue += nDust; // raise change until no more dust
	for (unsigned int i = 0; i < vecSend.size(); i++) // subtract from first recipient
	{
	if (vecSend[i].fSubtractFeeFromAmount)
	{
	txNew.vout[i].nValue -= nDust;
	if (txNew.vout[i].IsDust(::minRelayTxFee))
	{
	strFailReason = _("The transaction amount is too small to send after the fee has been deducted");
	return false;
	}
	break;
	}
	}
	}

	// Never create dust outputs; if we would, just
	// add the dust to the fee.
	if (newTxOut.IsDust(::minRelayTxFee))
	{
	nChangePosInOut = -1;
	nFeeRet += nChange;
	reservekey.ReturnKey();
	}
	else
	{
	if (nChangePosInOut == -1)
	{
	// Insert change txn at random position:
	nChangePosInOut = GetRandInt(txNew.vout.size()+1);
	}
	else if ((unsigned int)nChangePosInOut > txNew.vout.size())
	{
	strFailReason = _("Change index out of range");
	return false;
	}

	vector<CTxOut>::iterator position = txNew.vout.begin()+nChangePosInOut;
	txNew.vout.insert(position, newTxOut);
	}
	}
	else
	reservekey.ReturnKey();

	// Fill vin
	//
	// Note how the sequence number is set to max()-1 so that the
	// nLockTime set above actually works.
	BOOST_FOREACH(const PAIRTYPE(const CWalletTx*,unsigned int)& coin, setCoins)
	txNew.vin.push_back(CTxIn(coin.first->GetHash(),coin.second,CScript(),
	std::numeric_limits<unsigned int>::max()-1));

	// Sign
	int nIn = 0;
	CTransaction txNewConst(txNew);
	BOOST_FOREACH(const PAIRTYPE(const CWalletTx*,unsigned int)& coin, setCoins)
	{
	bool signSuccess;
	const CScript& scriptPubKey = coin.first->vout[coin.second].scriptPubKey;
	SignatureData sigdata;
	if (sign)
	signSuccess = ProduceSignature(TransactionSignatureCreator(this, &txNewConst, nIn, coin.first->vout[coin.second].nValue, SIGHASH_ALL), scriptPubKey, sigdata);
	else
	signSuccess = ProduceSignature(DummySignatureCreator(this), scriptPubKey, sigdata);

	if (!signSuccess)
	{
	strFailReason = _("Signing transaction failed");
	return false;
	} else {
	UpdateTransaction(txNew, nIn, sigdata);
	}

	nIn++;
	}

	unsigned int nBytes = GetVirtualTransactionSize(txNew);

	// Remove scriptSigs if we used dummy signatures for fee calculation
	if (!sign) {
	BOOST_FOREACH (CTxIn& vin, txNew.vin)
	vin.scriptSig = CScript();
	txNew.wit.SetNull();
	}

	// Embed the constructed transaction data in wtxNew.
	static_cast<CTransaction>(&wtxNew) = CTransaction(txNew);

	// Limit size
	if (GetTransactionWeight(txNew) >= MAX_STANDARD_TX_WEIGHT)
	{
	strFailReason = _("Transaction too large");
	return false;
	}

	dPriority = wtxNew.ComputePriority(dPriority, nBytes);

	// Can we complete this as a free transaction?
	if (fSendFreeTransactions && nBytes <= MAX_FREE_TRANSACTION_CREATE_SIZE)
	{
	// Not enough fee: enough priority?
	double dPriorityNeeded = mempool.estimateSmartPriority(nTxConfirmTarget);
	// Require at least hard-coded AllowFree.
	if (dPriority >= dPriorityNeeded && AllowFree(dPriority))
	break;
	}

	CAmount nFeeNeeded = GetMinimumFee(nBytes, nTxConfirmTarget, mempool);
	if (coinControl && nFeeNeeded > 0 && coinControl->nMinimumTotalFee > nFeeNeeded) {
	nFeeNeeded = coinControl->nMinimumTotalFee;
	}
	if (coinControl && coinControl->fOverrideFeeRate)
	nFeeNeeded = coinControl->nFeeRate.GetFee(nBytes);

	// If we made it here and we aren't even able to meet the relay fee on the next pass, give up
	// because we must be at the maximum allowed fee.
	if (nFeeNeeded < ::minRelayTxFee.GetFee(nBytes))
	{
	strFailReason = _("Transaction too large for fee policy");
	return false;
	}

	if (nFeeRet >= nFeeNeeded)
	break; // Done, enough fee included.

	// Include more fee and try again.
	nFeeRet = nFeeNeeded;
	continue;
	}
	}
	}

	return true;
	}

	/**
	* Call after CreateTransaction unless you want to abort
	*/
	bool CWallet::CommitTransaction(CWalletTx& wtxNew, CReserveKey& reservekey)
	{
	{
	LOCK2(cs_main, cs_wallet);
	LogPrintf("CommitTransaction:\n%s", wtxNew.ToString());
	{
	// This is only to keep the database open to defeat the auto-flush for the
	// duration of this scope. This is the only place where this optimization
	// maybe makes sense; please don't do it anywhere else.
	CWalletDB* pwalletdb = fFileBacked ? new CWalletDB(strWalletFile,"r+") : NULL;

	// Take key pair from key pool so it won't be used again
	reservekey.KeepKey();

	// Add tx to wallet, because if it has change it's also ours,
	// otherwise just for transaction history.
	AddToWallet(wtxNew, false, pwalletdb);

	// Notify that old coins are spent
	set<CWalletTx*> setCoins;
	BOOST_FOREACH(const CTxIn& txin, wtxNew.vin)
	{
	CWalletTx &coin = mapWallet[txin.prevout.hash];
	coin.BindWallet(this);
	NotifyTransactionChanged(this, coin.GetHash(), CT_UPDATED);
	}

	if (fFileBacked)
	delete pwalletdb;
	}

	// Track how many getdata requests our transaction gets
	mapRequestCount[wtxNew.GetHash()] = 0;

	if (fBroadcastTransactions)
	{
	// Broadcast
	if (!wtxNew.AcceptToMemoryPool(false, maxTxFee))
	{
	// This must not fail. The transaction has already been signed and recorded.
	LogPrintf("CommitTransaction(): Error: Transaction not valid\n");
	return false;
	}
	wtxNew.RelayWalletTransaction();
	}
	}
	return true;
	}

	bool CWallet::AddAccountingEntry(const CAccountingEntry& acentry, CWalletDB & pwalletdb)
	{
	if (!pwalletdb.WriteAccountingEntry_Backend(acentry))
	return false;

	laccentries.push_back(acentry);
	CAccountingEntry & entry = laccentries.back();
	wtxOrdered.insert(make_pair(entry.nOrderPos, TxPair((CWalletTx*)0, &entry)));

	return true;
	}

	CAmount CWallet::GetRequiredFee(unsigned int nTxBytes)
	{
	return std::max(minTxFee.GetFee(nTxBytes), ::minRelayTxFee.GetFee(nTxBytes));
	}

	CAmount CWallet::GetMinimumFee(unsigned int nTxBytes, unsigned int nConfirmTarget, const CTxMemPool& pool)
	{
	// payTxFee is user-set "I want to pay this much"
	CAmount nFeeNeeded = payTxFee.GetFee(nTxBytes);
	// User didn't set: use -txconfirmtarget to estimate...
	if (nFeeNeeded == 0) {
	int estimateFoundTarget = nConfirmTarget;
	nFeeNeeded = pool.estimateSmartFee(nConfirmTarget, &estimateFoundTarget).GetFee(nTxBytes);
	// ... unless we don't have enough mempool data for estimatefee, then use fallbackFee
	if (nFeeNeeded == 0)
	nFeeNeeded = fallbackFee.GetFee(nTxBytes);
	}
	// prevent user from paying a fee below minRelayTxFee or minTxFee
	nFeeNeeded = std::max(nFeeNeeded, GetRequiredFee(nTxBytes));
	// But always obey the maximum
	if (nFeeNeeded > maxTxFee)
	nFeeNeeded = maxTxFee;
	return nFeeNeeded;
	}




	DBErrors CWallet::LoadWallet(bool& fFirstRunRet)
	{
	if (!fFileBacked)
	return DB_LOAD_OK;
	fFirstRunRet = false;
	DBErrors nLoadWalletRet = CWalletDB(strWalletFile,"cr+").LoadWallet(this);
	if (nLoadWalletRet == DB_NEED_REWRITE)
	{
	if (CDB::Rewrite(strWalletFile, "\x04pool"))
	{
	LOCK(cs_wallet);
	setKeyPool.clear();
	// Note: can't top-up keypool here, because wallet is locked.
	// User will be prompted to unlock wallet the next operation
	// that requires a new key.
	}
	}

	if (nLoadWalletRet != DB_LOAD_OK)
	return nLoadWalletRet;
	fFirstRunRet = !vchDefaultKey.IsValid();

	uiInterface.LoadWallet(this);

	return DB_LOAD_OK;
	}

	DBErrors CWallet::ZapSelectTx(vector<uint256>& vHashIn, vector<uint256>& vHashOut)
	{
	if (!fFileBacked)
	return DB_LOAD_OK;
	DBErrors nZapSelectTxRet = CWalletDB(strWalletFile,"cr+").ZapSelectTx(this, vHashIn, vHashOut);
	if (nZapSelectTxRet == DB_NEED_REWRITE)
	{
	if (CDB::Rewrite(strWalletFile, "\x04pool"))
	{
	LOCK(cs_wallet);
	setKeyPool.clear();
	// Note: can't top-up keypool here, because wallet is locked.
	// User will be prompted to unlock wallet the next operation
	// that requires a new key.
	}
	}

	if (nZapSelectTxRet != DB_LOAD_OK)
	return nZapSelectTxRet;

	MarkDirty();

	return DB_LOAD_OK;

	}

	DBErrors CWallet::ZapWalletTx(std::vector<CWalletTx>& vWtx)
	{
	if (!fFileBacked)
	return DB_LOAD_OK;
	DBErrors nZapWalletTxRet = CWalletDB(strWalletFile,"cr+").ZapWalletTx(this, vWtx);
	if (nZapWalletTxRet == DB_NEED_REWRITE)
	{
	if (CDB::Rewrite(strWalletFile, "\x04pool"))
	{
	LOCK(cs_wallet);
	setKeyPool.clear();
	// Note: can't top-up keypool here, because wallet is locked.
	// User will be prompted to unlock wallet the next operation
	// that requires a new key.
	}
	}

	if (nZapWalletTxRet != DB_LOAD_OK)
	return nZapWalletTxRet;

	return DB_LOAD_OK;
	}


	bool CWallet::SetAddressBook(const CTxDestination& address, const string& strName, const string& strPurpose)
	{
	bool fUpdated = false;
	{
	LOCK(cs_wallet); // mapAddressBook
	std::map<CTxDestination, CAddressBookData>::iterator mi = mapAddressBook.find(address);
	fUpdated = mi != mapAddressBook.end();
	mapAddressBook[address].name = strName;
	if (!strPurpose.empty()) /* update purpose only if requested */
	mapAddressBook[address].purpose = strPurpose;
	}
	NotifyAddressBookChanged(this, address, strName, ::IsMine(*this, address) != ISMINE_NO,
	strPurpose, (fUpdated ? CT_UPDATED : CT_NEW) );
	if (!fFileBacked)
	return false;
	if (!strPurpose.empty() && !CWalletDB(strWalletFile).WritePurpose(CBitcoinAddress(address).ToString(), strPurpose))
	return false;
	return CWalletDB(strWalletFile).WriteName(CBitcoinAddress(address).ToString(), strName);
	}

	bool CWallet::DelAddressBook(const CTxDestination& address)
	{
	{
	LOCK(cs_wallet); // mapAddressBook

	if(fFileBacked)
	{
	// Delete destdata tuples associated with address
	std::string strAddress = CBitcoinAddress(address).ToString();
	BOOST_FOREACH(const PAIRTYPE(string, string) &item, mapAddressBook[address].destdata)
	{
	CWalletDB(strWalletFile).EraseDestData(strAddress, item.first);
	}
	}
	mapAddressBook.erase(address);
	}

	NotifyAddressBookChanged(this, address, "", ::IsMine(*this, address) != ISMINE_NO, "", CT_DELETED);

	if (!fFileBacked)
	return false;
	CWalletDB(strWalletFile).ErasePurpose(CBitcoinAddress(address).ToString());
	return CWalletDB(strWalletFile).EraseName(CBitcoinAddress(address).ToString());
	}

	bool CWallet::SetDefaultKey(const CPubKey &vchPubKey)
	{
	if (fFileBacked)
	{
	if (!CWalletDB(strWalletFile).WriteDefaultKey(vchPubKey))
	return false;
	}
	vchDefaultKey = vchPubKey;
	return true;
	}

	/**
	* Mark old keypool keys as used,
	* and generate all new keys
	*/
	bool CWallet::NewKeyPool()
	{
	{
	LOCK(cs_wallet);
	CWalletDB walletdb(strWalletFile);
	BOOST_FOREACH(int64_t nIndex, setKeyPool)
	walletdb.ErasePool(nIndex);
	setKeyPool.clear();

	if (IsLocked())
	return false;

	int64_t nKeys = max(GetArg("-keypool", DEFAULT_KEYPOOL_SIZE), (int64_t)0);
	for (int i = 0; i < nKeys; i++)
	{
	int64_t nIndex = i+1;
	walletdb.WritePool(nIndex, CKeyPool(GenerateNewKey()));
	setKeyPool.insert(nIndex);
	}
	LogPrintf("CWallet::NewKeyPool wrote %d new keys\n", nKeys);
	}
	return true;
	}

	bool CWallet::TopUpKeyPool(unsigned int kpSize)
	{
	{
	LOCK(cs_wallet);

	if (IsLocked())
	return false;

	CWalletDB walletdb(strWalletFile);

	// Top up key pool
	unsigned int nTargetSize;
	if (kpSize > 0)
	nTargetSize = kpSize;
	else
	nTargetSize = max(GetArg("-keypool", DEFAULT_KEYPOOL_SIZE), (int64_t) 0);

	while (setKeyPool.size() < (nTargetSize + 1))
	{
	int64_t nEnd = 1;
	if (!setKeyPool.empty())
	nEnd = *(--setKeyPool.end()) + 1;
	if (!walletdb.WritePool(nEnd, CKeyPool(GenerateNewKey())))
	throw runtime_error("TopUpKeyPool(): writing generated key failed");
	setKeyPool.insert(nEnd);
	LogPrintf("keypool added key %d, size=%u\n", nEnd, setKeyPool.size());
	}
	}
	return true;
	}

	void CWallet::ReserveKeyFromKeyPool(int64_t& nIndex, CKeyPool& keypool)
	{
	nIndex = -1;
	keypool.vchPubKey = CPubKey();
	{
	LOCK(cs_wallet);

	if (!IsLocked())
	TopUpKeyPool();

	// Get the oldest key
	if(setKeyPool.empty())
	return;

	CWalletDB walletdb(strWalletFile);

	nIndex = *(setKeyPool.begin());
	setKeyPool.erase(setKeyPool.begin());
	if (!walletdb.ReadPool(nIndex, keypool))
	throw runtime_error("ReserveKeyFromKeyPool(): read failed");
	if (!HaveKey(keypool.vchPubKey.GetID()))
	throw runtime_error("ReserveKeyFromKeyPool(): unknown key in key pool");
	assert(keypool.vchPubKey.IsValid());
	LogPrintf("keypool reserve %d\n", nIndex);
	}
	}

	void CWallet::KeepKey(int64_t nIndex)
	{
	// Remove from key pool
	if (fFileBacked)
	{
	CWalletDB walletdb(strWalletFile);
	walletdb.ErasePool(nIndex);
	}
	LogPrintf("keypool keep %d\n", nIndex);
	}

	void CWallet::ReturnKey(int64_t nIndex)
	{
	// Return to key pool
	{
	LOCK(cs_wallet);
	setKeyPool.insert(nIndex);
	}
	LogPrintf("keypool return %d\n", nIndex);
	}

	bool CWallet::GetKeyFromPool(CPubKey& result)
	{
	int64_t nIndex = 0;
	CKeyPool keypool;
	{
	LOCK(cs_wallet);
	ReserveKeyFromKeyPool(nIndex, keypool);
	if (nIndex == -1)
	{
	if (IsLocked()) return false;
	result = GenerateNewKey();
	return true;
	}
	KeepKey(nIndex);
	result = keypool.vchPubKey;
	}
	return true;
	}

	int64_t CWallet::GetOldestKeyPoolTime()
	{
	LOCK(cs_wallet);

	// if the keypool is empty, return <NOW>
	if (setKeyPool.empty())
	return GetTime();

	// load oldest key from keypool, get time and return
	CKeyPool keypool;
	CWalletDB walletdb(strWalletFile);
	int64_t nIndex = *(setKeyPool.begin());
	if (!walletdb.ReadPool(nIndex, keypool))
	throw runtime_error("GetOldestKeyPoolTime(): read oldest key in keypool failed");
	assert(keypool.vchPubKey.IsValid());
	return keypool.nTime;
	}

	std::map<CTxDestination, CAmount> CWallet::GetAddressBalances()
	{
	map<CTxDestination, CAmount> balances;

	{
	LOCK(cs_wallet);
	BOOST_FOREACH(PAIRTYPE(uint256, CWalletTx) walletEntry, mapWallet)
	{
	CWalletTx *pcoin = &walletEntry.second;

	if (!CheckFinalTx(*pcoin) \|\| !pcoin->IsTrusted())
	continue;

	if (pcoin->IsCoinBase() && pcoin->GetBlocksToMaturity() > 0)
	continue;

	int nDepth = pcoin->GetDepthInMainChain();
	if (nDepth < (pcoin->IsFromMe(ISMINE_ALL) ? 0 : 1))
	continue;

	for (unsigned int i = 0; i < pcoin->vout.size(); i++)
	{
	CTxDestination addr;
	if (!IsMine(pcoin->vout[i]))
	continue;
	if(!ExtractDestination(pcoin->vout[i].scriptPubKey, addr))
	continue;

	CAmount n = IsSpent(walletEntry.first, i) ? 0 : pcoin->vout[i].nValue;

	if (!balances.count(addr))
	balances[addr] = 0;
	balances[addr] += n;
	}
	}
	}

	return balances;
	}

	set< set<CTxDestination> > CWallet::GetAddressGroupings()
	{
	AssertLockHeld(cs_wallet); // mapWallet
	set< set<CTxDestination> > groupings;
	set<CTxDestination> grouping;

	BOOST_FOREACH(PAIRTYPE(uint256, CWalletTx) walletEntry, mapWallet)
	{
	CWalletTx *pcoin = &walletEntry.second;

	if (pcoin->vin.size() > 0)
	{
	bool any_mine = false;
	// group all input addresses with each other
	BOOST_FOREACH(CTxIn txin, pcoin->vin)
	{
	CTxDestination address;
	if(!IsMine(txin)) /* If this input isn't mine, ignore it */
	continue;
	if(!ExtractDestination(mapWallet[txin.prevout.hash].vout[txin.prevout.n].scriptPubKey, address))
	continue;
	grouping.insert(address);
	any_mine = true;
	}

	// group change with input addresses
	if (any_mine)
	{
	BOOST_FOREACH(CTxOut txout, pcoin->vout)
	if (IsChange(txout))
	{
	CTxDestination txoutAddr;
	if(!ExtractDestination(txout.scriptPubKey, txoutAddr))
	continue;
	grouping.insert(txoutAddr);
	}
	}
	if (grouping.size() > 0)
	{
	groupings.insert(grouping);
	grouping.clear();
	}
	}

	// group lone addrs by themselves
	for (unsigned int i = 0; i < pcoin->vout.size(); i++)
	if (IsMine(pcoin->vout[i]))
	{
	CTxDestination address;
	if(!ExtractDestination(pcoin->vout[i].scriptPubKey, address))
	continue;
	grouping.insert(address);
	groupings.insert(grouping);
	grouping.clear();
	}
	}

	set< set<CTxDestination>* > uniqueGroupings; // a set of pointers to groups of addresses
	map< CTxDestination, set<CTxDestination>* > setmap; // map addresses to the unique group containing it
	BOOST_FOREACH(set<CTxDestination> grouping, groupings)
	{
	// make a set of all the groups hit by this new group
	set< set<CTxDestination>* > hits;
	map< CTxDestination, set<CTxDestination>* >::iterator it;
	BOOST_FOREACH(CTxDestination address, grouping)
	if ((it = setmap.find(address)) != setmap.end())
	hits.insert((*it).second);

	// merge all hit groups into a new single group and delete old groups
	set<CTxDestination>* merged = new set<CTxDestination>(grouping);
	BOOST_FOREACH(set<CTxDestination>* hit, hits)
	{
	merged->insert(hit->begin(), hit->end());
	uniqueGroupings.erase(hit);
	delete hit;
	}
	uniqueGroupings.insert(merged);

	// update setmap
	BOOST_FOREACH(CTxDestination element, *merged)
	setmap[element] = merged;
	}

	set< set<CTxDestination> > ret;
	BOOST_FOREACH(set<CTxDestination>* uniqueGrouping, uniqueGroupings)
	{
	ret.insert(*uniqueGrouping);
	delete uniqueGrouping;
	}

	return ret;
	}

	CAmount CWallet::GetAccountBalance(const std::string& strAccount, int nMinDepth, const isminefilter& filter)
	{
	CWalletDB walletdb(strWalletFile);
	return GetAccountBalance(walletdb, strAccount, nMinDepth, filter);
	}

	CAmount CWallet::GetAccountBalance(CWalletDB& walletdb, const std::string& strAccount, int nMinDepth, const isminefilter& filter)
	{
	CAmount nBalance = 0;

	// Tally wallet transactions
	for (map<uint256, CWalletTx>::iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
	{
	const CWalletTx& wtx = (*it).second;
	if (!CheckFinalTx(wtx) \|\| wtx.GetBlocksToMaturity() > 0 \|\| wtx.GetDepthInMainChain() < 0)
	continue;

	CAmount nReceived, nSent, nFee;
	wtx.GetAccountAmounts(strAccount, nReceived, nSent, nFee, filter);

	if (nReceived != 0 && wtx.GetDepthInMainChain() >= nMinDepth)
	nBalance += nReceived;
	nBalance -= nSent + nFee;
	}

	// Tally internal accounting entries
	nBalance += walletdb.GetAccountCreditDebit(strAccount);

	return nBalance;
	}

	std::set<CTxDestination> CWallet::GetAccountAddresses(const std::string& strAccount) const
	{
	LOCK(cs_wallet);
	set<CTxDestination> result;
	BOOST_FOREACH(const PAIRTYPE(CTxDestination, CAddressBookData)& item, mapAddressBook)
	{
	const CTxDestination& address = item.first;
	const string& strName = item.second.name;
	if (strName == strAccount)
	result.insert(address);
	}
	return result;
	}

	bool CReserveKey::GetReservedKey(CPubKey& pubkey)
	{
	if (nIndex == -1)
	{
	CKeyPool keypool;
	pwallet->ReserveKeyFromKeyPool(nIndex, keypool);
	if (nIndex != -1)
	vchPubKey = keypool.vchPubKey;
	else {
	return false;
	}
	}
	assert(vchPubKey.IsValid());
	pubkey = vchPubKey;
	return true;
	}

	void CReserveKey::KeepKey()
	{
	if (nIndex != -1)
	pwallet->KeepKey(nIndex);
	nIndex = -1;
	vchPubKey = CPubKey();
	}

	void CReserveKey::ReturnKey()
	{
	if (nIndex != -1)
	pwallet->ReturnKey(nIndex);
	nIndex = -1;
	vchPubKey = CPubKey();
	}

	void CWallet::GetAllReserveKeys(set<CKeyID>& setAddress) const
	{
	setAddress.clear();

	CWalletDB walletdb(strWalletFile);

	LOCK2(cs_main, cs_wallet);
	BOOST_FOREACH(const int64_t& id, setKeyPool)
	{
	CKeyPool keypool;
	if (!walletdb.ReadPool(id, keypool))
	throw runtime_error("GetAllReserveKeyHashes(): read failed");
	assert(keypool.vchPubKey.IsValid());
	CKeyID keyID = keypool.vchPubKey.GetID();
	if (!HaveKey(keyID))
	throw runtime_error("GetAllReserveKeyHashes(): unknown key in key pool");
	setAddress.insert(keyID);
	}
	}

	void CWallet::UpdatedTransaction(const uint256 &hashTx)
	{
	{
	LOCK(cs_wallet);
	// Only notify UI if this transaction is in this wallet
	map<uint256, CWalletTx>::const_iterator mi = mapWallet.find(hashTx);
	if (mi != mapWallet.end())
	NotifyTransactionChanged(this, hashTx, CT_UPDATED);
	}
	}

	void CWallet::GetScriptForMining(boost::shared_ptr<CReserveScript> &script)
	{
	boost::shared_ptr<CReserveKey> rKey(new CReserveKey(this));
	CPubKey pubkey;
	if (!rKey->GetReservedKey(pubkey))
	return;

	script = rKey;
	script->reserveScript = CScript() << ToByteVector(pubkey) << OP_CHECKSIG;
	}

	void CWallet::LockCoin(const COutPoint& output)
	{
	AssertLockHeld(cs_wallet); // setLockedCoins
	setLockedCoins.insert(output);
	}

	void CWallet::UnlockCoin(const COutPoint& output)
	{
	AssertLockHeld(cs_wallet); // setLockedCoins
	setLockedCoins.erase(output);
	}

	void CWallet::UnlockAllCoins()
	{
	AssertLockHeld(cs_wallet); // setLockedCoins
	setLockedCoins.clear();
	}

	bool CWallet::IsLockedCoin(uint256 hash, unsigned int n) const
	{
	AssertLockHeld(cs_wallet); // setLockedCoins
	COutPoint outpt(hash, n);

	return (setLockedCoins.count(outpt) > 0);
	}

	void CWallet::ListLockedCoins(std::vector<COutPoint>& vOutpts)
	{
	AssertLockHeld(cs_wallet); // setLockedCoins
	for (std::set<COutPoint>::iterator it = setLockedCoins.begin();
	it != setLockedCoins.end(); it++) {
	COutPoint outpt = (*it);
	vOutpts.push_back(outpt);
	}
	}

	/** @} */ // end of Actions

	class CAffectedKeysVisitor : public boost::static_visitor<void> {
	private:
	const CKeyStore &keystore;
	std::vector<CKeyID> &vKeys;

	public:
	CAffectedKeysVisitor(const CKeyStore &keystoreIn, std::vector<CKeyID> &vKeysIn) : keystore(keystoreIn), vKeys(vKeysIn) {}

	void Process(const CScript &script) {
	txnouttype type;
	std::vector<CTxDestination> vDest;
	int nRequired;
	if (ExtractDestinations(script, type, vDest, nRequired)) {
	BOOST_FOREACH(const CTxDestination &dest, vDest)
	boost::apply_visitor(*this, dest);
	}
	}

	void operator()(const CKeyID &keyId) {
	if (keystore.HaveKey(keyId))
	vKeys.push_back(keyId);
	}

	void operator()(const CScriptID &scriptId) {
	CScript script;
	if (keystore.GetCScript(scriptId, script))
	Process(script);
	}

	void operator()(const CNoDestination &none) {}
	};

	void CWallet::GetKeyBirthTimes(std::map<CKeyID, int64_t> &mapKeyBirth) const {
	AssertLockHeld(cs_wallet); // mapKeyMetadata
	mapKeyBirth.clear();

	// get birth times for keys with metadata
	for (std::map<CKeyID, CKeyMetadata>::const_iterator it = mapKeyMetadata.begin(); it != mapKeyMetadata.end(); it++)
	if (it->second.nCreateTime)
	mapKeyBirth[it->first] = it->second.nCreateTime;

	// map in which we'll infer heights of other keys
	CBlockIndex *pindexMax = chainActive[std::max(0, chainActive.Height() - 144)]; // the tip can be reorganised; use a 144-block safety margin
	std::map<CKeyID, CBlockIndex*> mapKeyFirstBlock;
	std::set<CKeyID> setKeys;
	GetKeys(setKeys);
	BOOST_FOREACH(const CKeyID &keyid, setKeys) {
	if (mapKeyBirth.count(keyid) == 0)
	mapKeyFirstBlock[keyid] = pindexMax;
	}
	setKeys.clear();

	// if there are no such keys, we're done
	if (mapKeyFirstBlock.empty())
	return;

	// find first block that affects those keys, if there are any left
	std::vector<CKeyID> vAffected;
	for (std::map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); it++) {
	// iterate over all wallet transactions...
	const CWalletTx &wtx = (*it).second;
	BlockMap::const_iterator blit = mapBlockIndex.find(wtx.hashBlock);
	if (blit != mapBlockIndex.end() && chainActive.Contains(blit->second)) {
	// ... which are already in a block
	int nHeight = blit->second->nHeight;
	BOOST_FOREACH(const CTxOut &txout, wtx.vout) {
	// iterate over all their outputs
	CAffectedKeysVisitor(*this, vAffected).Process(txout.scriptPubKey);
	BOOST_FOREACH(const CKeyID &keyid, vAffected) {
	// ... and all their affected keys
	std::map<CKeyID, CBlockIndex*>::iterator rit = mapKeyFirstBlock.find(keyid);
	if (rit != mapKeyFirstBlock.end() && nHeight < rit->second->nHeight)
	rit->second = blit->second;
	}
	vAffected.clear();
	}
	}
	}

	// Extract block timestamps for those keys
	for (std::map<CKeyID, CBlockIndex*>::const_iterator it = mapKeyFirstBlock.begin(); it != mapKeyFirstBlock.end(); it++)
	mapKeyBirth[it->first] = it->second->GetBlockTime() - 7200; // block times can be 2h off
	}

	bool CWallet::AddDestData(const CTxDestination &dest, const std::string &key, const std::string &value)
	{
	if (boost::get<CNoDestination>(&dest))
	return false;

	mapAddressBook[dest].destdata.insert(std::make_pair(key, value));
	if (!fFileBacked)
	return true;
	return CWalletDB(strWalletFile).WriteDestData(CBitcoinAddress(dest).ToString(), key, value);
	}

	bool CWallet::EraseDestData(const CTxDestination &dest, const std::string &key)
	{
	if (!mapAddressBook[dest].destdata.erase(key))
	return false;
	if (!fFileBacked)
	return true;
	return CWalletDB(strWalletFile).EraseDestData(CBitcoinAddress(dest).ToString(), key);
	}

	bool CWallet::LoadDestData(const CTxDestination &dest, const std::string &key, const std::string &value)
	{
	mapAddressBook[dest].destdata.insert(std::make_pair(key, value));
	return true;
	}

	bool CWallet::GetDestData(const CTxDestination &dest, const std::string &key, std::string *value) const
	{
	std::map<CTxDestination, CAddressBookData>::const_iterator i = mapAddressBook.find(dest);
	if(i != mapAddressBook.end())
	{
	CAddressBookData::StringMap::const_iterator j = i->second.destdata.find(key);
	if(j != i->second.destdata.end())
	{
	if(value)
	*value = j->second;
	return true;
	}
	}
	return false;
	}

	std::string CWallet::GetWalletHelpString(bool showDebug)
	{
	std::string strUsage = HelpMessageGroup(_("Wallet options:"));
	strUsage += HelpMessageOpt("-disablewallet", _("Do not load the wallet and disable wallet RPC calls"));
	strUsage += HelpMessageOpt("-keypool=<n>", strprintf(_("Set key pool size to <n> (default: %u)"), DEFAULT_KEYPOOL_SIZE));
	strUsage += HelpMessageOpt("-fallbackfee=<amt>", strprintf(_("A fee rate (in %s/kB) that will be used when fee estimation has insufficient data (default: %s)"),
	CURRENCY_UNIT, FormatMoney(DEFAULT_FALLBACK_FEE)));
	strUsage += HelpMessageOpt("-mintxfee=<amt>", strprintf(_("Fees (in %s/kB) smaller than this are considered zero fee for transaction creation (default: %s)"),
	CURRENCY_UNIT, FormatMoney(DEFAULT_TRANSACTION_MINFEE)));
	strUsage += HelpMessageOpt("-paytxfee=<amt>", strprintf(_("Fee (in %s/kB) to add to transactions you send (default: %s)"),
	CURRENCY_UNIT, FormatMoney(payTxFee.GetFeePerK())));
	strUsage += HelpMessageOpt("-rescan", _("Rescan the block chain for missing wallet transactions on startup"));
	strUsage += HelpMessageOpt("-salvagewallet", _("Attempt to recover private keys from a corrupt wallet on startup"));
	if (showDebug)
	strUsage += HelpMessageOpt("-sendfreetransactions", strprintf(_("Send transactions as zero-fee transactions if possible (default: %u)"), DEFAULT_SEND_FREE_TRANSACTIONS));
	strUsage += HelpMessageOpt("-spendzeroconfchange", strprintf(_("Spend unconfirmed change when sending transactions (default: %u)"), DEFAULT_SPEND_ZEROCONF_CHANGE));
	strUsage += HelpMessageOpt("-txconfirmtarget=<n>", strprintf(_("If paytxfee is not set, include enough fee so transactions begin confirmation on average within n blocks (default: %u)"), DEFAULT_TX_CONFIRM_TARGET));
	strUsage += HelpMessageOpt("-usehd", _("Use hierarchical deterministic key generation (HD) after BIP32. Only has effect during wallet creation/first start") + " " + strprintf(_("(default: %u)"), DEFAULT_USE_HD_WALLET));
	strUsage += HelpMessageOpt("-upgradewallet", _("Upgrade wallet to latest format on startup"));
	strUsage += HelpMessageOpt("-wallet=<file>", _("Specify wallet file (within data directory)") + " " + strprintf(_("(default: %s)"), DEFAULT_WALLET_DAT));
	strUsage += HelpMessageOpt("-walletbroadcast", _("Make the wallet broadcast transactions") + " " + strprintf(_("(default: %u)"), DEFAULT_WALLETBROADCAST));
	strUsage += HelpMessageOpt("-walletnotify=<cmd>", _("Execute command when a wallet transaction changes (%s in cmd is replaced by TxID)"));
	strUsage += HelpMessageOpt("-zapwallettxes=<mode>", _("Delete all wallet transactions and only recover those parts of the blockchain through -rescan on startup") +
	" " + _("(1 = keep tx meta data e.g. account owner and payment request information, 2 = drop tx meta data)"));

	if (showDebug)
	{
	strUsage += HelpMessageGroup(_("Wallet debugging/testing options:"));

	strUsage += HelpMessageOpt("-dblogsize=<n>", strprintf("Flush wallet database activity from memory to disk log every <n> megabytes (default: %u)", DEFAULT_WALLET_DBLOGSIZE));
	strUsage += HelpMessageOpt("-flushwallet", strprintf("Run a thread to flush wallet periodically (default: %u)", DEFAULT_FLUSHWALLET));
	strUsage += HelpMessageOpt("-privdb", strprintf("Sets the DB_PRIVATE flag in the wallet db environment (default: %u)", DEFAULT_WALLET_PRIVDB));
	}

	return strUsage;
	}

	bool CWallet::InitLoadWallet()
	{
	std::string walletFile = GetArg("-wallet", DEFAULT_WALLET_DAT);

	// needed to restore wallet transaction meta data after -zapwallettxes
	std::vector<CWalletTx> vWtx;

	if (GetBoolArg("-zapwallettxes", false)) {
	uiInterface.InitMessage(_("Zapping all transactions from wallet..."));

	CWallet *tempWallet = new CWallet(walletFile);
	DBErrors nZapWalletRet = tempWallet->ZapWalletTx(vWtx);
	if (nZapWalletRet != DB_LOAD_OK) {
	return InitError(strprintf(_("Error loading %s: Wallet corrupted"), walletFile));
	}

	delete tempWallet;
	tempWallet = NULL;
	}

	uiInterface.InitMessage(_("Loading wallet..."));

	int64_t nStart = GetTimeMillis();
	bool fFirstRun = true;
	CWallet *walletInstance = new CWallet(walletFile);
	DBErrors nLoadWalletRet = walletInstance->LoadWallet(fFirstRun);
	if (nLoadWalletRet != DB_LOAD_OK)
	{
	if (nLoadWalletRet == DB_CORRUPT)
	return InitError(strprintf(_("Error loading %s: Wallet corrupted"), walletFile));
	else if (nLoadWalletRet == DB_NONCRITICAL_ERROR)
	{
	InitWarning(strprintf(_("Error reading %s! All keys read correctly, but transaction data"
	" or address book entries might be missing or incorrect."),
	walletFile));
	}
	else if (nLoadWalletRet == DB_TOO_NEW)
	return InitError(strprintf(_("Error loading %s: Wallet requires newer version of %s"),
	walletFile, _(PACKAGE_NAME)));
	else if (nLoadWalletRet == DB_NEED_REWRITE)
	{
	return InitError(strprintf(_("Wallet needed to be rewritten: restart %s to complete"), _(PACKAGE_NAME)));
	}
	else
	return InitError(strprintf(_("Error loading %s"), walletFile));
	}

	if (GetBoolArg("-upgradewallet", fFirstRun))
	{
	int nMaxVersion = GetArg("-upgradewallet", 0);
	if (nMaxVersion == 0) // the -upgradewallet without argument case
	{
	LogPrintf("Performing wallet upgrade to %i\n", FEATURE_LATEST);
	nMaxVersion = CLIENT_VERSION;
	walletInstance->SetMinVersion(FEATURE_LATEST); // permanently upgrade the wallet immediately
	}
	else
	LogPrintf("Allowing wallet upgrade up to %i\n", nMaxVersion);
	if (nMaxVersion < walletInstance->GetVersion())
	{
	return InitError(_("Cannot downgrade wallet"));
	}
	walletInstance->SetMaxVersion(nMaxVersion);
	}

	if (fFirstRun)
	{
	// Create new keyUser and set as default key
	if (GetBoolArg("-usehd", DEFAULT_USE_HD_WALLET) && walletInstance->hdChain.masterKeyID.IsNull()) {
	// generate a new master key
	CKey key;
	key.MakeNewKey(true);
	if (!walletInstance->SetHDMasterKey(key))
	throw std::runtime_error("CWallet::GenerateNewKey(): Storing master key failed");
	+
	+ // ensure this wallet.dat can only be opened by clients supporting HD
	+ walletInstance->SetMinVersion(FEATURE_HD);
	}
	CPubKey newDefaultKey;
	if (walletInstance->GetKeyFromPool(newDefaultKey)) {
	walletInstance->SetDefaultKey(newDefaultKey);
	if (!walletInstance->SetAddressBook(walletInstance->vchDefaultKey.GetID(), "", "receive"))
	return InitError(_("Cannot write default address") += "\n");
	}

	walletInstance->SetBestChain(chainActive.GetLocator());
	}
	else if (mapArgs.count("-usehd")) {
	bool useHD = GetBoolArg("-usehd", DEFAULT_USE_HD_WALLET);
	if (!walletInstance->hdChain.masterKeyID.IsNull() && !useHD)
	return InitError(strprintf(_("Error loading %s: You can't disable HD on a already existing HD wallet"), walletFile));
	if (walletInstance->hdChain.masterKeyID.IsNull() && useHD)
	return InitError(strprintf(_("Error loading %s: You can't enable HD on a already existing non-HD wallet"), walletFile));
	}

	LogPrintf(" wallet %15dms\n", GetTimeMillis() - nStart);

	RegisterValidationInterface(walletInstance);

	CBlockIndex *pindexRescan = chainActive.Tip();
	if (GetBoolArg("-rescan", false))
	pindexRescan = chainActive.Genesis();
	else
	{
	CWalletDB walletdb(walletFile);
	CBlockLocator locator;
	if (walletdb.ReadBestBlock(locator))
	pindexRescan = FindForkInGlobalIndex(chainActive, locator);
	else
	pindexRescan = chainActive.Genesis();
	}
	if (chainActive.Tip() && chainActive.Tip() != pindexRescan)
	{
	//We can't rescan beyond non-pruned blocks, stop and throw an error
	//this might happen if a user uses a old wallet within a pruned node
	// or if he ran -disablewallet for a longer time, then decided to re-enable
	if (fPruneMode)
	{
	CBlockIndex *block = chainActive.Tip();
	while (block && block->pprev && (block->pprev->nStatus & BLOCK_HAVE_DATA) && block->pprev->nTx > 0 && pindexRescan != block)
	block = block->pprev;

	if (pindexRescan != block)
	return InitError(_("Prune: last wallet synchronisation goes beyond pruned data. You need to -reindex (download the whole blockchain again in case of pruned node)"));
	}

	uiInterface.InitMessage(_("Rescanning..."));
	LogPrintf("Rescanning last %i blocks (from block %i)...\n", chainActive.Height() - pindexRescan->nHeight, pindexRescan->nHeight);
	nStart = GetTimeMillis();
	walletInstance->ScanForWalletTransactions(pindexRescan, true);
	LogPrintf(" rescan %15dms\n", GetTimeMillis() - nStart);
	walletInstance->SetBestChain(chainActive.GetLocator());
	nWalletDBUpdated++;

	// Restore wallet transaction metadata after -zapwallettxes=1
	if (GetBoolArg("-zapwallettxes", false) && GetArg("-zapwallettxes", "1") != "2")
	{
	CWalletDB walletdb(walletFile);

	BOOST_FOREACH(const CWalletTx& wtxOld, vWtx)
	{
	uint256 hash = wtxOld.GetHash();
	std::map<uint256, CWalletTx>::iterator mi = walletInstance->mapWallet.find(hash);
	if (mi != walletInstance->mapWallet.end())
	{
	const CWalletTx* copyFrom = &wtxOld;
	CWalletTx* copyTo = &mi->second;
	copyTo->mapValue = copyFrom->mapValue;
	copyTo->vOrderForm = copyFrom->vOrderForm;
	copyTo->nTimeReceived = copyFrom->nTimeReceived;
	copyTo->nTimeSmart = copyFrom->nTimeSmart;
	copyTo->fFromMe = copyFrom->fFromMe;
	copyTo->strFromAccount = copyFrom->strFromAccount;
	copyTo->nOrderPos = copyFrom->nOrderPos;
	walletdb.WriteTx(*copyTo);
	}
	}
	}
	}
	walletInstance->SetBroadcastTransactions(GetBoolArg("-walletbroadcast", DEFAULT_WALLETBROADCAST));

	pwalletMain = walletInstance;
	return true;
	}

	bool CWallet::ParameterInteraction()
	{
	if (mapArgs.count("-mintxfee"))
	{
	CAmount n = 0;
	if (ParseMoney(mapArgs["-mintxfee"], n) && n > 0)
	CWallet::minTxFee = CFeeRate(n);
	else
	return InitError(AmountErrMsg("mintxfee", mapArgs["-mintxfee"]));
	}
	if (mapArgs.count("-fallbackfee"))
	{
	CAmount nFeePerK = 0;
	if (!ParseMoney(mapArgs["-fallbackfee"], nFeePerK))
	return InitError(strprintf(_("Invalid amount for -fallbackfee=<amount>: '%s'"), mapArgs["-fallbackfee"]));
	if (nFeePerK > HIGH_TX_FEE_PER_KB)
	InitWarning(_("-fallbackfee is set very high! This is the transaction fee you may pay when fee estimates are not available."));
	CWallet::fallbackFee = CFeeRate(nFeePerK);
	}
	if (mapArgs.count("-paytxfee"))
	{
	CAmount nFeePerK = 0;
	if (!ParseMoney(mapArgs["-paytxfee"], nFeePerK))
	return InitError(AmountErrMsg("paytxfee", mapArgs["-paytxfee"]));
	if (nFeePerK > HIGH_TX_FEE_PER_KB)
	InitWarning(_("-paytxfee is set very high! This is the transaction fee you will pay if you send a transaction."));
	payTxFee = CFeeRate(nFeePerK, 1000);
	if (payTxFee < ::minRelayTxFee)
	{
	return InitError(strprintf(_("Invalid amount for -paytxfee=<amount>: '%s' (must be at least %s)"),
	mapArgs["-paytxfee"], ::minRelayTxFee.ToString()));
	}
	}
	if (mapArgs.count("-maxtxfee"))
	{
	CAmount nMaxFee = 0;
	if (!ParseMoney(mapArgs["-maxtxfee"], nMaxFee))
	return InitError(AmountErrMsg("maxtxfee", mapArgs["-maxtxfee"]));
	if (nMaxFee > HIGH_MAX_TX_FEE)
	InitWarning(_("-maxtxfee is set very high! Fees this large could be paid on a single transaction."));
	maxTxFee = nMaxFee;
	if (CFeeRate(maxTxFee, 1000) < ::minRelayTxFee)
	{
	return InitError(strprintf(_("Invalid amount for -maxtxfee=<amount>: '%s' (must be at least the minrelay fee of %s to prevent stuck transactions)"),
	mapArgs["-maxtxfee"], ::minRelayTxFee.ToString()));
	}
	}
	nTxConfirmTarget = GetArg("-txconfirmtarget", DEFAULT_TX_CONFIRM_TARGET);
	bSpendZeroConfChange = GetBoolArg("-spendzeroconfchange", DEFAULT_SPEND_ZEROCONF_CHANGE);
	fSendFreeTransactions = GetBoolArg("-sendfreetransactions", DEFAULT_SEND_FREE_TRANSACTIONS);

	return true;
	}

	bool CWallet::BackupWallet(const std::string& strDest)
	{
	if (!fFileBacked)
	return false;
	while (true)
	{
	{
	LOCK(bitdb.cs_db);
	if (!bitdb.mapFileUseCount.count(strWalletFile) \|\| bitdb.mapFileUseCount[strWalletFile] == 0)
	{
	// Flush log data to the dat file
	bitdb.CloseDb(strWalletFile);
	bitdb.CheckpointLSN(strWalletFile);
	bitdb.mapFileUseCount.erase(strWalletFile);

	// Copy wallet file
	boost::filesystem::path pathSrc = GetDataDir() / strWalletFile;
	boost::filesystem::path pathDest(strDest);
	if (boost::filesystem::is_directory(pathDest))
	pathDest /= strWalletFile;

	try {
	#if BOOST_VERSION >= 104000
	boost::filesystem::copy_file(pathSrc, pathDest, boost::filesystem::copy_option::overwrite_if_exists);
	#else
	boost::filesystem::copy_file(pathSrc, pathDest);
	#endif
	LogPrintf("copied %s to %s\n", strWalletFile, pathDest.string());
	return true;
	} catch (const boost::filesystem::filesystem_error& e) {
	LogPrintf("error copying %s to %s - %s\n", strWalletFile, pathDest.string(), e.what());
	return false;
	}
	}
	}
	MilliSleep(100);
	}
	return false;
	}

	CKeyPool::CKeyPool()
	{
	nTime = GetTime();
	}

	CKeyPool::CKeyPool(const CPubKey& vchPubKeyIn)
	{
	nTime = GetTime();
	vchPubKey = vchPubKeyIn;
	}

	CWalletKey::CWalletKey(int64_t nExpires)
	{
	nTimeCreated = (nExpires ? GetTime() : 0);
	nTimeExpires = nExpires;
	}

	int CMerkleTx::SetMerkleBranch(const CBlock& block)
	{
	AssertLockHeld(cs_main);
	CBlock blockTmp;

	// Update the tx's hashBlock
	hashBlock = block.GetHash();

	// Locate the transaction
	for (nIndex = 0; nIndex < (int)block.vtx.size(); nIndex++)
	if (block.vtx[nIndex] == (CTransaction)this)
	break;
	if (nIndex == (int)block.vtx.size())
	{
	nIndex = -1;
	LogPrintf("ERROR: SetMerkleBranch(): couldn't find tx in block\n");
	return 0;
	}

	// Is the tx in a block that's in the main chain
	BlockMap::iterator mi = mapBlockIndex.find(hashBlock);
	if (mi == mapBlockIndex.end())
	return 0;
	const CBlockIndex* pindex = (*mi).second;
	if (!pindex \|\| !chainActive.Contains(pindex))
	return 0;

	return chainActive.Height() - pindex->nHeight + 1;
	}

	int CMerkleTx::GetDepthInMainChain(const CBlockIndex* &pindexRet) const
	{
	if (hashUnset())
	return 0;

	AssertLockHeld(cs_main);

	// Find the block it claims to be in
	BlockMap::iterator mi = mapBlockIndex.find(hashBlock);
	if (mi == mapBlockIndex.end())
	return 0;
	CBlockIndex* pindex = (*mi).second;
	if (!pindex \|\| !chainActive.Contains(pindex))
	return 0;

	pindexRet = pindex;
	return ((nIndex == -1) ? (-1) : 1) * (chainActive.Height() - pindex->nHeight + 1);
	}

	int CMerkleTx::GetBlocksToMaturity() const
	{
	if (!IsCoinBase())
	return 0;
	return max(0, (COINBASE_MATURITY+1) - GetDepthInMainChain());
	}


	bool CMerkleTx::AcceptToMemoryPool(bool fLimitFree, CAmount nAbsurdFee)
	{
	CValidationState state;
	return ::AcceptToMemoryPool(mempool, state, *this, fLimitFree, NULL, false, nAbsurdFee);
	}
	diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
	index e9d669a7d1..3a3cb6d851 100644
	--- a/src/wallet/wallet.h
	+++ b/src/wallet/wallet.h
	@@ -1,962 +1,963 @@
	// Copyright (c) 2009-2010 Satoshi Nakamoto
	// Copyright (c) 2009-2015 The Bitcoin Core developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#ifndef BITCOIN_WALLET_WALLET_H
	#define BITCOIN_WALLET_WALLET_H

	#include "amount.h"
	#include "streams.h"
	#include "tinyformat.h"
	#include "ui_interface.h"
	#include "utilstrencodings.h"
	#include "validationinterface.h"
	#include "script/ismine.h"
	#include "wallet/crypter.h"
	#include "wallet/walletdb.h"
	#include "wallet/rpcwallet.h"

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

	#include <boost/shared_ptr.hpp>

	extern CWallet* pwalletMain;

	/**
	* Settings
	*/
	extern CFeeRate payTxFee;
	extern unsigned int nTxConfirmTarget;
	extern bool bSpendZeroConfChange;
	extern bool fSendFreeTransactions;

	static const unsigned int DEFAULT_KEYPOOL_SIZE = 100;
	//! -paytxfee default
	static const CAmount DEFAULT_TRANSACTION_FEE = 0;
	//! -fallbackfee default
	static const CAmount DEFAULT_FALLBACK_FEE = 20000;
	//! -mintxfee default
	static const CAmount DEFAULT_TRANSACTION_MINFEE = 1000;
	//! minimum change amount
	static const CAmount MIN_CHANGE = CENT;
	//! Default for -spendzeroconfchange
	static const bool DEFAULT_SPEND_ZEROCONF_CHANGE = true;
	//! Default for -sendfreetransactions
	static const bool DEFAULT_SEND_FREE_TRANSACTIONS = false;
	//! -txconfirmtarget default
	static const unsigned int DEFAULT_TX_CONFIRM_TARGET = 2;
	//! Largest (in bytes) free transaction we're willing to create
	static const unsigned int MAX_FREE_TRANSACTION_CREATE_SIZE = 1000;
	static const bool DEFAULT_WALLETBROADCAST = true;

	//! if set, all keys will be derived by using BIP32
	static const bool DEFAULT_USE_HD_WALLET = true;

	extern const char * DEFAULT_WALLET_DAT;

	class CBlockIndex;
	class CCoinControl;
	class COutput;
	class CReserveKey;
	class CScript;
	class CTxMemPool;
	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
	+ FEATURE_HD = 130000, // Hierarchical key derivation after BIP32 (HD Wallet)
	+ FEATURE_LATEST = FEATURE_COMPRPUBKEY // HD is optional, use FEATURE_COMPRPUBKEY as latest version
	};


	/** A key pool entry */
	class CKeyPool
	{
	public:
	int64_t nTime;
	CPubKey vchPubKey;

	CKeyPool();
	CKeyPool(const CPubKey& vchPubKeyIn);

	ADD_SERIALIZE_METHODS;

	template <typename Stream, typename Operation>
	inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
	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;
	};

	struct CRecipient
	{
	CScript scriptPubKey;
	CAmount nAmount;
	bool fSubtractFeeFromAmount;
	};

	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);
	}

	struct COutputEntry
	{
	CTxDestination destination;
	CAmount amount;
	int vout;
	};

	/** A transaction with a merkle branch linking it to the block chain. */
	class CMerkleTx : public CTransaction
	{
	private:
	/** Constant used in hashBlock to indicate tx has been abandoned */
	static const uint256 ABANDON_HASH;

	public:
	uint256 hashBlock;

	/* An nIndex == -1 means that hashBlock (in nonzero) refers to the earliest
	* block in the chain we know this or any in-wallet dependency conflicts
	* with. Older clients interpret nIndex == -1 as unconfirmed for backward
	* compatibility.
	*/
	int nIndex;

	CMerkleTx()
	{
	Init();
	}

	CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
	{
	Init();
	}

	void Init()
	{
	hashBlock = uint256();
	nIndex = -1;
	}

	ADD_SERIALIZE_METHODS;

	template <typename Stream, typename Operation>
	inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
	std::vector<uint256> vMerkleBranch; // For compatibility with older versions.
	READWRITE((CTransaction)this);
	nVersion = this->nVersion;
	READWRITE(hashBlock);
	READWRITE(vMerkleBranch);
	READWRITE(nIndex);
	}

	int SetMerkleBranch(const CBlock& block);

	/**
	* Return depth of transaction in blockchain:
	* <0 : conflicts with a transaction this deep in the blockchain
	* 0 : in memory pool, waiting to be included in a block
	* >=1 : this many blocks deep in the main chain
	*/
	int GetDepthInMainChain(const CBlockIndex* &pindexRet) const;
	int GetDepthInMainChain() const { const CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
	bool IsInMainChain() const { const CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet) > 0; }
	int GetBlocksToMaturity() const;
	/** Pass this transaction to the mempool. Fails if absolute fee exceeds absurd fee. */
	bool AcceptToMemoryPool(bool fLimitFree, const CAmount nAbsurdFee);
	bool hashUnset() const { return (hashBlock.IsNull() \|\| hashBlock == ABANDON_HASH); }
	bool isAbandoned() const { return (hashBlock == ABANDON_HASH); }
	void setAbandoned() { hashBlock = ABANDON_HASH; }
	};

	/**
	* 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:
	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;
	int64_t nOrderPos; //!< position in ordered transaction list

	// memory only
	mutable bool fDebitCached;
	mutable bool fCreditCached;
	mutable bool fImmatureCreditCached;
	mutable bool fAvailableCreditCached;
	mutable bool fWatchDebitCached;
	mutable bool fWatchCreditCached;
	mutable bool fImmatureWatchCreditCached;
	mutable bool fAvailableWatchCreditCached;
	mutable bool fChangeCached;
	mutable CAmount nDebitCached;
	mutable CAmount nCreditCached;
	mutable CAmount nImmatureCreditCached;
	mutable CAmount nAvailableCreditCached;
	mutable CAmount nWatchDebitCached;
	mutable CAmount nWatchCreditCached;
	mutable CAmount nImmatureWatchCreditCached;
	mutable CAmount nAvailableWatchCreditCached;
	mutable CAmount 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;
	mapValue.clear();
	vOrderForm.clear();
	fTimeReceivedIsTxTime = false;
	nTimeReceived = 0;
	nTimeSmart = 0;
	fFromMe = false;
	strFromAccount.clear();
	fDebitCached = false;
	fCreditCached = false;
	fImmatureCreditCached = false;
	fAvailableCreditCached = false;
	fWatchDebitCached = false;
	fWatchCreditCached = false;
	fImmatureWatchCreditCached = false;
	fAvailableWatchCreditCached = false;
	fChangeCached = false;
	nDebitCached = 0;
	nCreditCached = 0;
	nImmatureCreditCached = 0;
	nAvailableCreditCached = 0;
	nWatchDebitCached = 0;
	nWatchCreditCached = 0;
	nAvailableWatchCreditCached = 0;
	nImmatureWatchCreditCached = 0;
	nChangeCached = 0;
	nOrderPos = -1;
	}

	ADD_SERIALIZE_METHODS;

	template <typename Stream, typename Operation>
	inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
	if (ser_action.ForRead())
	Init(NULL);
	char fSpent = false;

	if (!ser_action.ForRead())
	{
	mapValue["fromaccount"] = strFromAccount;

	WriteOrderPos(nOrderPos, mapValue);

	if (nTimeSmart)
	mapValue["timesmart"] = strprintf("%u", nTimeSmart);
	}

	READWRITE((CMerkleTx)this);
	std::vector<CMerkleTx> vUnused; //!< Used to be vtxPrev
	READWRITE(vUnused);
	READWRITE(mapValue);
	READWRITE(vOrderForm);
	READWRITE(fTimeReceivedIsTxTime);
	READWRITE(nTimeReceived);
	READWRITE(fFromMe);
	READWRITE(fSpent);

	if (ser_action.ForRead())
	{
	strFromAccount = mapValue["fromaccount"];

	ReadOrderPos(nOrderPos, mapValue);

	nTimeSmart = mapValue.count("timesmart") ? (unsigned int)atoi64(mapValue["timesmart"]) : 0;
	}

	mapValue.erase("fromaccount");
	mapValue.erase("version");
	mapValue.erase("spent");
	mapValue.erase("n");
	mapValue.erase("timesmart");
	}

	//! make sure balances are recalculated
	void MarkDirty()
	{
	fCreditCached = false;
	fAvailableCreditCached = false;
	fWatchDebitCached = false;
	fWatchCreditCached = false;
	fAvailableWatchCreditCached = false;
	fImmatureWatchCreditCached = false;
	fDebitCached = false;
	fChangeCached = false;
	}

	void BindWallet(CWallet *pwalletIn)
	{
	pwallet = pwalletIn;
	MarkDirty();
	}

	//! filter decides which addresses will count towards the debit
	CAmount GetDebit(const isminefilter& filter) const;
	CAmount GetCredit(const isminefilter& filter) const;
	CAmount GetImmatureCredit(bool fUseCache=true) const;
	CAmount GetAvailableCredit(bool fUseCache=true) const;
	CAmount GetImmatureWatchOnlyCredit(const bool& fUseCache=true) const;
	CAmount GetAvailableWatchOnlyCredit(const bool& fUseCache=true) const;
	CAmount GetChange() const;

	void GetAmounts(std::list<COutputEntry>& listReceived,
	std::list<COutputEntry>& listSent, CAmount& nFee, std::string& strSentAccount, const isminefilter& filter) const;

	void GetAccountAmounts(const std::string& strAccount, CAmount& nReceived,
	CAmount& nSent, CAmount& nFee, const isminefilter& filter) const;

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

	// True if only scriptSigs are different
	bool IsEquivalentTo(const CWalletTx& tx) const;

	bool InMempool() const;
	bool IsTrusted() const;

	int64_t GetTxTime() const;
	int GetRequestCount() const;

	bool RelayWalletTransaction();

	std::set<uint256> GetConflicts() const;
	};




	class COutput
	{
	public:
	const CWalletTx *tx;
	int i;
	int nDepth;
	bool fSpendable;
	bool fSolvable;

	COutput(const CWalletTx *txIn, int iIn, int nDepthIn, bool fSpendableIn, bool fSolvableIn)
	{
	tx = txIn; i = iIn; nDepth = nDepthIn; fSpendable = fSpendableIn; fSolvable = fSolvableIn;
	}

	std::string ToString() const;
	};




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

	ADD_SERIALIZE_METHODS;

	template <typename Stream, typename Operation>
	inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
	if (!(nType & SER_GETHASH))
	READWRITE(nVersion);
	READWRITE(vchPrivKey);
	READWRITE(nTimeCreated);
	READWRITE(nTimeExpires);
	READWRITE(LIMITED_STRING(strComment, 65536));
	}
	};

	/**
	* Internal transfers.
	* Database key is acentry<account><counter>.
	*/
	class CAccountingEntry
	{
	public:
	std::string strAccount;
	CAmount 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;
	nEntryNo = 0;
	}

	ADD_SERIALIZE_METHODS;

	template <typename Stream, typename Operation>
	inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
	if (!(nType & SER_GETHASH))
	READWRITE(nVersion);
	//! Note: strAccount is serialized as part of the key, not here.
	READWRITE(nCreditDebit);
	READWRITE(nTime);
	READWRITE(LIMITED_STRING(strOtherAccount, 65536));

	if (!ser_action.ForRead())
	{
	WriteOrderPos(nOrderPos, 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());
	strComment.append(ss.str());
	}
	}

	READWRITE(LIMITED_STRING(strComment, 65536));

	size_t nSepPos = strComment.find("\0", 0, 1);
	if (ser_action.ForRead())
	{
	mapValue.clear();
	if (std::string::npos != nSepPos)
	{
	CDataStream ss(std::vector<char>(strComment.begin() + nSepPos + 1, strComment.end()), nType, nVersion);
	ss >> mapValue;
	_ssExtra = std::vector<char>(ss.begin(), ss.end());
	}
	ReadOrderPos(nOrderPos, mapValue);
	}
	if (std::string::npos != nSepPos)
	strComment.erase(nSepPos);

	mapValue.erase("n");
	}

	private:
	std::vector<char> _ssExtra;
	};


	/**
	* 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 CValidationInterface
	{
	private:
	/**
	* Select a set of coins such that nValueRet >= nTargetValue and at least
	* all coins from coinControl are selected; Never select unconfirmed coins
	* if they are not ours
	*/
	bool SelectCoins(const std::vector<COutput>& vAvailableCoins, const CAmount& nTargetValue, std::set<std::pair<const CWalletTx,unsigned int> >& setCoinsRet, CAmount& 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;
	bool fBroadcastTransactions;

	/**
	* Used to keep track of spent outpoints, and
	* detect and report conflicts (double-spends or
	* mutated transactions where the mutant gets mined).
	*/
	typedef std::multimap<COutPoint, uint256> TxSpends;
	TxSpends mapTxSpends;
	void AddToSpends(const COutPoint& outpoint, const uint256& wtxid);
	void AddToSpends(const uint256& wtxid);

	/* Mark a transaction (and its in-wallet descendants) as conflicting with a particular block. */
	void MarkConflicted(const uint256& hashBlock, const uint256& hashTx);

	void SyncMetaData(std::pair<TxSpends::iterator, TxSpends::iterator>);

	/* the HD chain data model (external chain counters) */
	CHDChain hdChain;

	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()
	{
	SetNull();
	}

	CWallet(const std::string& strWalletFileIn)
	{
	SetNull();

	strWalletFile = strWalletFileIn;
	fFileBacked = true;
	}

	~CWallet()
	{
	delete pwalletdbEncryption;
	pwalletdbEncryption = NULL;
	}

	void SetNull()
	{
	nWalletVersion = FEATURE_BASE;
	nWalletMaxVersion = FEATURE_BASE;
	fFileBacked = false;
	nMasterKeyMaxID = 0;
	pwalletdbEncryption = NULL;
	nOrderPosNext = 0;
	nNextResend = 0;
	nLastResend = 0;
	nTimeFirstKey = 0;
	fBroadcastTransactions = false;
	}

	std::map<uint256, CWalletTx> mapWallet;
	std::list<CAccountingEntry> laccentries;

	typedef std::pair<CWalletTx, CAccountingEntry> TxPair;
	typedef std::multimap<int64_t, TxPair > TxItems;
	TxItems wtxOrdered;

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

	std::map<CTxDestination, CAddressBookData> mapAddressBook;

	CPubKey vchDefaultKey;

	std::set<COutPoint> setLockedCoins;

	int64_t nTimeFirstKey;

	const CWalletTx* GetWalletTx(const uint256& hash) const;

	//! 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; }

	/**
	* populate vCoins with vector of available COutputs.
	*/
	void AvailableCoins(std::vector<COutput>& vCoins, bool fOnlyConfirmed=true, const CCoinControl *coinControl = NULL, bool fIncludeZeroValue=false) const;

	/**
	* Shuffle and select coins until nTargetValue is reached while avoiding
	* small change; This method is stochastic for some inputs and upon
	* completion the coin set and corresponding actual target value is
	* assembled
	*/
	bool SelectCoinsMinConf(const CAmount& nTargetValue, int nConfMine, int nConfTheirs, std::vector<COutput> vCoins, std::set<std::pair<const CWalletTx*,unsigned int> >& setCoinsRet, CAmount& nValueRet) const;

	bool IsSpent(const uint256& hash, unsigned int n) const;

	bool IsLockedCoin(uint256 hash, unsigned int n) const;
	void LockCoin(const COutPoint& output);
	void UnlockCoin(const 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);

	//! 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;

	//! Adds a watch-only address to the store, and saves it to disk.
	bool AddWatchOnly(const CScript &dest);
	bool RemoveWatchOnly(const CScript &dest);
	//! Adds a watch-only address to the store, without saving it to disk (used by LoadWallet)
	bool LoadWatchOnly(const CScript &dest);

	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);
	bool AccountMove(std::string strFrom, std::string strTo, CAmount nAmount, std::string strComment = "");
	bool GetAccountPubkey(CPubKey &pubKey, std::string strAccount, bool bForceNew = false);

	void MarkDirty();
	bool AddToWallet(const CWalletTx& wtxIn, bool fFromLoadWallet, CWalletDB* pwalletdb);
	void SyncTransaction(const CTransaction& tx, const CBlockIndex pindex, const CBlock pblock);
	bool AddToWalletIfInvolvingMe(const CTransaction& tx, const CBlock* pblock, bool fUpdate);
	int ScanForWalletTransactions(CBlockIndex* pindexStart, bool fUpdate = false);
	void ReacceptWalletTransactions();
	void ResendWalletTransactions(int64_t nBestBlockTime);
	std::vector<uint256> ResendWalletTransactionsBefore(int64_t nTime);
	CAmount GetBalance() const;
	CAmount GetUnconfirmedBalance() const;
	CAmount GetImmatureBalance() const;
	CAmount GetWatchOnlyBalance() const;
	CAmount GetUnconfirmedWatchOnlyBalance() const;
	CAmount GetImmatureWatchOnlyBalance() const;

	/**
	* Insert additional inputs into the transaction by
	* calling CreateTransaction();
	*/
	bool FundTransaction(CMutableTransaction& tx, CAmount& nFeeRet, bool overrideEstimatedFeeRate, const CFeeRate& specificFeeRate, int& nChangePosInOut, std::string& strFailReason, bool includeWatching, bool lockUnspents, const CTxDestination& destChange = CNoDestination());

	/**
	* Create a new transaction paying the recipients with a set of coins
	* selected by SelectCoins(); Also create the change output, when needed
	* @note passing nChangePosInOut as -1 will result in setting a random position
	*/
	bool CreateTransaction(const std::vector<CRecipient>& vecSend, CWalletTx& wtxNew, CReserveKey& reservekey, CAmount& nFeeRet, int& nChangePosInOut,
	std::string& strFailReason, const CCoinControl *coinControl = NULL, bool sign = true);
	bool CommitTransaction(CWalletTx& wtxNew, CReserveKey& reservekey);

	bool AddAccountingEntry(const CAccountingEntry&, CWalletDB & pwalletdb);

	static CFeeRate minTxFee;
	static CFeeRate fallbackFee;
	/**
	* Estimate the minimum fee considering user set parameters
	* and the required fee
	*/
	static CAmount GetMinimumFee(unsigned int nTxBytes, unsigned int nConfirmTarget, const CTxMemPool& pool);
	/**
	* Return the minimum required fee taking into account the
	* floating relay fee and user set minimum transaction fee
	*/
	static CAmount GetRequiredFee(unsigned int nTxBytes);

	bool NewKeyPool();
	bool TopUpKeyPool(unsigned int kpSize = 0);
	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, CAmount> GetAddressBalances();

	CAmount GetAccountBalance(const std::string& strAccount, int nMinDepth, const isminefilter& filter);
	CAmount GetAccountBalance(CWalletDB& walletdb, const std::string& strAccount, int nMinDepth, const isminefilter& filter);
	std::set<CTxDestination> GetAccountAddresses(const std::string& strAccount) const;

	isminetype IsMine(const CTxIn& txin) const;
	CAmount GetDebit(const CTxIn& txin, const isminefilter& filter) const;
	isminetype IsMine(const CTxOut& txout) const;
	CAmount GetCredit(const CTxOut& txout, const isminefilter& filter) const;
	bool IsChange(const CTxOut& txout) const;
	CAmount GetChange(const CTxOut& txout) const;
	bool IsMine(const CTransaction& tx) const;
	/** should probably be renamed to IsRelevantToMe */
	bool IsFromMe(const CTransaction& tx) const;
	CAmount GetDebit(const CTransaction& tx, const isminefilter& filter) const;
	CAmount GetCredit(const CTransaction& tx, const isminefilter& filter) const;
	CAmount GetChange(const CTransaction& tx) const;
	void SetBestChain(const CBlockLocator& loc);

	DBErrors LoadWallet(bool& fFirstRunRet);
	DBErrors ZapWalletTx(std::vector<CWalletTx>& vWtx);
	DBErrors ZapSelectTx(std::vector<uint256>& vHashIn, std::vector<uint256>& vHashOut);

	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++;
	}
	}

	void GetScriptForMining(boost::shared_ptr<CReserveScript> &script);
	void ResetRequestCount(const uint256 &hash)
	{
	LOCK(cs_wallet);
	mapRequestCount[hash] = 0;
	};

	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() { LOCK(cs_wallet); return nWalletVersion; }

	//! Get wallet transactions that conflict with given transaction (spend same outputs)
	std::set<uint256> GetConflicts(const uint256& txid) const;

	//! Flush wallet (bitdb flush)
	void Flush(bool shutdown=false);

	//! Verify the wallet database and perform salvage if required
	static bool Verify();

	/**
	* 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;

	/** Show progress e.g. for rescan */
	boost::signals2::signal<void (const std::string &title, int nProgress)> ShowProgress;

	/** Watch-only address added */
	boost::signals2::signal<void (bool fHaveWatchOnly)> NotifyWatchonlyChanged;

	/** Inquire whether this wallet broadcasts transactions. */
	bool GetBroadcastTransactions() const { return fBroadcastTransactions; }
	/** Set whether this wallet broadcasts transactions. */
	void SetBroadcastTransactions(bool broadcast) { fBroadcastTransactions = broadcast; }

	/* Mark a transaction (and it in-wallet descendants) as abandoned so its inputs may be respent. */
	bool AbandonTransaction(const uint256& hashTx);

	/* Returns the wallets help message */
	static std::string GetWalletHelpString(bool showDebug);

	/* Initializes the wallet, returns a new CWallet instance or a null pointer in case of an error */
	static bool InitLoadWallet();

	/* Wallets parameter interaction */
	static bool ParameterInteraction();

	bool BackupWallet(const std::string& strDest);

	/* Set the HD chain model (chain child index counters) */
	bool SetHDChain(const CHDChain& chain, bool memonly);

	/* Set the current HD master key (will reset the chain child index counters) */
	bool SetHDMasterKey(const CKey& key);
	const CHDChain& GetHDChain() { return hdChain; }
	};

	/** A key allocated from the key pool. */
	class CReserveKey : public CReserveScript
	{
	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();
	void KeepScript() { KeepKey(); }
	};


	/**
	* Account information.
	* Stored in wallet with key "acc"+string account name.
	*/
	class CAccount
	{
	public:
	CPubKey vchPubKey;

	CAccount()
	{
	SetNull();
	}

	void SetNull()
	{
	vchPubKey = CPubKey();
	}

	ADD_SERIALIZE_METHODS;

	template <typename Stream, typename Operation>
	inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
	if (!(nType & SER_GETHASH))
	READWRITE(nVersion);
	READWRITE(vchPubKey);
	}
	};

	#endif // BITCOIN_WALLET_WALLET_H

File Metadata

Mime Type: text/x-diff
Expires: Wed, May 21, 19:05 (22 h, 29 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5865758
Default Alt Text: (159 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions