No OneTemporary
Actions

Size

331 KB

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/src/qt/walletmodel.cpp b/src/qt/walletmodel.cpp
	index a0d0e70442..3867310cd6 100644
	--- a/src/qt/walletmodel.cpp
	+++ b/src/qt/walletmodel.cpp
	@@ -1,685 +1,685 @@
	// Copyright (c) 2011-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 "walletmodel.h"

	#include "addresstablemodel.h"
	#include "guiconstants.h"
	#include "guiutil.h"
	#include "paymentserver.h"
	#include "recentrequeststablemodel.h"
	#include "transactiontablemodel.h"

	#include "base58.h"
	#include "keystore.h"
	#include "main.h"
	#include "sync.h"
	#include "ui_interface.h"
	#include "wallet/wallet.h"
	#include "wallet/walletdb.h" // for BackupWallet

	#include <stdint.h>

	#include <QDebug>
	#include <QSet>
	#include <QTimer>

	#include <boost/foreach.hpp>

	WalletModel::WalletModel(const PlatformStyle platformStyle, CWallet wallet, OptionsModel optionsModel, QObject parent) :
	QObject(parent), wallet(wallet), optionsModel(optionsModel), addressTableModel(0),
	transactionTableModel(0),
	recentRequestsTableModel(0),
	cachedBalance(0), cachedUnconfirmedBalance(0), cachedImmatureBalance(0),
	cachedEncryptionStatus(Unencrypted),
	cachedNumBlocks(0)
	{
	fHaveWatchOnly = wallet->HaveWatchOnly();
	fForceCheckBalanceChanged = false;

	addressTableModel = new AddressTableModel(wallet, this);
	transactionTableModel = new TransactionTableModel(platformStyle, wallet, this);
	recentRequestsTableModel = new RecentRequestsTableModel(wallet, this);

	// This timer will be fired repeatedly to update the balance
	pollTimer = new QTimer(this);
	connect(pollTimer, SIGNAL(timeout()), this, SLOT(pollBalanceChanged()));
	pollTimer->start(MODEL_UPDATE_DELAY);

	subscribeToCoreSignals();
	}

	WalletModel::~WalletModel()
	{
	unsubscribeFromCoreSignals();
	}

	CAmount WalletModel::getBalance(const CCoinControl *coinControl) const
	{
	if (coinControl)
	{
	CAmount nBalance = 0;
	std::vector<COutput> vCoins;
	wallet->AvailableCoins(vCoins, true, coinControl);
	BOOST_FOREACH(const COutput& out, vCoins)
	if(out.fSpendable)
	nBalance += out.tx->vout[out.i].nValue;

	return nBalance;
	}

	return wallet->GetBalance();
	}

	CAmount WalletModel::getUnconfirmedBalance() const
	{
	return wallet->GetUnconfirmedBalance();
	}

	CAmount WalletModel::getImmatureBalance() const
	{
	return wallet->GetImmatureBalance();
	}

	bool WalletModel::haveWatchOnly() const
	{
	return fHaveWatchOnly;
	}

	CAmount WalletModel::getWatchBalance() const
	{
	return wallet->GetWatchOnlyBalance();
	}

	CAmount WalletModel::getWatchUnconfirmedBalance() const
	{
	return wallet->GetUnconfirmedWatchOnlyBalance();
	}

	CAmount WalletModel::getWatchImmatureBalance() const
	{
	return wallet->GetImmatureWatchOnlyBalance();
	}

	void WalletModel::updateStatus()
	{
	EncryptionStatus newEncryptionStatus = getEncryptionStatus();

	if(cachedEncryptionStatus != newEncryptionStatus)
	Q_EMIT encryptionStatusChanged(newEncryptionStatus);
	}

	void WalletModel::pollBalanceChanged()
	{
	// Get required locks upfront. This avoids the GUI from getting stuck on
	// periodical polls if the core is holding the locks for a longer time -
	// for example, during a wallet rescan.
	TRY_LOCK(cs_main, lockMain);
	if(!lockMain)
	return;
	TRY_LOCK(wallet->cs_wallet, lockWallet);
	if(!lockWallet)
	return;

	if(fForceCheckBalanceChanged \|\| chainActive.Height() != cachedNumBlocks)
	{
	fForceCheckBalanceChanged = false;

	// Balance and number of transactions might have changed
	cachedNumBlocks = chainActive.Height();

	checkBalanceChanged();
	if(transactionTableModel)
	transactionTableModel->updateConfirmations();
	}
	}

	void WalletModel::checkBalanceChanged()
	{
	CAmount newBalance = getBalance();
	CAmount newUnconfirmedBalance = getUnconfirmedBalance();
	CAmount newImmatureBalance = getImmatureBalance();
	CAmount newWatchOnlyBalance = 0;
	CAmount newWatchUnconfBalance = 0;
	CAmount newWatchImmatureBalance = 0;
	if (haveWatchOnly())
	{
	newWatchOnlyBalance = getWatchBalance();
	newWatchUnconfBalance = getWatchUnconfirmedBalance();
	newWatchImmatureBalance = getWatchImmatureBalance();
	}

	if(cachedBalance != newBalance \|\| cachedUnconfirmedBalance != newUnconfirmedBalance \|\| cachedImmatureBalance != newImmatureBalance \|\|
	cachedWatchOnlyBalance != newWatchOnlyBalance \|\| cachedWatchUnconfBalance != newWatchUnconfBalance \|\| cachedWatchImmatureBalance != newWatchImmatureBalance)
	{
	cachedBalance = newBalance;
	cachedUnconfirmedBalance = newUnconfirmedBalance;
	cachedImmatureBalance = newImmatureBalance;
	cachedWatchOnlyBalance = newWatchOnlyBalance;
	cachedWatchUnconfBalance = newWatchUnconfBalance;
	cachedWatchImmatureBalance = newWatchImmatureBalance;
	Q_EMIT balanceChanged(newBalance, newUnconfirmedBalance, newImmatureBalance,
	newWatchOnlyBalance, newWatchUnconfBalance, newWatchImmatureBalance);
	}
	}

	void WalletModel::updateTransaction()
	{
	// Balance and number of transactions might have changed
	fForceCheckBalanceChanged = true;
	}

	void WalletModel::updateAddressBook(const QString &address, const QString &label,
	bool isMine, const QString &purpose, int status)
	{
	if(addressTableModel)
	addressTableModel->updateEntry(address, label, isMine, purpose, status);
	}

	void WalletModel::updateWatchOnlyFlag(bool fHaveWatchonly)
	{
	fHaveWatchOnly = fHaveWatchonly;
	Q_EMIT notifyWatchonlyChanged(fHaveWatchonly);
	}

	bool WalletModel::validateAddress(const QString &address)
	{
	CBitcoinAddress addressParsed(address.toStdString());
	return addressParsed.IsValid();
	}

	WalletModel::SendCoinsReturn WalletModel::prepareTransaction(WalletModelTransaction &transaction, const CCoinControl *coinControl)
	{
	CAmount total = 0;
	bool fSubtractFeeFromAmount = false;
	QList<SendCoinsRecipient> recipients = transaction.getRecipients();
	std::vector<CRecipient> vecSend;

	if(recipients.empty())
	{
	return OK;
	}

	QSet<QString> setAddress; // Used to detect duplicates
	int nAddresses = 0;

	// Pre-check input data for validity
	Q_FOREACH(const SendCoinsRecipient &rcp, recipients)
	{
	if (rcp.fSubtractFeeFromAmount)
	fSubtractFeeFromAmount = true;

	if (rcp.paymentRequest.IsInitialized())
	{ // PaymentRequest...
	CAmount subtotal = 0;
	const payments::PaymentDetails& details = rcp.paymentRequest.getDetails();
	for (int i = 0; i < details.outputs_size(); i++)
	{
	const payments::Output& out = details.outputs(i);
	if (out.amount() <= 0) continue;
	subtotal += out.amount();
	const unsigned char* scriptStr = (const unsigned char*)out.script().data();
	CScript scriptPubKey(scriptStr, scriptStr+out.script().size());
	CAmount nAmount = out.amount();
	CRecipient recipient = {scriptPubKey, nAmount, rcp.fSubtractFeeFromAmount};
	vecSend.push_back(recipient);
	}
	if (subtotal <= 0)
	{
	return InvalidAmount;
	}
	total += subtotal;
	}
	else
	{ // User-entered bitcoin address / amount:
	if(!validateAddress(rcp.address))
	{
	return InvalidAddress;
	}
	if(rcp.amount <= 0)
	{
	return InvalidAmount;
	}
	setAddress.insert(rcp.address);
	++nAddresses;

	CScript scriptPubKey = GetScriptForDestination(CBitcoinAddress(rcp.address.toStdString()).Get());
	CRecipient recipient = {scriptPubKey, rcp.amount, rcp.fSubtractFeeFromAmount};
	vecSend.push_back(recipient);

	total += rcp.amount;
	}
	}
	if(setAddress.size() != nAddresses)
	{
	return DuplicateAddress;
	}

	CAmount nBalance = getBalance(coinControl);

	if(total > nBalance)
	{
	return AmountExceedsBalance;
	}

	{
	LOCK2(cs_main, wallet->cs_wallet);

	transaction.newPossibleKeyChange(wallet);

	CAmount nFeeRequired = 0;
	int nChangePosRet = -1;
	std::string strFailReason;

	CWalletTx *newTx = transaction.getTransaction();
	CReserveKey *keyChange = transaction.getPossibleKeyChange();
	bool fCreated = wallet->CreateTransaction(vecSend, newTx, keyChange, nFeeRequired, nChangePosRet, strFailReason, coinControl);
	transaction.setTransactionFee(nFeeRequired);
	if (fSubtractFeeFromAmount && fCreated)
	transaction.reassignAmounts(nChangePosRet);

	if(!fCreated)
	{
	if(!fSubtractFeeFromAmount && (total + nFeeRequired) > nBalance)
	{
	return SendCoinsReturn(AmountWithFeeExceedsBalance);
	}
	Q_EMIT message(tr("Send Coins"), QString::fromStdString(strFailReason),
	CClientUIInterface::MSG_ERROR);
	return TransactionCreationFailed;
	}

	// reject absurdly high fee. (This can never happen because the
	// wallet caps the fee at maxTxFee. This merely serves as a
	// belt-and-suspenders check)
	if (nFeeRequired > maxTxFee)
	return AbsurdFee;
	}

	return SendCoinsReturn(OK);
	}

	WalletModel::SendCoinsReturn WalletModel::sendCoins(WalletModelTransaction &transaction)
	{
	QByteArray transaction_array; /* store serialized transaction */

	{
	LOCK2(cs_main, wallet->cs_wallet);
	CWalletTx *newTx = transaction.getTransaction();

	Q_FOREACH(const SendCoinsRecipient &rcp, transaction.getRecipients())
	{
	if (rcp.paymentRequest.IsInitialized())
	{
	// Make sure any payment requests involved are still valid.
	if (PaymentServer::verifyExpired(rcp.paymentRequest.getDetails())) {
	return PaymentRequestExpired;
	}

	// Store PaymentRequests in wtx.vOrderForm in wallet.
	std::string key("PaymentRequest");
	std::string value;
	rcp.paymentRequest.SerializeToString(&value);
	newTx->vOrderForm.push_back(make_pair(key, value));
	}
	else if (!rcp.message.isEmpty()) // Message from normal bitcoin:URI (bitcoin:123...?message=example)
	newTx->vOrderForm.push_back(make_pair("Message", rcp.message.toStdString()));
	}

	CReserveKey *keyChange = transaction.getPossibleKeyChange();
	if(!wallet->CommitTransaction(newTx, keyChange))
	return TransactionCommitFailed;

	CTransaction* t = (CTransaction*)newTx;
	CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
	ssTx << *t;
	transaction_array.append(&(ssTx[0]), ssTx.size());
	}

	// Add addresses / update labels that we've sent to to the address book,
	// and emit coinsSent signal for each recipient
	Q_FOREACH(const SendCoinsRecipient &rcp, transaction.getRecipients())
	{
	// Don't touch the address book when we have a payment request
	if (!rcp.paymentRequest.IsInitialized())
	{
	std::string strAddress = rcp.address.toStdString();
	CTxDestination dest = CBitcoinAddress(strAddress).Get();
	std::string strLabel = rcp.label.toStdString();
	{
	LOCK(wallet->cs_wallet);

	std::map<CTxDestination, CAddressBookData>::iterator mi = wallet->mapAddressBook.find(dest);

	// Check if we have a new address or an updated label
	if (mi == wallet->mapAddressBook.end())
	{
	wallet->SetAddressBook(dest, strLabel, "send");
	}
	else if (mi->second.name != strLabel)
	{
	wallet->SetAddressBook(dest, strLabel, ""); // "" means don't change purpose
	}
	}
	}
	Q_EMIT coinsSent(wallet, rcp, transaction_array);
	}
	checkBalanceChanged(); // update balance immediately, otherwise there could be a short noticeable delay until pollBalanceChanged hits

	return SendCoinsReturn(OK);
	}

	OptionsModel *WalletModel::getOptionsModel()
	{
	return optionsModel;
	}

	AddressTableModel *WalletModel::getAddressTableModel()
	{
	return addressTableModel;
	}

	TransactionTableModel *WalletModel::getTransactionTableModel()
	{
	return transactionTableModel;
	}

	RecentRequestsTableModel *WalletModel::getRecentRequestsTableModel()
	{
	return recentRequestsTableModel;
	}

	WalletModel::EncryptionStatus WalletModel::getEncryptionStatus() const
	{
	if(!wallet->IsCrypted())
	{
	return Unencrypted;
	}
	else if(wallet->IsLocked())
	{
	return Locked;
	}
	else
	{
	return Unlocked;
	}
	}

	bool WalletModel::setWalletEncrypted(bool encrypted, const SecureString &passphrase)
	{
	if(encrypted)
	{
	// Encrypt
	return wallet->EncryptWallet(passphrase);
	}
	else
	{
	// Decrypt -- TODO; not supported yet
	return false;
	}
	}

	bool WalletModel::setWalletLocked(bool locked, const SecureString &passPhrase)
	{
	if(locked)
	{
	// Lock
	return wallet->Lock();
	}
	else
	{
	// Unlock
	return wallet->Unlock(passPhrase);
	}
	}

	bool WalletModel::changePassphrase(const SecureString &oldPass, const SecureString &newPass)
	{
	bool retval;
	{
	LOCK(wallet->cs_wallet);
	wallet->Lock(); // Make sure wallet is locked before attempting pass change
	retval = wallet->ChangeWalletPassphrase(oldPass, newPass);
	}
	return retval;
	}

	bool WalletModel::backupWallet(const QString &filename)
	{
	- return BackupWallet(*wallet, filename.toLocal8Bit().data());
	+ return wallet->BackupWallet(filename.toLocal8Bit().data());
	}

	// Handlers for core signals
	static void NotifyKeyStoreStatusChanged(WalletModel walletmodel, CCryptoKeyStore wallet)
	{
	qDebug() << "NotifyKeyStoreStatusChanged";
	QMetaObject::invokeMethod(walletmodel, "updateStatus", Qt::QueuedConnection);
	}

	static void NotifyAddressBookChanged(WalletModel walletmodel, CWallet wallet,
	const CTxDestination &address, const std::string &label, bool isMine,
	const std::string &purpose, ChangeType status)
	{
	QString strAddress = QString::fromStdString(CBitcoinAddress(address).ToString());
	QString strLabel = QString::fromStdString(label);
	QString strPurpose = QString::fromStdString(purpose);

	qDebug() << "NotifyAddressBookChanged: " + strAddress + " " + strLabel + " isMine=" + QString::number(isMine) + " purpose=" + strPurpose + " status=" + QString::number(status);
	QMetaObject::invokeMethod(walletmodel, "updateAddressBook", Qt::QueuedConnection,
	Q_ARG(QString, strAddress),
	Q_ARG(QString, strLabel),
	Q_ARG(bool, isMine),
	Q_ARG(QString, strPurpose),
	Q_ARG(int, status));
	}

	static void NotifyTransactionChanged(WalletModel walletmodel, CWallet wallet, const uint256 &hash, ChangeType status)
	{
	Q_UNUSED(wallet);
	Q_UNUSED(hash);
	Q_UNUSED(status);
	QMetaObject::invokeMethod(walletmodel, "updateTransaction", Qt::QueuedConnection);
	}

	static void ShowProgress(WalletModel *walletmodel, const std::string &title, int nProgress)
	{
	// emits signal "showProgress"
	QMetaObject::invokeMethod(walletmodel, "showProgress", Qt::QueuedConnection,
	Q_ARG(QString, QString::fromStdString(title)),
	Q_ARG(int, nProgress));
	}

	static void NotifyWatchonlyChanged(WalletModel *walletmodel, bool fHaveWatchonly)
	{
	QMetaObject::invokeMethod(walletmodel, "updateWatchOnlyFlag", Qt::QueuedConnection,
	Q_ARG(bool, fHaveWatchonly));
	}

	void WalletModel::subscribeToCoreSignals()
	{
	// Connect signals to wallet
	wallet->NotifyStatusChanged.connect(boost::bind(&NotifyKeyStoreStatusChanged, this, _1));
	wallet->NotifyAddressBookChanged.connect(boost::bind(NotifyAddressBookChanged, this, _1, _2, _3, _4, _5, _6));
	wallet->NotifyTransactionChanged.connect(boost::bind(NotifyTransactionChanged, this, _1, _2, _3));
	wallet->ShowProgress.connect(boost::bind(ShowProgress, this, _1, _2));
	wallet->NotifyWatchonlyChanged.connect(boost::bind(NotifyWatchonlyChanged, this, _1));
	}

	void WalletModel::unsubscribeFromCoreSignals()
	{
	// Disconnect signals from wallet
	wallet->NotifyStatusChanged.disconnect(boost::bind(&NotifyKeyStoreStatusChanged, this, _1));
	wallet->NotifyAddressBookChanged.disconnect(boost::bind(NotifyAddressBookChanged, this, _1, _2, _3, _4, _5, _6));
	wallet->NotifyTransactionChanged.disconnect(boost::bind(NotifyTransactionChanged, this, _1, _2, _3));
	wallet->ShowProgress.disconnect(boost::bind(ShowProgress, this, _1, _2));
	wallet->NotifyWatchonlyChanged.disconnect(boost::bind(NotifyWatchonlyChanged, this, _1));
	}

	// WalletModel::UnlockContext implementation
	WalletModel::UnlockContext WalletModel::requestUnlock()
	{
	bool was_locked = getEncryptionStatus() == Locked;
	if(was_locked)
	{
	// Request UI to unlock wallet
	Q_EMIT requireUnlock();
	}
	// If wallet is still locked, unlock was failed or cancelled, mark context as invalid
	bool valid = getEncryptionStatus() != Locked;

	return UnlockContext(this, valid, was_locked);
	}

	WalletModel::UnlockContext::UnlockContext(WalletModel *wallet, bool valid, bool relock):
	wallet(wallet),
	valid(valid),
	relock(relock)
	{
	}

	WalletModel::UnlockContext::~UnlockContext()
	{
	if(valid && relock)
	{
	wallet->setWalletLocked(true);
	}
	}

	void WalletModel::UnlockContext::CopyFrom(const UnlockContext& rhs)
	{
	// Transfer context; old object no longer relocks wallet
	*this = rhs;
	rhs.relock = false;
	}

	bool WalletModel::getPubKey(const CKeyID &address, CPubKey& vchPubKeyOut) const
	{
	return wallet->GetPubKey(address, vchPubKeyOut);
	}

	bool WalletModel::havePrivKey(const CKeyID &address) const
	{
	return wallet->HaveKey(address);
	}

	// returns a list of COutputs from COutPoints
	void WalletModel::getOutputs(const std::vector<COutPoint>& vOutpoints, std::vector<COutput>& vOutputs)
	{
	LOCK2(cs_main, wallet->cs_wallet);
	BOOST_FOREACH(const COutPoint& outpoint, vOutpoints)
	{
	if (!wallet->mapWallet.count(outpoint.hash)) continue;
	int nDepth = wallet->mapWallet[outpoint.hash].GetDepthInMainChain();
	if (nDepth < 0) continue;
	COutput out(&wallet->mapWallet[outpoint.hash], outpoint.n, nDepth, true, true);
	vOutputs.push_back(out);
	}
	}

	bool WalletModel::isSpent(const COutPoint& outpoint) const
	{
	LOCK2(cs_main, wallet->cs_wallet);
	return wallet->IsSpent(outpoint.hash, outpoint.n);
	}

	// AvailableCoins + LockedCoins grouped by wallet address (put change in one group with wallet address)
	void WalletModel::listCoins(std::map<QString, std::vector<COutput> >& mapCoins) const
	{
	std::vector<COutput> vCoins;
	wallet->AvailableCoins(vCoins);

	LOCK2(cs_main, wallet->cs_wallet); // ListLockedCoins, mapWallet
	std::vector<COutPoint> vLockedCoins;
	wallet->ListLockedCoins(vLockedCoins);

	// add locked coins
	BOOST_FOREACH(const COutPoint& outpoint, vLockedCoins)
	{
	if (!wallet->mapWallet.count(outpoint.hash)) continue;
	int nDepth = wallet->mapWallet[outpoint.hash].GetDepthInMainChain();
	if (nDepth < 0) continue;
	COutput out(&wallet->mapWallet[outpoint.hash], outpoint.n, nDepth, true, true);
	if (outpoint.n < out.tx->vout.size() && wallet->IsMine(out.tx->vout[outpoint.n]) == ISMINE_SPENDABLE)
	vCoins.push_back(out);
	}

	BOOST_FOREACH(const COutput& out, vCoins)
	{
	COutput cout = out;

	while (wallet->IsChange(cout.tx->vout[cout.i]) && cout.tx->vin.size() > 0 && wallet->IsMine(cout.tx->vin[0]))
	{
	if (!wallet->mapWallet.count(cout.tx->vin[0].prevout.hash)) break;
	cout = COutput(&wallet->mapWallet[cout.tx->vin[0].prevout.hash], cout.tx->vin[0].prevout.n, 0, true, true);
	}

	CTxDestination address;
	if(!out.fSpendable \|\| !ExtractDestination(cout.tx->vout[cout.i].scriptPubKey, address))
	continue;
	mapCoins[QString::fromStdString(CBitcoinAddress(address).ToString())].push_back(out);
	}
	}

	bool WalletModel::isLockedCoin(uint256 hash, unsigned int n) const
	{
	LOCK2(cs_main, wallet->cs_wallet);
	return wallet->IsLockedCoin(hash, n);
	}

	void WalletModel::lockCoin(COutPoint& output)
	{
	LOCK2(cs_main, wallet->cs_wallet);
	wallet->LockCoin(output);
	}

	void WalletModel::unlockCoin(COutPoint& output)
	{
	LOCK2(cs_main, wallet->cs_wallet);
	wallet->UnlockCoin(output);
	}

	void WalletModel::listLockedCoins(std::vector<COutPoint>& vOutpts)
	{
	LOCK2(cs_main, wallet->cs_wallet);
	wallet->ListLockedCoins(vOutpts);
	}

	void WalletModel::loadReceiveRequests(std::vector<std::string>& vReceiveRequests)
	{
	LOCK(wallet->cs_wallet);
	BOOST_FOREACH(const PAIRTYPE(CTxDestination, CAddressBookData)& item, wallet->mapAddressBook)
	BOOST_FOREACH(const PAIRTYPE(std::string, std::string)& item2, item.second.destdata)
	if (item2.first.size() > 2 && item2.first.substr(0,2) == "rr") // receive request
	vReceiveRequests.push_back(item2.second);
	}

	bool WalletModel::saveReceiveRequest(const std::string &sAddress, const int64_t nId, const std::string &sRequest)
	{
	CTxDestination dest = CBitcoinAddress(sAddress).Get();

	std::stringstream ss;
	ss << nId;
	std::string key = "rr" + ss.str(); // "rr" prefix = "receive request" in destdata

	LOCK(wallet->cs_wallet);
	if (sRequest.empty())
	return wallet->EraseDestData(dest, key);
	else
	return wallet->AddDestData(dest, key, sRequest);
	}

	bool WalletModel::transactionCanBeAbandoned(uint256 hash) const
	{
	LOCK2(cs_main, wallet->cs_wallet);
	const CWalletTx *wtx = wallet->GetWalletTx(hash);
	if (!wtx \|\| wtx->isAbandoned() \|\| wtx->GetDepthInMainChain() > 0 \|\| wtx->InMempool())
	return false;
	return true;
	}

	bool WalletModel::abandonTransaction(uint256 hash) const
	{
	LOCK2(cs_main, wallet->cs_wallet);
	return wallet->AbandonTransaction(hash);
	}
	diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
	index 8bd1279b7f..f11f299141 100644
	--- a/src/wallet/rpcwallet.cpp
	+++ b/src/wallet/rpcwallet.cpp
	@@ -1,2577 +1,2577 @@
	// Copyright (c) 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 "amount.h"
	#include "base58.h"
	#include "chain.h"
	#include "core_io.h"
	#include "init.h"
	#include "main.h"
	#include "net.h"
	#include "netbase.h"
	#include "policy/rbf.h"
	#include "rpc/server.h"
	#include "timedata.h"
	#include "util.h"
	#include "utilmoneystr.h"
	#include "wallet.h"
	#include "walletdb.h"

	#include <stdint.h>

	#include <boost/assign/list_of.hpp>

	#include <univalue.h>

	using namespace std;

	int64_t nWalletUnlockTime;
	static CCriticalSection cs_nWalletUnlockTime;

	std::string HelpRequiringPassphrase()
	{
	return pwalletMain && pwalletMain->IsCrypted()
	? "\nRequires wallet passphrase to be set with walletpassphrase call."
	: "";
	}

	bool EnsureWalletIsAvailable(bool avoidException)
	{
	if (!pwalletMain)
	{
	if (!avoidException)
	throw JSONRPCError(RPC_METHOD_NOT_FOUND, "Method not found (disabled)");
	else
	return false;
	}
	return true;
	}

	void EnsureWalletIsUnlocked()
	{
	if (pwalletMain->IsLocked())
	throw JSONRPCError(RPC_WALLET_UNLOCK_NEEDED, "Error: Please enter the wallet passphrase with walletpassphrase first.");
	}

	void WalletTxToJSON(const CWalletTx& wtx, UniValue& entry)
	{
	int confirms = wtx.GetDepthInMainChain();
	entry.push_back(Pair("confirmations", confirms));
	if (wtx.IsCoinBase())
	entry.push_back(Pair("generated", true));
	if (confirms > 0)
	{
	entry.push_back(Pair("blockhash", wtx.hashBlock.GetHex()));
	entry.push_back(Pair("blockindex", wtx.nIndex));
	entry.push_back(Pair("blocktime", mapBlockIndex[wtx.hashBlock]->GetBlockTime()));
	} else {
	entry.push_back(Pair("trusted", wtx.IsTrusted()));
	}
	uint256 hash = wtx.GetHash();
	entry.push_back(Pair("txid", hash.GetHex()));
	UniValue conflicts(UniValue::VARR);
	BOOST_FOREACH(const uint256& conflict, wtx.GetConflicts())
	conflicts.push_back(conflict.GetHex());
	entry.push_back(Pair("walletconflicts", conflicts));
	entry.push_back(Pair("time", wtx.GetTxTime()));
	entry.push_back(Pair("timereceived", (int64_t)wtx.nTimeReceived));

	// Add opt-in RBF status
	std::string rbfStatus = "no";
	if (confirms <= 0) {
	LOCK(mempool.cs);
	RBFTransactionState rbfState = IsRBFOptIn(wtx, mempool);
	if (rbfState == RBF_TRANSACTIONSTATE_UNKNOWN)
	rbfStatus = "unknown";
	else if (rbfState == RBF_TRANSACTIONSTATE_REPLACEABLE_BIP125)
	rbfStatus = "yes";
	}
	entry.push_back(Pair("bip125-replaceable", rbfStatus));

	BOOST_FOREACH(const PAIRTYPE(string,string)& item, wtx.mapValue)
	entry.push_back(Pair(item.first, item.second));
	}

	string AccountFromValue(const UniValue& value)
	{
	string strAccount = value.get_str();
	if (strAccount == "*")
	throw JSONRPCError(RPC_WALLET_INVALID_ACCOUNT_NAME, "Invalid account name");
	return strAccount;
	}

	UniValue getnewaddress(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() > 1)
	throw runtime_error(
	"getnewaddress ( \"account\" )\n"
	"\nReturns a new Bitcoin address for receiving payments.\n"
	"If 'account' is specified (DEPRECATED), it is added to the address book \n"
	"so payments received with the address will be credited to 'account'.\n"
	"\nArguments:\n"
	"1. \"account\" (string, optional) DEPRECATED. The account name for the address to be linked to. If not provided, the default account \"\" is used. It can also be set to the empty string \"\" to represent the default account. The account does not need to exist, it will be created if there is no account by the given name.\n"
	"\nResult:\n"
	"\"bitcoinaddress\" (string) The new bitcoin address\n"
	"\nExamples:\n"
	+ HelpExampleCli("getnewaddress", "")
	+ HelpExampleRpc("getnewaddress", "")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	// Parse the account first so we don't generate a key if there's an error
	string strAccount;
	if (params.size() > 0)
	strAccount = AccountFromValue(params[0]);

	if (!pwalletMain->IsLocked())
	pwalletMain->TopUpKeyPool();

	// Generate a new key that is added to wallet
	CPubKey newKey;
	if (!pwalletMain->GetKeyFromPool(newKey))
	throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, "Error: Keypool ran out, please call keypoolrefill first");
	CKeyID keyID = newKey.GetID();

	pwalletMain->SetAddressBook(keyID, strAccount, "receive");

	return CBitcoinAddress(keyID).ToString();
	}


	CBitcoinAddress GetAccountAddress(string strAccount, bool bForceNew=false)
	{
	CWalletDB walletdb(pwalletMain->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 = pwalletMain->mapWallet.begin();
	it != pwalletMain->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 (!pwalletMain->GetKeyFromPool(account.vchPubKey))
	throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, "Error: Keypool ran out, please call keypoolrefill first");

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

	return CBitcoinAddress(account.vchPubKey.GetID());
	}

	UniValue getaccountaddress(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() != 1)
	throw runtime_error(
	"getaccountaddress \"account\"\n"
	"\nDEPRECATED. Returns the current Bitcoin address for receiving payments to this account.\n"
	"\nArguments:\n"
	"1. \"account\" (string, required) The account name for the address. It can also be set to the empty string \"\" to represent the default account. The account does not need to exist, it will be created and a new address created if there is no account by the given name.\n"
	"\nResult:\n"
	"\"bitcoinaddress\" (string) The account bitcoin address\n"
	"\nExamples:\n"
	+ HelpExampleCli("getaccountaddress", "")
	+ HelpExampleCli("getaccountaddress", "\"\"")
	+ HelpExampleCli("getaccountaddress", "\"myaccount\"")
	+ HelpExampleRpc("getaccountaddress", "\"myaccount\"")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	// Parse the account first so we don't generate a key if there's an error
	string strAccount = AccountFromValue(params[0]);

	UniValue ret(UniValue::VSTR);

	ret = GetAccountAddress(strAccount).ToString();
	return ret;
	}


	UniValue getrawchangeaddress(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() > 1)
	throw runtime_error(
	"getrawchangeaddress\n"
	"\nReturns a new Bitcoin address, for receiving change.\n"
	"This is for use with raw transactions, NOT normal use.\n"
	"\nResult:\n"
	"\"address\" (string) The address\n"
	"\nExamples:\n"
	+ HelpExampleCli("getrawchangeaddress", "")
	+ HelpExampleRpc("getrawchangeaddress", "")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	if (!pwalletMain->IsLocked())
	pwalletMain->TopUpKeyPool();

	CReserveKey reservekey(pwalletMain);
	CPubKey vchPubKey;
	if (!reservekey.GetReservedKey(vchPubKey))
	throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, "Error: Keypool ran out, please call keypoolrefill first");

	reservekey.KeepKey();

	CKeyID keyID = vchPubKey.GetID();

	return CBitcoinAddress(keyID).ToString();
	}


	UniValue setaccount(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() < 1 \|\| params.size() > 2)
	throw runtime_error(
	"setaccount \"bitcoinaddress\" \"account\"\n"
	"\nDEPRECATED. Sets the account associated with the given address.\n"
	"\nArguments:\n"
	"1. \"bitcoinaddress\" (string, required) The bitcoin address to be associated with an account.\n"
	"2. \"account\" (string, required) The account to assign the address to.\n"
	"\nExamples:\n"
	+ HelpExampleCli("setaccount", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\" \"tabby\"")
	+ HelpExampleRpc("setaccount", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\", \"tabby\"")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	CBitcoinAddress address(params[0].get_str());
	if (!address.IsValid())
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Bitcoin address");

	string strAccount;
	if (params.size() > 1)
	strAccount = AccountFromValue(params[1]);

	// Only add the account if the address is yours.
	if (IsMine(*pwalletMain, address.Get()))
	{
	// Detect when changing the account of an address that is the 'unused current key' of another account:
	if (pwalletMain->mapAddressBook.count(address.Get()))
	{
	string strOldAccount = pwalletMain->mapAddressBook[address.Get()].name;
	if (address == GetAccountAddress(strOldAccount))
	GetAccountAddress(strOldAccount, true);
	}
	pwalletMain->SetAddressBook(address.Get(), strAccount, "receive");
	}
	else
	throw JSONRPCError(RPC_MISC_ERROR, "setaccount can only be used with own address");

	return NullUniValue;
	}


	UniValue getaccount(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() != 1)
	throw runtime_error(
	"getaccount \"bitcoinaddress\"\n"
	"\nDEPRECATED. Returns the account associated with the given address.\n"
	"\nArguments:\n"
	"1. \"bitcoinaddress\" (string, required) The bitcoin address for account lookup.\n"
	"\nResult:\n"
	"\"accountname\" (string) the account address\n"
	"\nExamples:\n"
	+ HelpExampleCli("getaccount", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\"")
	+ HelpExampleRpc("getaccount", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\"")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	CBitcoinAddress address(params[0].get_str());
	if (!address.IsValid())
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Bitcoin address");

	string strAccount;
	map<CTxDestination, CAddressBookData>::iterator mi = pwalletMain->mapAddressBook.find(address.Get());
	if (mi != pwalletMain->mapAddressBook.end() && !(*mi).second.name.empty())
	strAccount = (*mi).second.name;
	return strAccount;
	}


	UniValue getaddressesbyaccount(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() != 1)
	throw runtime_error(
	"getaddressesbyaccount \"account\"\n"
	"\nDEPRECATED. Returns the list of addresses for the given account.\n"
	"\nArguments:\n"
	"1. \"account\" (string, required) The account name.\n"
	"\nResult:\n"
	"[ (json array of string)\n"
	" \"bitcoinaddress\" (string) a bitcoin address associated with the given account\n"
	" ,...\n"
	"]\n"
	"\nExamples:\n"
	+ HelpExampleCli("getaddressesbyaccount", "\"tabby\"")
	+ HelpExampleRpc("getaddressesbyaccount", "\"tabby\"")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	string strAccount = AccountFromValue(params[0]);

	// Find all addresses that have the given account
	UniValue ret(UniValue::VARR);
	BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress, CAddressBookData)& item, pwalletMain->mapAddressBook)
	{
	const CBitcoinAddress& address = item.first;
	const string& strName = item.second.name;
	if (strName == strAccount)
	ret.push_back(address.ToString());
	}
	return ret;
	}

	static void SendMoney(const CTxDestination &address, CAmount nValue, bool fSubtractFeeFromAmount, CWalletTx& wtxNew)
	{
	CAmount curBalance = pwalletMain->GetBalance();

	// Check amount
	if (nValue <= 0)
	throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid amount");

	if (nValue > curBalance)
	throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, "Insufficient funds");

	// Parse Bitcoin address
	CScript scriptPubKey = GetScriptForDestination(address);

	// Create and send the transaction
	CReserveKey reservekey(pwalletMain);
	CAmount nFeeRequired;
	std::string strError;
	vector<CRecipient> vecSend;
	int nChangePosRet = -1;
	CRecipient recipient = {scriptPubKey, nValue, fSubtractFeeFromAmount};
	vecSend.push_back(recipient);
	if (!pwalletMain->CreateTransaction(vecSend, wtxNew, reservekey, nFeeRequired, nChangePosRet, strError)) {
	if (!fSubtractFeeFromAmount && nValue + nFeeRequired > pwalletMain->GetBalance())
	strError = strprintf("Error: This transaction requires a transaction fee of at least %s because of its amount, complexity, or use of recently received funds!", FormatMoney(nFeeRequired));
	throw JSONRPCError(RPC_WALLET_ERROR, strError);
	}
	if (!pwalletMain->CommitTransaction(wtxNew, reservekey))
	throw JSONRPCError(RPC_WALLET_ERROR, "Error: The transaction was rejected! This might happen if some of the coins in your wallet were already spent, such as if you used a copy of the wallet and coins were spent in the copy but not marked as spent here.");
	}

	UniValue sendtoaddress(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() < 2 \|\| params.size() > 5)
	throw runtime_error(
	"sendtoaddress \"bitcoinaddress\" amount ( \"comment\" \"comment-to\" subtractfeefromamount )\n"
	"\nSend an amount to a given address.\n"
	+ HelpRequiringPassphrase() +
	"\nArguments:\n"
	"1. \"bitcoinaddress\" (string, required) The bitcoin address to send to.\n"
	"2. \"amount\" (numeric or string, required) The amount in " + CURRENCY_UNIT + " to send. eg 0.1\n"
	"3. \"comment\" (string, optional) A comment used to store what the transaction is for. \n"
	" This is not part of the transaction, just kept in your wallet.\n"
	"4. \"comment-to\" (string, optional) A comment to store the name of the person or organization \n"
	" to which you're sending the transaction. This is not part of the \n"
	" transaction, just kept in your wallet.\n"
	"5. subtractfeefromamount (boolean, optional, default=false) The fee will be deducted from the amount being sent.\n"
	" The recipient will receive less bitcoins than you enter in the amount field.\n"
	"\nResult:\n"
	"\"transactionid\" (string) The transaction id.\n"
	"\nExamples:\n"
	+ HelpExampleCli("sendtoaddress", "\"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\" 0.1")
	+ HelpExampleCli("sendtoaddress", "\"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\" 0.1 \"donation\" \"seans outpost\"")
	+ HelpExampleCli("sendtoaddress", "\"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\" 0.1 \"\" \"\" true")
	+ HelpExampleRpc("sendtoaddress", "\"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\", 0.1, \"donation\", \"seans outpost\"")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	CBitcoinAddress address(params[0].get_str());
	if (!address.IsValid())
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Bitcoin address");

	// Amount
	CAmount nAmount = AmountFromValue(params[1]);
	if (nAmount <= 0)
	throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount for send");

	// Wallet comments
	CWalletTx wtx;
	if (params.size() > 2 && !params[2].isNull() && !params[2].get_str().empty())
	wtx.mapValue["comment"] = params[2].get_str();
	if (params.size() > 3 && !params[3].isNull() && !params[3].get_str().empty())
	wtx.mapValue["to"] = params[3].get_str();

	bool fSubtractFeeFromAmount = false;
	if (params.size() > 4)
	fSubtractFeeFromAmount = params[4].get_bool();

	EnsureWalletIsUnlocked();

	SendMoney(address.Get(), nAmount, fSubtractFeeFromAmount, wtx);

	return wtx.GetHash().GetHex();
	}

	UniValue listaddressgroupings(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp)
	throw runtime_error(
	"listaddressgroupings\n"
	"\nLists groups of addresses which have had their common ownership\n"
	"made public by common use as inputs or as the resulting change\n"
	"in past transactions\n"
	"\nResult:\n"
	"[\n"
	" [\n"
	" [\n"
	" \"bitcoinaddress\", (string) The bitcoin address\n"
	" amount, (numeric) The amount in " + CURRENCY_UNIT + "\n"
	" \"account\" (string, optional) The account (DEPRECATED)\n"
	" ]\n"
	" ,...\n"
	" ]\n"
	" ,...\n"
	"]\n"
	"\nExamples:\n"
	+ HelpExampleCli("listaddressgroupings", "")
	+ HelpExampleRpc("listaddressgroupings", "")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	UniValue jsonGroupings(UniValue::VARR);
	map<CTxDestination, CAmount> balances = pwalletMain->GetAddressBalances();
	BOOST_FOREACH(set<CTxDestination> grouping, pwalletMain->GetAddressGroupings())
	{
	UniValue jsonGrouping(UniValue::VARR);
	BOOST_FOREACH(CTxDestination address, grouping)
	{
	UniValue addressInfo(UniValue::VARR);
	addressInfo.push_back(CBitcoinAddress(address).ToString());
	addressInfo.push_back(ValueFromAmount(balances[address]));
	{
	if (pwalletMain->mapAddressBook.find(CBitcoinAddress(address).Get()) != pwalletMain->mapAddressBook.end())
	addressInfo.push_back(pwalletMain->mapAddressBook.find(CBitcoinAddress(address).Get())->second.name);
	}
	jsonGrouping.push_back(addressInfo);
	}
	jsonGroupings.push_back(jsonGrouping);
	}
	return jsonGroupings;
	}

	UniValue signmessage(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() != 2)
	throw runtime_error(
	"signmessage \"bitcoinaddress\" \"message\"\n"
	"\nSign a message with the private key of an address"
	+ HelpRequiringPassphrase() + "\n"
	"\nArguments:\n"
	"1. \"bitcoinaddress\" (string, required) The bitcoin address to use for the private key.\n"
	"2. \"message\" (string, required) The message to create a signature of.\n"
	"\nResult:\n"
	"\"signature\" (string) The signature of the message encoded in base 64\n"
	"\nExamples:\n"
	"\nUnlock the wallet for 30 seconds\n"
	+ HelpExampleCli("walletpassphrase", "\"mypassphrase\" 30") +
	"\nCreate the signature\n"
	+ HelpExampleCli("signmessage", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\" \"my message\"") +
	"\nVerify the signature\n"
	+ HelpExampleCli("verifymessage", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\" \"signature\" \"my message\"") +
	"\nAs json rpc\n"
	+ HelpExampleRpc("signmessage", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\", \"my message\"")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	EnsureWalletIsUnlocked();

	string strAddress = params[0].get_str();
	string strMessage = params[1].get_str();

	CBitcoinAddress addr(strAddress);
	if (!addr.IsValid())
	throw JSONRPCError(RPC_TYPE_ERROR, "Invalid address");

	CKeyID keyID;
	if (!addr.GetKeyID(keyID))
	throw JSONRPCError(RPC_TYPE_ERROR, "Address does not refer to key");

	CKey key;
	if (!pwalletMain->GetKey(keyID, key))
	throw JSONRPCError(RPC_WALLET_ERROR, "Private key not available");

	CHashWriter ss(SER_GETHASH, 0);
	ss << strMessageMagic;
	ss << strMessage;

	vector<unsigned char> vchSig;
	if (!key.SignCompact(ss.GetHash(), vchSig))
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Sign failed");

	return EncodeBase64(&vchSig[0], vchSig.size());
	}

	UniValue getreceivedbyaddress(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() < 1 \|\| params.size() > 2)
	throw runtime_error(
	"getreceivedbyaddress \"bitcoinaddress\" ( minconf )\n"
	"\nReturns the total amount received by the given bitcoinaddress in transactions with at least minconf confirmations.\n"
	"\nArguments:\n"
	"1. \"bitcoinaddress\" (string, required) The bitcoin address for transactions.\n"
	"2. minconf (numeric, optional, default=1) Only include transactions confirmed at least this many times.\n"
	"\nResult:\n"
	"amount (numeric) The total amount in " + CURRENCY_UNIT + " received at this address.\n"
	"\nExamples:\n"
	"\nThe amount from transactions with at least 1 confirmation\n"
	+ HelpExampleCli("getreceivedbyaddress", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\"") +
	"\nThe amount including unconfirmed transactions, zero confirmations\n"
	+ HelpExampleCli("getreceivedbyaddress", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\" 0") +
	"\nThe amount with at least 6 confirmation, very safe\n"
	+ HelpExampleCli("getreceivedbyaddress", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\" 6") +
	"\nAs a json rpc call\n"
	+ HelpExampleRpc("getreceivedbyaddress", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\", 6")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	// Bitcoin address
	CBitcoinAddress address = CBitcoinAddress(params[0].get_str());
	if (!address.IsValid())
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Bitcoin address");
	CScript scriptPubKey = GetScriptForDestination(address.Get());
	if (!IsMine(*pwalletMain,scriptPubKey))
	return (double)0.0;

	// Minimum confirmations
	int nMinDepth = 1;
	if (params.size() > 1)
	nMinDepth = params[1].get_int();

	// Tally
	CAmount nAmount = 0;
	for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
	{
	const CWalletTx& wtx = (*it).second;
	if (wtx.IsCoinBase() \|\| !CheckFinalTx(wtx))
	continue;

	BOOST_FOREACH(const CTxOut& txout, wtx.vout)
	if (txout.scriptPubKey == scriptPubKey)
	if (wtx.GetDepthInMainChain() >= nMinDepth)
	nAmount += txout.nValue;
	}

	return ValueFromAmount(nAmount);
	}


	UniValue getreceivedbyaccount(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() < 1 \|\| params.size() > 2)
	throw runtime_error(
	"getreceivedbyaccount \"account\" ( minconf )\n"
	"\nDEPRECATED. Returns the total amount received by addresses with <account> in transactions with at least [minconf] confirmations.\n"
	"\nArguments:\n"
	"1. \"account\" (string, required) The selected account, may be the default account using \"\".\n"
	"2. minconf (numeric, optional, default=1) Only include transactions confirmed at least this many times.\n"
	"\nResult:\n"
	"amount (numeric) The total amount in " + CURRENCY_UNIT + " received for this account.\n"
	"\nExamples:\n"
	"\nAmount received by the default account with at least 1 confirmation\n"
	+ HelpExampleCli("getreceivedbyaccount", "\"\"") +
	"\nAmount received at the tabby account including unconfirmed amounts with zero confirmations\n"
	+ HelpExampleCli("getreceivedbyaccount", "\"tabby\" 0") +
	"\nThe amount with at least 6 confirmation, very safe\n"
	+ HelpExampleCli("getreceivedbyaccount", "\"tabby\" 6") +
	"\nAs a json rpc call\n"
	+ HelpExampleRpc("getreceivedbyaccount", "\"tabby\", 6")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	// Minimum confirmations
	int nMinDepth = 1;
	if (params.size() > 1)
	nMinDepth = params[1].get_int();

	// Get the set of pub keys assigned to account
	string strAccount = AccountFromValue(params[0]);
	set<CTxDestination> setAddress = pwalletMain->GetAccountAddresses(strAccount);

	// Tally
	CAmount nAmount = 0;
	for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
	{
	const CWalletTx& wtx = (*it).second;
	if (wtx.IsCoinBase() \|\| !CheckFinalTx(wtx))
	continue;

	BOOST_FOREACH(const CTxOut& txout, wtx.vout)
	{
	CTxDestination address;
	if (ExtractDestination(txout.scriptPubKey, address) && IsMine(*pwalletMain, address) && setAddress.count(address))
	if (wtx.GetDepthInMainChain() >= nMinDepth)
	nAmount += txout.nValue;
	}
	}

	return (double)nAmount / (double)COIN;
	}


	UniValue getbalance(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() > 3)
	throw runtime_error(
	"getbalance ( \"account\" minconf includeWatchonly )\n"
	"\nIf account is not specified, returns the server's total available balance.\n"
	"If account is specified (DEPRECATED), returns the balance in the account.\n"
	"Note that the account \"\" is not the same as leaving the parameter out.\n"
	"The server total may be different to the balance in the default \"\" account.\n"
	"\nArguments:\n"
	"1. \"account\" (string, optional) DEPRECATED. The selected account, or \"*\" for entire wallet. It may be the default account using \"\".\n"
	"2. minconf (numeric, optional, default=1) Only include transactions confirmed at least this many times.\n"
	"3. includeWatchonly (bool, optional, default=false) Also include balance in watchonly addresses (see 'importaddress')\n"
	"\nResult:\n"
	"amount (numeric) The total amount in " + CURRENCY_UNIT + " received for this account.\n"
	"\nExamples:\n"
	"\nThe total amount in the wallet\n"
	+ HelpExampleCli("getbalance", "") +
	"\nThe total amount in the wallet at least 5 blocks confirmed\n"
	+ HelpExampleCli("getbalance", "\"*\" 6") +
	"\nAs a json rpc call\n"
	+ HelpExampleRpc("getbalance", "\"*\", 6")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	if (params.size() == 0)
	return ValueFromAmount(pwalletMain->GetBalance());

	int nMinDepth = 1;
	if (params.size() > 1)
	nMinDepth = params[1].get_int();
	isminefilter filter = ISMINE_SPENDABLE;
	if(params.size() > 2)
	if(params[2].get_bool())
	filter = filter \| ISMINE_WATCH_ONLY;

	if (params[0].get_str() == "*") {
	// Calculate total balance a different way from GetBalance()
	// (GetBalance() sums up all unspent TxOuts)
	// getbalance and "getbalance * 1 true" should return the same number
	CAmount nBalance = 0;
	for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
	{
	const CWalletTx& wtx = (*it).second;
	if (!CheckFinalTx(wtx) \|\| wtx.GetBlocksToMaturity() > 0 \|\| wtx.GetDepthInMainChain() < 0)
	continue;

	CAmount allFee;
	string strSentAccount;
	list<COutputEntry> listReceived;
	list<COutputEntry> listSent;
	wtx.GetAmounts(listReceived, listSent, allFee, strSentAccount, filter);
	if (wtx.GetDepthInMainChain() >= nMinDepth)
	{
	BOOST_FOREACH(const COutputEntry& r, listReceived)
	nBalance += r.amount;
	}
	BOOST_FOREACH(const COutputEntry& s, listSent)
	nBalance -= s.amount;
	nBalance -= allFee;
	}
	return ValueFromAmount(nBalance);
	}

	string strAccount = AccountFromValue(params[0]);

	CAmount nBalance = pwalletMain->GetAccountBalance(strAccount, nMinDepth, filter);

	return ValueFromAmount(nBalance);
	}

	UniValue getunconfirmedbalance(const UniValue &params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() > 0)
	throw runtime_error(
	"getunconfirmedbalance\n"
	"Returns the server's total unconfirmed balance\n");

	LOCK2(cs_main, pwalletMain->cs_wallet);

	return ValueFromAmount(pwalletMain->GetUnconfirmedBalance());
	}


	UniValue movecmd(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() < 3 \|\| params.size() > 5)
	throw runtime_error(
	"move \"fromaccount\" \"toaccount\" amount ( minconf \"comment\" )\n"
	"\nDEPRECATED. Move a specified amount from one account in your wallet to another.\n"
	"\nArguments:\n"
	"1. \"fromaccount\" (string, required) The name of the account to move funds from. May be the default account using \"\".\n"
	"2. \"toaccount\" (string, required) The name of the account to move funds to. May be the default account using \"\".\n"
	"3. amount (numeric) Quantity of " + CURRENCY_UNIT + " to move between accounts.\n"
	"4. minconf (numeric, optional, default=1) Only use funds with at least this many confirmations.\n"
	"5. \"comment\" (string, optional) An optional comment, stored in the wallet only.\n"
	"\nResult:\n"
	"true\|false (boolean) true if successful.\n"
	"\nExamples:\n"
	"\nMove 0.01 " + CURRENCY_UNIT + " from the default account to the account named tabby\n"
	+ HelpExampleCli("move", "\"\" \"tabby\" 0.01") +
	"\nMove 0.01 " + CURRENCY_UNIT + " timotei to akiko with a comment and funds have 6 confirmations\n"
	+ HelpExampleCli("move", "\"timotei\" \"akiko\" 0.01 6 \"happy birthday!\"") +
	"\nAs a json rpc call\n"
	+ HelpExampleRpc("move", "\"timotei\", \"akiko\", 0.01, 6, \"happy birthday!\"")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	string strFrom = AccountFromValue(params[0]);
	string strTo = AccountFromValue(params[1]);
	CAmount nAmount = AmountFromValue(params[2]);
	if (nAmount <= 0)
	throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount for send");
	if (params.size() > 3)
	// unused parameter, used to be nMinDepth, keep type-checking it though
	(void)params[3].get_int();
	string strComment;
	if (params.size() > 4)
	strComment = params[4].get_str();

	CWalletDB walletdb(pwalletMain->strWalletFile);
	if (!walletdb.TxnBegin())
	throw JSONRPCError(RPC_DATABASE_ERROR, "database error");

	int64_t nNow = GetAdjustedTime();

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

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

	if (!walletdb.TxnCommit())
	throw JSONRPCError(RPC_DATABASE_ERROR, "database error");

	return true;
	}


	UniValue sendfrom(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() < 3 \|\| params.size() > 6)
	throw runtime_error(
	"sendfrom \"fromaccount\" \"tobitcoinaddress\" amount ( minconf \"comment\" \"comment-to\" )\n"
	"\nDEPRECATED (use sendtoaddress). Sent an amount from an account to a bitcoin address."
	+ HelpRequiringPassphrase() + "\n"
	"\nArguments:\n"
	"1. \"fromaccount\" (string, required) The name of the account to send funds from. May be the default account using \"\".\n"
	"2. \"tobitcoinaddress\" (string, required) The bitcoin address to send funds to.\n"
	"3. amount (numeric or string, required) The amount in " + CURRENCY_UNIT + " (transaction fee is added on top).\n"
	"4. minconf (numeric, optional, default=1) Only use funds with at least this many confirmations.\n"
	"5. \"comment\" (string, optional) A comment used to store what the transaction is for. \n"
	" This is not part of the transaction, just kept in your wallet.\n"
	"6. \"comment-to\" (string, optional) An optional comment to store the name of the person or organization \n"
	" to which you're sending the transaction. This is not part of the transaction, \n"
	" it is just kept in your wallet.\n"
	"\nResult:\n"
	"\"transactionid\" (string) The transaction id.\n"
	"\nExamples:\n"
	"\nSend 0.01 " + CURRENCY_UNIT + " from the default account to the address, must have at least 1 confirmation\n"
	+ HelpExampleCli("sendfrom", "\"\" \"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\" 0.01") +
	"\nSend 0.01 from the tabby account to the given address, funds must have at least 6 confirmations\n"
	+ HelpExampleCli("sendfrom", "\"tabby\" \"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\" 0.01 6 \"donation\" \"seans outpost\"") +
	"\nAs a json rpc call\n"
	+ HelpExampleRpc("sendfrom", "\"tabby\", \"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\", 0.01, 6, \"donation\", \"seans outpost\"")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	string strAccount = AccountFromValue(params[0]);
	CBitcoinAddress address(params[1].get_str());
	if (!address.IsValid())
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Bitcoin address");
	CAmount nAmount = AmountFromValue(params[2]);
	if (nAmount <= 0)
	throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount for send");
	int nMinDepth = 1;
	if (params.size() > 3)
	nMinDepth = params[3].get_int();

	CWalletTx wtx;
	wtx.strFromAccount = strAccount;
	if (params.size() > 4 && !params[4].isNull() && !params[4].get_str().empty())
	wtx.mapValue["comment"] = params[4].get_str();
	if (params.size() > 5 && !params[5].isNull() && !params[5].get_str().empty())
	wtx.mapValue["to"] = params[5].get_str();

	EnsureWalletIsUnlocked();

	// Check funds
	CAmount nBalance = pwalletMain->GetAccountBalance(strAccount, nMinDepth, ISMINE_SPENDABLE);
	if (nAmount > nBalance)
	throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, "Account has insufficient funds");

	SendMoney(address.Get(), nAmount, false, wtx);

	return wtx.GetHash().GetHex();
	}


	UniValue sendmany(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() < 2 \|\| params.size() > 5)
	throw runtime_error(
	"sendmany \"fromaccount\" {\"address\":amount,...} ( minconf \"comment\" [\"address\",...] )\n"
	"\nSend multiple times. Amounts are double-precision floating point numbers."
	+ HelpRequiringPassphrase() + "\n"
	"\nArguments:\n"
	"1. \"fromaccount\" (string, required) DEPRECATED. The account to send the funds from. Should be \"\" for the default account\n"
	"2. \"amounts\" (string, required) A json object with addresses and amounts\n"
	" {\n"
	" \"address\":amount (numeric or string) The bitcoin address is the key, the numeric amount (can be string) in " + CURRENCY_UNIT + " is the value\n"
	" ,...\n"
	" }\n"
	"3. minconf (numeric, optional, default=1) Only use the balance confirmed at least this many times.\n"
	"4. \"comment\" (string, optional) A comment\n"
	"5. subtractfeefromamount (string, optional) A json array with addresses.\n"
	" The fee will be equally deducted from the amount of each selected address.\n"
	" Those recipients will receive less bitcoins than you enter in their corresponding amount field.\n"
	" If no addresses are specified here, the sender pays the fee.\n"
	" [\n"
	" \"address\" (string) Subtract fee from this address\n"
	" ,...\n"
	" ]\n"
	"\nResult:\n"
	"\"transactionid\" (string) The transaction id for the send. Only 1 transaction is created regardless of \n"
	" the number of addresses.\n"
	"\nExamples:\n"
	"\nSend two amounts to two different addresses:\n"
	+ HelpExampleCli("sendmany", "\"\" \"{\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\\\":0.01,\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\":0.02}\"") +
	"\nSend two amounts to two different addresses setting the confirmation and comment:\n"
	+ HelpExampleCli("sendmany", "\"\" \"{\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\\\":0.01,\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\":0.02}\" 6 \"testing\"") +
	"\nSend two amounts to two different addresses, subtract fee from amount:\n"
	+ HelpExampleCli("sendmany", "\"\" \"{\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\\\":0.01,\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\":0.02}\" 1 \"\" \"[\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\\\",\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\"]\"") +
	"\nAs a json rpc call\n"
	+ HelpExampleRpc("sendmany", "\"\", \"{\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\\\":0.01,\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\":0.02}\", 6, \"testing\"")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	string strAccount = AccountFromValue(params[0]);
	UniValue sendTo = params[1].get_obj();
	int nMinDepth = 1;
	if (params.size() > 2)
	nMinDepth = params[2].get_int();

	CWalletTx wtx;
	wtx.strFromAccount = strAccount;
	if (params.size() > 3 && !params[3].isNull() && !params[3].get_str().empty())
	wtx.mapValue["comment"] = params[3].get_str();

	UniValue subtractFeeFromAmount(UniValue::VARR);
	if (params.size() > 4)
	subtractFeeFromAmount = params[4].get_array();

	set<CBitcoinAddress> setAddress;
	vector<CRecipient> vecSend;

	CAmount totalAmount = 0;
	vector<string> keys = sendTo.getKeys();
	BOOST_FOREACH(const string& name_, keys)
	{
	CBitcoinAddress address(name_);
	if (!address.IsValid())
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, string("Invalid Bitcoin address: ")+name_);

	if (setAddress.count(address))
	throw JSONRPCError(RPC_INVALID_PARAMETER, string("Invalid parameter, duplicated address: ")+name_);
	setAddress.insert(address);

	CScript scriptPubKey = GetScriptForDestination(address.Get());
	CAmount nAmount = AmountFromValue(sendTo[name_]);
	if (nAmount <= 0)
	throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount for send");
	totalAmount += nAmount;

	bool fSubtractFeeFromAmount = false;
	for (unsigned int idx = 0; idx < subtractFeeFromAmount.size(); idx++) {
	const UniValue& addr = subtractFeeFromAmount[idx];
	if (addr.get_str() == name_)
	fSubtractFeeFromAmount = true;
	}

	CRecipient recipient = {scriptPubKey, nAmount, fSubtractFeeFromAmount};
	vecSend.push_back(recipient);
	}

	EnsureWalletIsUnlocked();

	// Check funds
	CAmount nBalance = pwalletMain->GetAccountBalance(strAccount, nMinDepth, ISMINE_SPENDABLE);
	if (totalAmount > nBalance)
	throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, "Account has insufficient funds");

	// Send
	CReserveKey keyChange(pwalletMain);
	CAmount nFeeRequired = 0;
	int nChangePosRet = -1;
	string strFailReason;
	bool fCreated = pwalletMain->CreateTransaction(vecSend, wtx, keyChange, nFeeRequired, nChangePosRet, strFailReason);
	if (!fCreated)
	throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, strFailReason);
	if (!pwalletMain->CommitTransaction(wtx, keyChange))
	throw JSONRPCError(RPC_WALLET_ERROR, "Transaction commit failed");

	return wtx.GetHash().GetHex();
	}

	// Defined in rpc/misc.cpp
	extern CScript _createmultisig_redeemScript(const UniValue& params);

	UniValue addmultisigaddress(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() < 2 \|\| params.size() > 3)
	{
	string msg = "addmultisigaddress nrequired [\"key\",...] ( \"account\" )\n"
	"\nAdd a nrequired-to-sign multisignature address to the wallet.\n"
	"Each key is a Bitcoin address or hex-encoded public key.\n"
	"If 'account' is specified (DEPRECATED), assign address to that account.\n"

	"\nArguments:\n"
	"1. nrequired (numeric, required) The number of required signatures out of the n keys or addresses.\n"
	"2. \"keysobject\" (string, required) A json array of bitcoin addresses or hex-encoded public keys\n"
	" [\n"
	" \"address\" (string) bitcoin address or hex-encoded public key\n"
	" ...,\n"
	" ]\n"
	"3. \"account\" (string, optional) DEPRECATED. An account to assign the addresses to.\n"

	"\nResult:\n"
	"\"bitcoinaddress\" (string) A bitcoin address associated with the keys.\n"

	"\nExamples:\n"
	"\nAdd a multisig address from 2 addresses\n"
	+ HelpExampleCli("addmultisigaddress", "2 \"[\\\"16sSauSf5pF2UkUwvKGq4qjNRzBZYqgEL5\\\",\\\"171sgjn4YtPu27adkKGrdDwzRTxnRkBfKV\\\"]\"") +
	"\nAs json rpc call\n"
	+ HelpExampleRpc("addmultisigaddress", "2, \"[\\\"16sSauSf5pF2UkUwvKGq4qjNRzBZYqgEL5\\\",\\\"171sgjn4YtPu27adkKGrdDwzRTxnRkBfKV\\\"]\"")
	;
	throw runtime_error(msg);
	}

	LOCK2(cs_main, pwalletMain->cs_wallet);

	string strAccount;
	if (params.size() > 2)
	strAccount = AccountFromValue(params[2]);

	// Construct using pay-to-script-hash:
	CScript inner = _createmultisig_redeemScript(params);
	CScriptID innerID(inner);
	pwalletMain->AddCScript(inner);

	pwalletMain->SetAddressBook(innerID, strAccount, "send");
	return CBitcoinAddress(innerID).ToString();
	}


	struct tallyitem
	{
	CAmount nAmount;
	int nConf;
	vector<uint256> txids;
	bool fIsWatchonly;
	tallyitem()
	{
	nAmount = 0;
	nConf = std::numeric_limits<int>::max();
	fIsWatchonly = false;
	}
	};

	UniValue ListReceived(const UniValue& params, bool fByAccounts)
	{
	// Minimum confirmations
	int nMinDepth = 1;
	if (params.size() > 0)
	nMinDepth = params[0].get_int();

	// Whether to include empty accounts
	bool fIncludeEmpty = false;
	if (params.size() > 1)
	fIncludeEmpty = params[1].get_bool();

	isminefilter filter = ISMINE_SPENDABLE;
	if(params.size() > 2)
	if(params[2].get_bool())
	filter = filter \| ISMINE_WATCH_ONLY;

	// Tally
	map<CBitcoinAddress, tallyitem> mapTally;
	for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
	{
	const CWalletTx& wtx = (*it).second;

	if (wtx.IsCoinBase() \|\| !CheckFinalTx(wtx))
	continue;

	int nDepth = wtx.GetDepthInMainChain();
	if (nDepth < nMinDepth)
	continue;

	BOOST_FOREACH(const CTxOut& txout, wtx.vout)
	{
	CTxDestination address;
	if (!ExtractDestination(txout.scriptPubKey, address))
	continue;

	isminefilter mine = IsMine(*pwalletMain, address);
	if(!(mine & filter))
	continue;

	tallyitem& item = mapTally[address];
	item.nAmount += txout.nValue;
	item.nConf = min(item.nConf, nDepth);
	item.txids.push_back(wtx.GetHash());
	if (mine & ISMINE_WATCH_ONLY)
	item.fIsWatchonly = true;
	}
	}

	// Reply
	UniValue ret(UniValue::VARR);
	map<string, tallyitem> mapAccountTally;
	BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress, CAddressBookData)& item, pwalletMain->mapAddressBook)
	{
	const CBitcoinAddress& address = item.first;
	const string& strAccount = item.second.name;
	map<CBitcoinAddress, tallyitem>::iterator it = mapTally.find(address);
	if (it == mapTally.end() && !fIncludeEmpty)
	continue;

	CAmount nAmount = 0;
	int nConf = std::numeric_limits<int>::max();
	bool fIsWatchonly = false;
	if (it != mapTally.end())
	{
	nAmount = (*it).second.nAmount;
	nConf = (*it).second.nConf;
	fIsWatchonly = (*it).second.fIsWatchonly;
	}

	if (fByAccounts)
	{
	tallyitem& item = mapAccountTally[strAccount];
	item.nAmount += nAmount;
	item.nConf = min(item.nConf, nConf);
	item.fIsWatchonly = fIsWatchonly;
	}
	else
	{
	UniValue obj(UniValue::VOBJ);
	if(fIsWatchonly)
	obj.push_back(Pair("involvesWatchonly", true));
	obj.push_back(Pair("address", address.ToString()));
	obj.push_back(Pair("account", strAccount));
	obj.push_back(Pair("amount", ValueFromAmount(nAmount)));
	obj.push_back(Pair("confirmations", (nConf == std::numeric_limits<int>::max() ? 0 : nConf)));
	if (!fByAccounts)
	obj.push_back(Pair("label", strAccount));
	UniValue transactions(UniValue::VARR);
	if (it != mapTally.end())
	{
	BOOST_FOREACH(const uint256& item, (*it).second.txids)
	{
	transactions.push_back(item.GetHex());
	}
	}
	obj.push_back(Pair("txids", transactions));
	ret.push_back(obj);
	}
	}

	if (fByAccounts)
	{
	for (map<string, tallyitem>::iterator it = mapAccountTally.begin(); it != mapAccountTally.end(); ++it)
	{
	CAmount nAmount = (*it).second.nAmount;
	int nConf = (*it).second.nConf;
	UniValue obj(UniValue::VOBJ);
	if((*it).second.fIsWatchonly)
	obj.push_back(Pair("involvesWatchonly", true));
	obj.push_back(Pair("account", (*it).first));
	obj.push_back(Pair("amount", ValueFromAmount(nAmount)));
	obj.push_back(Pair("confirmations", (nConf == std::numeric_limits<int>::max() ? 0 : nConf)));
	ret.push_back(obj);
	}
	}

	return ret;
	}

	UniValue listreceivedbyaddress(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() > 3)
	throw runtime_error(
	"listreceivedbyaddress ( minconf includeempty includeWatchonly)\n"
	"\nList balances by receiving address.\n"
	"\nArguments:\n"
	"1. minconf (numeric, optional, default=1) The minimum number of confirmations before payments are included.\n"
	"2. includeempty (bool, optional, default=false) Whether to include addresses that haven't received any payments.\n"
	"3. includeWatchonly (bool, optional, default=false) Whether to include watchonly addresses (see 'importaddress').\n"

	"\nResult:\n"
	"[\n"
	" {\n"
	" \"involvesWatchonly\" : true, (bool) Only returned if imported addresses were involved in transaction\n"
	" \"address\" : \"receivingaddress\", (string) The receiving address\n"
	" \"account\" : \"accountname\", (string) DEPRECATED. The account of the receiving address. The default account is \"\".\n"
	" \"amount\" : x.xxx, (numeric) The total amount in " + CURRENCY_UNIT + " received by the address\n"
	" \"confirmations\" : n, (numeric) The number of confirmations of the most recent transaction included\n"
	" \"label\" : \"label\" (string) A comment for the address/transaction, if any\n"
	" }\n"
	" ,...\n"
	"]\n"

	"\nExamples:\n"
	+ HelpExampleCli("listreceivedbyaddress", "")
	+ HelpExampleCli("listreceivedbyaddress", "6 true")
	+ HelpExampleRpc("listreceivedbyaddress", "6, true, true")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	return ListReceived(params, false);
	}

	UniValue listreceivedbyaccount(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() > 3)
	throw runtime_error(
	"listreceivedbyaccount ( minconf includeempty includeWatchonly)\n"
	"\nDEPRECATED. List balances by account.\n"
	"\nArguments:\n"
	"1. minconf (numeric, optional, default=1) The minimum number of confirmations before payments are included.\n"
	"2. includeempty (bool, optional, default=false) Whether to include accounts that haven't received any payments.\n"
	"3. includeWatchonly (bool, optional, default=false) Whether to include watchonly addresses (see 'importaddress').\n"

	"\nResult:\n"
	"[\n"
	" {\n"
	" \"involvesWatchonly\" : true, (bool) Only returned if imported addresses were involved in transaction\n"
	" \"account\" : \"accountname\", (string) The account name of the receiving account\n"
	" \"amount\" : x.xxx, (numeric) The total amount received by addresses with this account\n"
	" \"confirmations\" : n, (numeric) The number of confirmations of the most recent transaction included\n"
	" \"label\" : \"label\" (string) A comment for the address/transaction, if any\n"
	" }\n"
	" ,...\n"
	"]\n"

	"\nExamples:\n"
	+ HelpExampleCli("listreceivedbyaccount", "")
	+ HelpExampleCli("listreceivedbyaccount", "6 true")
	+ HelpExampleRpc("listreceivedbyaccount", "6, true, true")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	return ListReceived(params, true);
	}

	static void MaybePushAddress(UniValue & entry, const CTxDestination &dest)
	{
	CBitcoinAddress addr;
	if (addr.Set(dest))
	entry.push_back(Pair("address", addr.ToString()));
	}

	void ListTransactions(const CWalletTx& wtx, const string& strAccount, int nMinDepth, bool fLong, UniValue& ret, const isminefilter& filter)
	{
	CAmount nFee;
	string strSentAccount;
	list<COutputEntry> listReceived;
	list<COutputEntry> listSent;

	wtx.GetAmounts(listReceived, listSent, nFee, strSentAccount, filter);

	bool fAllAccounts = (strAccount == string("*"));
	bool involvesWatchonly = wtx.IsFromMe(ISMINE_WATCH_ONLY);

	// Sent
	if ((!listSent.empty() \|\| nFee != 0) && (fAllAccounts \|\| strAccount == strSentAccount))
	{
	BOOST_FOREACH(const COutputEntry& s, listSent)
	{
	UniValue entry(UniValue::VOBJ);
	if(involvesWatchonly \|\| (::IsMine(*pwalletMain, s.destination) & ISMINE_WATCH_ONLY))
	entry.push_back(Pair("involvesWatchonly", true));
	entry.push_back(Pair("account", strSentAccount));
	MaybePushAddress(entry, s.destination);
	entry.push_back(Pair("category", "send"));
	entry.push_back(Pair("amount", ValueFromAmount(-s.amount)));
	if (pwalletMain->mapAddressBook.count(s.destination))
	entry.push_back(Pair("label", pwalletMain->mapAddressBook[s.destination].name));
	entry.push_back(Pair("vout", s.vout));
	entry.push_back(Pair("fee", ValueFromAmount(-nFee)));
	if (fLong)
	WalletTxToJSON(wtx, entry);
	entry.push_back(Pair("abandoned", wtx.isAbandoned()));
	ret.push_back(entry);
	}
	}

	// Received
	if (listReceived.size() > 0 && wtx.GetDepthInMainChain() >= nMinDepth)
	{
	BOOST_FOREACH(const COutputEntry& r, listReceived)
	{
	string account;
	if (pwalletMain->mapAddressBook.count(r.destination))
	account = pwalletMain->mapAddressBook[r.destination].name;
	if (fAllAccounts \|\| (account == strAccount))
	{
	UniValue entry(UniValue::VOBJ);
	if(involvesWatchonly \|\| (::IsMine(*pwalletMain, r.destination) & ISMINE_WATCH_ONLY))
	entry.push_back(Pair("involvesWatchonly", true));
	entry.push_back(Pair("account", account));
	MaybePushAddress(entry, r.destination);
	if (wtx.IsCoinBase())
	{
	if (wtx.GetDepthInMainChain() < 1)
	entry.push_back(Pair("category", "orphan"));
	else if (wtx.GetBlocksToMaturity() > 0)
	entry.push_back(Pair("category", "immature"));
	else
	entry.push_back(Pair("category", "generate"));
	}
	else
	{
	entry.push_back(Pair("category", "receive"));
	}
	entry.push_back(Pair("amount", ValueFromAmount(r.amount)));
	if (pwalletMain->mapAddressBook.count(r.destination))
	entry.push_back(Pair("label", account));
	entry.push_back(Pair("vout", r.vout));
	if (fLong)
	WalletTxToJSON(wtx, entry);
	ret.push_back(entry);
	}
	}
	}
	}

	void AcentryToJSON(const CAccountingEntry& acentry, const string& strAccount, UniValue& ret)
	{
	bool fAllAccounts = (strAccount == string("*"));

	if (fAllAccounts \|\| acentry.strAccount == strAccount)
	{
	UniValue entry(UniValue::VOBJ);
	entry.push_back(Pair("account", acentry.strAccount));
	entry.push_back(Pair("category", "move"));
	entry.push_back(Pair("time", acentry.nTime));
	entry.push_back(Pair("amount", ValueFromAmount(acentry.nCreditDebit)));
	entry.push_back(Pair("otheraccount", acentry.strOtherAccount));
	entry.push_back(Pair("comment", acentry.strComment));
	ret.push_back(entry);
	}
	}

	UniValue listtransactions(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() > 4)
	throw runtime_error(
	"listtransactions ( \"account\" count from includeWatchonly)\n"
	"\nReturns up to 'count' most recent transactions skipping the first 'from' transactions for account 'account'.\n"
	"\nArguments:\n"
	"1. \"account\" (string, optional) DEPRECATED. The account name. Should be \"*\".\n"
	"2. count (numeric, optional, default=10) The number of transactions to return\n"
	"3. from (numeric, optional, default=0) The number of transactions to skip\n"
	"4. includeWatchonly (bool, optional, default=false) Include transactions to watchonly addresses (see 'importaddress')\n"
	"\nResult:\n"
	"[\n"
	" {\n"
	" \"account\":\"accountname\", (string) DEPRECATED. The account name associated with the transaction. \n"
	" It will be \"\" for the default account.\n"
	" \"address\":\"bitcoinaddress\", (string) The bitcoin address of the transaction. Not present for \n"
	" move transactions (category = move).\n"
	" \"category\":\"send\|receive\|move\", (string) The transaction category. 'move' is a local (off blockchain)\n"
	" transaction between accounts, and not associated with an address,\n"
	" transaction id or block. 'send' and 'receive' transactions are \n"
	" associated with an address, transaction id and block details\n"
	" \"amount\": x.xxx, (numeric) The amount in " + CURRENCY_UNIT + ". This is negative for the 'send' category, and for the\n"
	" 'move' category for moves outbound. It is positive for the 'receive' category,\n"
	" and for the 'move' category for inbound funds.\n"
	" \"vout\": n, (numeric) the vout value\n"
	" \"fee\": x.xxx, (numeric) The amount of the fee in " + CURRENCY_UNIT + ". This is negative and only available for the \n"
	" 'send' category of transactions.\n"
	" \"abandoned\": xxx (bool) 'true' if the transaction has been abandoned (inputs are respendable).\n"
	" \"confirmations\": n, (numeric) The number of confirmations for the transaction. Available for 'send' and \n"
	" 'receive' category of transactions. Negative confirmations indicate the\n"
	" transaction conflicts with the block chain\n"
	" \"trusted\": xxx (bool) Whether we consider the outputs of this unconfirmed transaction safe to spend.\n"
	" \"blockhash\": \"hashvalue\", (string) The block hash containing the transaction. Available for 'send' and 'receive'\n"
	" category of transactions.\n"
	" \"blockindex\": n, (numeric) The index of the transaction in the block that includes it. Available for 'send' and 'receive'\n"
	" category of transactions.\n"
	" \"blocktime\": xxx, (numeric) The block time in seconds since epoch (1 Jan 1970 GMT).\n"
	" \"txid\": \"transactionid\", (string) The transaction id. Available for 'send' and 'receive' category of transactions.\n"
	" \"time\": xxx, (numeric) The transaction time in seconds since epoch (midnight Jan 1 1970 GMT).\n"
	" \"timereceived\": xxx, (numeric) The time received in seconds since epoch (midnight Jan 1 1970 GMT). Available \n"
	" for 'send' and 'receive' category of transactions.\n"
	" \"comment\": \"...\", (string) If a comment is associated with the transaction.\n"
	" \"label\": \"label\" (string) A comment for the address/transaction, if any\n"
	" \"otheraccount\": \"accountname\", (string) For the 'move' category of transactions, the account the funds came \n"
	" from (for receiving funds, positive amounts), or went to (for sending funds,\n"
	" negative amounts).\n"
	" \"bip125-replaceable\": \"yes\|no\|unknown\" (string) Whether this transaction could be replaced due to BIP125 (replace-by-fee);\n"
	" may be unknown for unconfirmed transactions not in the mempool\n"
	" }\n"
	"]\n"

	"\nExamples:\n"
	"\nList the most recent 10 transactions in the systems\n"
	+ HelpExampleCli("listtransactions", "") +
	"\nList transactions 100 to 120\n"
	+ HelpExampleCli("listtransactions", "\"*\" 20 100") +
	"\nAs a json rpc call\n"
	+ HelpExampleRpc("listtransactions", "\"*\", 20, 100")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	string strAccount = "*";
	if (params.size() > 0)
	strAccount = params[0].get_str();
	int nCount = 10;
	if (params.size() > 1)
	nCount = params[1].get_int();
	int nFrom = 0;
	if (params.size() > 2)
	nFrom = params[2].get_int();
	isminefilter filter = ISMINE_SPENDABLE;
	if(params.size() > 3)
	if(params[3].get_bool())
	filter = filter \| ISMINE_WATCH_ONLY;

	if (nCount < 0)
	throw JSONRPCError(RPC_INVALID_PARAMETER, "Negative count");
	if (nFrom < 0)
	throw JSONRPCError(RPC_INVALID_PARAMETER, "Negative from");

	UniValue ret(UniValue::VARR);

	const CWallet::TxItems & txOrdered = pwalletMain->wtxOrdered;

	// iterate backwards until we have nCount items to return:
	for (CWallet::TxItems::const_reverse_iterator it = txOrdered.rbegin(); it != txOrdered.rend(); ++it)
	{
	CWalletTx const pwtx = (it).second.first;
	if (pwtx != 0)
	ListTransactions(*pwtx, strAccount, 0, true, ret, filter);
	CAccountingEntry const pacentry = (it).second.second;
	if (pacentry != 0)
	AcentryToJSON(*pacentry, strAccount, ret);

	if ((int)ret.size() >= (nCount+nFrom)) break;
	}
	// ret is newest to oldest

	if (nFrom > (int)ret.size())
	nFrom = ret.size();
	if ((nFrom + nCount) > (int)ret.size())
	nCount = ret.size() - nFrom;

	vector<UniValue> arrTmp = ret.getValues();

	vector<UniValue>::iterator first = arrTmp.begin();
	std::advance(first, nFrom);
	vector<UniValue>::iterator last = arrTmp.begin();
	std::advance(last, nFrom+nCount);

	if (last != arrTmp.end()) arrTmp.erase(last, arrTmp.end());
	if (first != arrTmp.begin()) arrTmp.erase(arrTmp.begin(), first);

	std::reverse(arrTmp.begin(), arrTmp.end()); // Return oldest to newest

	ret.clear();
	ret.setArray();
	ret.push_backV(arrTmp);

	return ret;
	}

	UniValue listaccounts(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() > 2)
	throw runtime_error(
	"listaccounts ( minconf includeWatchonly)\n"
	"\nDEPRECATED. Returns Object that has account names as keys, account balances as values.\n"
	"\nArguments:\n"
	"1. minconf (numeric, optional, default=1) Only include transactions with at least this many confirmations\n"
	"2. includeWatchonly (bool, optional, default=false) Include balances in watchonly addresses (see 'importaddress')\n"
	"\nResult:\n"
	"{ (json object where keys are account names, and values are numeric balances\n"
	" \"account\": x.xxx, (numeric) The property name is the account name, and the value is the total balance for the account.\n"
	" ...\n"
	"}\n"
	"\nExamples:\n"
	"\nList account balances where there at least 1 confirmation\n"
	+ HelpExampleCli("listaccounts", "") +
	"\nList account balances including zero confirmation transactions\n"
	+ HelpExampleCli("listaccounts", "0") +
	"\nList account balances for 6 or more confirmations\n"
	+ HelpExampleCli("listaccounts", "6") +
	"\nAs json rpc call\n"
	+ HelpExampleRpc("listaccounts", "6")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	int nMinDepth = 1;
	if (params.size() > 0)
	nMinDepth = params[0].get_int();
	isminefilter includeWatchonly = ISMINE_SPENDABLE;
	if(params.size() > 1)
	if(params[1].get_bool())
	includeWatchonly = includeWatchonly \| ISMINE_WATCH_ONLY;

	map<string, CAmount> mapAccountBalances;
	BOOST_FOREACH(const PAIRTYPE(CTxDestination, CAddressBookData)& entry, pwalletMain->mapAddressBook) {
	if (IsMine(*pwalletMain, entry.first) & includeWatchonly) // This address belongs to me
	mapAccountBalances[entry.second.name] = 0;
	}

	for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
	{
	const CWalletTx& wtx = (*it).second;
	CAmount nFee;
	string strSentAccount;
	list<COutputEntry> listReceived;
	list<COutputEntry> listSent;
	int nDepth = wtx.GetDepthInMainChain();
	if (wtx.GetBlocksToMaturity() > 0 \|\| nDepth < 0)
	continue;
	wtx.GetAmounts(listReceived, listSent, nFee, strSentAccount, includeWatchonly);
	mapAccountBalances[strSentAccount] -= nFee;
	BOOST_FOREACH(const COutputEntry& s, listSent)
	mapAccountBalances[strSentAccount] -= s.amount;
	if (nDepth >= nMinDepth)
	{
	BOOST_FOREACH(const COutputEntry& r, listReceived)
	if (pwalletMain->mapAddressBook.count(r.destination))
	mapAccountBalances[pwalletMain->mapAddressBook[r.destination].name] += r.amount;
	else
	mapAccountBalances[""] += r.amount;
	}
	}

	const list<CAccountingEntry> & acentries = pwalletMain->laccentries;
	BOOST_FOREACH(const CAccountingEntry& entry, acentries)
	mapAccountBalances[entry.strAccount] += entry.nCreditDebit;

	UniValue ret(UniValue::VOBJ);
	BOOST_FOREACH(const PAIRTYPE(string, CAmount)& accountBalance, mapAccountBalances) {
	ret.push_back(Pair(accountBalance.first, ValueFromAmount(accountBalance.second)));
	}
	return ret;
	}

	UniValue listsinceblock(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp)
	throw runtime_error(
	"listsinceblock ( \"blockhash\" target-confirmations includeWatchonly)\n"
	"\nGet all transactions in blocks since block [blockhash], or all transactions if omitted\n"
	"\nArguments:\n"
	"1. \"blockhash\" (string, optional) The block hash to list transactions since\n"
	"2. target-confirmations: (numeric, optional) The confirmations required, must be 1 or more\n"
	"3. includeWatchonly: (bool, optional, default=false) Include transactions to watchonly addresses (see 'importaddress')"
	"\nResult:\n"
	"{\n"
	" \"transactions\": [\n"
	" \"account\":\"accountname\", (string) DEPRECATED. The account name associated with the transaction. Will be \"\" for the default account.\n"
	" \"address\":\"bitcoinaddress\", (string) The bitcoin address of the transaction. Not present for move transactions (category = move).\n"
	" \"category\":\"send\|receive\", (string) The transaction category. 'send' has negative amounts, 'receive' has positive amounts.\n"
	" \"amount\": x.xxx, (numeric) The amount in " + CURRENCY_UNIT + ". This is negative for the 'send' category, and for the 'move' category for moves \n"
	" outbound. It is positive for the 'receive' category, and for the 'move' category for inbound funds.\n"
	" \"vout\" : n, (numeric) the vout value\n"
	" \"fee\": x.xxx, (numeric) The amount of the fee in " + CURRENCY_UNIT + ". This is negative and only available for the 'send' category of transactions.\n"
	" \"confirmations\": n, (numeric) The number of confirmations for the transaction. Available for 'send' and 'receive' category of transactions.\n"
	" \"blockhash\": \"hashvalue\", (string) The block hash containing the transaction. Available for 'send' and 'receive' category of transactions.\n"
	" \"blockindex\": n, (numeric) The index of the transaction in the block that includes it. Available for 'send' and 'receive' category of transactions.\n"
	" \"blocktime\": xxx, (numeric) The block time in seconds since epoch (1 Jan 1970 GMT).\n"
	" \"txid\": \"transactionid\", (string) The transaction id. Available for 'send' and 'receive' category of transactions.\n"
	" \"time\": xxx, (numeric) The transaction time in seconds since epoch (Jan 1 1970 GMT).\n"
	" \"timereceived\": xxx, (numeric) The time received in seconds since epoch (Jan 1 1970 GMT). Available for 'send' and 'receive' category of transactions.\n"
	" \"comment\": \"...\", (string) If a comment is associated with the transaction.\n"
	" \"label\" : \"label\" (string) A comment for the address/transaction, if any\n"
	" \"to\": \"...\", (string) If a comment to is associated with the transaction.\n"
	" ],\n"
	" \"lastblock\": \"lastblockhash\" (string) The hash of the last block\n"
	"}\n"
	"\nExamples:\n"
	+ HelpExampleCli("listsinceblock", "")
	+ HelpExampleCli("listsinceblock", "\"000000000000000bacf66f7497b7dc45ef753ee9a7d38571037cdb1a57f663ad\" 6")
	+ HelpExampleRpc("listsinceblock", "\"000000000000000bacf66f7497b7dc45ef753ee9a7d38571037cdb1a57f663ad\", 6")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	CBlockIndex *pindex = NULL;
	int target_confirms = 1;
	isminefilter filter = ISMINE_SPENDABLE;

	if (params.size() > 0)
	{
	uint256 blockId;

	blockId.SetHex(params[0].get_str());
	BlockMap::iterator it = mapBlockIndex.find(blockId);
	if (it != mapBlockIndex.end())
	pindex = it->second;
	}

	if (params.size() > 1)
	{
	target_confirms = params[1].get_int();

	if (target_confirms < 1)
	throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter");
	}

	if(params.size() > 2)
	if(params[2].get_bool())
	filter = filter \| ISMINE_WATCH_ONLY;

	int depth = pindex ? (1 + chainActive.Height() - pindex->nHeight) : -1;

	UniValue transactions(UniValue::VARR);

	for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); it++)
	{
	CWalletTx tx = (*it).second;

	if (depth == -1 \|\| tx.GetDepthInMainChain() < depth)
	ListTransactions(tx, "*", 0, true, transactions, filter);
	}

	CBlockIndex *pblockLast = chainActive[chainActive.Height() + 1 - target_confirms];
	uint256 lastblock = pblockLast ? pblockLast->GetBlockHash() : uint256();

	UniValue ret(UniValue::VOBJ);
	ret.push_back(Pair("transactions", transactions));
	ret.push_back(Pair("lastblock", lastblock.GetHex()));

	return ret;
	}

	UniValue gettransaction(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() < 1 \|\| params.size() > 2)
	throw runtime_error(
	"gettransaction \"txid\" ( includeWatchonly )\n"
	"\nGet detailed information about in-wallet transaction <txid>\n"
	"\nArguments:\n"
	"1. \"txid\" (string, required) The transaction id\n"
	"2. \"includeWatchonly\" (bool, optional, default=false) Whether to include watchonly addresses in balance calculation and details[]\n"
	"\nResult:\n"
	"{\n"
	" \"amount\" : x.xxx, (numeric) The transaction amount in " + CURRENCY_UNIT + "\n"
	" \"confirmations\" : n, (numeric) The number of confirmations\n"
	" \"blockhash\" : \"hash\", (string) The block hash\n"
	" \"blockindex\" : xx, (numeric) The index of the transaction in the block that includes it\n"
	" \"blocktime\" : ttt, (numeric) The time in seconds since epoch (1 Jan 1970 GMT)\n"
	" \"txid\" : \"transactionid\", (string) The transaction id.\n"
	" \"time\" : ttt, (numeric) The transaction time in seconds since epoch (1 Jan 1970 GMT)\n"
	" \"timereceived\" : ttt, (numeric) The time received in seconds since epoch (1 Jan 1970 GMT)\n"
	" \"bip125-replaceable\": \"yes\|no\|unknown\" (string) Whether this transaction could be replaced due to BIP125 (replace-by-fee);\n"
	" may be unknown for unconfirmed transactions not in the mempool\n"
	" \"details\" : [\n"
	" {\n"
	" \"account\" : \"accountname\", (string) DEPRECATED. The account name involved in the transaction, can be \"\" for the default account.\n"
	" \"address\" : \"bitcoinaddress\", (string) The bitcoin address involved in the transaction\n"
	" \"category\" : \"send\|receive\", (string) The category, either 'send' or 'receive'\n"
	" \"amount\" : x.xxx, (numeric) The amount in " + CURRENCY_UNIT + "\n"
	" \"label\" : \"label\", (string) A comment for the address/transaction, if any\n"
	" \"vout\" : n, (numeric) the vout value\n"
	" }\n"
	" ,...\n"
	" ],\n"
	" \"hex\" : \"data\" (string) Raw data for transaction\n"
	"}\n"

	"\nExamples:\n"
	+ HelpExampleCli("gettransaction", "\"1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d\"")
	+ HelpExampleCli("gettransaction", "\"1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d\" true")
	+ HelpExampleRpc("gettransaction", "\"1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d\"")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	uint256 hash;
	hash.SetHex(params[0].get_str());

	isminefilter filter = ISMINE_SPENDABLE;
	if(params.size() > 1)
	if(params[1].get_bool())
	filter = filter \| ISMINE_WATCH_ONLY;

	UniValue entry(UniValue::VOBJ);
	if (!pwalletMain->mapWallet.count(hash))
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid or non-wallet transaction id");
	const CWalletTx& wtx = pwalletMain->mapWallet[hash];

	CAmount nCredit = wtx.GetCredit(filter);
	CAmount nDebit = wtx.GetDebit(filter);
	CAmount nNet = nCredit - nDebit;
	CAmount nFee = (wtx.IsFromMe(filter) ? wtx.GetValueOut() - nDebit : 0);

	entry.push_back(Pair("amount", ValueFromAmount(nNet - nFee)));
	if (wtx.IsFromMe(filter))
	entry.push_back(Pair("fee", ValueFromAmount(nFee)));

	WalletTxToJSON(wtx, entry);

	UniValue details(UniValue::VARR);
	ListTransactions(wtx, "*", 0, false, details, filter);
	entry.push_back(Pair("details", details));

	string strHex = EncodeHexTx(static_cast<CTransaction>(wtx));
	entry.push_back(Pair("hex", strHex));

	return entry;
	}

	UniValue abandontransaction(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() != 1)
	throw runtime_error(
	"abandontransaction \"txid\"\n"
	"\nMark in-wallet transaction <txid> as abandoned\n"
	"This will mark this transaction and all its in-wallet descendants as abandoned which will allow\n"
	"for their inputs to be respent. It can be used to replace \"stuck\" or evicted transactions.\n"
	"It only works on transactions which are not included in a block and are not currently in the mempool.\n"
	"It has no effect on transactions which are already conflicted or abandoned.\n"
	"\nArguments:\n"
	"1. \"txid\" (string, required) The transaction id\n"
	"\nResult:\n"
	"\nExamples:\n"
	+ HelpExampleCli("abandontransaction", "\"1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d\"")
	+ HelpExampleRpc("abandontransaction", "\"1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d\"")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	uint256 hash;
	hash.SetHex(params[0].get_str());

	if (!pwalletMain->mapWallet.count(hash))
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid or non-wallet transaction id");
	if (!pwalletMain->AbandonTransaction(hash))
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Transaction not eligible for abandonment");

	return NullUniValue;
	}


	UniValue backupwallet(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() != 1)
	throw runtime_error(
	"backupwallet \"destination\"\n"
	"\nSafely copies current wallet file to destination, which can be a directory or a path with filename.\n"
	"\nArguments:\n"
	"1. \"destination\" (string) The destination directory or file\n"
	"\nExamples:\n"
	+ HelpExampleCli("backupwallet", "\"backup.dat\"")
	+ HelpExampleRpc("backupwallet", "\"backup.dat\"")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	string strDest = params[0].get_str();
	- if (!BackupWallet(*pwalletMain, strDest))
	+ if (!pwalletMain->BackupWallet(strDest))
	throw JSONRPCError(RPC_WALLET_ERROR, "Error: Wallet backup failed!");

	return NullUniValue;
	}


	UniValue keypoolrefill(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() > 1)
	throw runtime_error(
	"keypoolrefill ( newsize )\n"
	"\nFills the keypool."
	+ HelpRequiringPassphrase() + "\n"
	"\nArguments\n"
	"1. newsize (numeric, optional, default=100) The new keypool size\n"
	"\nExamples:\n"
	+ HelpExampleCli("keypoolrefill", "")
	+ HelpExampleRpc("keypoolrefill", "")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	// 0 is interpreted by TopUpKeyPool() as the default keypool size given by -keypool
	unsigned int kpSize = 0;
	if (params.size() > 0) {
	if (params[0].get_int() < 0)
	throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, expected valid size.");
	kpSize = (unsigned int)params[0].get_int();
	}

	EnsureWalletIsUnlocked();
	pwalletMain->TopUpKeyPool(kpSize);

	if (pwalletMain->GetKeyPoolSize() < kpSize)
	throw JSONRPCError(RPC_WALLET_ERROR, "Error refreshing keypool.");

	return NullUniValue;
	}


	static void LockWallet(CWallet* pWallet)
	{
	LOCK(cs_nWalletUnlockTime);
	nWalletUnlockTime = 0;
	pWallet->Lock();
	}

	UniValue walletpassphrase(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (pwalletMain->IsCrypted() && (fHelp \|\| params.size() != 2))
	throw runtime_error(
	"walletpassphrase \"passphrase\" timeout\n"
	"\nStores the wallet decryption key in memory for 'timeout' seconds.\n"
	"This is needed prior to performing transactions related to private keys such as sending bitcoins\n"
	"\nArguments:\n"
	"1. \"passphrase\" (string, required) The wallet passphrase\n"
	"2. timeout (numeric, required) The time to keep the decryption key in seconds.\n"
	"\nNote:\n"
	"Issuing the walletpassphrase command while the wallet is already unlocked will set a new unlock\n"
	"time that overrides the old one.\n"
	"\nExamples:\n"
	"\nunlock the wallet for 60 seconds\n"
	+ HelpExampleCli("walletpassphrase", "\"my pass phrase\" 60") +
	"\nLock the wallet again (before 60 seconds)\n"
	+ HelpExampleCli("walletlock", "") +
	"\nAs json rpc call\n"
	+ HelpExampleRpc("walletpassphrase", "\"my pass phrase\", 60")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	if (fHelp)
	return true;
	if (!pwalletMain->IsCrypted())
	throw JSONRPCError(RPC_WALLET_WRONG_ENC_STATE, "Error: running with an unencrypted wallet, but walletpassphrase was called.");

	// Note that the walletpassphrase is stored in params[0] which is not mlock()ed
	SecureString strWalletPass;
	strWalletPass.reserve(100);
	// TODO: get rid of this .c_str() by implementing SecureString::operator=(std::string)
	// Alternately, find a way to make params[0] mlock()'d to begin with.
	strWalletPass = params[0].get_str().c_str();

	if (strWalletPass.length() > 0)
	{
	if (!pwalletMain->Unlock(strWalletPass))
	throw JSONRPCError(RPC_WALLET_PASSPHRASE_INCORRECT, "Error: The wallet passphrase entered was incorrect.");
	}
	else
	throw runtime_error(
	"walletpassphrase <passphrase> <timeout>\n"
	"Stores the wallet decryption key in memory for <timeout> seconds.");

	pwalletMain->TopUpKeyPool();

	int64_t nSleepTime = params[1].get_int64();
	LOCK(cs_nWalletUnlockTime);
	nWalletUnlockTime = GetTime() + nSleepTime;
	RPCRunLater("lockwallet", boost::bind(LockWallet, pwalletMain), nSleepTime);

	return NullUniValue;
	}


	UniValue walletpassphrasechange(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (pwalletMain->IsCrypted() && (fHelp \|\| params.size() != 2))
	throw runtime_error(
	"walletpassphrasechange \"oldpassphrase\" \"newpassphrase\"\n"
	"\nChanges the wallet passphrase from 'oldpassphrase' to 'newpassphrase'.\n"
	"\nArguments:\n"
	"1. \"oldpassphrase\" (string) The current passphrase\n"
	"2. \"newpassphrase\" (string) The new passphrase\n"
	"\nExamples:\n"
	+ HelpExampleCli("walletpassphrasechange", "\"old one\" \"new one\"")
	+ HelpExampleRpc("walletpassphrasechange", "\"old one\", \"new one\"")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	if (fHelp)
	return true;
	if (!pwalletMain->IsCrypted())
	throw JSONRPCError(RPC_WALLET_WRONG_ENC_STATE, "Error: running with an unencrypted wallet, but walletpassphrasechange was called.");

	// TODO: get rid of these .c_str() calls by implementing SecureString::operator=(std::string)
	// Alternately, find a way to make params[0] mlock()'d to begin with.
	SecureString strOldWalletPass;
	strOldWalletPass.reserve(100);
	strOldWalletPass = params[0].get_str().c_str();

	SecureString strNewWalletPass;
	strNewWalletPass.reserve(100);
	strNewWalletPass = params[1].get_str().c_str();

	if (strOldWalletPass.length() < 1 \|\| strNewWalletPass.length() < 1)
	throw runtime_error(
	"walletpassphrasechange <oldpassphrase> <newpassphrase>\n"
	"Changes the wallet passphrase from <oldpassphrase> to <newpassphrase>.");

	if (!pwalletMain->ChangeWalletPassphrase(strOldWalletPass, strNewWalletPass))
	throw JSONRPCError(RPC_WALLET_PASSPHRASE_INCORRECT, "Error: The wallet passphrase entered was incorrect.");

	return NullUniValue;
	}


	UniValue walletlock(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (pwalletMain->IsCrypted() && (fHelp \|\| params.size() != 0))
	throw runtime_error(
	"walletlock\n"
	"\nRemoves the wallet encryption key from memory, locking the wallet.\n"
	"After calling this method, you will need to call walletpassphrase again\n"
	"before being able to call any methods which require the wallet to be unlocked.\n"
	"\nExamples:\n"
	"\nSet the passphrase for 2 minutes to perform a transaction\n"
	+ HelpExampleCli("walletpassphrase", "\"my pass phrase\" 120") +
	"\nPerform a send (requires passphrase set)\n"
	+ HelpExampleCli("sendtoaddress", "\"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\" 1.0") +
	"\nClear the passphrase since we are done before 2 minutes is up\n"
	+ HelpExampleCli("walletlock", "") +
	"\nAs json rpc call\n"
	+ HelpExampleRpc("walletlock", "")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	if (fHelp)
	return true;
	if (!pwalletMain->IsCrypted())
	throw JSONRPCError(RPC_WALLET_WRONG_ENC_STATE, "Error: running with an unencrypted wallet, but walletlock was called.");

	{
	LOCK(cs_nWalletUnlockTime);
	pwalletMain->Lock();
	nWalletUnlockTime = 0;
	}

	return NullUniValue;
	}


	UniValue encryptwallet(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (!pwalletMain->IsCrypted() && (fHelp \|\| params.size() != 1))
	throw runtime_error(
	"encryptwallet \"passphrase\"\n"
	"\nEncrypts the wallet with 'passphrase'. This is for first time encryption.\n"
	"After this, any calls that interact with private keys such as sending or signing \n"
	"will require the passphrase to be set prior the making these calls.\n"
	"Use the walletpassphrase call for this, and then walletlock call.\n"
	"If the wallet is already encrypted, use the walletpassphrasechange call.\n"
	"Note that this will shutdown the server.\n"
	"\nArguments:\n"
	"1. \"passphrase\" (string) The pass phrase to encrypt the wallet with. It must be at least 1 character, but should be long.\n"
	"\nExamples:\n"
	"\nEncrypt you wallet\n"
	+ HelpExampleCli("encryptwallet", "\"my pass phrase\"") +
	"\nNow set the passphrase to use the wallet, such as for signing or sending bitcoin\n"
	+ HelpExampleCli("walletpassphrase", "\"my pass phrase\"") +
	"\nNow we can so something like sign\n"
	+ HelpExampleCli("signmessage", "\"bitcoinaddress\" \"test message\"") +
	"\nNow lock the wallet again by removing the passphrase\n"
	+ HelpExampleCli("walletlock", "") +
	"\nAs a json rpc call\n"
	+ HelpExampleRpc("encryptwallet", "\"my pass phrase\"")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	if (fHelp)
	return true;
	if (pwalletMain->IsCrypted())
	throw JSONRPCError(RPC_WALLET_WRONG_ENC_STATE, "Error: running with an encrypted wallet, but encryptwallet was called.");

	// TODO: get rid of this .c_str() by implementing SecureString::operator=(std::string)
	// Alternately, find a way to make params[0] mlock()'d to begin with.
	SecureString strWalletPass;
	strWalletPass.reserve(100);
	strWalletPass = params[0].get_str().c_str();

	if (strWalletPass.length() < 1)
	throw runtime_error(
	"encryptwallet <passphrase>\n"
	"Encrypts the wallet with <passphrase>.");

	if (!pwalletMain->EncryptWallet(strWalletPass))
	throw JSONRPCError(RPC_WALLET_ENCRYPTION_FAILED, "Error: Failed to encrypt the wallet.");

	// BDB seems to have a bad habit of writing old data into
	// slack space in .dat files; that is bad if the old data is
	// unencrypted private keys. So:
	StartShutdown();
	return "wallet encrypted; Bitcoin server stopping, restart to run with encrypted wallet. The keypool has been flushed, you need to make a new backup.";
	}

	UniValue lockunspent(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() < 1 \|\| params.size() > 2)
	throw runtime_error(
	"lockunspent unlock ([{\"txid\":\"txid\",\"vout\":n},...])\n"
	"\nUpdates list of temporarily unspendable outputs.\n"
	"Temporarily lock (unlock=false) or unlock (unlock=true) specified transaction outputs.\n"
	"If no transaction outputs are specified when unlocking then all current locked transaction outputs are unlocked.\n"
	"A locked transaction output will not be chosen by automatic coin selection, when spending bitcoins.\n"
	"Locks are stored in memory only. Nodes start with zero locked outputs, and the locked output list\n"
	"is always cleared (by virtue of process exit) when a node stops or fails.\n"
	"Also see the listunspent call\n"
	"\nArguments:\n"
	"1. unlock (boolean, required) Whether to unlock (true) or lock (false) the specified transactions\n"
	"2. \"transactions\" (string, optional) A json array of objects. Each object the txid (string) vout (numeric)\n"
	" [ (json array of json objects)\n"
	" {\n"
	" \"txid\":\"id\", (string) The transaction id\n"
	" \"vout\": n (numeric) The output number\n"
	" }\n"
	" ,...\n"
	" ]\n"

	"\nResult:\n"
	"true\|false (boolean) Whether the command was successful or not\n"

	"\nExamples:\n"
	"\nList the unspent transactions\n"
	+ HelpExampleCli("listunspent", "") +
	"\nLock an unspent transaction\n"
	+ HelpExampleCli("lockunspent", "false \"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":1}]\"") +
	"\nList the locked transactions\n"
	+ HelpExampleCli("listlockunspent", "") +
	"\nUnlock the transaction again\n"
	+ HelpExampleCli("lockunspent", "true \"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":1}]\"") +
	"\nAs a json rpc call\n"
	+ HelpExampleRpc("lockunspent", "false, \"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":1}]\"")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	if (params.size() == 1)
	RPCTypeCheck(params, boost::assign::list_of(UniValue::VBOOL));
	else
	RPCTypeCheck(params, boost::assign::list_of(UniValue::VBOOL)(UniValue::VARR));

	bool fUnlock = params[0].get_bool();

	if (params.size() == 1) {
	if (fUnlock)
	pwalletMain->UnlockAllCoins();
	return true;
	}

	UniValue outputs = params[1].get_array();
	for (unsigned int idx = 0; idx < outputs.size(); idx++) {
	const UniValue& output = outputs[idx];
	if (!output.isObject())
	throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, expected object");
	const UniValue& o = output.get_obj();

	RPCTypeCheckObj(o, boost::assign::map_list_of("txid", UniValue::VSTR)("vout", UniValue::VNUM));

	string txid = find_value(o, "txid").get_str();
	if (!IsHex(txid))
	throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, expected hex txid");

	int nOutput = find_value(o, "vout").get_int();
	if (nOutput < 0)
	throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, vout must be positive");

	COutPoint outpt(uint256S(txid), nOutput);

	if (fUnlock)
	pwalletMain->UnlockCoin(outpt);
	else
	pwalletMain->LockCoin(outpt);
	}

	return true;
	}

	UniValue listlockunspent(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() > 0)
	throw runtime_error(
	"listlockunspent\n"
	"\nReturns list of temporarily unspendable outputs.\n"
	"See the lockunspent call to lock and unlock transactions for spending.\n"
	"\nResult:\n"
	"[\n"
	" {\n"
	" \"txid\" : \"transactionid\", (string) The transaction id locked\n"
	" \"vout\" : n (numeric) The vout value\n"
	" }\n"
	" ,...\n"
	"]\n"
	"\nExamples:\n"
	"\nList the unspent transactions\n"
	+ HelpExampleCli("listunspent", "") +
	"\nLock an unspent transaction\n"
	+ HelpExampleCli("lockunspent", "false \"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":1}]\"") +
	"\nList the locked transactions\n"
	+ HelpExampleCli("listlockunspent", "") +
	"\nUnlock the transaction again\n"
	+ HelpExampleCli("lockunspent", "true \"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":1}]\"") +
	"\nAs a json rpc call\n"
	+ HelpExampleRpc("listlockunspent", "")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	vector<COutPoint> vOutpts;
	pwalletMain->ListLockedCoins(vOutpts);

	UniValue ret(UniValue::VARR);

	BOOST_FOREACH(COutPoint &outpt, vOutpts) {
	UniValue o(UniValue::VOBJ);

	o.push_back(Pair("txid", outpt.hash.GetHex()));
	o.push_back(Pair("vout", (int)outpt.n));
	ret.push_back(o);
	}

	return ret;
	}

	UniValue settxfee(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() < 1 \|\| params.size() > 1)
	throw runtime_error(
	"settxfee amount\n"
	"\nSet the transaction fee per kB. Overwrites the paytxfee parameter.\n"
	"\nArguments:\n"
	"1. amount (numeric or sting, required) The transaction fee in " + CURRENCY_UNIT + "/kB\n"
	"\nResult\n"
	"true\|false (boolean) Returns true if successful\n"
	"\nExamples:\n"
	+ HelpExampleCli("settxfee", "0.00001")
	+ HelpExampleRpc("settxfee", "0.00001")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	// Amount
	CAmount nAmount = AmountFromValue(params[0]);

	payTxFee = CFeeRate(nAmount, 1000);
	return true;
	}

	UniValue getwalletinfo(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() != 0)
	throw runtime_error(
	"getwalletinfo\n"
	"Returns an object containing various wallet state info.\n"
	"\nResult:\n"
	"{\n"
	" \"walletversion\": xxxxx, (numeric) the wallet version\n"
	" \"balance\": xxxxxxx, (numeric) the total confirmed balance of the wallet in " + CURRENCY_UNIT + "\n"
	" \"unconfirmed_balance\": xxx, (numeric) the total unconfirmed balance of the wallet in " + CURRENCY_UNIT + "\n"
	" \"immature_balance\": xxxxxx, (numeric) the total immature balance of the wallet in " + CURRENCY_UNIT + "\n"
	" \"txcount\": xxxxxxx, (numeric) the total number of transactions in the wallet\n"
	" \"keypoololdest\": xxxxxx, (numeric) the timestamp (seconds since GMT epoch) of the oldest pre-generated key in the key pool\n"
	" \"keypoolsize\": xxxx, (numeric) how many new keys are pre-generated\n"
	" \"unlocked_until\": ttt, (numeric) the timestamp in seconds since epoch (midnight Jan 1 1970 GMT) that the wallet is unlocked for transfers, or 0 if the wallet is locked\n"
	" \"paytxfee\": x.xxxx, (numeric) the transaction fee configuration, set in " + CURRENCY_UNIT + "/kB\n"
	"}\n"
	"\nExamples:\n"
	+ HelpExampleCli("getwalletinfo", "")
	+ HelpExampleRpc("getwalletinfo", "")
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	UniValue obj(UniValue::VOBJ);
	obj.push_back(Pair("walletversion", pwalletMain->GetVersion()));
	obj.push_back(Pair("balance", ValueFromAmount(pwalletMain->GetBalance())));
	obj.push_back(Pair("unconfirmed_balance", ValueFromAmount(pwalletMain->GetUnconfirmedBalance())));
	obj.push_back(Pair("immature_balance", ValueFromAmount(pwalletMain->GetImmatureBalance())));
	obj.push_back(Pair("txcount", (int)pwalletMain->mapWallet.size()));
	obj.push_back(Pair("keypoololdest", pwalletMain->GetOldestKeyPoolTime()));
	obj.push_back(Pair("keypoolsize", (int)pwalletMain->GetKeyPoolSize()));
	if (pwalletMain->IsCrypted())
	obj.push_back(Pair("unlocked_until", nWalletUnlockTime));
	obj.push_back(Pair("paytxfee", ValueFromAmount(payTxFee.GetFeePerK())));
	return obj;
	}

	UniValue resendwallettransactions(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() != 0)
	throw runtime_error(
	"resendwallettransactions\n"
	"Immediately re-broadcast unconfirmed wallet transactions to all peers.\n"
	"Intended only for testing; the wallet code periodically re-broadcasts\n"
	"automatically.\n"
	"Returns array of transaction ids that were re-broadcast.\n"
	);

	LOCK2(cs_main, pwalletMain->cs_wallet);

	std::vector<uint256> txids = pwalletMain->ResendWalletTransactionsBefore(GetTime());
	UniValue result(UniValue::VARR);
	BOOST_FOREACH(const uint256& txid, txids)
	{
	result.push_back(txid.ToString());
	}
	return result;
	}

	UniValue listunspent(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() > 3)
	throw runtime_error(
	"listunspent ( minconf maxconf [\"address\",...] )\n"
	"\nReturns array of unspent transaction outputs\n"
	"with between minconf and maxconf (inclusive) confirmations.\n"
	"Optionally filter to only include txouts paid to specified addresses.\n"
	"Results are an array of Objects, each of which has:\n"
	"{txid, vout, scriptPubKey, amount, confirmations}\n"
	"\nArguments:\n"
	"1. minconf (numeric, optional, default=1) The minimum confirmations to filter\n"
	"2. maxconf (numeric, optional, default=9999999) The maximum confirmations to filter\n"
	"3. \"addresses\" (string) A json array of bitcoin addresses to filter\n"
	" [\n"
	" \"address\" (string) bitcoin address\n"
	" ,...\n"
	" ]\n"
	"\nResult\n"
	"[ (array of json object)\n"
	" {\n"
	" \"txid\" : \"txid\", (string) the transaction id \n"
	" \"vout\" : n, (numeric) the vout value\n"
	" \"address\" : \"address\", (string) the bitcoin address\n"
	" \"account\" : \"account\", (string) DEPRECATED. The associated account, or \"\" for the default account\n"
	" \"scriptPubKey\" : \"key\", (string) the script key\n"
	" \"amount\" : x.xxx, (numeric) the transaction amount in " + CURRENCY_UNIT + "\n"
	" \"confirmations\" : n, (numeric) The number of confirmations\n"
	" \"spendable\" : xxx, (bool) Whether we have the private keys to spend this output\n"
	" \"solvable\" : xxx (bool) Whether we know how to spend this output, ignoring the lack of keys\n"
	" }\n"
	" ,...\n"
	"]\n"

	"\nExamples\n"
	+ HelpExampleCli("listunspent", "")
	+ HelpExampleCli("listunspent", "6 9999999 \"[\\\"1PGFqEzfmQch1gKD3ra4k18PNj3tTUUSqg\\\",\\\"1LtvqCaApEdUGFkpKMM4MstjcaL4dKg8SP\\\"]\"")
	+ HelpExampleRpc("listunspent", "6, 9999999 \"[\\\"1PGFqEzfmQch1gKD3ra4k18PNj3tTUUSqg\\\",\\\"1LtvqCaApEdUGFkpKMM4MstjcaL4dKg8SP\\\"]\"")
	);

	RPCTypeCheck(params, boost::assign::list_of(UniValue::VNUM)(UniValue::VNUM)(UniValue::VARR));

	int nMinDepth = 1;
	if (params.size() > 0)
	nMinDepth = params[0].get_int();

	int nMaxDepth = 9999999;
	if (params.size() > 1)
	nMaxDepth = params[1].get_int();

	set<CBitcoinAddress> setAddress;
	if (params.size() > 2) {
	UniValue inputs = params[2].get_array();
	for (unsigned int idx = 0; idx < inputs.size(); idx++) {
	const UniValue& input = inputs[idx];
	CBitcoinAddress address(input.get_str());
	if (!address.IsValid())
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, string("Invalid Bitcoin address: ")+input.get_str());
	if (setAddress.count(address))
	throw JSONRPCError(RPC_INVALID_PARAMETER, string("Invalid parameter, duplicated address: ")+input.get_str());
	setAddress.insert(address);
	}
	}

	UniValue results(UniValue::VARR);
	vector<COutput> vecOutputs;
	assert(pwalletMain != NULL);
	LOCK2(cs_main, pwalletMain->cs_wallet);
	pwalletMain->AvailableCoins(vecOutputs, false, NULL, true);
	BOOST_FOREACH(const COutput& out, vecOutputs) {
	if (out.nDepth < nMinDepth \|\| out.nDepth > nMaxDepth)
	continue;

	if (setAddress.size()) {
	CTxDestination address;
	if (!ExtractDestination(out.tx->vout[out.i].scriptPubKey, address))
	continue;

	if (!setAddress.count(address))
	continue;
	}

	CAmount nValue = out.tx->vout[out.i].nValue;
	const CScript& pk = out.tx->vout[out.i].scriptPubKey;
	UniValue entry(UniValue::VOBJ);
	entry.push_back(Pair("txid", out.tx->GetHash().GetHex()));
	entry.push_back(Pair("vout", out.i));
	CTxDestination address;
	if (ExtractDestination(out.tx->vout[out.i].scriptPubKey, address)) {
	entry.push_back(Pair("address", CBitcoinAddress(address).ToString()));
	if (pwalletMain->mapAddressBook.count(address))
	entry.push_back(Pair("account", pwalletMain->mapAddressBook[address].name));
	}
	entry.push_back(Pair("scriptPubKey", HexStr(pk.begin(), pk.end())));
	if (pk.IsPayToScriptHash()) {
	CTxDestination address;
	if (ExtractDestination(pk, address)) {
	const CScriptID& hash = boost::get<CScriptID>(address);
	CScript redeemScript;
	if (pwalletMain->GetCScript(hash, redeemScript))
	entry.push_back(Pair("redeemScript", HexStr(redeemScript.begin(), redeemScript.end())));
	}
	}
	entry.push_back(Pair("amount",ValueFromAmount(nValue)));
	entry.push_back(Pair("confirmations",out.nDepth));
	entry.push_back(Pair("spendable", out.fSpendable));
	entry.push_back(Pair("solvable", out.fSolvable));
	results.push_back(entry);
	}

	return results;
	}

	UniValue fundrawtransaction(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() < 1 \|\| params.size() > 2)
	throw runtime_error(
	"fundrawtransaction \"hexstring\" ( options )\n"
	"\nAdd inputs to a transaction until it has enough in value to meet its out value.\n"
	"This will not modify existing inputs, and will add one change output to the outputs.\n"
	"Note that inputs which were signed may need to be resigned after completion since in/outputs have been added.\n"
	"The inputs added will not be signed, use signrawtransaction for that.\n"
	"Note that all existing inputs must have their previous output transaction be in the wallet.\n"
	"Note that all inputs selected must be of standard form and P2SH scripts must be\n"
	"in the wallet using importaddress or addmultisigaddress (to calculate fees).\n"
	"You can see whether this is the case by checking the \"solvable\" field in the listunspent output.\n"
	"Only pay-to-pubkey, multisig, and P2SH versions thereof are currently supported for watch-only\n"
	"\nArguments:\n"
	"1. \"hexstring\" (string, required) The hex string of the raw transaction\n"
	"2. options (object, optional)\n"
	" {\n"
	" \"changeAddress\" (string, optional, default pool address) The bitcoin address to receive the change\n"
	" \"changePosition\" (numeric, optional, default random) The index of the change output\n"
	" \"includeWatching\" (boolean, optional, default false) Also select inputs which are watch only\n"
	" \"lockUnspents\" (boolean, optional, default false) Lock selected unspent outputs\n"
	" }\n"
	" for backward compatibility: passing in a true instead of an object will result in {\"includeWatching\":true}\n"
	"\nResult:\n"
	"{\n"
	" \"hex\": \"value\", (string) The resulting raw transaction (hex-encoded string)\n"
	" \"fee\": n, (numeric) Fee the resulting transaction pays\n"
	" \"changepos\": n (numeric) The position of the added change output, or -1\n"
	"}\n"
	"\"hex\" \n"
	"\nExamples:\n"
	"\nCreate a transaction with no inputs\n"
	+ HelpExampleCli("createrawtransaction", "\"[]\" \"{\\\"myaddress\\\":0.01}\"") +
	"\nAdd sufficient unsigned inputs to meet the output value\n"
	+ HelpExampleCli("fundrawtransaction", "\"rawtransactionhex\"") +
	"\nSign the transaction\n"
	+ HelpExampleCli("signrawtransaction", "\"fundedtransactionhex\"") +
	"\nSend the transaction\n"
	+ HelpExampleCli("sendrawtransaction", "\"signedtransactionhex\"")
	);

	RPCTypeCheck(params, boost::assign::list_of(UniValue::VSTR));

	CTxDestination changeAddress = CNoDestination();
	int changePosition = -1;
	bool includeWatching = false;
	bool lockUnspents = false;

	if (params.size() > 1) {
	if (params[1].type() == UniValue::VBOOL) {
	// backward compatibility bool only fallback
	includeWatching = params[1].get_bool();
	}
	else {
	RPCTypeCheck(params, boost::assign::list_of(UniValue::VSTR)(UniValue::VOBJ));

	UniValue options = params[1];

	RPCTypeCheckObj(options, boost::assign::map_list_of("changeAddress", UniValue::VSTR)("changePosition", UniValue::VNUM)("includeWatching", UniValue::VBOOL)("lockUnspents", UniValue::VBOOL), true, true);

	if (options.exists("changeAddress")) {
	CBitcoinAddress address(options["changeAddress"].get_str());

	if (!address.IsValid())
	throw JSONRPCError(RPC_INVALID_PARAMETER, "changeAddress must be a valid bitcoin address");

	changeAddress = address.Get();
	}

	if (options.exists("changePosition"))
	changePosition = options["changePosition"].get_int();

	if (options.exists("includeWatching"))
	includeWatching = options["includeWatching"].get_bool();

	if (options.exists("lockUnspents"))
	lockUnspents = options["lockUnspents"].get_bool();
	}
	}

	// parse hex string from parameter
	CTransaction origTx;
	if (!DecodeHexTx(origTx, params[0].get_str()))
	throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");

	if (origTx.vout.size() == 0)
	throw JSONRPCError(RPC_INVALID_PARAMETER, "TX must have at least one output");

	if (changePosition != -1 && (changePosition < 0 \|\| changePosition > origTx.vout.size()))
	throw JSONRPCError(RPC_INVALID_PARAMETER, "changePosition out of bounds");

	CMutableTransaction tx(origTx);
	CAmount nFee;
	string strFailReason;

	if(!pwalletMain->FundTransaction(tx, nFee, changePosition, strFailReason, includeWatching, lockUnspents, changeAddress))
	throw JSONRPCError(RPC_INTERNAL_ERROR, strFailReason);

	UniValue result(UniValue::VOBJ);
	result.push_back(Pair("hex", EncodeHexTx(tx)));
	result.push_back(Pair("changepos", changePosition));
	result.push_back(Pair("fee", ValueFromAmount(nFee)));

	return result;
	}

	extern UniValue dumpprivkey(const UniValue& params, bool fHelp); // in rpcdump.cpp
	extern UniValue importprivkey(const UniValue& params, bool fHelp);
	extern UniValue importaddress(const UniValue& params, bool fHelp);
	extern UniValue importpubkey(const UniValue& params, bool fHelp);
	extern UniValue dumpwallet(const UniValue& params, bool fHelp);
	extern UniValue importwallet(const UniValue& params, bool fHelp);
	extern UniValue importprunedfunds(const UniValue& params, bool fHelp);
	extern UniValue removeprunedfunds(const UniValue& params, bool fHelp);

	static const CRPCCommand commands[] =
	{ // category name actor (function) okSafeMode
	// --------------------- ------------------------ ----------------------- ----------
	{ "rawtransactions", "fundrawtransaction", &fundrawtransaction, false },
	{ "hidden", "resendwallettransactions", &resendwallettransactions, true },
	{ "wallet", "abandontransaction", &abandontransaction, false },
	{ "wallet", "addmultisigaddress", &addmultisigaddress, true },
	{ "wallet", "backupwallet", &backupwallet, true },
	{ "wallet", "dumpprivkey", &dumpprivkey, true },
	{ "wallet", "dumpwallet", &dumpwallet, true },
	{ "wallet", "encryptwallet", &encryptwallet, true },
	{ "wallet", "getaccountaddress", &getaccountaddress, true },
	{ "wallet", "getaccount", &getaccount, true },
	{ "wallet", "getaddressesbyaccount", &getaddressesbyaccount, true },
	{ "wallet", "getbalance", &getbalance, false },
	{ "wallet", "getnewaddress", &getnewaddress, true },
	{ "wallet", "getrawchangeaddress", &getrawchangeaddress, true },
	{ "wallet", "getreceivedbyaccount", &getreceivedbyaccount, false },
	{ "wallet", "getreceivedbyaddress", &getreceivedbyaddress, false },
	{ "wallet", "gettransaction", &gettransaction, false },
	{ "wallet", "getunconfirmedbalance", &getunconfirmedbalance, false },
	{ "wallet", "getwalletinfo", &getwalletinfo, false },
	{ "wallet", "importprivkey", &importprivkey, true },
	{ "wallet", "importwallet", &importwallet, true },
	{ "wallet", "importaddress", &importaddress, true },
	{ "wallet", "importprunedfunds", &importprunedfunds, true },
	{ "wallet", "importpubkey", &importpubkey, true },
	{ "wallet", "keypoolrefill", &keypoolrefill, true },
	{ "wallet", "listaccounts", &listaccounts, false },
	{ "wallet", "listaddressgroupings", &listaddressgroupings, false },
	{ "wallet", "listlockunspent", &listlockunspent, false },
	{ "wallet", "listreceivedbyaccount", &listreceivedbyaccount, false },
	{ "wallet", "listreceivedbyaddress", &listreceivedbyaddress, false },
	{ "wallet", "listsinceblock", &listsinceblock, false },
	{ "wallet", "listtransactions", &listtransactions, false },
	{ "wallet", "listunspent", &listunspent, false },
	{ "wallet", "lockunspent", &lockunspent, true },
	{ "wallet", "move", &movecmd, false },
	{ "wallet", "sendfrom", &sendfrom, false },
	{ "wallet", "sendmany", &sendmany, false },
	{ "wallet", "sendtoaddress", &sendtoaddress, false },
	{ "wallet", "setaccount", &setaccount, true },
	{ "wallet", "settxfee", &settxfee, true },
	{ "wallet", "signmessage", &signmessage, true },
	{ "wallet", "walletlock", &walletlock, true },
	{ "wallet", "walletpassphrasechange", &walletpassphrasechange, true },
	{ "wallet", "walletpassphrase", &walletpassphrase, true },
	{ "wallet", "removeprunedfunds", &removeprunedfunds, true },
	};

	void RegisterWalletRPCCommands(CRPCTable &tableRPC)
	{
	for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++)
	tableRPC.appendCommand(commands[vcidx].name, &commands[vcidx]);
	}
	diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
	index 4809e3baa6..5d1a431190 100644
	--- a/src/wallet/wallet.cpp
	+++ b/src/wallet/wallet.cpp
	@@ -1,3364 +1,3404 @@
	// 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";

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

	// Create new metadata
	int64_t nCreationTime = GetTime();
	mapKeyMetadata[pubkey.GetID()] = CKeyMetadata(nCreationTime);
	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;
	RandAddSeedPerfmon();

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

	CMasterKey kMasterKey;
	RandAddSeedPerfmon();

	kMasterKey.vchSalt.resize(WALLET_CRYPTO_SALT_SIZE);
	GetRandBytes(&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;
	}

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

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

	//Reduces the approximate best subset by removing any inputs that are smaller than the surplus of nTotal beyond nTargetValue.
	for (unsigned int i = 0; i < vValue.size(); i++)
	{
	if (vfBest[i] && (nBest - vValue[i].first) >= nTargetValue )
	{
	vfBest[i] = false;
	nBest -= vValue[i].first;
	}
	}
	}

	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, 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;
	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 (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;
	CScript& scriptSigRes = txNew.vin[nIn].scriptSig;
	if (sign)
	signSuccess = ProduceSignature(TransactionSignatureCreator(this, &txNewConst, nIn, SIGHASH_ALL), scriptPubKey, scriptSigRes);
	else
	signSuccess = ProduceSignature(DummySignatureCreator(this), scriptPubKey, scriptSigRes);

	if (!signSuccess)
	{
	strFailReason = _("Signing transaction failed");
	return false;
	}
	nIn++;
	}

	unsigned int nBytes = ::GetSerializeSize(txNew, SER_NETWORK, PROTOCOL_VERSION);

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

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

	// Limit size
	if (nBytes >= MAX_STANDARD_TX_SIZE)
	{
	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 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("-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
	RandAddSeedPerfmon();

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

	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 631f2b31ef..b2180a5a26 100644
	--- a/src/wallet/wallet.h
	+++ b/src/wallet/wallet.h
	@@ -1,945 +1,947 @@
	// 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;

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


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

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

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

	/** 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
	diff --git a/src/wallet/walletdb.cpp b/src/wallet/walletdb.cpp
	index 48579b2821..b5037c9a65 100644
	--- a/src/wallet/walletdb.cpp
	+++ b/src/wallet/walletdb.cpp
	@@ -1,1045 +1,1005 @@
	// 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/walletdb.h"

	#include "base58.h"
	#include "consensus/validation.h"
	#include "main.h" // For CheckTransaction
	#include "protocol.h"
	#include "serialize.h"
	#include "sync.h"
	#include "util.h"
	#include "utiltime.h"
	#include "wallet/wallet.h"

	#include <boost/version.hpp>
	#include <boost/filesystem.hpp>
	#include <boost/foreach.hpp>
	#include <boost/scoped_ptr.hpp>
	#include <boost/thread.hpp>

	using namespace std;

	static uint64_t nAccountingEntryNumber = 0;

	//
	// CWalletDB
	//

	bool CWalletDB::WriteName(const string& strAddress, const string& strName)
	{
	nWalletDBUpdated++;
	return Write(make_pair(string("name"), strAddress), strName);
	}

	bool CWalletDB::EraseName(const string& strAddress)
	{
	// This should only be used for sending addresses, never for receiving addresses,
	// receiving addresses must always have an address book entry if they're not change return.
	nWalletDBUpdated++;
	return Erase(make_pair(string("name"), strAddress));
	}

	bool CWalletDB::WritePurpose(const string& strAddress, const string& strPurpose)
	{
	nWalletDBUpdated++;
	return Write(make_pair(string("purpose"), strAddress), strPurpose);
	}

	bool CWalletDB::ErasePurpose(const string& strPurpose)
	{
	nWalletDBUpdated++;
	return Erase(make_pair(string("purpose"), strPurpose));
	}

	bool CWalletDB::WriteTx(const CWalletTx& wtx)
	{
	nWalletDBUpdated++;
	return Write(std::make_pair(std::string("tx"), wtx.GetHash()), wtx);
	}

	bool CWalletDB::EraseTx(uint256 hash)
	{
	nWalletDBUpdated++;
	return Erase(std::make_pair(std::string("tx"), hash));
	}

	bool CWalletDB::WriteKey(const CPubKey& vchPubKey, const CPrivKey& vchPrivKey, const CKeyMetadata& keyMeta)
	{
	nWalletDBUpdated++;

	if (!Write(std::make_pair(std::string("keymeta"), vchPubKey),
	keyMeta, false))
	return false;

	// hash pubkey/privkey to accelerate wallet load
	std::vector<unsigned char> vchKey;
	vchKey.reserve(vchPubKey.size() + vchPrivKey.size());
	vchKey.insert(vchKey.end(), vchPubKey.begin(), vchPubKey.end());
	vchKey.insert(vchKey.end(), vchPrivKey.begin(), vchPrivKey.end());

	return Write(std::make_pair(std::string("key"), vchPubKey), std::make_pair(vchPrivKey, Hash(vchKey.begin(), vchKey.end())), false);
	}

	bool CWalletDB::WriteCryptedKey(const CPubKey& vchPubKey,
	const std::vector<unsigned char>& vchCryptedSecret,
	const CKeyMetadata &keyMeta)
	{
	const bool fEraseUnencryptedKey = true;
	nWalletDBUpdated++;

	if (!Write(std::make_pair(std::string("keymeta"), vchPubKey),
	keyMeta))
	return false;

	if (!Write(std::make_pair(std::string("ckey"), vchPubKey), vchCryptedSecret, false))
	return false;
	if (fEraseUnencryptedKey)
	{
	Erase(std::make_pair(std::string("key"), vchPubKey));
	Erase(std::make_pair(std::string("wkey"), vchPubKey));
	}
	return true;
	}

	bool CWalletDB::WriteMasterKey(unsigned int nID, const CMasterKey& kMasterKey)
	{
	nWalletDBUpdated++;
	return Write(std::make_pair(std::string("mkey"), nID), kMasterKey, true);
	}

	bool CWalletDB::WriteCScript(const uint160& hash, const CScript& redeemScript)
	{
	nWalletDBUpdated++;
	return Write(std::make_pair(std::string("cscript"), hash), (const CScriptBase)(&redeemScript), false);
	}

	bool CWalletDB::WriteWatchOnly(const CScript &dest)
	{
	nWalletDBUpdated++;
	return Write(std::make_pair(std::string("watchs"), (const CScriptBase)(&dest)), '1');
	}

	bool CWalletDB::EraseWatchOnly(const CScript &dest)
	{
	nWalletDBUpdated++;
	return Erase(std::make_pair(std::string("watchs"), (const CScriptBase)(&dest)));
	}

	bool CWalletDB::WriteBestBlock(const CBlockLocator& locator)
	{
	nWalletDBUpdated++;
	Write(std::string("bestblock"), CBlockLocator()); // Write empty block locator so versions that require a merkle branch automatically rescan
	return Write(std::string("bestblock_nomerkle"), locator);
	}

	bool CWalletDB::ReadBestBlock(CBlockLocator& locator)
	{
	if (Read(std::string("bestblock"), locator) && !locator.vHave.empty()) return true;
	return Read(std::string("bestblock_nomerkle"), locator);
	}

	bool CWalletDB::WriteOrderPosNext(int64_t nOrderPosNext)
	{
	nWalletDBUpdated++;
	return Write(std::string("orderposnext"), nOrderPosNext);
	}

	bool CWalletDB::WriteDefaultKey(const CPubKey& vchPubKey)
	{
	nWalletDBUpdated++;
	return Write(std::string("defaultkey"), vchPubKey);
	}

	bool CWalletDB::ReadPool(int64_t nPool, CKeyPool& keypool)
	{
	return Read(std::make_pair(std::string("pool"), nPool), keypool);
	}

	bool CWalletDB::WritePool(int64_t nPool, const CKeyPool& keypool)
	{
	nWalletDBUpdated++;
	return Write(std::make_pair(std::string("pool"), nPool), keypool);
	}

	bool CWalletDB::ErasePool(int64_t nPool)
	{
	nWalletDBUpdated++;
	return Erase(std::make_pair(std::string("pool"), nPool));
	}

	bool CWalletDB::WriteMinVersion(int nVersion)
	{
	return Write(std::string("minversion"), nVersion);
	}

	bool CWalletDB::ReadAccount(const string& strAccount, CAccount& account)
	{
	account.SetNull();
	return Read(make_pair(string("acc"), strAccount), account);
	}

	bool CWalletDB::WriteAccount(const string& strAccount, const CAccount& account)
	{
	return Write(make_pair(string("acc"), strAccount), account);
	}

	bool CWalletDB::WriteAccountingEntry(const uint64_t nAccEntryNum, const CAccountingEntry& acentry)
	{
	return Write(std::make_pair(std::string("acentry"), std::make_pair(acentry.strAccount, nAccEntryNum)), acentry);
	}

	bool CWalletDB::WriteAccountingEntry_Backend(const CAccountingEntry& acentry)
	{
	return WriteAccountingEntry(++nAccountingEntryNumber, acentry);
	}

	CAmount CWalletDB::GetAccountCreditDebit(const string& strAccount)
	{
	list<CAccountingEntry> entries;
	ListAccountCreditDebit(strAccount, entries);

	CAmount nCreditDebit = 0;
	BOOST_FOREACH (const CAccountingEntry& entry, entries)
	nCreditDebit += entry.nCreditDebit;

	return nCreditDebit;
	}

	void CWalletDB::ListAccountCreditDebit(const string& strAccount, list<CAccountingEntry>& entries)
	{
	bool fAllAccounts = (strAccount == "*");

	Dbc* pcursor = GetCursor();
	if (!pcursor)
	throw runtime_error("CWalletDB::ListAccountCreditDebit(): cannot create DB cursor");
	unsigned int fFlags = DB_SET_RANGE;
	while (true)
	{
	// Read next record
	CDataStream ssKey(SER_DISK, CLIENT_VERSION);
	if (fFlags == DB_SET_RANGE)
	ssKey << std::make_pair(std::string("acentry"), std::make_pair((fAllAccounts ? string("") : strAccount), uint64_t(0)));
	CDataStream ssValue(SER_DISK, CLIENT_VERSION);
	int ret = ReadAtCursor(pcursor, ssKey, ssValue, fFlags);
	fFlags = DB_NEXT;
	if (ret == DB_NOTFOUND)
	break;
	else if (ret != 0)
	{
	pcursor->close();
	throw runtime_error("CWalletDB::ListAccountCreditDebit(): error scanning DB");
	}

	// Unserialize
	string strType;
	ssKey >> strType;
	if (strType != "acentry")
	break;
	CAccountingEntry acentry;
	ssKey >> acentry.strAccount;
	if (!fAllAccounts && acentry.strAccount != strAccount)
	break;

	ssValue >> acentry;
	ssKey >> acentry.nEntryNo;
	entries.push_back(acentry);
	}

	pcursor->close();
	}

	DBErrors CWalletDB::ReorderTransactions(CWallet* pwallet)
	{
	LOCK(pwallet->cs_wallet);
	// Old wallets didn't have any defined order for transactions
	// Probably a bad idea to change the output of this

	// First: get all CWalletTx and CAccountingEntry into a sorted-by-time multimap.
	typedef pair<CWalletTx, CAccountingEntry> TxPair;
	typedef multimap<int64_t, TxPair > TxItems;
	TxItems txByTime;

	for (map<uint256, CWalletTx>::iterator it = pwallet->mapWallet.begin(); it != pwallet->mapWallet.end(); ++it)
	{
	CWalletTx* wtx = &((*it).second);
	txByTime.insert(make_pair(wtx->nTimeReceived, TxPair(wtx, (CAccountingEntry*)0)));
	}
	list<CAccountingEntry> acentries;
	ListAccountCreditDebit("", acentries);
	BOOST_FOREACH(CAccountingEntry& entry, acentries)
	{
	txByTime.insert(make_pair(entry.nTime, TxPair((CWalletTx*)0, &entry)));
	}

	int64_t& nOrderPosNext = pwallet->nOrderPosNext;
	nOrderPosNext = 0;
	std::vector<int64_t> nOrderPosOffsets;
	for (TxItems::iterator it = txByTime.begin(); it != txByTime.end(); ++it)
	{
	CWalletTx const pwtx = (it).second.first;
	CAccountingEntry const pacentry = (it).second.second;
	int64_t& nOrderPos = (pwtx != 0) ? pwtx->nOrderPos : pacentry->nOrderPos;

	if (nOrderPos == -1)
	{
	nOrderPos = nOrderPosNext++;
	nOrderPosOffsets.push_back(nOrderPos);

	if (pwtx)
	{
	if (!WriteTx(*pwtx))
	return DB_LOAD_FAIL;
	}
	else
	if (!WriteAccountingEntry(pacentry->nEntryNo, *pacentry))
	return DB_LOAD_FAIL;
	}
	else
	{
	int64_t nOrderPosOff = 0;
	BOOST_FOREACH(const int64_t& nOffsetStart, nOrderPosOffsets)
	{
	if (nOrderPos >= nOffsetStart)
	++nOrderPosOff;
	}
	nOrderPos += nOrderPosOff;
	nOrderPosNext = std::max(nOrderPosNext, nOrderPos + 1);

	if (!nOrderPosOff)
	continue;

	// Since we're changing the order, write it back
	if (pwtx)
	{
	if (!WriteTx(*pwtx))
	return DB_LOAD_FAIL;
	}
	else
	if (!WriteAccountingEntry(pacentry->nEntryNo, *pacentry))
	return DB_LOAD_FAIL;
	}
	}
	WriteOrderPosNext(nOrderPosNext);

	return DB_LOAD_OK;
	}

	class CWalletScanState {
	public:
	unsigned int nKeys;
	unsigned int nCKeys;
	unsigned int nKeyMeta;
	bool fIsEncrypted;
	bool fAnyUnordered;
	int nFileVersion;
	vector<uint256> vWalletUpgrade;

	CWalletScanState() {
	nKeys = nCKeys = nKeyMeta = 0;
	fIsEncrypted = false;
	fAnyUnordered = false;
	nFileVersion = 0;
	}
	};

	bool
	ReadKeyValue(CWallet* pwallet, CDataStream& ssKey, CDataStream& ssValue,
	CWalletScanState &wss, string& strType, string& strErr)
	{
	try {
	// Unserialize
	// Taking advantage of the fact that pair serialization
	// is just the two items serialized one after the other
	ssKey >> strType;
	if (strType == "name")
	{
	string strAddress;
	ssKey >> strAddress;
	ssValue >> pwallet->mapAddressBook[CBitcoinAddress(strAddress).Get()].name;
	}
	else if (strType == "purpose")
	{
	string strAddress;
	ssKey >> strAddress;
	ssValue >> pwallet->mapAddressBook[CBitcoinAddress(strAddress).Get()].purpose;
	}
	else if (strType == "tx")
	{
	uint256 hash;
	ssKey >> hash;
	CWalletTx wtx;
	ssValue >> wtx;
	CValidationState state;
	if (!(CheckTransaction(wtx, state) && (wtx.GetHash() == hash) && state.IsValid()))
	return false;

	// Undo serialize changes in 31600
	if (31404 <= wtx.fTimeReceivedIsTxTime && wtx.fTimeReceivedIsTxTime <= 31703)
	{
	if (!ssValue.empty())
	{
	char fTmp;
	char fUnused;
	ssValue >> fTmp >> fUnused >> wtx.strFromAccount;
	strErr = strprintf("LoadWallet() upgrading tx ver=%d %d '%s' %s",
	wtx.fTimeReceivedIsTxTime, fTmp, wtx.strFromAccount, hash.ToString());
	wtx.fTimeReceivedIsTxTime = fTmp;
	}
	else
	{
	strErr = strprintf("LoadWallet() repairing tx ver=%d %s", wtx.fTimeReceivedIsTxTime, hash.ToString());
	wtx.fTimeReceivedIsTxTime = 0;
	}
	wss.vWalletUpgrade.push_back(hash);
	}

	if (wtx.nOrderPos == -1)
	wss.fAnyUnordered = true;

	pwallet->AddToWallet(wtx, true, NULL);
	}
	else if (strType == "acentry")
	{
	string strAccount;
	ssKey >> strAccount;
	uint64_t nNumber;
	ssKey >> nNumber;
	if (nNumber > nAccountingEntryNumber)
	nAccountingEntryNumber = nNumber;

	if (!wss.fAnyUnordered)
	{
	CAccountingEntry acentry;
	ssValue >> acentry;
	if (acentry.nOrderPos == -1)
	wss.fAnyUnordered = true;
	}
	}
	else if (strType == "watchs")
	{
	CScript script;
	ssKey >> (CScriptBase)(&script);
	char fYes;
	ssValue >> fYes;
	if (fYes == '1')
	pwallet->LoadWatchOnly(script);

	// Watch-only addresses have no birthday information for now,
	// so set the wallet birthday to the beginning of time.
	pwallet->nTimeFirstKey = 1;
	}
	else if (strType == "key" \|\| strType == "wkey")
	{
	CPubKey vchPubKey;
	ssKey >> vchPubKey;
	if (!vchPubKey.IsValid())
	{
	strErr = "Error reading wallet database: CPubKey corrupt";
	return false;
	}
	CKey key;
	CPrivKey pkey;
	uint256 hash;

	if (strType == "key")
	{
	wss.nKeys++;
	ssValue >> pkey;
	} else {
	CWalletKey wkey;
	ssValue >> wkey;
	pkey = wkey.vchPrivKey;
	}

	// Old wallets store keys as "key" [pubkey] => [privkey]
	// ... which was slow for wallets with lots of keys, because the public key is re-derived from the private key
	// using EC operations as a checksum.
	// Newer wallets store keys as "key"[pubkey] => [privkey][hash(pubkey,privkey)], which is much faster while
	// remaining backwards-compatible.
	try
	{
	ssValue >> hash;
	}
	catch (...) {}

	bool fSkipCheck = false;

	if (!hash.IsNull())
	{
	// hash pubkey/privkey to accelerate wallet load
	std::vector<unsigned char> vchKey;
	vchKey.reserve(vchPubKey.size() + pkey.size());
	vchKey.insert(vchKey.end(), vchPubKey.begin(), vchPubKey.end());
	vchKey.insert(vchKey.end(), pkey.begin(), pkey.end());

	if (Hash(vchKey.begin(), vchKey.end()) != hash)
	{
	strErr = "Error reading wallet database: CPubKey/CPrivKey corrupt";
	return false;
	}

	fSkipCheck = true;
	}

	if (!key.Load(pkey, vchPubKey, fSkipCheck))
	{
	strErr = "Error reading wallet database: CPrivKey corrupt";
	return false;
	}
	if (!pwallet->LoadKey(key, vchPubKey))
	{
	strErr = "Error reading wallet database: LoadKey failed";
	return false;
	}
	}
	else if (strType == "mkey")
	{
	unsigned int nID;
	ssKey >> nID;
	CMasterKey kMasterKey;
	ssValue >> kMasterKey;
	if(pwallet->mapMasterKeys.count(nID) != 0)
	{
	strErr = strprintf("Error reading wallet database: duplicate CMasterKey id %u", nID);
	return false;
	}
	pwallet->mapMasterKeys[nID] = kMasterKey;
	if (pwallet->nMasterKeyMaxID < nID)
	pwallet->nMasterKeyMaxID = nID;
	}
	else if (strType == "ckey")
	{
	CPubKey vchPubKey;
	ssKey >> vchPubKey;
	if (!vchPubKey.IsValid())
	{
	strErr = "Error reading wallet database: CPubKey corrupt";
	return false;
	}
	vector<unsigned char> vchPrivKey;
	ssValue >> vchPrivKey;
	wss.nCKeys++;

	if (!pwallet->LoadCryptedKey(vchPubKey, vchPrivKey))
	{
	strErr = "Error reading wallet database: LoadCryptedKey failed";
	return false;
	}
	wss.fIsEncrypted = true;
	}
	else if (strType == "keymeta")
	{
	CPubKey vchPubKey;
	ssKey >> vchPubKey;
	CKeyMetadata keyMeta;
	ssValue >> keyMeta;
	wss.nKeyMeta++;

	pwallet->LoadKeyMetadata(vchPubKey, keyMeta);

	// find earliest key creation time, as wallet birthday
	if (!pwallet->nTimeFirstKey \|\|
	(keyMeta.nCreateTime < pwallet->nTimeFirstKey))
	pwallet->nTimeFirstKey = keyMeta.nCreateTime;
	}
	else if (strType == "defaultkey")
	{
	ssValue >> pwallet->vchDefaultKey;
	}
	else if (strType == "pool")
	{
	int64_t nIndex;
	ssKey >> nIndex;
	CKeyPool keypool;
	ssValue >> keypool;
	pwallet->setKeyPool.insert(nIndex);

	// If no metadata exists yet, create a default with the pool key's
	// creation time. Note that this may be overwritten by actually
	// stored metadata for that key later, which is fine.
	CKeyID keyid = keypool.vchPubKey.GetID();
	if (pwallet->mapKeyMetadata.count(keyid) == 0)
	pwallet->mapKeyMetadata[keyid] = CKeyMetadata(keypool.nTime);
	}
	else if (strType == "version")
	{
	ssValue >> wss.nFileVersion;
	if (wss.nFileVersion == 10300)
	wss.nFileVersion = 300;
	}
	else if (strType == "cscript")
	{
	uint160 hash;
	ssKey >> hash;
	CScript script;
	ssValue >> (CScriptBase)(&script);
	if (!pwallet->LoadCScript(script))
	{
	strErr = "Error reading wallet database: LoadCScript failed";
	return false;
	}
	}
	else if (strType == "orderposnext")
	{
	ssValue >> pwallet->nOrderPosNext;
	}
	else if (strType == "destdata")
	{
	std::string strAddress, strKey, strValue;
	ssKey >> strAddress;
	ssKey >> strKey;
	ssValue >> strValue;
	if (!pwallet->LoadDestData(CBitcoinAddress(strAddress).Get(), strKey, strValue))
	{
	strErr = "Error reading wallet database: LoadDestData failed";
	return false;
	}
	}
	} catch (...)
	{
	return false;
	}
	return true;
	}

	static bool IsKeyType(string strType)
	{
	return (strType== "key" \|\| strType == "wkey" \|\|
	strType == "mkey" \|\| strType == "ckey");
	}

	DBErrors CWalletDB::LoadWallet(CWallet* pwallet)
	{
	pwallet->vchDefaultKey = CPubKey();
	CWalletScanState wss;
	bool fNoncriticalErrors = false;
	DBErrors result = DB_LOAD_OK;

	try {
	LOCK(pwallet->cs_wallet);
	int nMinVersion = 0;
	if (Read((string)"minversion", nMinVersion))
	{
	if (nMinVersion > CLIENT_VERSION)
	return DB_TOO_NEW;
	pwallet->LoadMinVersion(nMinVersion);
	}

	// Get cursor
	Dbc* pcursor = GetCursor();
	if (!pcursor)
	{
	LogPrintf("Error getting wallet database cursor\n");
	return DB_CORRUPT;
	}

	while (true)
	{
	// Read next record
	CDataStream ssKey(SER_DISK, CLIENT_VERSION);
	CDataStream ssValue(SER_DISK, CLIENT_VERSION);
	int ret = ReadAtCursor(pcursor, ssKey, ssValue);
	if (ret == DB_NOTFOUND)
	break;
	else if (ret != 0)
	{
	LogPrintf("Error reading next record from wallet database\n");
	return DB_CORRUPT;
	}

	// Try to be tolerant of single corrupt records:
	string strType, strErr;
	if (!ReadKeyValue(pwallet, ssKey, ssValue, wss, strType, strErr))
	{
	// losing keys is considered a catastrophic error, anything else
	// we assume the user can live with:
	if (IsKeyType(strType))
	result = DB_CORRUPT;
	else
	{
	// Leave other errors alone, if we try to fix them we might make things worse.
	fNoncriticalErrors = true; // ... but do warn the user there is something wrong.
	if (strType == "tx")
	// Rescan if there is a bad transaction record:
	SoftSetBoolArg("-rescan", true);
	}
	}
	if (!strErr.empty())
	LogPrintf("%s\n", strErr);
	}
	pcursor->close();
	}
	catch (const boost::thread_interrupted&) {
	throw;
	}
	catch (...) {
	result = DB_CORRUPT;
	}

	if (fNoncriticalErrors && result == DB_LOAD_OK)
	result = DB_NONCRITICAL_ERROR;

	// Any wallet corruption at all: skip any rewriting or
	// upgrading, we don't want to make it worse.
	if (result != DB_LOAD_OK)
	return result;

	LogPrintf("nFileVersion = %d\n", wss.nFileVersion);

	LogPrintf("Keys: %u plaintext, %u encrypted, %u w/ metadata, %u total\n",
	wss.nKeys, wss.nCKeys, wss.nKeyMeta, wss.nKeys + wss.nCKeys);

	// nTimeFirstKey is only reliable if all keys have metadata
	if ((wss.nKeys + wss.nCKeys) != wss.nKeyMeta)
	pwallet->nTimeFirstKey = 1; // 0 would be considered 'no value'

	BOOST_FOREACH(uint256 hash, wss.vWalletUpgrade)
	WriteTx(pwallet->mapWallet[hash]);

	// Rewrite encrypted wallets of versions 0.4.0 and 0.5.0rc:
	if (wss.fIsEncrypted && (wss.nFileVersion == 40000 \|\| wss.nFileVersion == 50000))
	return DB_NEED_REWRITE;

	if (wss.nFileVersion < CLIENT_VERSION) // Update
	WriteVersion(CLIENT_VERSION);

	if (wss.fAnyUnordered)
	result = ReorderTransactions(pwallet);

	pwallet->laccentries.clear();
	ListAccountCreditDebit("*", pwallet->laccentries);
	BOOST_FOREACH(CAccountingEntry& entry, pwallet->laccentries) {
	pwallet->wtxOrdered.insert(make_pair(entry.nOrderPos, CWallet::TxPair((CWalletTx*)0, &entry)));
	}

	return result;
	}

	DBErrors CWalletDB::FindWalletTx(CWallet* pwallet, vector<uint256>& vTxHash, vector<CWalletTx>& vWtx)
	{
	pwallet->vchDefaultKey = CPubKey();
	bool fNoncriticalErrors = false;
	DBErrors result = DB_LOAD_OK;

	try {
	LOCK(pwallet->cs_wallet);
	int nMinVersion = 0;
	if (Read((string)"minversion", nMinVersion))
	{
	if (nMinVersion > CLIENT_VERSION)
	return DB_TOO_NEW;
	pwallet->LoadMinVersion(nMinVersion);
	}

	// Get cursor
	Dbc* pcursor = GetCursor();
	if (!pcursor)
	{
	LogPrintf("Error getting wallet database cursor\n");
	return DB_CORRUPT;
	}

	while (true)
	{
	// Read next record
	CDataStream ssKey(SER_DISK, CLIENT_VERSION);
	CDataStream ssValue(SER_DISK, CLIENT_VERSION);
	int ret = ReadAtCursor(pcursor, ssKey, ssValue);
	if (ret == DB_NOTFOUND)
	break;
	else if (ret != 0)
	{
	LogPrintf("Error reading next record from wallet database\n");
	return DB_CORRUPT;
	}

	string strType;
	ssKey >> strType;
	if (strType == "tx") {
	uint256 hash;
	ssKey >> hash;

	CWalletTx wtx;
	ssValue >> wtx;

	vTxHash.push_back(hash);
	vWtx.push_back(wtx);
	}
	}
	pcursor->close();
	}
	catch (const boost::thread_interrupted&) {
	throw;
	}
	catch (...) {
	result = DB_CORRUPT;
	}

	if (fNoncriticalErrors && result == DB_LOAD_OK)
	result = DB_NONCRITICAL_ERROR;

	return result;
	}

	DBErrors CWalletDB::ZapSelectTx(CWallet* pwallet, vector<uint256>& vTxHashIn, vector<uint256>& vTxHashOut)
	{
	// build list of wallet TXs and hashes
	vector<uint256> vTxHash;
	vector<CWalletTx> vWtx;
	DBErrors err = FindWalletTx(pwallet, vTxHash, vWtx);
	if (err != DB_LOAD_OK) {
	return err;
	}

	std::sort(vTxHash.begin(), vTxHash.end());
	std::sort(vTxHashIn.begin(), vTxHashIn.end());

	// erase each matching wallet TX
	bool delerror = false;
	vector<uint256>::iterator it = vTxHashIn.begin();
	BOOST_FOREACH (uint256 hash, vTxHash) {
	while (it < vTxHashIn.end() && (*it) < hash) {
	it++;
	}
	if (it == vTxHashIn.end()) {
	break;
	}
	else if ((*it) == hash) {
	pwallet->mapWallet.erase(hash);
	if(!EraseTx(hash)) {
	LogPrint("db", "Transaction was found for deletion but returned database error: %s\n", hash.GetHex());
	delerror = true;
	}
	vTxHashOut.push_back(hash);
	}
	}

	if (delerror) {
	return DB_CORRUPT;
	}
	return DB_LOAD_OK;
	}

	DBErrors CWalletDB::ZapWalletTx(CWallet* pwallet, vector<CWalletTx>& vWtx)
	{
	// build list of wallet TXs
	vector<uint256> vTxHash;
	DBErrors err = FindWalletTx(pwallet, vTxHash, vWtx);
	if (err != DB_LOAD_OK)
	return err;

	// erase each wallet TX
	BOOST_FOREACH (uint256& hash, vTxHash) {
	if (!EraseTx(hash))
	return DB_CORRUPT;
	}

	return DB_LOAD_OK;
	}

	void ThreadFlushWalletDB(const string& strFile)
	{
	// Make this thread recognisable as the wallet flushing thread
	RenameThread("bitcoin-wallet");

	static bool fOneThread;
	if (fOneThread)
	return;
	fOneThread = true;
	if (!GetBoolArg("-flushwallet", DEFAULT_FLUSHWALLET))
	return;

	unsigned int nLastSeen = nWalletDBUpdated;
	unsigned int nLastFlushed = nWalletDBUpdated;
	int64_t nLastWalletUpdate = GetTime();
	while (true)
	{
	MilliSleep(500);

	if (nLastSeen != nWalletDBUpdated)
	{
	nLastSeen = nWalletDBUpdated;
	nLastWalletUpdate = GetTime();
	}

	if (nLastFlushed != nWalletDBUpdated && GetTime() - nLastWalletUpdate >= 2)
	{
	TRY_LOCK(bitdb.cs_db,lockDb);
	if (lockDb)
	{
	// Don't do this if any databases are in use
	int nRefCount = 0;
	map<string, int>::iterator mi = bitdb.mapFileUseCount.begin();
	while (mi != bitdb.mapFileUseCount.end())
	{
	nRefCount += (*mi).second;
	mi++;
	}

	if (nRefCount == 0)
	{
	boost::this_thread::interruption_point();
	map<string, int>::iterator mi = bitdb.mapFileUseCount.find(strFile);
	if (mi != bitdb.mapFileUseCount.end())
	{
	LogPrint("db", "Flushing %s\n", strFile);
	nLastFlushed = nWalletDBUpdated;
	int64_t nStart = GetTimeMillis();

	// Flush wallet file so it's self contained
	bitdb.CloseDb(strFile);
	bitdb.CheckpointLSN(strFile);

	bitdb.mapFileUseCount.erase(mi++);
	LogPrint("db", "Flushed %s %dms\n", strFile, GetTimeMillis() - nStart);
	}
	}
	}
	}
	}
	}

	-bool BackupWallet(const CWallet& wallet, const string& strDest)
	-{
	- if (!wallet.fFileBacked)
	- return false;
	- while (true)
	- {
	- {
	- LOCK(bitdb.cs_db);
	- if (!bitdb.mapFileUseCount.count(wallet.strWalletFile) \|\| bitdb.mapFileUseCount[wallet.strWalletFile] == 0)
	- {
	- // Flush log data to the dat file
	- bitdb.CloseDb(wallet.strWalletFile);
	- bitdb.CheckpointLSN(wallet.strWalletFile);
	- bitdb.mapFileUseCount.erase(wallet.strWalletFile);
	-
	- // Copy wallet file
	- boost::filesystem::path pathSrc = GetDataDir() / wallet.strWalletFile;
	- boost::filesystem::path pathDest(strDest);
	- if (boost::filesystem::is_directory(pathDest))
	- pathDest /= wallet.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", wallet.strWalletFile, pathDest.string());
	- return true;
	- } catch (const boost::filesystem::filesystem_error& e) {
	- LogPrintf("error copying %s to %s - %s\n", wallet.strWalletFile, pathDest.string(), e.what());
	- return false;
	- }
	- }
	- }
	- MilliSleep(100);
	- }
	- return false;
	-}
	-
	//
	// Try to (very carefully!) recover wallet file if there is a problem.
	//
	bool CWalletDB::Recover(CDBEnv& dbenv, const std::string& filename, bool fOnlyKeys)
	{
	// Recovery procedure:
	// move wallet file to wallet.timestamp.bak
	// Call Salvage with fAggressive=true to
	// get as much data as possible.
	// Rewrite salvaged data to fresh wallet file
	// Set -rescan so any missing transactions will be
	// found.
	int64_t now = GetTime();
	std::string newFilename = strprintf("wallet.%d.bak", now);

	int result = dbenv.dbenv->dbrename(NULL, filename.c_str(), NULL,
	newFilename.c_str(), DB_AUTO_COMMIT);
	if (result == 0)
	LogPrintf("Renamed %s to %s\n", filename, newFilename);
	else
	{
	LogPrintf("Failed to rename %s to %s\n", filename, newFilename);
	return false;
	}

	std::vector<CDBEnv::KeyValPair> salvagedData;
	bool fSuccess = dbenv.Salvage(newFilename, true, salvagedData);
	if (salvagedData.empty())
	{
	LogPrintf("Salvage(aggressive) found no records in %s.\n", newFilename);
	return false;
	}
	LogPrintf("Salvage(aggressive) found %u records\n", salvagedData.size());

	boost::scoped_ptr<Db> pdbCopy(new Db(dbenv.dbenv, 0));
	int ret = pdbCopy->open(NULL, // Txn pointer
	filename.c_str(), // Filename
	"main", // Logical db name
	DB_BTREE, // Database type
	DB_CREATE, // Flags
	0);
	if (ret > 0)
	{
	LogPrintf("Cannot create database file %s\n", filename);
	return false;
	}
	CWallet dummyWallet;
	CWalletScanState wss;

	DbTxn* ptxn = dbenv.TxnBegin();
	BOOST_FOREACH(CDBEnv::KeyValPair& row, salvagedData)
	{
	if (fOnlyKeys)
	{
	CDataStream ssKey(row.first, SER_DISK, CLIENT_VERSION);
	CDataStream ssValue(row.second, SER_DISK, CLIENT_VERSION);
	string strType, strErr;
	bool fReadOK;
	{
	// Required in LoadKeyMetadata():
	LOCK(dummyWallet.cs_wallet);
	fReadOK = ReadKeyValue(&dummyWallet, ssKey, ssValue,
	wss, strType, strErr);
	}
	if (!IsKeyType(strType))
	continue;
	if (!fReadOK)
	{
	LogPrintf("WARNING: CWalletDB::Recover skipping %s: %s\n", strType, strErr);
	continue;
	}
	}
	Dbt datKey(&row.first[0], row.first.size());
	Dbt datValue(&row.second[0], row.second.size());
	int ret2 = pdbCopy->put(ptxn, &datKey, &datValue, DB_NOOVERWRITE);
	if (ret2 > 0)
	fSuccess = false;
	}
	ptxn->commit(0);
	pdbCopy->close(0);

	return fSuccess;
	}

	bool CWalletDB::Recover(CDBEnv& dbenv, const std::string& filename)
	{
	return CWalletDB::Recover(dbenv, filename, false);
	}

	bool CWalletDB::WriteDestData(const std::string &address, const std::string &key, const std::string &value)
	{
	nWalletDBUpdated++;
	return Write(std::make_pair(std::string("destdata"), std::make_pair(address, key)), value);
	}

	bool CWalletDB::EraseDestData(const std::string &address, const std::string &key)
	{
	nWalletDBUpdated++;
	return Erase(std::make_pair(std::string("destdata"), std::make_pair(address, key)));
	}
	diff --git a/src/wallet/walletdb.h b/src/wallet/walletdb.h
	index 5345c0907e..00c10ea70f 100644
	--- a/src/wallet/walletdb.h
	+++ b/src/wallet/walletdb.h
	@@ -1,147 +1,146 @@
	// 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_WALLETDB_H
	#define BITCOIN_WALLET_WALLETDB_H

	#include "amount.h"
	#include "wallet/db.h"
	#include "key.h"

	#include <list>
	#include <stdint.h>
	#include <string>
	#include <utility>
	#include <vector>

	static const bool DEFAULT_FLUSHWALLET = true;

	class CAccount;
	class CAccountingEntry;
	struct CBlockLocator;
	class CKeyPool;
	class CMasterKey;
	class CScript;
	class CWallet;
	class CWalletTx;
	class uint160;
	class uint256;

	/** Error statuses for the wallet database */
	enum DBErrors
	{
	DB_LOAD_OK,
	DB_CORRUPT,
	DB_NONCRITICAL_ERROR,
	DB_TOO_NEW,
	DB_LOAD_FAIL,
	DB_NEED_REWRITE
	};

	class CKeyMetadata
	{
	public:
	static const int CURRENT_VERSION=1;
	int nVersion;
	int64_t nCreateTime; // 0 means unknown

	CKeyMetadata()
	{
	SetNull();
	}
	CKeyMetadata(int64_t nCreateTime_)
	{
	nVersion = CKeyMetadata::CURRENT_VERSION;
	nCreateTime = nCreateTime_;
	}

	ADD_SERIALIZE_METHODS;

	template <typename Stream, typename Operation>
	inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
	READWRITE(this->nVersion);
	nVersion = this->nVersion;
	READWRITE(nCreateTime);
	}

	void SetNull()
	{
	nVersion = CKeyMetadata::CURRENT_VERSION;
	nCreateTime = 0;
	}
	};

	/** Access to the wallet database */
	class CWalletDB : public CDB
	{
	public:
	CWalletDB(const std::string& strFilename, const char* pszMode = "r+", bool fFlushOnClose = true) : CDB(strFilename, pszMode, fFlushOnClose)
	{
	}

	bool WriteName(const std::string& strAddress, const std::string& strName);
	bool EraseName(const std::string& strAddress);

	bool WritePurpose(const std::string& strAddress, const std::string& purpose);
	bool ErasePurpose(const std::string& strAddress);

	bool WriteTx(const CWalletTx& wtx);
	bool EraseTx(uint256 hash);

	bool WriteKey(const CPubKey& vchPubKey, const CPrivKey& vchPrivKey, const CKeyMetadata &keyMeta);
	bool WriteCryptedKey(const CPubKey& vchPubKey, const std::vector<unsigned char>& vchCryptedSecret, const CKeyMetadata &keyMeta);
	bool WriteMasterKey(unsigned int nID, const CMasterKey& kMasterKey);

	bool WriteCScript(const uint160& hash, const CScript& redeemScript);

	bool WriteWatchOnly(const CScript &script);
	bool EraseWatchOnly(const CScript &script);

	bool WriteBestBlock(const CBlockLocator& locator);
	bool ReadBestBlock(CBlockLocator& locator);

	bool WriteOrderPosNext(int64_t nOrderPosNext);

	bool WriteDefaultKey(const CPubKey& vchPubKey);

	bool ReadPool(int64_t nPool, CKeyPool& keypool);
	bool WritePool(int64_t nPool, const CKeyPool& keypool);
	bool ErasePool(int64_t nPool);

	bool WriteMinVersion(int nVersion);

	/// This writes directly to the database, and will not update the CWallet's cached accounting entries!
	/// Use wallet.AddAccountingEntry instead, to write and update its caches.
	bool WriteAccountingEntry_Backend(const CAccountingEntry& acentry);
	bool ReadAccount(const std::string& strAccount, CAccount& account);
	bool WriteAccount(const std::string& strAccount, const CAccount& account);

	/// Write destination data key,value tuple to database
	bool WriteDestData(const std::string &address, const std::string &key, const std::string &value);
	/// Erase destination data tuple from wallet database
	bool EraseDestData(const std::string &address, const std::string &key);

	CAmount GetAccountCreditDebit(const std::string& strAccount);
	void ListAccountCreditDebit(const std::string& strAccount, std::list<CAccountingEntry>& acentries);

	DBErrors ReorderTransactions(CWallet* pwallet);
	DBErrors LoadWallet(CWallet* pwallet);
	DBErrors FindWalletTx(CWallet* pwallet, std::vector<uint256>& vTxHash, std::vector<CWalletTx>& vWtx);
	DBErrors ZapWalletTx(CWallet* pwallet, std::vector<CWalletTx>& vWtx);
	DBErrors ZapSelectTx(CWallet* pwallet, std::vector<uint256>& vHashIn, std::vector<uint256>& vHashOut);
	static bool Recover(CDBEnv& dbenv, const std::string& filename, bool fOnlyKeys);
	static bool Recover(CDBEnv& dbenv, const std::string& filename);

	private:
	CWalletDB(const CWalletDB&);
	void operator=(const CWalletDB&);

	bool WriteAccountingEntry(const uint64_t nAccEntryNum, const CAccountingEntry& acentry);
	};

	-bool BackupWallet(const CWallet& wallet, const std::string& strDest);
	void ThreadFlushWalletDB(const std::string& strFile);

	#endif // BITCOIN_WALLET_WALLETDB_H

File Metadata

Mime Type: text/x-diff
Expires: Sun, Mar 2, 10:12 (1 d, 4 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5187307
Default Alt Text: (331 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions