No OneTemporary
Actions

Size

297 KB

Subscribers

None

View Options

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

	diff --git a/src/amount.cpp b/src/amount.cpp
	index 0a394c96fc..b469181984 100644
	--- a/src/amount.cpp
	+++ b/src/amount.cpp
	@@ -1,31 +1,33 @@
	// Copyright (c) 2009-2010 Satoshi Nakamoto
	// Copyright (c) 2009-2014 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 "tinyformat.h"

	+const std::string CURRENCY_UNIT = "BTC";
	+
	CFeeRate::CFeeRate(const CAmount& nFeePaid, size_t nSize)
	{
	if (nSize > 0)
	nSatoshisPerK = nFeePaid*1000/nSize;
	else
	nSatoshisPerK = 0;
	}

	CAmount CFeeRate::GetFee(size_t nSize) const
	{
	CAmount nFee = nSatoshisPerK*nSize / 1000;

	if (nFee == 0 && nSatoshisPerK > 0)
	nFee = nSatoshisPerK;

	return nFee;
	}

	std::string CFeeRate::ToString() const
	{
	- return strprintf("%d.%08d BTC/kB", nSatoshisPerK / COIN, nSatoshisPerK % COIN);
	+ return strprintf("%d.%08d %s/kB", nSatoshisPerK / COIN, nSatoshisPerK % COIN, CURRENCY_UNIT);
	}
	diff --git a/src/amount.h b/src/amount.h
	index 7dc62edac4..90e6b5aa8e 100644
	--- a/src/amount.h
	+++ b/src/amount.h
	@@ -1,62 +1,64 @@
	// Copyright (c) 2009-2010 Satoshi Nakamoto
	// Copyright (c) 2009-2014 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_AMOUNT_H
	#define BITCOIN_AMOUNT_H

	#include "serialize.h"

	#include <stdlib.h>
	#include <string>

	typedef int64_t CAmount;

	static const CAmount COIN = 100000000;
	static const CAmount CENT = 1000000;

	+extern const std::string CURRENCY_UNIT;
	+
	/** No amount larger than this (in satoshi) is valid.
	*
	* Note that this constant is not the total money supply, which in Bitcoin
	* currently happens to be less than 21,000,000 BTC for various reasons, but
	* rather a sanity check. As this sanity check is used by consensus-critical
	* validation code, the exact value of the MAX_MONEY constant is consensus
	* critical; in unusual circumstances like a(nother) overflow bug that allowed
	* for the creation of coins out of thin air modification could lead to a fork.
	* */
	static const CAmount MAX_MONEY = 21000000 * COIN;
	inline bool MoneyRange(const CAmount& nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }

	/** Type-safe wrapper class to for fee rates
	* (how much to pay based on transaction size)
	*/
	class CFeeRate
	{
	private:
	CAmount nSatoshisPerK; // unit is satoshis-per-1,000-bytes
	public:
	CFeeRate() : nSatoshisPerK(0) { }
	explicit CFeeRate(const CAmount& _nSatoshisPerK): nSatoshisPerK(_nSatoshisPerK) { }
	CFeeRate(const CAmount& nFeePaid, size_t nSize);
	CFeeRate(const CFeeRate& other) { nSatoshisPerK = other.nSatoshisPerK; }

	CAmount GetFee(size_t size) const; // unit returned is satoshis
	CAmount GetFeePerK() const { return GetFee(1000); } // satoshis-per-1000-bytes

	friend bool operator<(const CFeeRate& a, const CFeeRate& b) { return a.nSatoshisPerK < b.nSatoshisPerK; }
	friend bool operator>(const CFeeRate& a, const CFeeRate& b) { return a.nSatoshisPerK > b.nSatoshisPerK; }
	friend bool operator==(const CFeeRate& a, const CFeeRate& b) { return a.nSatoshisPerK == b.nSatoshisPerK; }
	friend bool operator<=(const CFeeRate& a, const CFeeRate& b) { return a.nSatoshisPerK <= b.nSatoshisPerK; }
	friend bool operator>=(const CFeeRate& a, const CFeeRate& b) { return a.nSatoshisPerK >= b.nSatoshisPerK; }
	std::string ToString() const;

	ADD_SERIALIZE_METHODS;

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

	#endif // BITCOIN_AMOUNT_H
	diff --git a/src/init.cpp b/src/init.cpp
	index 6bea42a20e..9d43a58fe0 100644
	--- a/src/init.cpp
	+++ b/src/init.cpp
	@@ -1,1518 +1,1520 @@
	// Copyright (c) 2009-2010 Satoshi Nakamoto
	// Copyright (c) 2009-2014 The Bitcoin Core developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#if defined(HAVE_CONFIG_H)
	#include "config/bitcoin-config.h"
	#endif

	#include "init.h"

	#include "addrman.h"
	#include "amount.h"
	#include "chain.h"
	#include "chainparams.h"
	#include "checkpoints.h"
	#include "compat/sanity.h"
	#include "consensus/validation.h"
	#include "key.h"
	#include "main.h"
	#include "miner.h"
	#include "net.h"
	#include "policy/policy.h"
	#include "rpcserver.h"
	#include "script/standard.h"
	#include "scheduler.h"
	#include "txdb.h"
	#include "txmempool.h"
	#include "ui_interface.h"
	#include "util.h"
	#include "utilmoneystr.h"
	#include "utilstrencodings.h"
	#include "validationinterface.h"
	#ifdef ENABLE_WALLET
	#include "wallet/db.h"
	#include "wallet/wallet.h"
	#include "wallet/walletdb.h"
	#endif

	#include <stdint.h>
	#include <stdio.h>

	#ifndef WIN32
	#include <signal.h>
	#endif

	#include <boost/algorithm/string/predicate.hpp>
	#include <boost/algorithm/string/replace.hpp>
	#include <boost/bind.hpp>
	#include <boost/filesystem.hpp>
	#include <boost/function.hpp>
	#include <boost/interprocess/sync/file_lock.hpp>
	#include <boost/thread.hpp>
	#include <openssl/crypto.h>

	using namespace std;

	#ifdef ENABLE_WALLET
	CWallet* pwalletMain = NULL;
	#endif
	bool fFeeEstimatesInitialized = false;

	#ifdef WIN32
	// Win32 LevelDB doesn't use filedescriptors, and the ones used for
	// accessing block files don't count towards the fd_set size limit
	// anyway.
	#define MIN_CORE_FILEDESCRIPTORS 0
	#else
	#define MIN_CORE_FILEDESCRIPTORS 150
	#endif

	/** Used to pass flags to the Bind() function */
	enum BindFlags {
	BF_NONE = 0,
	BF_EXPLICIT = (1U << 0),
	BF_REPORT_ERROR = (1U << 1),
	BF_WHITELIST = (1U << 2),
	};

	static const char* FEE_ESTIMATES_FILENAME="fee_estimates.dat";
	CClientUIInterface uiInterface; // Declared but not defined in ui_interface.h

	//////////////////////////////////////////////////////////////////////////////
	//
	// Shutdown
	//

	//
	// Thread management and startup/shutdown:
	//
	// The network-processing threads are all part of a thread group
	// created by AppInit() or the Qt main() function.
	//
	// A clean exit happens when StartShutdown() or the SIGTERM
	// signal handler sets fRequestShutdown, which triggers
	// the DetectShutdownThread(), which interrupts the main thread group.
	// DetectShutdownThread() then exits, which causes AppInit() to
	// continue (it .joins the shutdown thread).
	// Shutdown() is then
	// called to clean up database connections, and stop other
	// threads that should only be stopped after the main network-processing
	// threads have exited.
	//
	// Note that if running -daemon the parent process returns from AppInit2
	// before adding any threads to the threadGroup, so .join_all() returns
	// immediately and the parent exits from main().
	//
	// Shutdown for Qt is very similar, only it uses a QTimer to detect
	// fRequestShutdown getting set, and then does the normal Qt
	// shutdown thing.
	//

	volatile bool fRequestShutdown = false;

	void StartShutdown()
	{
	fRequestShutdown = true;
	}
	bool ShutdownRequested()
	{
	return fRequestShutdown;
	}

	class CCoinsViewErrorCatcher : public CCoinsViewBacked
	{
	public:
	CCoinsViewErrorCatcher(CCoinsView* view) : CCoinsViewBacked(view) {}
	bool GetCoins(const uint256 &txid, CCoins &coins) const {
	try {
	return CCoinsViewBacked::GetCoins(txid, coins);
	} catch(const std::runtime_error& e) {
	uiInterface.ThreadSafeMessageBox(_("Error reading from database, shutting down."), "", CClientUIInterface::MSG_ERROR);
	LogPrintf("Error reading from database: %s\n", e.what());
	// Starting the shutdown sequence and returning false to the caller would be
	// interpreted as 'entry not found' (as opposed to unable to read data), and
	// could lead to invalid interpretation. Just exit immediately, as we can't
	// continue anyway, and all writes should be atomic.
	abort();
	}
	}
	// Writes do not need similar protection, as failure to write is handled by the caller.
	};

	static CCoinsViewDB *pcoinsdbview = NULL;
	static CCoinsViewErrorCatcher *pcoinscatcher = NULL;

	void Shutdown()
	{
	LogPrintf("%s: In progress...\n", __func__);
	static CCriticalSection cs_Shutdown;
	TRY_LOCK(cs_Shutdown, lockShutdown);
	if (!lockShutdown)
	return;

	/// Note: Shutdown() must be able to handle cases in which AppInit2() failed part of the way,
	/// for example if the data directory was found to be locked.
	/// Be sure that anything that writes files or flushes caches only does this if the respective
	/// module was initialized.
	RenameThread("bitcoin-shutoff");
	mempool.AddTransactionsUpdated(1);
	StopRPCThreads();
	#ifdef ENABLE_WALLET
	if (pwalletMain)
	pwalletMain->Flush(false);
	#endif
	GenerateBitcoins(false, 0, Params());
	StopNode();
	UnregisterNodeSignals(GetNodeSignals());

	if (fFeeEstimatesInitialized)
	{
	boost::filesystem::path est_path = GetDataDir() / FEE_ESTIMATES_FILENAME;
	CAutoFile est_fileout(fopen(est_path.string().c_str(), "wb"), SER_DISK, CLIENT_VERSION);
	if (!est_fileout.IsNull())
	mempool.WriteFeeEstimates(est_fileout);
	else
	LogPrintf("%s: Failed to write fee estimates to %s\n", __func__, est_path.string());
	fFeeEstimatesInitialized = false;
	}

	{
	LOCK(cs_main);
	if (pcoinsTip != NULL) {
	FlushStateToDisk();
	}
	delete pcoinsTip;
	pcoinsTip = NULL;
	delete pcoinscatcher;
	pcoinscatcher = NULL;
	delete pcoinsdbview;
	pcoinsdbview = NULL;
	delete pblocktree;
	pblocktree = NULL;
	}
	#ifdef ENABLE_WALLET
	if (pwalletMain)
	pwalletMain->Flush(true);
	#endif
	#ifndef WIN32
	try {
	boost::filesystem::remove(GetPidFile());
	} catch (const boost::filesystem::filesystem_error& e) {
	LogPrintf("%s: Unable to remove pidfile: %s\n", __func__, e.what());
	}
	#endif
	UnregisterAllValidationInterfaces();
	#ifdef ENABLE_WALLET
	delete pwalletMain;
	pwalletMain = NULL;
	#endif
	ECC_Stop();
	LogPrintf("%s: done\n", __func__);
	}

	/**
	* Signal handlers are very limited in what they are allowed to do, so:
	*/
	void HandleSIGTERM(int)
	{
	fRequestShutdown = true;
	}

	void HandleSIGHUP(int)
	{
	fReopenDebugLog = true;
	}

	bool static InitError(const std::string &str)
	{
	uiInterface.ThreadSafeMessageBox(str, "", CClientUIInterface::MSG_ERROR);
	return false;
	}

	bool static InitWarning(const std::string &str)
	{
	uiInterface.ThreadSafeMessageBox(str, "", CClientUIInterface::MSG_WARNING);
	return true;
	}

	bool static Bind(const CService &addr, unsigned int flags) {
	if (!(flags & BF_EXPLICIT) && IsLimited(addr))
	return false;
	std::string strError;
	if (!BindListenPort(addr, strError, (flags & BF_WHITELIST) != 0)) {
	if (flags & BF_REPORT_ERROR)
	return InitError(strError);
	return false;
	}
	return true;
	}

	void OnRPCStopped()
	{
	cvBlockChange.notify_all();
	LogPrint("rpc", "RPC stopped.\n");
	}

	void OnRPCPreCommand(const CRPCCommand& cmd)
	{
	// Observe safe mode
	string strWarning = GetWarnings("rpc");
	if (strWarning != "" && !GetBoolArg("-disablesafemode", false) &&
	!cmd.okSafeMode)
	throw JSONRPCError(RPC_FORBIDDEN_BY_SAFE_MODE, string("Safe mode: ") + strWarning);
	}

	std::string HelpMessage(HelpMessageMode mode)
	{
	const bool showDebug = GetBoolArg("-help-debug", false);

	// When adding new options to the categories, please keep and ensure alphabetical ordering.
	// Do not translate _(...) -help-debug options, Many technical terms, and only a very small audience, so is unnecessary stress to translators.
	string strUsage = HelpMessageGroup(_("Options:"));
	strUsage += HelpMessageOpt("-?", _("This help message"));
	strUsage += HelpMessageOpt("-alerts", strprintf(_("Receive and display P2P network alerts (default: %u)"), DEFAULT_ALERTS));
	strUsage += HelpMessageOpt("-alertnotify=<cmd>", _("Execute command when a relevant alert is received or we see a really long fork (%s in cmd is replaced by message)"));
	strUsage += HelpMessageOpt("-blocknotify=<cmd>", _("Execute command when the best block changes (%s in cmd is replaced by block hash)"));
	strUsage += HelpMessageOpt("-checkblocks=<n>", strprintf(_("How many blocks to check at startup (default: %u, 0 = all)"), 288));
	strUsage += HelpMessageOpt("-checklevel=<n>", strprintf(_("How thorough the block verification of -checkblocks is (0-4, default: %u)"), 3));
	strUsage += HelpMessageOpt("-conf=<file>", strprintf(_("Specify configuration file (default: %s)"), "bitcoin.conf"));
	if (mode == HMM_BITCOIND)
	{
	#if !defined(WIN32)
	strUsage += HelpMessageOpt("-daemon", _("Run in the background as a daemon and accept commands"));
	#endif
	}
	strUsage += HelpMessageOpt("-datadir=<dir>", _("Specify data directory"));
	strUsage += HelpMessageOpt("-dbcache=<n>", strprintf(_("Set database cache size in megabytes (%d to %d, default: %d)"), nMinDbCache, nMaxDbCache, nDefaultDbCache));
	strUsage += HelpMessageOpt("-loadblock=<file>", _("Imports blocks from external blk000??.dat file") + " " + _("on startup"));
	strUsage += HelpMessageOpt("-maxorphantx=<n>", strprintf(_("Keep at most <n> unconnectable transactions in memory (default: %u)"), DEFAULT_MAX_ORPHAN_TRANSACTIONS));
	strUsage += HelpMessageOpt("-par=<n>", strprintf(_("Set the number of script verification threads (%u to %d, 0 = auto, <0 = leave that many cores free, default: %d)"),
	-GetNumCores(), MAX_SCRIPTCHECK_THREADS, DEFAULT_SCRIPTCHECK_THREADS));
	#ifndef WIN32
	strUsage += HelpMessageOpt("-pid=<file>", strprintf(_("Specify pid file (default: %s)"), "bitcoind.pid"));
	#endif
	strUsage += HelpMessageOpt("-prune=<n>", strprintf(_("Reduce storage requirements by pruning (deleting) old blocks. This mode disables wallet support and is incompatible with -txindex. "
	"Warning: Reverting this setting requires re-downloading the entire blockchain. "
	"(default: 0 = disable pruning blocks, >%u = target size in MiB to use for block files)"), MIN_DISK_SPACE_FOR_BLOCK_FILES / 1024 / 1024));
	strUsage += HelpMessageOpt("-reindex", _("Rebuild block chain index from current blk000??.dat files on startup"));
	#if !defined(WIN32)
	strUsage += HelpMessageOpt("-sysperms", _("Create new files with system default permissions, instead of umask 077 (only effective with disabled wallet functionality)"));
	#endif
	strUsage += HelpMessageOpt("-txindex", strprintf(_("Maintain a full transaction index, used by the getrawtransaction rpc call (default: %u)"), 0));

	strUsage += HelpMessageGroup(_("Connection options:"));
	strUsage += HelpMessageOpt("-addnode=<ip>", _("Add a node to connect to and attempt to keep the connection open"));
	strUsage += HelpMessageOpt("-banscore=<n>", strprintf(_("Threshold for disconnecting misbehaving peers (default: %u)"), 100));
	strUsage += HelpMessageOpt("-bantime=<n>", strprintf(_("Number of seconds to keep misbehaving peers from reconnecting (default: %u)"), 86400));
	strUsage += HelpMessageOpt("-bind=<addr>", _("Bind to given address and always listen on it. Use [host]:port notation for IPv6"));
	strUsage += HelpMessageOpt("-connect=<ip>", _("Connect only to the specified node(s)"));
	strUsage += HelpMessageOpt("-discover", _("Discover own IP addresses (default: 1 when listening and no -externalip or -proxy)"));
	strUsage += HelpMessageOpt("-dns", _("Allow DNS lookups for -addnode, -seednode and -connect") + " " + _("(default: 1)"));
	strUsage += HelpMessageOpt("-dnsseed", _("Query for peer addresses via DNS lookup, if low on addresses (default: 1 unless -connect)"));
	strUsage += HelpMessageOpt("-externalip=<ip>", _("Specify your own public address"));
	strUsage += HelpMessageOpt("-forcednsseed", strprintf(_("Always query for peer addresses via DNS lookup (default: %u)"), 0));
	strUsage += HelpMessageOpt("-listen", _("Accept connections from outside (default: 1 if no -proxy or -connect)"));
	strUsage += HelpMessageOpt("-maxconnections=<n>", strprintf(_("Maintain at most <n> connections to peers (default: %u)"), 125));
	strUsage += HelpMessageOpt("-maxreceivebuffer=<n>", strprintf(_("Maximum per-connection receive buffer, <n>*1000 bytes (default: %u)"), 5000));
	strUsage += HelpMessageOpt("-maxsendbuffer=<n>", strprintf(_("Maximum per-connection send buffer, <n>*1000 bytes (default: %u)"), 1000));
	strUsage += HelpMessageOpt("-onion=<ip:port>", strprintf(_("Use separate SOCKS5 proxy to reach peers via Tor hidden services (default: %s)"), "-proxy"));
	strUsage += HelpMessageOpt("-onlynet=<net>", _("Only connect to nodes in network <net> (ipv4, ipv6 or onion)"));
	strUsage += HelpMessageOpt("-permitbaremultisig", strprintf(_("Relay non-P2SH multisig (default: %u)"), 1));
	strUsage += HelpMessageOpt("-port=<port>", strprintf(_("Listen for connections on <port> (default: %u or testnet: %u)"), 8333, 18333));
	strUsage += HelpMessageOpt("-proxy=<ip:port>", _("Connect through SOCKS5 proxy"));
	strUsage += HelpMessageOpt("-proxyrandomize", strprintf(_("Randomize credentials for every proxy connection. This enables Tor stream isolation (default: %u)"), 1));
	strUsage += HelpMessageOpt("-seednode=<ip>", _("Connect to a node to retrieve peer addresses, and disconnect"));
	strUsage += HelpMessageOpt("-timeout=<n>", strprintf(_("Specify connection timeout in milliseconds (minimum: 1, default: %d)"), DEFAULT_CONNECT_TIMEOUT));
	#ifdef USE_UPNP
	#if USE_UPNP
	strUsage += HelpMessageOpt("-upnp", _("Use UPnP to map the listening port (default: 1 when listening and no -proxy)"));
	#else
	strUsage += HelpMessageOpt("-upnp", strprintf(_("Use UPnP to map the listening port (default: %u)"), 0));
	#endif
	#endif
	strUsage += HelpMessageOpt("-whitebind=<addr>", _("Bind to given address and whitelist peers connecting to it. Use [host]:port notation for IPv6"));
	strUsage += HelpMessageOpt("-whitelist=<netmask>", _("Whitelist peers connecting from the given netmask or IP address. Can be specified multiple times.") +
	" " + _("Whitelisted peers cannot be DoS banned and their transactions are always relayed, even if they are already in the mempool, useful e.g. for a gateway"));
	strUsage += HelpMessageOpt("-whiteconnections=<n>", strprintf(_("Reserve this many inbound connections for whitelisted peers (default: %d)"), 0));

	#ifdef ENABLE_WALLET
	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)"), 100));
	if (showDebug)
	- strUsage += HelpMessageOpt("-mintxfee=<amt>", strprintf("Fees (in BTC/Kb) smaller than this are considered zero fee for transaction creation (default: %s)",
	- FormatMoney(CWallet::minTxFee.GetFeePerK())));
	- strUsage += HelpMessageOpt("-paytxfee=<amt>", strprintf(_("Fee (in BTC/kB) to add to transactions you send (default: %s)"), FormatMoney(payTxFee.GetFeePerK())));
	+ strUsage += HelpMessageOpt("-mintxfee=<amt>", strprintf("Fees (in %s/kB) smaller than this are considered zero fee for transaction creation (default: %s)",
	+ CURRENCY_UNIT, FormatMoney(CWallet::minTxFee.GetFeePerK())));
	+ 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.dat") + " " + _("on startup"));
	strUsage += HelpMessageOpt("-sendfreetransactions", strprintf(_("Send transactions as zero-fee transactions if possible (default: %u)"), 0));
	strUsage += HelpMessageOpt("-spendzeroconfchange", strprintf(_("Spend unconfirmed change when sending transactions (default: %u)"), 1));
	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("-maxtxfee=<amt>", strprintf(_("Maximum total fees to use in a single wallet transaction; setting this too low may abort large transactions (default: %s)"),
	- FormatMoney(maxTxFee)));
	+ strUsage += HelpMessageOpt("-maxtxfee=<amt>", strprintf(_("Maximum total fees (in %s) to use in a single wallet transaction; setting this too low may abort large transactions (default: %s)"),
	+ CURRENCY_UNIT, FormatMoney(maxTxFee)));
	strUsage += HelpMessageOpt("-upgradewallet", _("Upgrade wallet to latest format") + " " + _("on startup"));
	strUsage += HelpMessageOpt("-wallet=<file>", _("Specify wallet file (within data directory)") + " " + strprintf(_("(default: %s)"), "wallet.dat"));
	strUsage += HelpMessageOpt("-walletbroadcast", _("Make the wallet broadcast transactions") + " " + strprintf(_("(default: %u)"), true));
	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)"));
	#endif

	strUsage += HelpMessageGroup(_("Debugging/Testing options:"));
	if (showDebug)
	{
	strUsage += HelpMessageOpt("-checkpoints", strprintf("Disable expensive verification for known chain history (default: %u)", 1));
	strUsage += HelpMessageOpt("-dblogsize=<n>", strprintf("Flush database activity from memory pool to disk log every <n> megabytes (default: %u)", 100));
	strUsage += HelpMessageOpt("-disablesafemode", strprintf("Disable safemode, override a real safe mode event (default: %u)", 0));
	strUsage += HelpMessageOpt("-testsafemode", strprintf("Force safe mode (default: %u)", 0));
	strUsage += HelpMessageOpt("-dropmessagestest=<n>", "Randomly drop 1 of every <n> network messages");
	strUsage += HelpMessageOpt("-fuzzmessagestest=<n>", "Randomly fuzz 1 of every <n> network messages");
	strUsage += HelpMessageOpt("-flushwallet", strprintf("Run a thread to flush wallet periodically (default: %u)", 1));
	strUsage += HelpMessageOpt("-stopafterblockimport", strprintf("Stop running after importing blocks from disk (default: %u)", 0));
	}
	string debugCategories = "addrman, alert, bench, coindb, db, lock, rand, rpc, selectcoins, mempool, net, proxy, prune"; // Don't translate these and qt below
	if (mode == HMM_BITCOIN_QT)
	debugCategories += ", qt";
	strUsage += HelpMessageOpt("-debug=<category>", strprintf(_("Output debugging information (default: %u, supplying <category> is optional)"), 0) + ". " +
	_("If <category> is not supplied or if <category> = 1, output all debugging information.") + _("<category> can be:") + " " + debugCategories + ".");
	strUsage += HelpMessageOpt("-gen", strprintf(_("Generate coins (default: %u)"), 0));
	strUsage += HelpMessageOpt("-genproclimit=<n>", strprintf(_("Set the number of threads for coin generation if enabled (-1 = all cores, default: %d)"), 1));
	strUsage += HelpMessageOpt("-help-debug", _("Show all debugging options (usage: --help -help-debug)"));
	strUsage += HelpMessageOpt("-logips", strprintf(_("Include IP addresses in debug output (default: %u)"), 0));
	strUsage += HelpMessageOpt("-logtimestamps", strprintf(_("Prepend debug output with timestamp (default: %u)"), 1));
	if (showDebug)
	{
	strUsage += HelpMessageOpt("-limitfreerelay=<n>", strprintf("Continuously rate-limit free transactions to <n>*1000 bytes per minute (default: %u)", 15));
	strUsage += HelpMessageOpt("-relaypriority", strprintf("Require high priority for relaying free or low-fee transactions (default: %u)", 1));
	strUsage += HelpMessageOpt("-maxsigcachesize=<n>", strprintf("Limit size of signature cache to <n> entries (default: %u)", 50000));
	}
	- strUsage += HelpMessageOpt("-minrelaytxfee=<amt>", strprintf(_("Fees (in BTC/Kb) smaller than this are considered zero fee for relaying (default: %s)"), FormatMoney(::minRelayTxFee.GetFeePerK())));
	+ strUsage += HelpMessageOpt("-minrelaytxfee=<amt>", strprintf(_("Fees (in %s/kB) smaller than this are considered zero fee for relaying (default: %s)"),
	+ CURRENCY_UNIT, FormatMoney(::minRelayTxFee.GetFeePerK())));
	strUsage += HelpMessageOpt("-printtoconsole", _("Send trace/debug info to console instead of debug.log file"));
	if (showDebug)
	{
	strUsage += HelpMessageOpt("-printpriority", strprintf("Log transaction priority and fee per kB when mining blocks (default: %u)", 0));
	strUsage += HelpMessageOpt("-privdb", strprintf("Sets the DB_PRIVATE flag in the wallet db environment (default: %u)", 1));
	strUsage += HelpMessageOpt("-regtest", "Enter regression test mode, which uses a special chain in which blocks can be solved instantly. "
	"This is intended for regression testing tools and app development.");
	}
	strUsage += HelpMessageOpt("-shrinkdebugfile", _("Shrink debug.log file on client startup (default: 1 when no -debug)"));
	strUsage += HelpMessageOpt("-testnet", _("Use the test network"));

	strUsage += HelpMessageGroup(_("Node relay options:"));
	if (showDebug)
	strUsage += HelpMessageOpt("-acceptnonstdtxn", strprintf("Relay and mine \"non-standard\" transactions (%sdefault: %u)", "testnet/regtest only; ", !Params(CBaseChainParams::TESTNET).RequireStandard()));
	strUsage += HelpMessageOpt("-datacarrier", strprintf(_("Relay and mine data carrier transactions (default: %u)"), 1));
	strUsage += HelpMessageOpt("-datacarriersize", strprintf(_("Maximum size of data in data carrier transactions we relay and mine (default: %u)"), MAX_OP_RETURN_RELAY));

	strUsage += HelpMessageGroup(_("Block creation options:"));
	strUsage += HelpMessageOpt("-blockminsize=<n>", strprintf(_("Set minimum block size in bytes (default: %u)"), 0));
	strUsage += HelpMessageOpt("-blockmaxsize=<n>", strprintf(_("Set maximum block size in bytes (default: %d)"), DEFAULT_BLOCK_MAX_SIZE));
	strUsage += HelpMessageOpt("-blockprioritysize=<n>", strprintf(_("Set maximum size of high-priority/low-fee transactions in bytes (default: %d)"), DEFAULT_BLOCK_PRIORITY_SIZE));
	if (showDebug)
	strUsage += HelpMessageOpt("-blockversion=<n>", strprintf("Override block version to test forking scenarios (default: %d)", (int)CBlock::CURRENT_VERSION));

	strUsage += HelpMessageGroup(_("RPC server options:"));
	strUsage += HelpMessageOpt("-server", _("Accept command line and JSON-RPC commands"));
	strUsage += HelpMessageOpt("-rest", strprintf(_("Accept public REST requests (default: %u)"), 0));
	strUsage += HelpMessageOpt("-rpcbind=<addr>", _("Bind to given address to listen for JSON-RPC connections. Use [host]:port notation for IPv6. This option can be specified multiple times (default: bind to all interfaces)"));
	strUsage += HelpMessageOpt("-rpcuser=<user>", _("Username for JSON-RPC connections"));
	strUsage += HelpMessageOpt("-rpcpassword=<pw>", _("Password for JSON-RPC connections"));
	strUsage += HelpMessageOpt("-rpcport=<port>", strprintf(_("Listen for JSON-RPC connections on <port> (default: %u or testnet: %u)"), 8332, 18332));
	strUsage += HelpMessageOpt("-rpcallowip=<ip>", _("Allow JSON-RPC connections from specified source. Valid for <ip> are a single IP (e.g. 1.2.3.4), a network/netmask (e.g. 1.2.3.4/255.255.255.0) or a network/CIDR (e.g. 1.2.3.4/24). This option can be specified multiple times"));
	strUsage += HelpMessageOpt("-rpcthreads=<n>", strprintf(_("Set the number of threads to service RPC calls (default: %d)"), 4));
	strUsage += HelpMessageOpt("-rpckeepalive", strprintf(_("RPC support for HTTP persistent connections (default: %d)"), 1));

	strUsage += HelpMessageGroup(_("RPC SSL options: (see the Bitcoin Wiki for SSL setup instructions)"));
	strUsage += HelpMessageOpt("-rpcssl", _("Use OpenSSL (https) for JSON-RPC connections"));
	strUsage += HelpMessageOpt("-rpcsslcertificatechainfile=<file.cert>", strprintf(_("Server certificate file (default: %s)"), "server.cert"));
	strUsage += HelpMessageOpt("-rpcsslprivatekeyfile=<file.pem>", strprintf(_("Server private key (default: %s)"), "server.pem"));
	strUsage += HelpMessageOpt("-rpcsslciphers=<ciphers>", strprintf(_("Acceptable ciphers (default: %s)"), "TLSv1.2+HIGH:TLSv1+HIGH:!SSLv2:!aNULL:!eNULL:!3DES:@STRENGTH"));

	if (mode == HMM_BITCOIN_QT)
	{
	strUsage += HelpMessageGroup(_("UI Options:"));
	if (showDebug) {
	strUsage += HelpMessageOpt("-allowselfsignedrootcertificates", "Allow self signed root certificates (default: 0)");
	}
	strUsage += HelpMessageOpt("-choosedatadir", _("Choose data directory on startup (default: 0)"));
	strUsage += HelpMessageOpt("-lang=<lang>", _("Set language, for example \"de_DE\" (default: system locale)"));
	strUsage += HelpMessageOpt("-min", _("Start minimized"));
	strUsage += HelpMessageOpt("-rootcertificates=<file>", _("Set SSL root certificates for payment request (default: -system-)"));
	strUsage += HelpMessageOpt("-splash", _("Show splash screen on startup (default: 1)"));
	if (showDebug) {
	strUsage += HelpMessageOpt("-uiplatform", "Select platform to customize UI for (one of windows, macosx, other; default: platform compiled on)");
	}
	}

	return strUsage;
	}

	std::string LicenseInfo()
	{
	return FormatParagraph(strprintf(_("Copyright (C) 2009-%i The Bitcoin Core Developers"), COPYRIGHT_YEAR)) + "\n" +
	"\n" +
	FormatParagraph(_("This is experimental software.")) + "\n" +
	"\n" +
	FormatParagraph(_("Distributed under the MIT software license, see the accompanying file COPYING or <http://www.opensource.org/licenses/mit-license.php>.")) + "\n" +
	"\n" +
	FormatParagraph(_("This product includes software developed by the OpenSSL Project for use in the OpenSSL Toolkit <https://www.openssl.org/> and cryptographic software written by Eric Young and UPnP software written by Thomas Bernard.")) +
	"\n";
	}

	static void BlockNotifyCallback(const uint256& hashNewTip)
	{
	std::string strCmd = GetArg("-blocknotify", "");

	boost::replace_all(strCmd, "%s", hashNewTip.GetHex());
	boost::thread t(runCommand, strCmd); // thread runs free
	}

	struct CImportingNow
	{
	CImportingNow() {
	assert(fImporting == false);
	fImporting = true;
	}

	~CImportingNow() {
	assert(fImporting == true);
	fImporting = false;
	}
	};


	// If we're using -prune with -reindex, then delete block files that will be ignored by the
	// reindex. Since reindexing works by starting at block file 0 and looping until a blockfile
	// is missing, do the same here to delete any later block files after a gap. Also delete all
	// rev files since they'll be rewritten by the reindex anyway. This ensures that vinfoBlockFile
	// is in sync with what's actually on disk by the time we start downloading, so that pruning
	// works correctly.
	void CleanupBlockRevFiles()
	{
	using namespace boost::filesystem;
	map<string, path> mapBlockFiles;

	// Glob all blk?????.dat and rev?????.dat files from the blocks directory.
	// Remove the rev files immediately and insert the blk file paths into an
	// ordered map keyed by block file index.
	LogPrintf("Removing unusable blk?????.dat and rev?????.dat files for -reindex with -prune\n");
	path blocksdir = GetDataDir() / "blocks";
	for (directory_iterator it(blocksdir); it != directory_iterator(); it++) {
	if (is_regular_file(*it) &&
	it->path().filename().string().length() == 12 &&
	it->path().filename().string().substr(8,4) == ".dat")
	{
	if (it->path().filename().string().substr(0,3) == "blk")
	mapBlockFiles[it->path().filename().string().substr(3,5)] = it->path();
	else if (it->path().filename().string().substr(0,3) == "rev")
	remove(it->path());
	}
	}

	// Remove all block files that aren't part of a contiguous set starting at
	// zero by walking the ordered map (keys are block file indices) by
	// keeping a separate counter. Once we hit a gap (or if 0 doesn't exist)
	// start removing block files.
	int nContigCounter = 0;
	BOOST_FOREACH(const PAIRTYPE(string, path)& item, mapBlockFiles) {
	if (atoi(item.first) == nContigCounter) {
	nContigCounter++;
	continue;
	}
	remove(item.second);
	}
	}

	void ThreadImport(std::vector<boost::filesystem::path> vImportFiles)
	{
	RenameThread("bitcoin-loadblk");
	// -reindex
	if (fReindex) {
	CImportingNow imp;
	int nFile = 0;
	while (true) {
	CDiskBlockPos pos(nFile, 0);
	if (!boost::filesystem::exists(GetBlockPosFilename(pos, "blk")))
	break; // No block files left to reindex
	FILE *file = OpenBlockFile(pos, true);
	if (!file)
	break; // This error is logged in OpenBlockFile
	LogPrintf("Reindexing block file blk%05u.dat...\n", (unsigned int)nFile);
	LoadExternalBlockFile(file, &pos);
	nFile++;
	}
	pblocktree->WriteReindexing(false);
	fReindex = false;
	LogPrintf("Reindexing finished\n");
	// To avoid ending up in a situation without genesis block, re-try initializing (no-op if reindexing worked):
	InitBlockIndex();
	}

	// hardcoded $DATADIR/bootstrap.dat
	boost::filesystem::path pathBootstrap = GetDataDir() / "bootstrap.dat";
	if (boost::filesystem::exists(pathBootstrap)) {
	FILE *file = fopen(pathBootstrap.string().c_str(), "rb");
	if (file) {
	CImportingNow imp;
	boost::filesystem::path pathBootstrapOld = GetDataDir() / "bootstrap.dat.old";
	LogPrintf("Importing bootstrap.dat...\n");
	LoadExternalBlockFile(file);
	RenameOver(pathBootstrap, pathBootstrapOld);
	} else {
	LogPrintf("Warning: Could not open bootstrap file %s\n", pathBootstrap.string());
	}
	}

	// -loadblock=
	BOOST_FOREACH(const boost::filesystem::path& path, vImportFiles) {
	FILE *file = fopen(path.string().c_str(), "rb");
	if (file) {
	CImportingNow imp;
	LogPrintf("Importing blocks file %s...\n", path.string());
	LoadExternalBlockFile(file);
	} else {
	LogPrintf("Warning: Could not open blocks file %s\n", path.string());
	}
	}

	if (GetBoolArg("-stopafterblockimport", false)) {
	LogPrintf("Stopping after block import\n");
	StartShutdown();
	}
	}

	/** Sanity checks
	* Ensure that Bitcoin is running in a usable environment with all
	* necessary library support.
	*/
	bool InitSanityCheck(void)
	{
	if(!ECC_InitSanityCheck()) {
	InitError("OpenSSL appears to lack support for elliptic curve cryptography. For more "
	"information, visit https://en.bitcoin.it/wiki/OpenSSL_and_EC_Libraries");
	return false;
	}
	if (!glibc_sanity_test() \|\| !glibcxx_sanity_test())
	return false;

	return true;
	}

	/** Initialize bitcoin.
	* @pre Parameters should be parsed and config file should be read.
	*/
	bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
	{
	// ********************************************************* Step 1: setup
	#ifdef _MSC_VER
	// Turn off Microsoft heap dump noise
	_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
	_CrtSetReportFile(_CRT_WARN, CreateFileA("NUL", GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0));
	#endif
	#if _MSC_VER >= 1400
	// Disable confusing "helpful" text message on abort, Ctrl-C
	_set_abort_behavior(0, _WRITE_ABORT_MSG \| _CALL_REPORTFAULT);
	#endif
	#ifdef WIN32
	// Enable Data Execution Prevention (DEP)
	// Minimum supported OS versions: WinXP SP3, WinVista >= SP1, Win Server 2008
	// A failure is non-critical and needs no further attention!
	#ifndef PROCESS_DEP_ENABLE
	// We define this here, because GCCs winbase.h limits this to _WIN32_WINNT >= 0x0601 (Windows 7),
	// which is not correct. Can be removed, when GCCs winbase.h is fixed!
	#define PROCESS_DEP_ENABLE 0x00000001
	#endif
	typedef BOOL (WINAPI *PSETPROCDEPPOL)(DWORD);
	PSETPROCDEPPOL setProcDEPPol = (PSETPROCDEPPOL)GetProcAddress(GetModuleHandleA("Kernel32.dll"), "SetProcessDEPPolicy");
	if (setProcDEPPol != NULL) setProcDEPPol(PROCESS_DEP_ENABLE);

	// Initialize Windows Sockets
	WSADATA wsadata;
	int ret = WSAStartup(MAKEWORD(2,2), &wsadata);
	if (ret != NO_ERROR \|\| LOBYTE(wsadata.wVersion ) != 2 \|\| HIBYTE(wsadata.wVersion) != 2)
	{
	return InitError(strprintf("Error: Winsock library failed to start (WSAStartup returned error %d)", ret));
	}
	#endif
	#ifndef WIN32

	if (GetBoolArg("-sysperms", false)) {
	#ifdef ENABLE_WALLET
	if (!GetBoolArg("-disablewallet", false))
	return InitError("Error: -sysperms is not allowed in combination with enabled wallet functionality");
	#endif
	} else {
	umask(077);
	}

	// Clean shutdown on SIGTERM
	struct sigaction sa;
	sa.sa_handler = HandleSIGTERM;
	sigemptyset(&sa.sa_mask);
	sa.sa_flags = 0;
	sigaction(SIGTERM, &sa, NULL);
	sigaction(SIGINT, &sa, NULL);

	// Reopen debug.log on SIGHUP
	struct sigaction sa_hup;
	sa_hup.sa_handler = HandleSIGHUP;
	sigemptyset(&sa_hup.sa_mask);
	sa_hup.sa_flags = 0;
	sigaction(SIGHUP, &sa_hup, NULL);

	#if defined (__SVR4) && defined (__sun)
	// ignore SIGPIPE on Solaris
	signal(SIGPIPE, SIG_IGN);
	#endif
	#endif

	// ********************************************************* Step 2: parameter interactions
	const CChainParams& chainparams = Params();

	// Set this early so that parameter interactions go to console
	fPrintToConsole = GetBoolArg("-printtoconsole", false);
	fLogTimestamps = GetBoolArg("-logtimestamps", true);
	fLogIPs = GetBoolArg("-logips", false);

	LogPrintf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
	LogPrintf("Bitcoin version %s (%s)\n", FormatFullVersion(), CLIENT_DATE);

	// when specifying an explicit binding address, you want to listen on it
	// even when -connect or -proxy is specified
	if (mapArgs.count("-bind")) {
	if (SoftSetBoolArg("-listen", true))
	LogPrintf("%s: parameter interaction: -bind set -> setting -listen=1\n", __func__);
	}
	if (mapArgs.count("-whitebind")) {
	if (SoftSetBoolArg("-listen", true))
	LogPrintf("%s: parameter interaction: -whitebind set -> setting -listen=1\n", __func__);
	}

	if (mapArgs.count("-connect") && mapMultiArgs["-connect"].size() > 0) {
	// when only connecting to trusted nodes, do not seed via DNS, or listen by default
	if (SoftSetBoolArg("-dnsseed", false))
	LogPrintf("%s: parameter interaction: -connect set -> setting -dnsseed=0\n", __func__);
	if (SoftSetBoolArg("-listen", false))
	LogPrintf("%s: parameter interaction: -connect set -> setting -listen=0\n", __func__);
	}

	if (mapArgs.count("-proxy")) {
	// to protect privacy, do not listen by default if a default proxy server is specified
	if (SoftSetBoolArg("-listen", false))
	LogPrintf("%s: parameter interaction: -proxy set -> setting -listen=0\n", __func__);
	// to protect privacy, do not use UPNP when a proxy is set. The user may still specify -listen=1
	// to listen locally, so don't rely on this happening through -listen below.
	if (SoftSetBoolArg("-upnp", false))
	LogPrintf("%s: parameter interaction: -proxy set -> setting -upnp=0\n", __func__);
	// to protect privacy, do not discover addresses by default
	if (SoftSetBoolArg("-discover", false))
	LogPrintf("%s: parameter interaction: -proxy set -> setting -discover=0\n", __func__);
	}

	if (!GetBoolArg("-listen", DEFAULT_LISTEN)) {
	// do not map ports or try to retrieve public IP when not listening (pointless)
	if (SoftSetBoolArg("-upnp", false))
	LogPrintf("%s: parameter interaction: -listen=0 -> setting -upnp=0\n", __func__);
	if (SoftSetBoolArg("-discover", false))
	LogPrintf("%s: parameter interaction: -listen=0 -> setting -discover=0\n", __func__);
	}

	if (mapArgs.count("-externalip")) {
	// if an explicit public IP is specified, do not try to find others
	if (SoftSetBoolArg("-discover", false))
	LogPrintf("%s: parameter interaction: -externalip set -> setting -discover=0\n", __func__);
	}

	if (GetBoolArg("-salvagewallet", false)) {
	// Rewrite just private keys: rescan to find transactions
	if (SoftSetBoolArg("-rescan", true))
	LogPrintf("%s: parameter interaction: -salvagewallet=1 -> setting -rescan=1\n", __func__);
	}

	// -zapwallettx implies a rescan
	if (GetBoolArg("-zapwallettxes", false)) {
	if (SoftSetBoolArg("-rescan", true))
	LogPrintf("%s: parameter interaction: -zapwallettxes=<mode> -> setting -rescan=1\n", __func__);
	}

	// if using block pruning, then disable txindex
	if (GetArg("-prune", 0)) {
	if (GetBoolArg("-txindex", false))
	return InitError(_("Prune mode is incompatible with -txindex."));
	#ifdef ENABLE_WALLET
	if (GetBoolArg("-rescan", false)) {
	return InitError(_("Rescans are not possible in pruned mode. You will need to use -reindex which will download the whole blockchain again."));
	}
	#endif
	}

	// Make sure enough file descriptors are available
	int nBind = std::max((int)mapArgs.count("-bind") + (int)mapArgs.count("-whitebind"), 1);
	int nUserMaxConnections = GetArg("-maxconnections", 125);
	nMaxConnections = std::max(nUserMaxConnections, 0);
	int nUserWhiteConnections = GetArg("-whiteconnections", 0);
	nWhiteConnections = std::max(nUserWhiteConnections, 0);

	if ((mapArgs.count("-whitelist")) \|\| (mapArgs.count("-whitebind"))) {
	if (!(mapArgs.count("-maxconnections"))) {
	// User is using whitelist feature,
	// but did not specify -maxconnections parameter.
	// Silently increase the default to compensate,
	// so that the whitelist connection reservation feature
	// does not inadvertently reduce the default
	// inbound connection capacity of the network.
	nMaxConnections += nWhiteConnections;
	}
	} else {
	// User not using whitelist feature.
	// Silently disable connection reservation,
	// for the same reason as above.
	nWhiteConnections = 0;
	}

	// Trim requested connection counts, to fit into system limitations
	nMaxConnections = std::max(std::min(nMaxConnections, (int)(FD_SETSIZE - nBind - MIN_CORE_FILEDESCRIPTORS)), 0);
	int nFD = RaiseFileDescriptorLimit(nMaxConnections + MIN_CORE_FILEDESCRIPTORS);
	if (nFD < MIN_CORE_FILEDESCRIPTORS)
	return InitError(_("Not enough file descriptors available."));
	nMaxConnections = std::min(nFD - MIN_CORE_FILEDESCRIPTORS, nMaxConnections);

	if (nMaxConnections < nUserMaxConnections)
	InitWarning(strprintf(_("Reducing -maxconnections from %d to %d, because of system limitations."), nUserMaxConnections, nMaxConnections));

	// Connection capacity is prioritized in this order:
	// outbound connections (hardcoded to 8),
	// then whitelisted connections,
	// then non-whitelisted connections get whatever's left (if any).
	if ((nWhiteConnections > 0) && (nWhiteConnections >= (nMaxConnections - 8)))
	InitWarning(strprintf(_("All non-whitelisted incoming connections will be dropped, because -whiteconnections is %d and -maxconnections is only %d."), nWhiteConnections, nMaxConnections));

	// ********************************************************* Step 3: parameter-to-internal-flags

	fDebug = !mapMultiArgs["-debug"].empty();
	// Special-case: if -debug=0/-nodebug is set, turn off debugging messages
	const vector<string>& categories = mapMultiArgs["-debug"];
	if (GetBoolArg("-nodebug", false) \|\| find(categories.begin(), categories.end(), string("0")) != categories.end())
	fDebug = false;

	// Check for -debugnet
	if (GetBoolArg("-debugnet", false))
	InitWarning(_("Warning: Unsupported argument -debugnet ignored, use -debug=net."));
	// Check for -socks - as this is a privacy risk to continue, exit here
	if (mapArgs.count("-socks"))
	return InitError(_("Error: Unsupported argument -socks found. Setting SOCKS version isn't possible anymore, only SOCKS5 proxies are supported."));
	// Check for -tor - as this is a privacy risk to continue, exit here
	if (GetBoolArg("-tor", false))
	return InitError(_("Error: Unsupported argument -tor found, use -onion."));

	if (GetBoolArg("-benchmark", false))
	InitWarning(_("Warning: Unsupported argument -benchmark ignored, use -debug=bench."));

	// Checkmempool and checkblockindex default to true in regtest mode
	mempool.setSanityCheck(GetBoolArg("-checkmempool", chainparams.DefaultConsistencyChecks()));
	fCheckBlockIndex = GetBoolArg("-checkblockindex", chainparams.DefaultConsistencyChecks());
	fCheckpointsEnabled = GetBoolArg("-checkpoints", true);

	// -par=0 means autodetect, but nScriptCheckThreads==0 means no concurrency
	nScriptCheckThreads = GetArg("-par", DEFAULT_SCRIPTCHECK_THREADS);
	if (nScriptCheckThreads <= 0)
	nScriptCheckThreads += GetNumCores();
	if (nScriptCheckThreads <= 1)
	nScriptCheckThreads = 0;
	else if (nScriptCheckThreads > MAX_SCRIPTCHECK_THREADS)
	nScriptCheckThreads = MAX_SCRIPTCHECK_THREADS;

	fServer = GetBoolArg("-server", false);

	// block pruning; get the amount of disk space (in MB) to allot for block & undo files
	int64_t nSignedPruneTarget = GetArg("-prune", 0) * 1024 * 1024;
	if (nSignedPruneTarget < 0) {
	return InitError(_("Prune cannot be configured with a negative value."));
	}
	nPruneTarget = (uint64_t) nSignedPruneTarget;
	if (nPruneTarget) {
	if (nPruneTarget < MIN_DISK_SPACE_FOR_BLOCK_FILES) {
	return InitError(strprintf(_("Prune configured below the minimum of %d MB. Please use a higher number."), MIN_DISK_SPACE_FOR_BLOCK_FILES / 1024 / 1024));
	}
	LogPrintf("Prune configured to target %uMiB on disk for block and undo files.\n", nPruneTarget / 1024 / 1024);
	fPruneMode = true;
	}

	#ifdef ENABLE_WALLET
	bool fDisableWallet = GetBoolArg("-disablewallet", false);
	#endif

	nConnectTimeout = GetArg("-timeout", DEFAULT_CONNECT_TIMEOUT);
	if (nConnectTimeout <= 0)
	nConnectTimeout = DEFAULT_CONNECT_TIMEOUT;

	// Fee-per-kilobyte amount considered the same as "free"
	// If you are mining, be careful setting this:
	// if you set it to zero then
	// a transaction spammer can cheaply fill blocks using
	// 1-satoshi-fee transactions. It should be set above the real
	// cost to you of processing a transaction.
	if (mapArgs.count("-minrelaytxfee"))
	{
	CAmount n = 0;
	if (ParseMoney(mapArgs["-minrelaytxfee"], n) && n > 0)
	::minRelayTxFee = CFeeRate(n);
	else
	return InitError(strprintf(_("Invalid amount for -minrelaytxfee=<amount>: '%s'"), mapArgs["-minrelaytxfee"]));
	}

	fRequireStandard = !GetBoolArg("-acceptnonstdtxn", !Params().RequireStandard());
	if (Params().RequireStandard() && !fRequireStandard)
	return InitError(strprintf("acceptnonstdtxn is not currently supported for %s chain", chainparams.NetworkIDString()));

	#ifdef ENABLE_WALLET
	if (mapArgs.count("-mintxfee"))
	{
	CAmount n = 0;
	if (ParseMoney(mapArgs["-mintxfee"], n) && n > 0)
	CWallet::minTxFee = CFeeRate(n);
	else
	return InitError(strprintf(_("Invalid amount for -mintxfee=<amount>: '%s'"), mapArgs["-mintxfee"]));
	}
	if (mapArgs.count("-paytxfee"))
	{
	CAmount nFeePerK = 0;
	if (!ParseMoney(mapArgs["-paytxfee"], nFeePerK))
	return InitError(strprintf(_("Invalid amount for -paytxfee=<amount>: '%s'"), mapArgs["-paytxfee"]));
	if (nFeePerK > nHighTransactionFeeWarning)
	InitWarning(_("Warning: -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(strprintf(_("Invalid amount for -maxtxfee=<amount>: '%s'"), mapArgs["-maptxfee"]));
	if (nMaxFee > nHighTransactionMaxFeeWarning)
	InitWarning(_("Warning: -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", true);
	fSendFreeTransactions = GetBoolArg("-sendfreetransactions", false);

	std::string strWalletFile = GetArg("-wallet", "wallet.dat");
	#endif // ENABLE_WALLET

	fIsBareMultisigStd = GetBoolArg("-permitbaremultisig", true);
	nMaxDatacarrierBytes = GetArg("-datacarriersize", nMaxDatacarrierBytes);

	fAlerts = GetBoolArg("-alerts", DEFAULT_ALERTS);

	// Option to startup with mocktime set (used for regression testing):
	SetMockTime(GetArg("-mocktime", 0)); // SetMockTime(0) is a no-op

	// ********************************************************* Step 4: application initialization: dir lock, daemonize, pidfile, debug log

	// Initialize elliptic curve code
	ECC_Start();

	// Sanity check
	if (!InitSanityCheck())
	return InitError(_("Initialization sanity check failed. Bitcoin Core is shutting down."));

	std::string strDataDir = GetDataDir().string();
	#ifdef ENABLE_WALLET
	// Wallet file must be a plain filename without a directory
	if (strWalletFile != boost::filesystem::basename(strWalletFile) + boost::filesystem::extension(strWalletFile))
	return InitError(strprintf(_("Wallet %s resides outside data directory %s"), strWalletFile, strDataDir));
	#endif
	// Make sure only a single Bitcoin process is using the data directory.
	boost::filesystem::path pathLockFile = GetDataDir() / ".lock";
	FILE* file = fopen(pathLockFile.string().c_str(), "a"); // empty lock file; created if it doesn't exist.
	if (file) fclose(file);

	try {
	static boost::interprocess::file_lock lock(pathLockFile.string().c_str());
	if (!lock.try_lock())
	return InitError(strprintf(_("Cannot obtain a lock on data directory %s. Bitcoin Core is probably already running."), strDataDir));
	} catch(const boost::interprocess::interprocess_exception& e) {
	return InitError(strprintf(_("Cannot obtain a lock on data directory %s. Bitcoin Core is probably already running.") + " %s.", strDataDir, e.what()));
	}

	#ifndef WIN32
	CreatePidFile(GetPidFile(), getpid());
	#endif
	if (GetBoolArg("-shrinkdebugfile", !fDebug))
	ShrinkDebugFile();

	if (fPrintToDebugLog)
	OpenDebugLog();

	LogPrintf("Using OpenSSL version %s\n", SSLeay_version(SSLEAY_VERSION));
	#ifdef ENABLE_WALLET
	LogPrintf("Using BerkeleyDB version %s\n", DbEnv::version(0, 0, 0));
	#endif
	if (!fLogTimestamps)
	LogPrintf("Startup time: %s\n", DateTimeStrFormat("%Y-%m-%d %H:%M:%S", GetTime()));
	LogPrintf("Default data directory %s\n", GetDefaultDataDir().string());
	LogPrintf("Using data directory %s\n", strDataDir);
	LogPrintf("Using config file %s\n", GetConfigFile().string());
	LogPrintf("Using at most %i connections (%i file descriptors available)\n", nMaxConnections, nFD);
	if (nWhiteConnections > 0)
	LogPrintf("Reserving %i of these connections for whitelisted inbound peers\n", nWhiteConnections);
	std::ostringstream strErrors;

	LogPrintf("Using %u threads for script verification\n", nScriptCheckThreads);
	if (nScriptCheckThreads) {
	for (int i=0; i<nScriptCheckThreads-1; i++)
	threadGroup.create_thread(&ThreadScriptCheck);
	}

	// Start the lightweight task scheduler thread
	CScheduler::Function serviceLoop = boost::bind(&CScheduler::serviceQueue, &scheduler);
	threadGroup.create_thread(boost::bind(&TraceThread<CScheduler::Function>, "scheduler", serviceLoop));

	/* Start the RPC server already. It will be started in "warmup" mode
	* and not really process calls already (but it will signify connections
	* that the server is there and will be ready later). Warmup mode will
	* be disabled when initialisation is finished.
	*/
	if (fServer)
	{
	uiInterface.InitMessage.connect(SetRPCWarmupStatus);
	RPCServer::OnStopped(&OnRPCStopped);
	RPCServer::OnPreCommand(&OnRPCPreCommand);
	StartRPCThreads();
	}

	int64_t nStart;

	// ********************************************************* Step 5: verify wallet database integrity
	#ifdef ENABLE_WALLET
	if (!fDisableWallet) {
	LogPrintf("Using wallet %s\n", strWalletFile);
	uiInterface.InitMessage(_("Verifying wallet..."));

	std::string warningString;
	std::string errorString;

	if (!CWallet::Verify(strWalletFile, warningString, errorString))
	return false;

	if (!warningString.empty())
	InitWarning(warningString);
	if (!errorString.empty())
	return InitError(warningString);

	} // (!fDisableWallet)
	#endif // ENABLE_WALLET
	// ********************************************************* Step 6: network initialization

	RegisterNodeSignals(GetNodeSignals());

	if (mapArgs.count("-onlynet")) {
	std::set<enum Network> nets;
	BOOST_FOREACH(const std::string& snet, mapMultiArgs["-onlynet"]) {
	enum Network net = ParseNetwork(snet);
	if (net == NET_UNROUTABLE)
	return InitError(strprintf(_("Unknown network specified in -onlynet: '%s'"), snet));
	nets.insert(net);
	}
	for (int n = 0; n < NET_MAX; n++) {
	enum Network net = (enum Network)n;
	if (!nets.count(net))
	SetLimited(net);
	}
	}

	if (mapArgs.count("-whitelist")) {
	BOOST_FOREACH(const std::string& net, mapMultiArgs["-whitelist"]) {
	CSubNet subnet(net);
	if (!subnet.IsValid())
	return InitError(strprintf(_("Invalid netmask specified in -whitelist: '%s'"), net));
	CNode::AddWhitelistedRange(subnet);
	}
	}

	bool proxyRandomize = GetBoolArg("-proxyrandomize", true);
	// -proxy sets a proxy for all outgoing network traffic
	// -noproxy (or -proxy=0) as well as the empty string can be used to not set a proxy, this is the default
	std::string proxyArg = GetArg("-proxy", "");
	if (proxyArg != "" && proxyArg != "0") {
	proxyType addrProxy = proxyType(CService(proxyArg, 9050), proxyRandomize);
	if (!addrProxy.IsValid())
	return InitError(strprintf(_("Invalid -proxy address: '%s'"), proxyArg));

	SetProxy(NET_IPV4, addrProxy);
	SetProxy(NET_IPV6, addrProxy);
	SetProxy(NET_TOR, addrProxy);
	SetNameProxy(addrProxy);
	SetReachable(NET_TOR); // by default, -proxy sets onion as reachable, unless -noonion later
	}

	// -onion can be used to set only a proxy for .onion, or override normal proxy for .onion addresses
	// -noonion (or -onion=0) disables connecting to .onion entirely
	// An empty string is used to not override the onion proxy (in which case it defaults to -proxy set above, or none)
	std::string onionArg = GetArg("-onion", "");
	if (onionArg != "") {
	if (onionArg == "0") { // Handle -noonion/-onion=0
	SetReachable(NET_TOR, false); // set onions as unreachable
	} else {
	proxyType addrOnion = proxyType(CService(onionArg, 9050), proxyRandomize);
	if (!addrOnion.IsValid())
	return InitError(strprintf(_("Invalid -onion address: '%s'"), onionArg));
	SetProxy(NET_TOR, addrOnion);
	SetReachable(NET_TOR);
	}
	}

	// see Step 2: parameter interactions for more information about these
	fListen = GetBoolArg("-listen", DEFAULT_LISTEN);
	fDiscover = GetBoolArg("-discover", true);
	fNameLookup = GetBoolArg("-dns", true);

	bool fBound = false;
	if (fListen) {
	if (mapArgs.count("-bind") \|\| mapArgs.count("-whitebind")) {
	BOOST_FOREACH(const std::string& strBind, mapMultiArgs["-bind"]) {
	CService addrBind;
	if (!Lookup(strBind.c_str(), addrBind, GetListenPort(), false))
	return InitError(strprintf(_("Cannot resolve -bind address: '%s'"), strBind));
	fBound \|= Bind(addrBind, (BF_EXPLICIT \| BF_REPORT_ERROR));
	}
	BOOST_FOREACH(const std::string& strBind, mapMultiArgs["-whitebind"]) {
	CService addrBind;
	if (!Lookup(strBind.c_str(), addrBind, 0, false))
	return InitError(strprintf(_("Cannot resolve -whitebind address: '%s'"), strBind));
	if (addrBind.GetPort() == 0)
	return InitError(strprintf(_("Need to specify a port with -whitebind: '%s'"), strBind));
	fBound \|= Bind(addrBind, (BF_EXPLICIT \| BF_REPORT_ERROR \| BF_WHITELIST));
	}
	}
	else {
	struct in_addr inaddr_any;
	inaddr_any.s_addr = INADDR_ANY;
	fBound \|= Bind(CService(in6addr_any, GetListenPort()), BF_NONE);
	fBound \|= Bind(CService(inaddr_any, GetListenPort()), !fBound ? BF_REPORT_ERROR : BF_NONE);
	}
	if (!fBound)
	return InitError(_("Failed to listen on any port. Use -listen=0 if you want this."));
	}

	if (mapArgs.count("-externalip")) {
	BOOST_FOREACH(const std::string& strAddr, mapMultiArgs["-externalip"]) {
	CService addrLocal(strAddr, GetListenPort(), fNameLookup);
	if (!addrLocal.IsValid())
	return InitError(strprintf(_("Cannot resolve -externalip address: '%s'"), strAddr));
	AddLocal(CService(strAddr, GetListenPort(), fNameLookup), LOCAL_MANUAL);
	}
	}

	BOOST_FOREACH(const std::string& strDest, mapMultiArgs["-seednode"])
	AddOneShot(strDest);

	// ********************************************************* Step 7: load block chain

	fReindex = GetBoolArg("-reindex", false);

	// Upgrading to 0.8; hard-link the old blknnnn.dat files into /blocks/
	boost::filesystem::path blocksDir = GetDataDir() / "blocks";
	if (!boost::filesystem::exists(blocksDir))
	{
	boost::filesystem::create_directories(blocksDir);
	bool linked = false;
	for (unsigned int i = 1; i < 10000; i++) {
	boost::filesystem::path source = GetDataDir() / strprintf("blk%04u.dat", i);
	if (!boost::filesystem::exists(source)) break;
	boost::filesystem::path dest = blocksDir / strprintf("blk%05u.dat", i-1);
	try {
	boost::filesystem::create_hard_link(source, dest);
	LogPrintf("Hardlinked %s -> %s\n", source.string(), dest.string());
	linked = true;
	} catch (const boost::filesystem::filesystem_error& e) {
	// Note: hardlink creation failing is not a disaster, it just means
	// blocks will get re-downloaded from peers.
	LogPrintf("Error hardlinking blk%04u.dat: %s\n", i, e.what());
	break;
	}
	}
	if (linked)
	{
	fReindex = true;
	}
	}

	// cache size calculations
	int64_t nTotalCache = (GetArg("-dbcache", nDefaultDbCache) << 20);
	nTotalCache = std::max(nTotalCache, nMinDbCache << 20); // total cache cannot be less than nMinDbCache
	nTotalCache = std::min(nTotalCache, nMaxDbCache << 20); // total cache cannot be greated than nMaxDbcache
	int64_t nBlockTreeDBCache = nTotalCache / 8;
	if (nBlockTreeDBCache > (1 << 21) && !GetBoolArg("-txindex", false))
	nBlockTreeDBCache = (1 << 21); // block tree db cache shouldn't be larger than 2 MiB
	nTotalCache -= nBlockTreeDBCache;
	int64_t nCoinDBCache = std::min(nTotalCache / 2, (nTotalCache / 4) + (1 << 23)); // use 25%-50% of the remainder for disk cache
	nTotalCache -= nCoinDBCache;
	nCoinCacheUsage = nTotalCache; // the rest goes to in-memory cache
	LogPrintf("Cache configuration:\n");
	LogPrintf("* Using %.1fMiB for block index database\n", nBlockTreeDBCache * (1.0 / 1024 / 1024));
	LogPrintf("* Using %.1fMiB for chain state database\n", nCoinDBCache * (1.0 / 1024 / 1024));
	LogPrintf("* Using %.1fMiB for in-memory UTXO set\n", nCoinCacheUsage * (1.0 / 1024 / 1024));

	bool fLoaded = false;
	while (!fLoaded) {
	bool fReset = fReindex;
	std::string strLoadError;

	uiInterface.InitMessage(_("Loading block index..."));

	nStart = GetTimeMillis();
	do {
	try {
	UnloadBlockIndex();
	delete pcoinsTip;
	delete pcoinsdbview;
	delete pcoinscatcher;
	delete pblocktree;

	pblocktree = new CBlockTreeDB(nBlockTreeDBCache, false, fReindex);
	pcoinsdbview = new CCoinsViewDB(nCoinDBCache, false, fReindex);
	pcoinscatcher = new CCoinsViewErrorCatcher(pcoinsdbview);
	pcoinsTip = new CCoinsViewCache(pcoinscatcher);

	if (fReindex) {
	pblocktree->WriteReindexing(true);
	//If we're reindexing in prune mode, wipe away unusable block files and all undo data files
	if (fPruneMode)
	CleanupBlockRevFiles();
	}

	if (!LoadBlockIndex()) {
	strLoadError = _("Error loading block database");
	break;
	}

	// If the loaded chain has a wrong genesis, bail out immediately
	// (we're likely using a testnet datadir, or the other way around).
	if (!mapBlockIndex.empty() && mapBlockIndex.count(chainparams.GetConsensus().hashGenesisBlock) == 0)
	return InitError(_("Incorrect or no genesis block found. Wrong datadir for network?"));

	// Initialize the block index (no-op if non-empty database was already loaded)
	if (!InitBlockIndex()) {
	strLoadError = _("Error initializing block database");
	break;
	}

	// Check for changed -txindex state
	if (fTxIndex != GetBoolArg("-txindex", false)) {
	strLoadError = _("You need to rebuild the database using -reindex to change -txindex");
	break;
	}

	// Check for changed -prune state. What we are concerned about is a user who has pruned blocks
	// in the past, but is now trying to run unpruned.
	if (fHavePruned && !fPruneMode) {
	strLoadError = _("You need to rebuild the database using -reindex to go back to unpruned mode. This will redownload the entire blockchain");
	break;
	}

	uiInterface.InitMessage(_("Verifying blocks..."));
	if (fHavePruned && GetArg("-checkblocks", 288) > MIN_BLOCKS_TO_KEEP) {
	LogPrintf("Prune: pruned datadir may not have more than %d blocks; -checkblocks=%d may fail\n",
	MIN_BLOCKS_TO_KEEP, GetArg("-checkblocks", 288));
	}
	if (!CVerifyDB().VerifyDB(pcoinsdbview, GetArg("-checklevel", 3),
	GetArg("-checkblocks", 288))) {
	strLoadError = _("Corrupted block database detected");
	break;
	}
	} catch (const std::exception& e) {
	if (fDebug) LogPrintf("%s\n", e.what());
	strLoadError = _("Error opening block database");
	break;
	}

	fLoaded = true;
	} while(false);

	if (!fLoaded) {
	// first suggest a reindex
	if (!fReset) {
	bool fRet = uiInterface.ThreadSafeMessageBox(
	strLoadError + ".\n\n" + _("Do you want to rebuild the block database now?"),
	"", CClientUIInterface::MSG_ERROR \| CClientUIInterface::BTN_ABORT);
	if (fRet) {
	fReindex = true;
	fRequestShutdown = false;
	} else {
	LogPrintf("Aborted block database rebuild. Exiting.\n");
	return false;
	}
	} else {
	return InitError(strLoadError);
	}
	}
	}

	// As LoadBlockIndex can take several minutes, it's possible the user
	// requested to kill the GUI during the last operation. If so, exit.
	// As the program has not fully started yet, Shutdown() is possibly overkill.
	if (fRequestShutdown)
	{
	LogPrintf("Shutdown requested. Exiting.\n");
	return false;
	}
	LogPrintf(" block index %15dms\n", GetTimeMillis() - nStart);

	boost::filesystem::path est_path = GetDataDir() / FEE_ESTIMATES_FILENAME;
	CAutoFile est_filein(fopen(est_path.string().c_str(), "rb"), SER_DISK, CLIENT_VERSION);
	// Allowed to fail as this file IS missing on first startup.
	if (!est_filein.IsNull())
	mempool.ReadFeeEstimates(est_filein);
	fFeeEstimatesInitialized = true;

	// ********************************************************* Step 8: load wallet
	#ifdef ENABLE_WALLET
	if (fDisableWallet) {
	pwalletMain = NULL;
	LogPrintf("Wallet disabled!\n");
	} else {

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

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

	pwalletMain = new CWallet(strWalletFile);
	DBErrors nZapWalletRet = pwalletMain->ZapWalletTx(vWtx);
	if (nZapWalletRet != DB_LOAD_OK) {
	uiInterface.InitMessage(_("Error loading wallet.dat: Wallet corrupted"));
	return false;
	}

	delete pwalletMain;
	pwalletMain = NULL;
	}

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

	nStart = GetTimeMillis();
	bool fFirstRun = true;
	pwalletMain = new CWallet(strWalletFile);
	DBErrors nLoadWalletRet = pwalletMain->LoadWallet(fFirstRun);
	if (nLoadWalletRet != DB_LOAD_OK)
	{
	if (nLoadWalletRet == DB_CORRUPT)
	strErrors << _("Error loading wallet.dat: Wallet corrupted") << "\n";
	else if (nLoadWalletRet == DB_NONCRITICAL_ERROR)
	{
	string msg(_("Warning: error reading wallet.dat! All keys read correctly, but transaction data"
	" or address book entries might be missing or incorrect."));
	InitWarning(msg);
	}
	else if (nLoadWalletRet == DB_TOO_NEW)
	strErrors << _("Error loading wallet.dat: Wallet requires newer version of Bitcoin Core") << "\n";
	else if (nLoadWalletRet == DB_NEED_REWRITE)
	{
	strErrors << _("Wallet needed to be rewritten: restart Bitcoin Core to complete") << "\n";
	LogPrintf("%s", strErrors.str());
	return InitError(strErrors.str());
	}
	else
	strErrors << _("Error loading wallet.dat") << "\n";
	}

	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;
	pwalletMain->SetMinVersion(FEATURE_LATEST); // permanently upgrade the wallet immediately
	}
	else
	LogPrintf("Allowing wallet upgrade up to %i\n", nMaxVersion);
	if (nMaxVersion < pwalletMain->GetVersion())
	strErrors << _("Cannot downgrade wallet") << "\n";
	pwalletMain->SetMaxVersion(nMaxVersion);
	}

	if (fFirstRun)
	{
	// Create new keyUser and set as default key
	RandAddSeedPerfmon();

	CPubKey newDefaultKey;
	if (pwalletMain->GetKeyFromPool(newDefaultKey)) {
	pwalletMain->SetDefaultKey(newDefaultKey);
	if (!pwalletMain->SetAddressBook(pwalletMain->vchDefaultKey.GetID(), "", "receive"))
	strErrors << _("Cannot write default address") << "\n";
	}

	pwalletMain->SetBestChain(chainActive.GetLocator());
	}

	LogPrintf("%s", strErrors.str());
	LogPrintf(" wallet %15dms\n", GetTimeMillis() - nStart);

	RegisterValidationInterface(pwalletMain);

	CBlockIndex *pindexRescan = chainActive.Tip();
	if (GetBoolArg("-rescan", false))
	pindexRescan = chainActive.Genesis();
	else
	{
	CWalletDB walletdb(strWalletFile);
	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();
	pwalletMain->ScanForWalletTransactions(pindexRescan, true);
	LogPrintf(" rescan %15dms\n", GetTimeMillis() - nStart);
	pwalletMain->SetBestChain(chainActive.GetLocator());
	nWalletDBUpdated++;

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

	BOOST_FOREACH(const CWalletTx& wtxOld, vWtx)
	{
	uint256 hash = wtxOld.GetHash();
	std::map<uint256, CWalletTx>::iterator mi = pwalletMain->mapWallet.find(hash);
	if (mi != pwalletMain->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;
	copyTo->WriteToDisk(&walletdb);
	}
	}
	}
	}
	pwalletMain->SetBroadcastTransactions(GetBoolArg("-walletbroadcast", true));
	} // (!fDisableWallet)
	#else // ENABLE_WALLET
	LogPrintf("No wallet support compiled in!\n");
	#endif // !ENABLE_WALLET

	// ********************************************************* Step 9: data directory maintenance

	// if pruning, unset the service bit and perform the initial blockstore prune
	// after any wallet rescanning has taken place.
	if (fPruneMode) {
	uiInterface.InitMessage(_("Pruning blockstore..."));
	LogPrintf("Unsetting NODE_NETWORK on prune mode\n");
	nLocalServices &= ~NODE_NETWORK;
	if (!fReindex) {
	PruneAndFlush();
	}
	}

	// ********************************************************* Step 10: import blocks

	if (mapArgs.count("-blocknotify"))
	uiInterface.NotifyBlockTip.connect(BlockNotifyCallback);

	uiInterface.InitMessage(_("Activating best chain..."));
	// scan for better chains in the block chain database, that are not yet connected in the active best chain
	CValidationState state;
	if (!ActivateBestChain(state))
	strErrors << "Failed to connect best block";

	std::vector<boost::filesystem::path> vImportFiles;
	if (mapArgs.count("-loadblock"))
	{
	BOOST_FOREACH(const std::string& strFile, mapMultiArgs["-loadblock"])
	vImportFiles.push_back(strFile);
	}
	threadGroup.create_thread(boost::bind(&ThreadImport, vImportFiles));
	if (chainActive.Tip() == NULL) {
	LogPrintf("Waiting for genesis block to be imported...\n");
	while (!fRequestShutdown && chainActive.Tip() == NULL)
	MilliSleep(10);
	}

	// ********************************************************* Step 11: start node

	if (!CheckDiskSpace())
	return false;

	if (!strErrors.str().empty())
	return InitError(strErrors.str());

	RandAddSeedPerfmon();

	//// debug print
	LogPrintf("mapBlockIndex.size() = %u\n", mapBlockIndex.size());
	LogPrintf("nBestHeight = %d\n", chainActive.Height());
	#ifdef ENABLE_WALLET
	LogPrintf("setKeyPool.size() = %u\n", pwalletMain ? pwalletMain->setKeyPool.size() : 0);
	LogPrintf("mapWallet.size() = %u\n", pwalletMain ? pwalletMain->mapWallet.size() : 0);
	LogPrintf("mapAddressBook.size() = %u\n", pwalletMain ? pwalletMain->mapAddressBook.size() : 0);
	#endif

	StartNode(threadGroup, scheduler);

	// Monitor the chain, and alert if we get blocks much quicker or slower than expected
	int64_t nPowTargetSpacing = Params().GetConsensus().nPowTargetSpacing;
	CScheduler::Function f = boost::bind(&PartitionCheck, &IsInitialBlockDownload,
	boost::ref(cs_main), boost::cref(pindexBestHeader), nPowTargetSpacing);
	scheduler.scheduleEvery(f, nPowTargetSpacing);

	// Generate coins in the background
	GenerateBitcoins(GetBoolArg("-gen", false), GetArg("-genproclimit", 1), Params());

	// ********************************************************* Step 11: finished

	SetRPCWarmupFinished();
	uiInterface.InitMessage(_("Done loading"));

	#ifdef ENABLE_WALLET
	if (pwalletMain) {
	// Add wallet transactions that aren't already in a block to mapTransactions
	pwalletMain->ReacceptWalletTransactions();

	// Run a thread to flush wallet periodically
	threadGroup.create_thread(boost::bind(&ThreadFlushWalletDB, boost::ref(pwalletMain->strWalletFile)));
	}
	#endif

	return !fRequestShutdown;
	}
	diff --git a/src/rpcblockchain.cpp b/src/rpcblockchain.cpp
	index 5817f0ce57..80d49490d2 100644
	--- a/src/rpcblockchain.cpp
	+++ b/src/rpcblockchain.cpp
	@@ -1,859 +1,860 @@
	// Copyright (c) 2010 Satoshi Nakamoto
	// Copyright (c) 2009-2014 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 "chain.h"
	#include "chainparams.h"
	#include "checkpoints.h"
	#include "coins.h"
	#include "consensus/validation.h"
	#include "main.h"
	#include "primitives/transaction.h"
	#include "rpcserver.h"
	#include "streams.h"
	#include "sync.h"
	#include "txmempool.h"
	#include "util.h"
	#include "utilstrencodings.h"

	#include <stdint.h>

	#include "univalue/univalue.h"

	using namespace std;

	extern void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue& entry);
	void ScriptPubKeyToJSON(const CScript& scriptPubKey, UniValue& out, bool fIncludeHex);

	double GetDifficulty(const CBlockIndex* blockindex)
	{
	// Floating point number that is a multiple of the minimum difficulty,
	// minimum difficulty = 1.0.
	if (blockindex == NULL)
	{
	if (chainActive.Tip() == NULL)
	return 1.0;
	else
	blockindex = chainActive.Tip();
	}

	int nShift = (blockindex->nBits >> 24) & 0xff;

	double dDiff =
	(double)0x0000ffff / (double)(blockindex->nBits & 0x00ffffff);

	while (nShift < 29)
	{
	dDiff *= 256.0;
	nShift++;
	}
	while (nShift > 29)
	{
	dDiff /= 256.0;
	nShift--;
	}

	return dDiff;
	}

	UniValue blockheaderToJSON(const CBlockIndex* blockindex)
	{
	UniValue result(UniValue::VOBJ);
	result.push_back(Pair("hash", blockindex->GetBlockHash().GetHex()));
	int confirmations = -1;
	// Only report confirmations if the block is on the main chain
	if (chainActive.Contains(blockindex))
	confirmations = chainActive.Height() - blockindex->nHeight + 1;
	result.push_back(Pair("confirmations", confirmations));
	result.push_back(Pair("height", blockindex->nHeight));
	result.push_back(Pair("version", blockindex->nVersion));
	result.push_back(Pair("merkleroot", blockindex->hashMerkleRoot.GetHex()));
	result.push_back(Pair("time", (int64_t)blockindex->nTime));
	result.push_back(Pair("nonce", (uint64_t)blockindex->nNonce));
	result.push_back(Pair("bits", strprintf("%08x", blockindex->nBits)));
	result.push_back(Pair("difficulty", GetDifficulty(blockindex)));
	result.push_back(Pair("chainwork", blockindex->nChainWork.GetHex()));

	if (blockindex->pprev)
	result.push_back(Pair("previousblockhash", blockindex->pprev->GetBlockHash().GetHex()));
	CBlockIndex *pnext = chainActive.Next(blockindex);
	if (pnext)
	result.push_back(Pair("nextblockhash", pnext->GetBlockHash().GetHex()));
	return result;
	}

	UniValue blockToJSON(const CBlock& block, const CBlockIndex* blockindex, bool txDetails = false)
	{
	UniValue result(UniValue::VOBJ);
	result.push_back(Pair("hash", block.GetHash().GetHex()));
	int confirmations = -1;
	// Only report confirmations if the block is on the main chain
	if (chainActive.Contains(blockindex))
	confirmations = chainActive.Height() - blockindex->nHeight + 1;
	result.push_back(Pair("confirmations", confirmations));
	result.push_back(Pair("size", (int)::GetSerializeSize(block, SER_NETWORK, PROTOCOL_VERSION)));
	result.push_back(Pair("height", blockindex->nHeight));
	result.push_back(Pair("version", block.nVersion));
	result.push_back(Pair("merkleroot", block.hashMerkleRoot.GetHex()));
	UniValue txs(UniValue::VARR);
	BOOST_FOREACH(const CTransaction&tx, block.vtx)
	{
	if(txDetails)
	{
	UniValue objTx(UniValue::VOBJ);
	TxToJSON(tx, uint256(), objTx);
	txs.push_back(objTx);
	}
	else
	txs.push_back(tx.GetHash().GetHex());
	}
	result.push_back(Pair("tx", txs));
	result.push_back(Pair("time", block.GetBlockTime()));
	result.push_back(Pair("nonce", (uint64_t)block.nNonce));
	result.push_back(Pair("bits", strprintf("%08x", block.nBits)));
	result.push_back(Pair("difficulty", GetDifficulty(blockindex)));
	result.push_back(Pair("chainwork", blockindex->nChainWork.GetHex()));

	if (blockindex->pprev)
	result.push_back(Pair("previousblockhash", blockindex->pprev->GetBlockHash().GetHex()));
	CBlockIndex *pnext = chainActive.Next(blockindex);
	if (pnext)
	result.push_back(Pair("nextblockhash", pnext->GetBlockHash().GetHex()));
	return result;
	}

	UniValue getblockcount(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() != 0)
	throw runtime_error(
	"getblockcount\n"
	"\nReturns the number of blocks in the longest block chain.\n"
	"\nResult:\n"
	"n (numeric) The current block count\n"
	"\nExamples:\n"
	+ HelpExampleCli("getblockcount", "")
	+ HelpExampleRpc("getblockcount", "")
	);

	LOCK(cs_main);
	return chainActive.Height();
	}

	UniValue getbestblockhash(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() != 0)
	throw runtime_error(
	"getbestblockhash\n"
	"\nReturns the hash of the best (tip) block in the longest block chain.\n"
	"\nResult\n"
	"\"hex\" (string) the block hash hex encoded\n"
	"\nExamples\n"
	+ HelpExampleCli("getbestblockhash", "")
	+ HelpExampleRpc("getbestblockhash", "")
	);

	LOCK(cs_main);
	return chainActive.Tip()->GetBlockHash().GetHex();
	}

	UniValue getdifficulty(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() != 0)
	throw runtime_error(
	"getdifficulty\n"
	"\nReturns the proof-of-work difficulty as a multiple of the minimum difficulty.\n"
	"\nResult:\n"
	"n.nnn (numeric) the proof-of-work difficulty as a multiple of the minimum difficulty.\n"
	"\nExamples:\n"
	+ HelpExampleCli("getdifficulty", "")
	+ HelpExampleRpc("getdifficulty", "")
	);

	LOCK(cs_main);
	return GetDifficulty();
	}


	UniValue getrawmempool(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() > 1)
	throw runtime_error(
	"getrawmempool ( verbose )\n"
	"\nReturns all transaction ids in memory pool as a json array of string transaction ids.\n"
	"\nArguments:\n"
	"1. verbose (boolean, optional, default=false) true for a json object, false for array of transaction ids\n"
	"\nResult: (for verbose = false):\n"
	"[ (json array of string)\n"
	" \"transactionid\" (string) The transaction id\n"
	" ,...\n"
	"]\n"
	"\nResult: (for verbose = true):\n"
	"{ (json object)\n"
	" \"transactionid\" : { (json object)\n"
	" \"size\" : n, (numeric) transaction size in bytes\n"
	- " \"fee\" : n, (numeric) transaction fee in bitcoins\n"
	+ " \"fee\" : n, (numeric) transaction fee in " + CURRENCY_UNIT + "\n"
	" \"time\" : n, (numeric) local time transaction entered pool in seconds since 1 Jan 1970 GMT\n"
	" \"height\" : n, (numeric) block height when transaction entered pool\n"
	" \"startingpriority\" : n, (numeric) priority when transaction entered pool\n"
	" \"currentpriority\" : n, (numeric) transaction priority now\n"
	" \"depends\" : [ (array) unconfirmed transactions used as inputs for this transaction\n"
	" \"transactionid\", (string) parent transaction id\n"
	" ... ]\n"
	" }, ...\n"
	"}\n"
	"\nExamples\n"
	+ HelpExampleCli("getrawmempool", "true")
	+ HelpExampleRpc("getrawmempool", "true")
	);

	LOCK(cs_main);

	bool fVerbose = false;
	if (params.size() > 0)
	fVerbose = params[0].get_bool();

	if (fVerbose)
	{
	LOCK(mempool.cs);
	UniValue o(UniValue::VOBJ);
	BOOST_FOREACH(const PAIRTYPE(uint256, CTxMemPoolEntry)& entry, mempool.mapTx)
	{
	const uint256& hash = entry.first;
	const CTxMemPoolEntry& e = entry.second;
	UniValue info(UniValue::VOBJ);
	info.push_back(Pair("size", (int)e.GetTxSize()));
	info.push_back(Pair("fee", ValueFromAmount(e.GetFee())));
	info.push_back(Pair("time", e.GetTime()));
	info.push_back(Pair("height", (int)e.GetHeight()));
	info.push_back(Pair("startingpriority", e.GetPriority(e.GetHeight())));
	info.push_back(Pair("currentpriority", e.GetPriority(chainActive.Height())));
	const CTransaction& tx = e.GetTx();
	set<string> setDepends;
	BOOST_FOREACH(const CTxIn& txin, tx.vin)
	{
	if (mempool.exists(txin.prevout.hash))
	setDepends.insert(txin.prevout.hash.ToString());
	}

	UniValue depends(UniValue::VARR);
	BOOST_FOREACH(const string& dep, setDepends)
	{
	depends.push_back(dep);
	}

	info.push_back(Pair("depends", depends));
	o.push_back(Pair(hash.ToString(), info));
	}
	return o;
	}
	else
	{
	vector<uint256> vtxid;
	mempool.queryHashes(vtxid);

	UniValue a(UniValue::VARR);
	BOOST_FOREACH(const uint256& hash, vtxid)
	a.push_back(hash.ToString());

	return a;
	}
	}

	UniValue getblockhash(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() != 1)
	throw runtime_error(
	"getblockhash index\n"
	"\nReturns hash of block in best-block-chain at index provided.\n"
	"\nArguments:\n"
	"1. index (numeric, required) The block index\n"
	"\nResult:\n"
	"\"hash\" (string) The block hash\n"
	"\nExamples:\n"
	+ HelpExampleCli("getblockhash", "1000")
	+ HelpExampleRpc("getblockhash", "1000")
	);

	LOCK(cs_main);

	int nHeight = params[0].get_int();
	if (nHeight < 0 \|\| nHeight > chainActive.Height())
	throw JSONRPCError(RPC_INVALID_PARAMETER, "Block height out of range");

	CBlockIndex* pblockindex = chainActive[nHeight];
	return pblockindex->GetBlockHash().GetHex();
	}

	UniValue getblockheader(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() < 1 \|\| params.size() > 2)
	throw runtime_error(
	"getblockheader \"hash\" ( verbose )\n"
	"\nIf verbose is false, returns a string that is serialized, hex-encoded data for blockheader 'hash'.\n"
	"If verbose is true, returns an Object with information about blockheader <hash>.\n"
	"\nArguments:\n"
	"1. \"hash\" (string, required) The block hash\n"
	"2. verbose (boolean, optional, default=true) true for a json object, false for the hex encoded data\n"
	"\nResult (for verbose = true):\n"
	"{\n"
	" \"hash\" : \"hash\", (string) the block hash (same as provided)\n"
	" \"confirmations\" : n, (numeric) The number of confirmations, or -1 if the block is not on the main chain\n"
	" \"height\" : n, (numeric) The block height or index\n"
	" \"version\" : n, (numeric) The block version\n"
	" \"merkleroot\" : \"xxxx\", (string) The merkle root\n"
	" \"time\" : ttt, (numeric) The block time in seconds since epoch (Jan 1 1970 GMT)\n"
	" \"nonce\" : n, (numeric) The nonce\n"
	" \"bits\" : \"1d00ffff\", (string) The bits\n"
	" \"difficulty\" : x.xxx, (numeric) The difficulty\n"
	" \"previousblockhash\" : \"hash\", (string) The hash of the previous block\n"
	" \"nextblockhash\" : \"hash\" (string) The hash of the next block\n"
	"}\n"
	"\nResult (for verbose=false):\n"
	"\"data\" (string) A string that is serialized, hex-encoded data for block 'hash'.\n"
	"\nExamples:\n"
	+ HelpExampleCli("getblockheader", "\"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\"")
	+ HelpExampleRpc("getblockheader", "\"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\"")
	);

	LOCK(cs_main);

	std::string strHash = params[0].get_str();
	uint256 hash(uint256S(strHash));

	bool fVerbose = true;
	if (params.size() > 1)
	fVerbose = params[1].get_bool();

	if (mapBlockIndex.count(hash) == 0)
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");

	CBlockIndex* pblockindex = mapBlockIndex[hash];

	if (!fVerbose)
	{
	CDataStream ssBlock(SER_NETWORK, PROTOCOL_VERSION);
	ssBlock << pblockindex->GetBlockHeader();
	std::string strHex = HexStr(ssBlock.begin(), ssBlock.end());
	return strHex;
	}

	return blockheaderToJSON(pblockindex);
	}

	UniValue getblock(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() < 1 \|\| params.size() > 2)
	throw runtime_error(
	"getblock \"hash\" ( verbose )\n"
	"\nIf verbose is false, returns a string that is serialized, hex-encoded data for block 'hash'.\n"
	"If verbose is true, returns an Object with information about block <hash>.\n"
	"\nArguments:\n"
	"1. \"hash\" (string, required) The block hash\n"
	"2. verbose (boolean, optional, default=true) true for a json object, false for the hex encoded data\n"
	"\nResult (for verbose = true):\n"
	"{\n"
	" \"hash\" : \"hash\", (string) the block hash (same as provided)\n"
	" \"confirmations\" : n, (numeric) The number of confirmations, or -1 if the block is not on the main chain\n"
	" \"size\" : n, (numeric) The block size\n"
	" \"height\" : n, (numeric) The block height or index\n"
	" \"version\" : n, (numeric) The block version\n"
	" \"merkleroot\" : \"xxxx\", (string) The merkle root\n"
	" \"tx\" : [ (array of string) The transaction ids\n"
	" \"transactionid\" (string) The transaction id\n"
	" ,...\n"
	" ],\n"
	" \"time\" : ttt, (numeric) The block time in seconds since epoch (Jan 1 1970 GMT)\n"
	" \"nonce\" : n, (numeric) The nonce\n"
	" \"bits\" : \"1d00ffff\", (string) The bits\n"
	" \"difficulty\" : x.xxx, (numeric) The difficulty\n"
	" \"previousblockhash\" : \"hash\", (string) The hash of the previous block\n"
	" \"nextblockhash\" : \"hash\" (string) The hash of the next block\n"
	"}\n"
	"\nResult (for verbose=false):\n"
	"\"data\" (string) A string that is serialized, hex-encoded data for block 'hash'.\n"
	"\nExamples:\n"
	+ HelpExampleCli("getblock", "\"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\"")
	+ HelpExampleRpc("getblock", "\"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\"")
	);

	LOCK(cs_main);

	std::string strHash = params[0].get_str();
	uint256 hash(uint256S(strHash));

	bool fVerbose = true;
	if (params.size() > 1)
	fVerbose = params[1].get_bool();

	if (mapBlockIndex.count(hash) == 0)
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");

	CBlock block;
	CBlockIndex* pblockindex = mapBlockIndex[hash];

	if (fHavePruned && !(pblockindex->nStatus & BLOCK_HAVE_DATA) && pblockindex->nTx > 0)
	throw JSONRPCError(RPC_INTERNAL_ERROR, "Block not available (pruned data)");

	if(!ReadBlockFromDisk(block, pblockindex))
	throw JSONRPCError(RPC_INTERNAL_ERROR, "Can't read block from disk");

	if (!fVerbose)
	{
	CDataStream ssBlock(SER_NETWORK, PROTOCOL_VERSION);
	ssBlock << block;
	std::string strHex = HexStr(ssBlock.begin(), ssBlock.end());
	return strHex;
	}

	return blockToJSON(block, pblockindex);
	}

	UniValue gettxoutsetinfo(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() != 0)
	throw runtime_error(
	"gettxoutsetinfo\n"
	"\nReturns statistics about the unspent transaction output set.\n"
	"Note this call may take some time.\n"
	"\nResult:\n"
	"{\n"
	" \"height\":n, (numeric) The current block height (index)\n"
	" \"bestblock\": \"hex\", (string) the best block hash hex\n"
	" \"transactions\": n, (numeric) The number of transactions\n"
	" \"txouts\": n, (numeric) The number of output transactions\n"
	" \"bytes_serialized\": n, (numeric) The serialized size\n"
	" \"hash_serialized\": \"hash\", (string) The serialized hash\n"
	" \"total_amount\": x.xxx (numeric) The total amount\n"
	"}\n"
	"\nExamples:\n"
	+ HelpExampleCli("gettxoutsetinfo", "")
	+ HelpExampleRpc("gettxoutsetinfo", "")
	);

	UniValue ret(UniValue::VOBJ);

	CCoinsStats stats;
	FlushStateToDisk();
	if (pcoinsTip->GetStats(stats)) {
	ret.push_back(Pair("height", (int64_t)stats.nHeight));
	ret.push_back(Pair("bestblock", stats.hashBlock.GetHex()));
	ret.push_back(Pair("transactions", (int64_t)stats.nTransactions));
	ret.push_back(Pair("txouts", (int64_t)stats.nTransactionOutputs));
	ret.push_back(Pair("bytes_serialized", (int64_t)stats.nSerializedSize));
	ret.push_back(Pair("hash_serialized", stats.hashSerialized.GetHex()));
	ret.push_back(Pair("total_amount", ValueFromAmount(stats.nTotalAmount)));
	}
	return ret;
	}

	UniValue gettxout(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() < 2 \|\| params.size() > 3)
	throw runtime_error(
	"gettxout \"txid\" n ( includemempool )\n"
	"\nReturns details about an unspent transaction output.\n"
	"\nArguments:\n"
	"1. \"txid\" (string, required) The transaction id\n"
	"2. n (numeric, required) vout value\n"
	"3. includemempool (boolean, optional) Whether to included the mem pool\n"
	"\nResult:\n"
	"{\n"
	" \"bestblock\" : \"hash\", (string) the block hash\n"
	" \"confirmations\" : n, (numeric) The number of confirmations\n"
	- " \"value\" : x.xxx, (numeric) The transaction value in btc\n"
	+ " \"value\" : x.xxx, (numeric) The transaction value in " + CURRENCY_UNIT + "\n"
	" \"scriptPubKey\" : { (json object)\n"
	" \"asm\" : \"code\", (string) \n"
	" \"hex\" : \"hex\", (string) \n"
	" \"reqSigs\" : n, (numeric) Number of required signatures\n"
	" \"type\" : \"pubkeyhash\", (string) The type, eg pubkeyhash\n"
	" \"addresses\" : [ (array of string) array of bitcoin addresses\n"
	" \"bitcoinaddress\" (string) bitcoin address\n"
	" ,...\n"
	" ]\n"
	" },\n"
	" \"version\" : n, (numeric) The version\n"
	" \"coinbase\" : true\|false (boolean) Coinbase or not\n"
	"}\n"

	"\nExamples:\n"
	"\nGet unspent transactions\n"
	+ HelpExampleCli("listunspent", "") +
	"\nView the details\n"
	+ HelpExampleCli("gettxout", "\"txid\" 1") +
	"\nAs a json rpc call\n"
	+ HelpExampleRpc("gettxout", "\"txid\", 1")
	);

	LOCK(cs_main);

	UniValue ret(UniValue::VOBJ);

	std::string strHash = params[0].get_str();
	uint256 hash(uint256S(strHash));
	int n = params[1].get_int();
	bool fMempool = true;
	if (params.size() > 2)
	fMempool = params[2].get_bool();

	CCoins coins;
	if (fMempool) {
	LOCK(mempool.cs);
	CCoinsViewMemPool view(pcoinsTip, mempool);
	if (!view.GetCoins(hash, coins))
	return NullUniValue;
	mempool.pruneSpent(hash, coins); // TODO: this should be done by the CCoinsViewMemPool
	} else {
	if (!pcoinsTip->GetCoins(hash, coins))
	return NullUniValue;
	}
	if (n<0 \|\| (unsigned int)n>=coins.vout.size() \|\| coins.vout[n].IsNull())
	return NullUniValue;

	BlockMap::iterator it = mapBlockIndex.find(pcoinsTip->GetBestBlock());
	CBlockIndex *pindex = it->second;
	ret.push_back(Pair("bestblock", pindex->GetBlockHash().GetHex()));
	if ((unsigned int)coins.nHeight == MEMPOOL_HEIGHT)
	ret.push_back(Pair("confirmations", 0));
	else
	ret.push_back(Pair("confirmations", pindex->nHeight - coins.nHeight + 1));
	ret.push_back(Pair("value", ValueFromAmount(coins.vout[n].nValue)));
	UniValue o(UniValue::VOBJ);
	ScriptPubKeyToJSON(coins.vout[n].scriptPubKey, o, true);
	ret.push_back(Pair("scriptPubKey", o));
	ret.push_back(Pair("version", coins.nVersion));
	ret.push_back(Pair("coinbase", coins.fCoinBase));

	return ret;
	}

	UniValue verifychain(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() > 2)
	throw runtime_error(
	"verifychain ( checklevel numblocks )\n"
	"\nVerifies blockchain database.\n"
	"\nArguments:\n"
	"1. checklevel (numeric, optional, 0-4, default=3) How thorough the block verification is.\n"
	"2. numblocks (numeric, optional, default=288, 0=all) The number of blocks to check.\n"
	"\nResult:\n"
	"true\|false (boolean) Verified or not\n"
	"\nExamples:\n"
	+ HelpExampleCli("verifychain", "")
	+ HelpExampleRpc("verifychain", "")
	);

	LOCK(cs_main);

	int nCheckLevel = GetArg("-checklevel", 3);
	int nCheckDepth = GetArg("-checkblocks", 288);
	if (params.size() > 0)
	nCheckLevel = params[0].get_int();
	if (params.size() > 1)
	nCheckDepth = params[1].get_int();

	return CVerifyDB().VerifyDB(pcoinsTip, nCheckLevel, nCheckDepth);
	}

	/** Implementation of IsSuperMajority with better feedback */
	static UniValue SoftForkMajorityDesc(int minVersion, CBlockIndex* pindex, int nRequired, const Consensus::Params& consensusParams)
	{
	int nFound = 0;
	CBlockIndex* pstart = pindex;
	for (int i = 0; i < consensusParams.nMajorityWindow && pstart != NULL; i++)
	{
	if (pstart->nVersion >= minVersion)
	++nFound;
	pstart = pstart->pprev;
	}

	UniValue rv(UniValue::VOBJ);
	rv.push_back(Pair("status", nFound >= nRequired));
	rv.push_back(Pair("found", nFound));
	rv.push_back(Pair("required", nRequired));
	rv.push_back(Pair("window", consensusParams.nMajorityWindow));
	return rv;
	}

	static UniValue SoftForkDesc(const std::string &name, int version, CBlockIndex* pindex, const Consensus::Params& consensusParams)
	{
	UniValue rv(UniValue::VOBJ);
	rv.push_back(Pair("id", name));
	rv.push_back(Pair("version", version));
	rv.push_back(Pair("enforce", SoftForkMajorityDesc(version, pindex, consensusParams.nMajorityEnforceBlockUpgrade, consensusParams)));
	rv.push_back(Pair("reject", SoftForkMajorityDesc(version, pindex, consensusParams.nMajorityRejectBlockOutdated, consensusParams)));
	return rv;
	}

	UniValue getblockchaininfo(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() != 0)
	throw runtime_error(
	"getblockchaininfo\n"
	"Returns an object containing various state info regarding block chain processing.\n"
	"\nResult:\n"
	"{\n"
	" \"chain\": \"xxxx\", (string) current network name as defined in BIP70 (main, test, regtest)\n"
	" \"blocks\": xxxxxx, (numeric) the current number of blocks processed in the server\n"
	" \"headers\": xxxxxx, (numeric) the current number of headers we have validated\n"
	" \"bestblockhash\": \"...\", (string) the hash of the currently best block\n"
	" \"difficulty\": xxxxxx, (numeric) the current difficulty\n"
	" \"verificationprogress\": xxxx, (numeric) estimate of verification progress [0..1]\n"
	" \"chainwork\": \"xxxx\" (string) total amount of work in active chain, in hexadecimal\n"
	" \"pruned\": xx, (boolean) if the blocks are subject to pruning\n"
	" \"pruneheight\": xxxxxx, (numeric) heighest block available\n"
	" \"softforks\": [ (array) status of softforks in progress\n"
	" {\n"
	" \"id\": \"xxxx\", (string) name of softfork\n"
	" \"version\": xx, (numeric) block version\n"
	" \"enforce\": { (object) progress toward enforcing the softfork rules for new-version blocks\n"
	" \"status\": xx, (boolean) true if threshold reached\n"
	" \"found\": xx, (numeric) number of blocks with the new version found\n"
	" \"required\": xx, (numeric) number of blocks required to trigger\n"
	" \"window\": xx, (numeric) maximum size of examined window of recent blocks\n"
	" },\n"
	" \"reject\": { ... } (object) progress toward rejecting pre-softfork blocks (same fields as \"enforce\")\n"
	" }, ...\n"
	" ]\n"
	"}\n"
	"\nExamples:\n"
	+ HelpExampleCli("getblockchaininfo", "")
	+ HelpExampleRpc("getblockchaininfo", "")
	);

	LOCK(cs_main);

	UniValue obj(UniValue::VOBJ);
	obj.push_back(Pair("chain", Params().NetworkIDString()));
	obj.push_back(Pair("blocks", (int)chainActive.Height()));
	obj.push_back(Pair("headers", pindexBestHeader ? pindexBestHeader->nHeight : -1));
	obj.push_back(Pair("bestblockhash", chainActive.Tip()->GetBlockHash().GetHex()));
	obj.push_back(Pair("difficulty", (double)GetDifficulty()));
	obj.push_back(Pair("verificationprogress", Checkpoints::GuessVerificationProgress(Params().Checkpoints(), chainActive.Tip())));
	obj.push_back(Pair("chainwork", chainActive.Tip()->nChainWork.GetHex()));
	obj.push_back(Pair("pruned", fPruneMode));

	const Consensus::Params& consensusParams = Params().GetConsensus();
	CBlockIndex* tip = chainActive.Tip();
	UniValue softforks(UniValue::VARR);
	softforks.push_back(SoftForkDesc("bip34", 2, tip, consensusParams));
	softforks.push_back(SoftForkDesc("bip66", 3, tip, consensusParams));
	obj.push_back(Pair("softforks", softforks));

	if (fPruneMode)
	{
	CBlockIndex *block = chainActive.Tip();
	while (block && block->pprev && (block->pprev->nStatus & BLOCK_HAVE_DATA))
	block = block->pprev;

	obj.push_back(Pair("pruneheight", block->nHeight));
	}
	return obj;
	}

	/** Comparison function for sorting the getchaintips heads. */
	struct CompareBlocksByHeight
	{
	bool operator()(const CBlockIndex* a, const CBlockIndex* b) const
	{
	/* Make sure that unequal blocks with the same height do not compare
	equal. Use the pointers themselves to make a distinction. */

	if (a->nHeight != b->nHeight)
	return (a->nHeight > b->nHeight);

	return a < b;
	}
	};

	UniValue getchaintips(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() != 0)
	throw runtime_error(
	"getchaintips\n"
	"Return information about all known tips in the block tree,"
	" including the main chain as well as orphaned branches.\n"
	"\nResult:\n"
	"[\n"
	" {\n"
	" \"height\": xxxx, (numeric) height of the chain tip\n"
	" \"hash\": \"xxxx\", (string) block hash of the tip\n"
	" \"branchlen\": 0 (numeric) zero for main chain\n"
	" \"status\": \"active\" (string) \"active\" for the main chain\n"
	" },\n"
	" {\n"
	" \"height\": xxxx,\n"
	" \"hash\": \"xxxx\",\n"
	" \"branchlen\": 1 (numeric) length of branch connecting the tip to the main chain\n"
	" \"status\": \"xxxx\" (string) status of the chain (active, valid-fork, valid-headers, headers-only, invalid)\n"
	" }\n"
	"]\n"
	"Possible values for status:\n"
	"1. \"invalid\" This branch contains at least one invalid block\n"
	"2. \"headers-only\" Not all blocks for this branch are available, but the headers are valid\n"
	"3. \"valid-headers\" All blocks are available for this branch, but they were never fully validated\n"
	"4. \"valid-fork\" This branch is not part of the active chain, but is fully validated\n"
	"5. \"active\" This is the tip of the active main chain, which is certainly valid\n"
	"\nExamples:\n"
	+ HelpExampleCli("getchaintips", "")
	+ HelpExampleRpc("getchaintips", "")
	);

	LOCK(cs_main);

	/* Build up a list of chain tips. We start with the list of all
	known blocks, and successively remove blocks that appear as pprev
	of another block. */
	std::set<const CBlockIndex*, CompareBlocksByHeight> setTips;
	BOOST_FOREACH(const PAIRTYPE(const uint256, CBlockIndex*)& item, mapBlockIndex)
	setTips.insert(item.second);
	BOOST_FOREACH(const PAIRTYPE(const uint256, CBlockIndex*)& item, mapBlockIndex)
	{
	const CBlockIndex* pprev = item.second->pprev;
	if (pprev)
	setTips.erase(pprev);
	}

	// Always report the currently active tip.
	setTips.insert(chainActive.Tip());

	/* Construct the output array. */
	UniValue res(UniValue::VARR);
	BOOST_FOREACH(const CBlockIndex* block, setTips)
	{
	UniValue obj(UniValue::VOBJ);
	obj.push_back(Pair("height", block->nHeight));
	obj.push_back(Pair("hash", block->phashBlock->GetHex()));

	const int branchLen = block->nHeight - chainActive.FindFork(block)->nHeight;
	obj.push_back(Pair("branchlen", branchLen));

	string status;
	if (chainActive.Contains(block)) {
	// This block is part of the currently active chain.
	status = "active";
	} else if (block->nStatus & BLOCK_FAILED_MASK) {
	// This block or one of its ancestors is invalid.
	status = "invalid";
	} else if (block->nChainTx == 0) {
	// This block cannot be connected because full block data for it or one of its parents is missing.
	status = "headers-only";
	} else if (block->IsValid(BLOCK_VALID_SCRIPTS)) {
	// This block is fully validated, but no longer part of the active chain. It was probably the active block once, but was reorganized.
	status = "valid-fork";
	} else if (block->IsValid(BLOCK_VALID_TREE)) {
	// The headers for this block are valid, but it has not been validated. It was probably never part of the most-work chain.
	status = "valid-headers";
	} else {
	// No clue.
	status = "unknown";
	}
	obj.push_back(Pair("status", status));

	res.push_back(obj);
	}

	return res;
	}

	UniValue getmempoolinfo(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() != 0)
	throw runtime_error(
	"getmempoolinfo\n"
	"\nReturns details on the active state of the TX memory pool.\n"
	"\nResult:\n"
	"{\n"
	" \"size\": xxxxx (numeric) Current tx count\n"
	" \"bytes\": xxxxx (numeric) Sum of all tx sizes\n"
	" \"usage\": xxxxx (numeric) Total memory usage for the mempool\n"
	"}\n"
	"\nExamples:\n"
	+ HelpExampleCli("getmempoolinfo", "")
	+ HelpExampleRpc("getmempoolinfo", "")
	);

	UniValue ret(UniValue::VOBJ);
	ret.push_back(Pair("size", (int64_t) mempool.size()));
	ret.push_back(Pair("bytes", (int64_t) mempool.GetTotalTxSize()));
	ret.push_back(Pair("usage", (int64_t) mempool.DynamicMemoryUsage()));

	return ret;
	}

	UniValue invalidateblock(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() != 1)
	throw runtime_error(
	"invalidateblock \"hash\"\n"
	"\nPermanently marks a block as invalid, as if it violated a consensus rule.\n"
	"\nArguments:\n"
	"1. hash (string, required) the hash of the block to mark as invalid\n"
	"\nResult:\n"
	"\nExamples:\n"
	+ HelpExampleCli("invalidateblock", "\"blockhash\"")
	+ HelpExampleRpc("invalidateblock", "\"blockhash\"")
	);

	std::string strHash = params[0].get_str();
	uint256 hash(uint256S(strHash));
	CValidationState state;

	{
	LOCK(cs_main);
	if (mapBlockIndex.count(hash) == 0)
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");

	CBlockIndex* pblockindex = mapBlockIndex[hash];
	InvalidateBlock(state, pblockindex);
	}

	if (state.IsValid()) {
	ActivateBestChain(state);
	}

	if (!state.IsValid()) {
	throw JSONRPCError(RPC_DATABASE_ERROR, state.GetRejectReason());
	}

	return NullUniValue;
	}

	UniValue reconsiderblock(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() != 1)
	throw runtime_error(
	"reconsiderblock \"hash\"\n"
	"\nRemoves invalidity status of a block and its descendants, reconsider them for activation.\n"
	"This can be used to undo the effects of invalidateblock.\n"
	"\nArguments:\n"
	"1. hash (string, required) the hash of the block to reconsider\n"
	"\nResult:\n"
	"\nExamples:\n"
	+ HelpExampleCli("reconsiderblock", "\"blockhash\"")
	+ HelpExampleRpc("reconsiderblock", "\"blockhash\"")
	);

	std::string strHash = params[0].get_str();
	uint256 hash(uint256S(strHash));
	CValidationState state;

	{
	LOCK(cs_main);
	if (mapBlockIndex.count(hash) == 0)
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");

	CBlockIndex* pblockindex = mapBlockIndex[hash];
	ReconsiderBlock(state, pblockindex);
	}

	if (state.IsValid()) {
	ActivateBestChain(state);
	}

	if (!state.IsValid()) {
	throw JSONRPCError(RPC_DATABASE_ERROR, state.GetRejectReason());
	}

	return NullUniValue;
	}
	diff --git a/src/rpcmisc.cpp b/src/rpcmisc.cpp
	index 82003e09b9..6d10d1ce15 100644
	--- a/src/rpcmisc.cpp
	+++ b/src/rpcmisc.cpp
	@@ -1,397 +1,397 @@
	// Copyright (c) 2010 Satoshi Nakamoto
	// Copyright (c) 2009-2014 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 "base58.h"
	#include "clientversion.h"
	#include "init.h"
	#include "main.h"
	#include "net.h"
	#include "netbase.h"
	#include "rpcserver.h"
	#include "timedata.h"
	#include "util.h"
	#include "utilstrencodings.h"
	#ifdef ENABLE_WALLET
	#include "wallet/wallet.h"
	#include "wallet/walletdb.h"
	#endif

	#include <stdint.h>

	#include <boost/assign/list_of.hpp>

	#include "univalue/univalue.h"

	using namespace std;

	/**
	* @note Do not add or change anything in the information returned by this
	* method. `getinfo` exists for backwards-compatibility only. It combines
	* information from wildly different sources in the program, which is a mess,
	* and is thus planned to be deprecated eventually.
	*
	* Based on the source of the information, new information should be added to:
	* - `getblockchaininfo`,
	* - `getnetworkinfo` or
	* - `getwalletinfo`
	*
	* Or alternatively, create a specific query method for the information.
	**/
	UniValue getinfo(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() != 0)
	throw runtime_error(
	"getinfo\n"
	"Returns an object containing various state info.\n"
	"\nResult:\n"
	"{\n"
	" \"version\": xxxxx, (numeric) the server version\n"
	" \"protocolversion\": xxxxx, (numeric) the protocol version\n"
	" \"walletversion\": xxxxx, (numeric) the wallet version\n"
	" \"balance\": xxxxxxx, (numeric) the total bitcoin balance of the wallet\n"
	" \"blocks\": xxxxxx, (numeric) the current number of blocks processed in the server\n"
	" \"timeoffset\": xxxxx, (numeric) the time offset\n"
	" \"connections\": xxxxx, (numeric) the number of connections\n"
	" \"proxy\": \"host:port\", (string, optional) the proxy used by the server\n"
	" \"difficulty\": xxxxxx, (numeric) the current difficulty\n"
	" \"testnet\": true\|false, (boolean) if the server is using testnet or not\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 set in btc/kb\n"
	- " \"relayfee\": x.xxxx, (numeric) minimum relay fee for non-free transactions in btc/kb\n"
	+ " \"paytxfee\": x.xxxx, (numeric) the transaction fee set in " + CURRENCY_UNIT + "/kB\n"
	+ " \"relayfee\": x.xxxx, (numeric) minimum relay fee for non-free transactions in " + CURRENCY_UNIT + "/kB\n"
	" \"errors\": \"...\" (string) any error messages\n"
	"}\n"
	"\nExamples:\n"
	+ HelpExampleCli("getinfo", "")
	+ HelpExampleRpc("getinfo", "")
	);

	#ifdef ENABLE_WALLET
	LOCK2(cs_main, pwalletMain ? &pwalletMain->cs_wallet : NULL);
	#else
	LOCK(cs_main);
	#endif

	proxyType proxy;
	GetProxy(NET_IPV4, proxy);

	UniValue obj(UniValue::VOBJ);
	obj.push_back(Pair("version", CLIENT_VERSION));
	obj.push_back(Pair("protocolversion", PROTOCOL_VERSION));
	#ifdef ENABLE_WALLET
	if (pwalletMain) {
	obj.push_back(Pair("walletversion", pwalletMain->GetVersion()));
	obj.push_back(Pair("balance", ValueFromAmount(pwalletMain->GetBalance())));
	}
	#endif
	obj.push_back(Pair("blocks", (int)chainActive.Height()));
	obj.push_back(Pair("timeoffset", GetTimeOffset()));
	obj.push_back(Pair("connections", (int)vNodes.size()));
	obj.push_back(Pair("proxy", (proxy.IsValid() ? proxy.proxy.ToStringIPPort() : string())));
	obj.push_back(Pair("difficulty", (double)GetDifficulty()));
	obj.push_back(Pair("testnet", Params().TestnetToBeDeprecatedFieldRPC()));
	#ifdef ENABLE_WALLET
	if (pwalletMain) {
	obj.push_back(Pair("keypoololdest", pwalletMain->GetOldestKeyPoolTime()));
	obj.push_back(Pair("keypoolsize", (int)pwalletMain->GetKeyPoolSize()));
	}
	if (pwalletMain && pwalletMain->IsCrypted())
	obj.push_back(Pair("unlocked_until", nWalletUnlockTime));
	obj.push_back(Pair("paytxfee", ValueFromAmount(payTxFee.GetFeePerK())));
	#endif
	obj.push_back(Pair("relayfee", ValueFromAmount(::minRelayTxFee.GetFeePerK())));
	obj.push_back(Pair("errors", GetWarnings("statusbar")));
	return obj;
	}

	#ifdef ENABLE_WALLET
	class DescribeAddressVisitor : public boost::static_visitor<UniValue>
	{
	public:
	UniValue operator()(const CNoDestination &dest) const { return UniValue(UniValue::VOBJ); }

	UniValue operator()(const CKeyID &keyID) const {
	UniValue obj(UniValue::VOBJ);
	CPubKey vchPubKey;
	obj.push_back(Pair("isscript", false));
	if (pwalletMain->GetPubKey(keyID, vchPubKey)) {
	obj.push_back(Pair("pubkey", HexStr(vchPubKey)));
	obj.push_back(Pair("iscompressed", vchPubKey.IsCompressed()));
	}
	return obj;
	}

	UniValue operator()(const CScriptID &scriptID) const {
	UniValue obj(UniValue::VOBJ);
	CScript subscript;
	obj.push_back(Pair("isscript", true));
	if (pwalletMain->GetCScript(scriptID, subscript)) {
	std::vector<CTxDestination> addresses;
	txnouttype whichType;
	int nRequired;
	ExtractDestinations(subscript, whichType, addresses, nRequired);
	obj.push_back(Pair("script", GetTxnOutputType(whichType)));
	obj.push_back(Pair("hex", HexStr(subscript.begin(), subscript.end())));
	UniValue a(UniValue::VARR);
	BOOST_FOREACH(const CTxDestination& addr, addresses)
	a.push_back(CBitcoinAddress(addr).ToString());
	obj.push_back(Pair("addresses", a));
	if (whichType == TX_MULTISIG)
	obj.push_back(Pair("sigsrequired", nRequired));
	}
	return obj;
	}
	};
	#endif

	UniValue validateaddress(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() != 1)
	throw runtime_error(
	"validateaddress \"bitcoinaddress\"\n"
	"\nReturn information about the given bitcoin address.\n"
	"\nArguments:\n"
	"1. \"bitcoinaddress\" (string, required) The bitcoin address to validate\n"
	"\nResult:\n"
	"{\n"
	" \"isvalid\" : true\|false, (boolean) If the address is valid or not. If not, this is the only property returned.\n"
	" \"address\" : \"bitcoinaddress\", (string) The bitcoin address validated\n"
	" \"scriptPubKey\" : \"hex\", (string) The hex encoded scriptPubKey generated by the address\n"
	" \"ismine\" : true\|false, (boolean) If the address is yours or not\n"
	" \"isscript\" : true\|false, (boolean) If the key is a script\n"
	" \"pubkey\" : \"publickeyhex\", (string) The hex value of the raw public key\n"
	" \"iscompressed\" : true\|false, (boolean) If the address is compressed\n"
	" \"account\" : \"account\" (string) DEPRECATED. The account associated with the address, \"\" is the default account\n"
	"}\n"
	"\nExamples:\n"
	+ HelpExampleCli("validateaddress", "\"1PSSGeFHDnKNxiEyFrD1wcEaHr9hrQDDWc\"")
	+ HelpExampleRpc("validateaddress", "\"1PSSGeFHDnKNxiEyFrD1wcEaHr9hrQDDWc\"")
	);

	#ifdef ENABLE_WALLET
	LOCK2(cs_main, pwalletMain ? &pwalletMain->cs_wallet : NULL);
	#else
	LOCK(cs_main);
	#endif

	CBitcoinAddress address(params[0].get_str());
	bool isValid = address.IsValid();

	UniValue ret(UniValue::VOBJ);
	ret.push_back(Pair("isvalid", isValid));
	if (isValid)
	{
	CTxDestination dest = address.Get();
	string currentAddress = address.ToString();
	ret.push_back(Pair("address", currentAddress));

	CScript scriptPubKey = GetScriptForDestination(dest);
	ret.push_back(Pair("scriptPubKey", HexStr(scriptPubKey.begin(), scriptPubKey.end())));

	#ifdef ENABLE_WALLET
	isminetype mine = pwalletMain ? IsMine(*pwalletMain, dest) : ISMINE_NO;
	ret.push_back(Pair("ismine", (mine & ISMINE_SPENDABLE) ? true : false));
	ret.push_back(Pair("iswatchonly", (mine & ISMINE_WATCH_ONLY) ? true: false));
	UniValue detail = boost::apply_visitor(DescribeAddressVisitor(), dest);
	ret.pushKVs(detail);
	if (pwalletMain && pwalletMain->mapAddressBook.count(dest))
	ret.push_back(Pair("account", pwalletMain->mapAddressBook[dest].name));
	#endif
	}
	return ret;
	}

	/**
	* Used by addmultisigaddress / createmultisig:
	*/
	CScript _createmultisig_redeemScript(const UniValue& params)
	{
	int nRequired = params[0].get_int();
	const UniValue& keys = params[1].get_array();

	// Gather public keys
	if (nRequired < 1)
	throw runtime_error("a multisignature address must require at least one key to redeem");
	if ((int)keys.size() < nRequired)
	throw runtime_error(
	strprintf("not enough keys supplied "
	"(got %u keys, but need at least %d to redeem)", keys.size(), nRequired));
	if (keys.size() > 16)
	throw runtime_error("Number of addresses involved in the multisignature address creation > 16\nReduce the number");
	std::vector<CPubKey> pubkeys;
	pubkeys.resize(keys.size());
	for (unsigned int i = 0; i < keys.size(); i++)
	{
	const std::string& ks = keys[i].get_str();
	#ifdef ENABLE_WALLET
	// Case 1: Bitcoin address and we have full public key:
	CBitcoinAddress address(ks);
	if (pwalletMain && address.IsValid())
	{
	CKeyID keyID;
	if (!address.GetKeyID(keyID))
	throw runtime_error(
	strprintf("%s does not refer to a key",ks));
	CPubKey vchPubKey;
	if (!pwalletMain->GetPubKey(keyID, vchPubKey))
	throw runtime_error(
	strprintf("no full public key for address %s",ks));
	if (!vchPubKey.IsFullyValid())
	throw runtime_error(" Invalid public key: "+ks);
	pubkeys[i] = vchPubKey;
	}

	// Case 2: hex public key
	else
	#endif
	if (IsHex(ks))
	{
	CPubKey vchPubKey(ParseHex(ks));
	if (!vchPubKey.IsFullyValid())
	throw runtime_error(" Invalid public key: "+ks);
	pubkeys[i] = vchPubKey;
	}
	else
	{
	throw runtime_error(" Invalid public key: "+ks);
	}
	}
	CScript result = GetScriptForMultisig(nRequired, pubkeys);

	if (result.size() > MAX_SCRIPT_ELEMENT_SIZE)
	throw runtime_error(
	strprintf("redeemScript exceeds size limit: %d > %d", result.size(), MAX_SCRIPT_ELEMENT_SIZE));

	return result;
	}

	UniValue createmultisig(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() < 2 \|\| params.size() > 2)
	{
	string msg = "createmultisig nrequired [\"key\",...]\n"
	"\nCreates a multi-signature address with n signature of m keys required.\n"
	"It returns a json object with the address and redeemScript.\n"

	"\nArguments:\n"
	"1. nrequired (numeric, required) The number of required signatures out of the n keys or addresses.\n"
	"2. \"keys\" (string, required) A json array of keys which are bitcoin addresses or hex-encoded public keys\n"
	" [\n"
	" \"key\" (string) bitcoin address or hex-encoded public key\n"
	" ,...\n"
	" ]\n"

	"\nResult:\n"
	"{\n"
	" \"address\":\"multisigaddress\", (string) The value of the new multisig address.\n"
	" \"redeemScript\":\"script\" (string) The string value of the hex-encoded redemption script.\n"
	"}\n"

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

	// Construct using pay-to-script-hash:
	CScript inner = _createmultisig_redeemScript(params);
	CScriptID innerID(inner);
	CBitcoinAddress address(innerID);

	UniValue result(UniValue::VOBJ);
	result.push_back(Pair("address", address.ToString()));
	result.push_back(Pair("redeemScript", HexStr(inner.begin(), inner.end())));

	return result;
	}

	UniValue verifymessage(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() != 3)
	throw runtime_error(
	"verifymessage \"bitcoinaddress\" \"signature\" \"message\"\n"
	"\nVerify a signed message\n"
	"\nArguments:\n"
	"1. \"bitcoinaddress\" (string, required) The bitcoin address to use for the signature.\n"
	"2. \"signature\" (string, required) The signature provided by the signer in base 64 encoding (see signmessage).\n"
	"3. \"message\" (string, required) The message that was signed.\n"
	"\nResult:\n"
	"true\|false (boolean) If the signature is verified or not.\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("verifymessage", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\", \"signature\", \"my message\"")
	);

	LOCK(cs_main);

	string strAddress = params[0].get_str();
	string strSign = params[1].get_str();
	string strMessage = params[2].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");

	bool fInvalid = false;
	vector<unsigned char> vchSig = DecodeBase64(strSign.c_str(), &fInvalid);

	if (fInvalid)
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Malformed base64 encoding");

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

	CPubKey pubkey;
	if (!pubkey.RecoverCompact(ss.GetHash(), vchSig))
	return false;

	return (pubkey.GetID() == keyID);
	}

	UniValue setmocktime(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() != 1)
	throw runtime_error(
	"setmocktime timestamp\n"
	"\nSet the local time to given timestamp (-regtest only)\n"
	"\nArguments:\n"
	"1. timestamp (integer, required) Unix seconds-since-epoch timestamp\n"
	" Pass 0 to go back to using the system time."
	);

	if (!Params().MineBlocksOnDemand())
	throw runtime_error("setmocktime for regression testing (-regtest mode) only");

	// cs_vNodes is locked and node send/receive times are updated
	// atomically with the time change to prevent peers from being
	// disconnected because we think we haven't communicated with them
	// in a long time.
	LOCK2(cs_main, cs_vNodes);

	RPCTypeCheck(params, boost::assign::list_of(UniValue::VNUM));
	SetMockTime(params[0].get_int64());

	uint64_t t = GetTime();
	BOOST_FOREACH(CNode* pnode, vNodes) {
	pnode->nLastSend = pnode->nLastRecv = t;
	}

	return NullUniValue;
	}
	diff --git a/src/rpcnet.cpp b/src/rpcnet.cpp
	index ed903f9fd3..d51aa50305 100644
	--- a/src/rpcnet.cpp
	+++ b/src/rpcnet.cpp
	@@ -1,581 +1,581 @@
	// Copyright (c) 2009-2014 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 "rpcserver.h"

	#include "chainparams.h"
	#include "clientversion.h"
	#include "main.h"
	#include "net.h"
	#include "netbase.h"
	#include "protocol.h"
	#include "sync.h"
	#include "timedata.h"
	#include "util.h"
	#include "utilstrencodings.h"
	#include "version.h"

	#include <boost/foreach.hpp>

	#include "univalue/univalue.h"

	using namespace std;

	UniValue getconnectioncount(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() != 0)
	throw runtime_error(
	"getconnectioncount\n"
	"\nReturns the number of connections to other nodes.\n"
	"\nbResult:\n"
	"n (numeric) The connection count\n"
	"\nExamples:\n"
	+ HelpExampleCli("getconnectioncount", "")
	+ HelpExampleRpc("getconnectioncount", "")
	);

	LOCK2(cs_main, cs_vNodes);

	return (int)vNodes.size();
	}

	UniValue ping(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() != 0)
	throw runtime_error(
	"ping\n"
	"\nRequests that a ping be sent to all other nodes, to measure ping time.\n"
	"Results provided in getpeerinfo, pingtime and pingwait fields are decimal seconds.\n"
	"Ping command is handled in queue with all other commands, so it measures processing backlog, not just network ping.\n"
	"\nExamples:\n"
	+ HelpExampleCli("ping", "")
	+ HelpExampleRpc("ping", "")
	);

	// Request that each node send a ping during next message processing pass
	LOCK2(cs_main, cs_vNodes);

	BOOST_FOREACH(CNode* pNode, vNodes) {
	pNode->fPingQueued = true;
	}

	return NullUniValue;
	}

	static void CopyNodeStats(std::vector<CNodeStats>& vstats)
	{
	vstats.clear();

	LOCK(cs_vNodes);
	vstats.reserve(vNodes.size());
	BOOST_FOREACH(CNode* pnode, vNodes) {
	CNodeStats stats;
	pnode->copyStats(stats);
	vstats.push_back(stats);
	}
	}

	UniValue getpeerinfo(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() != 0)
	throw runtime_error(
	"getpeerinfo\n"
	"\nReturns data about each connected network node as a json array of objects.\n"
	"\nbResult:\n"
	"[\n"
	" {\n"
	" \"id\": n, (numeric) Peer index\n"
	" \"addr\":\"host:port\", (string) The ip address and port of the peer\n"
	" \"addrlocal\":\"ip:port\", (string) local address\n"
	" \"services\":\"xxxxxxxxxxxxxxxx\", (string) The services offered\n"
	" \"lastsend\": ttt, (numeric) The time in seconds since epoch (Jan 1 1970 GMT) of the last send\n"
	" \"lastrecv\": ttt, (numeric) The time in seconds since epoch (Jan 1 1970 GMT) of the last receive\n"
	" \"bytessent\": n, (numeric) The total bytes sent\n"
	" \"bytesrecv\": n, (numeric) The total bytes received\n"
	" \"conntime\": ttt, (numeric) The connection time in seconds since epoch (Jan 1 1970 GMT)\n"
	" \"timeoffset\": ttt, (numeric) The time offset in seconds\n"
	" \"pingtime\": n, (numeric) ping time\n"
	" \"pingwait\": n, (numeric) ping wait\n"
	" \"version\": v, (numeric) The peer version, such as 7001\n"
	" \"subver\": \"/Satoshi:0.8.5/\", (string) The string version\n"
	" \"inbound\": true\|false, (boolean) Inbound (true) or Outbound (false)\n"
	" \"startingheight\": n, (numeric) The starting height (block) of the peer\n"
	" \"banscore\": n, (numeric) The ban score\n"
	" \"synced_headers\": n, (numeric) The last header we have in common with this peer\n"
	" \"synced_blocks\": n, (numeric) The last block we have in common with this peer\n"
	" \"inflight\": [\n"
	" n, (numeric) The heights of blocks we're currently asking from this peer\n"
	" ...\n"
	" ]\n"
	" }\n"
	" ,...\n"
	"]\n"
	"\nExamples:\n"
	+ HelpExampleCli("getpeerinfo", "")
	+ HelpExampleRpc("getpeerinfo", "")
	);

	LOCK(cs_main);

	vector<CNodeStats> vstats;
	CopyNodeStats(vstats);

	UniValue ret(UniValue::VARR);

	BOOST_FOREACH(const CNodeStats& stats, vstats) {
	UniValue obj(UniValue::VOBJ);
	CNodeStateStats statestats;
	bool fStateStats = GetNodeStateStats(stats.nodeid, statestats);
	obj.push_back(Pair("id", stats.nodeid));
	obj.push_back(Pair("addr", stats.addrName));
	if (!(stats.addrLocal.empty()))
	obj.push_back(Pair("addrlocal", stats.addrLocal));
	obj.push_back(Pair("services", strprintf("%016x", stats.nServices)));
	obj.push_back(Pair("lastsend", stats.nLastSend));
	obj.push_back(Pair("lastrecv", stats.nLastRecv));
	obj.push_back(Pair("bytessent", stats.nSendBytes));
	obj.push_back(Pair("bytesrecv", stats.nRecvBytes));
	obj.push_back(Pair("conntime", stats.nTimeConnected));
	obj.push_back(Pair("timeoffset", stats.nTimeOffset));
	obj.push_back(Pair("pingtime", stats.dPingTime));
	if (stats.dPingWait > 0.0)
	obj.push_back(Pair("pingwait", stats.dPingWait));
	obj.push_back(Pair("version", stats.nVersion));
	// Use the sanitized form of subver here, to avoid tricksy remote peers from
	// corrupting or modifiying the JSON output by putting special characters in
	// their ver message.
	obj.push_back(Pair("subver", stats.cleanSubVer));
	obj.push_back(Pair("inbound", stats.fInbound));
	obj.push_back(Pair("startingheight", stats.nStartingHeight));
	if (fStateStats) {
	obj.push_back(Pair("banscore", statestats.nMisbehavior));
	obj.push_back(Pair("synced_headers", statestats.nSyncHeight));
	obj.push_back(Pair("synced_blocks", statestats.nCommonHeight));
	UniValue heights(UniValue::VARR);
	BOOST_FOREACH(int height, statestats.vHeightInFlight) {
	heights.push_back(height);
	}
	obj.push_back(Pair("inflight", heights));
	}
	obj.push_back(Pair("whitelisted", stats.fWhitelisted));

	ret.push_back(obj);
	}

	return ret;
	}

	UniValue addnode(const UniValue& params, bool fHelp)
	{
	string strCommand;
	if (params.size() == 2)
	strCommand = params[1].get_str();
	if (fHelp \|\| params.size() != 2 \|\|
	(strCommand != "onetry" && strCommand != "add" && strCommand != "remove"))
	throw runtime_error(
	"addnode \"node\" \"add\|remove\|onetry\"\n"
	"\nAttempts add or remove a node from the addnode list.\n"
	"Or try a connection to a node once.\n"
	"\nArguments:\n"
	"1. \"node\" (string, required) The node (see getpeerinfo for nodes)\n"
	"2. \"command\" (string, required) 'add' to add a node to the list, 'remove' to remove a node from the list, 'onetry' to try a connection to the node once\n"
	"\nExamples:\n"
	+ HelpExampleCli("addnode", "\"192.168.0.6:8333\" \"onetry\"")
	+ HelpExampleRpc("addnode", "\"192.168.0.6:8333\", \"onetry\"")
	);

	string strNode = params[0].get_str();

	if (strCommand == "onetry")
	{
	CAddress addr;
	OpenNetworkConnection(addr, NULL, strNode.c_str());
	return NullUniValue;
	}

	LOCK(cs_vAddedNodes);
	vector<string>::iterator it = vAddedNodes.begin();
	for(; it != vAddedNodes.end(); it++)
	if (strNode == *it)
	break;

	if (strCommand == "add")
	{
	if (it != vAddedNodes.end())
	throw JSONRPCError(RPC_CLIENT_NODE_ALREADY_ADDED, "Error: Node already added");
	vAddedNodes.push_back(strNode);
	}
	else if(strCommand == "remove")
	{
	if (it == vAddedNodes.end())
	throw JSONRPCError(RPC_CLIENT_NODE_NOT_ADDED, "Error: Node has not been added.");
	vAddedNodes.erase(it);
	}

	return NullUniValue;
	}

	UniValue disconnectnode(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() != 1)
	throw runtime_error(
	"disconnectnode \"node\" \n"
	"\nImmediately disconnects from the specified node.\n"
	"\nArguments:\n"
	"1. \"node\" (string, required) The node (see getpeerinfo for nodes)\n"
	"\nExamples:\n"
	+ HelpExampleCli("disconnectnode", "\"192.168.0.6:8333\"")
	+ HelpExampleRpc("disconnectnode", "\"192.168.0.6:8333\"")
	);

	CNode* pNode = FindNode(params[0].get_str());
	if (pNode == NULL)
	throw JSONRPCError(RPC_CLIENT_NODE_NOT_CONNECTED, "Node not found in connected nodes");

	pNode->fDisconnect = true;

	return NullUniValue;
	}

	UniValue getaddednodeinfo(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() < 1 \|\| params.size() > 2)
	throw runtime_error(
	"getaddednodeinfo dns ( \"node\" )\n"
	"\nReturns information about the given added node, or all added nodes\n"
	"(note that onetry addnodes are not listed here)\n"
	"If dns is false, only a list of added nodes will be provided,\n"
	"otherwise connected information will also be available.\n"
	"\nArguments:\n"
	"1. dns (boolean, required) If false, only a list of added nodes will be provided, otherwise connected information will also be available.\n"
	"2. \"node\" (string, optional) If provided, return information about this specific node, otherwise all nodes are returned.\n"
	"\nResult:\n"
	"[\n"
	" {\n"
	" \"addednode\" : \"192.168.0.201\", (string) The node ip address\n"
	" \"connected\" : true\|false, (boolean) If connected\n"
	" \"addresses\" : [\n"
	" {\n"
	" \"address\" : \"192.168.0.201:8333\", (string) The bitcoin server host and port\n"
	" \"connected\" : \"outbound\" (string) connection, inbound or outbound\n"
	" }\n"
	" ,...\n"
	" ]\n"
	" }\n"
	" ,...\n"
	"]\n"
	"\nExamples:\n"
	+ HelpExampleCli("getaddednodeinfo", "true")
	+ HelpExampleCli("getaddednodeinfo", "true \"192.168.0.201\"")
	+ HelpExampleRpc("getaddednodeinfo", "true, \"192.168.0.201\"")
	);

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

	list<string> laddedNodes(0);
	if (params.size() == 1)
	{
	LOCK(cs_vAddedNodes);
	BOOST_FOREACH(const std::string& strAddNode, vAddedNodes)
	laddedNodes.push_back(strAddNode);
	}
	else
	{
	string strNode = params[1].get_str();
	LOCK(cs_vAddedNodes);
	BOOST_FOREACH(const std::string& strAddNode, vAddedNodes) {
	if (strAddNode == strNode)
	{
	laddedNodes.push_back(strAddNode);
	break;
	}
	}
	if (laddedNodes.size() == 0)
	throw JSONRPCError(RPC_CLIENT_NODE_NOT_ADDED, "Error: Node has not been added.");
	}

	UniValue ret(UniValue::VARR);
	if (!fDns)
	{
	BOOST_FOREACH (const std::string& strAddNode, laddedNodes) {
	UniValue obj(UniValue::VOBJ);
	obj.push_back(Pair("addednode", strAddNode));
	ret.push_back(obj);
	}
	return ret;
	}

	list<pair<string, vector<CService> > > laddedAddreses(0);
	BOOST_FOREACH(const std::string& strAddNode, laddedNodes) {
	vector<CService> vservNode(0);
	if(Lookup(strAddNode.c_str(), vservNode, Params().GetDefaultPort(), fNameLookup, 0))
	laddedAddreses.push_back(make_pair(strAddNode, vservNode));
	else
	{
	UniValue obj(UniValue::VOBJ);
	obj.push_back(Pair("addednode", strAddNode));
	obj.push_back(Pair("connected", false));
	UniValue addresses(UniValue::VARR);
	obj.push_back(Pair("addresses", addresses));
	}
	}

	LOCK(cs_vNodes);
	for (list<pair<string, vector<CService> > >::iterator it = laddedAddreses.begin(); it != laddedAddreses.end(); it++)
	{
	UniValue obj(UniValue::VOBJ);
	obj.push_back(Pair("addednode", it->first));

	UniValue addresses(UniValue::VARR);
	bool fConnected = false;
	BOOST_FOREACH(const CService& addrNode, it->second) {
	bool fFound = false;
	UniValue node(UniValue::VOBJ);
	node.push_back(Pair("address", addrNode.ToString()));
	BOOST_FOREACH(CNode* pnode, vNodes) {
	if (pnode->addr == addrNode)
	{
	fFound = true;
	fConnected = true;
	node.push_back(Pair("connected", pnode->fInbound ? "inbound" : "outbound"));
	break;
	}
	}
	if (!fFound)
	node.push_back(Pair("connected", "false"));
	addresses.push_back(node);
	}
	obj.push_back(Pair("connected", fConnected));
	obj.push_back(Pair("addresses", addresses));
	ret.push_back(obj);
	}

	return ret;
	}

	UniValue getnettotals(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() > 0)
	throw runtime_error(
	"getnettotals\n"
	"\nReturns information about network traffic, including bytes in, bytes out,\n"
	"and current time.\n"
	"\nResult:\n"
	"{\n"
	" \"totalbytesrecv\": n, (numeric) Total bytes received\n"
	" \"totalbytessent\": n, (numeric) Total bytes sent\n"
	" \"timemillis\": t (numeric) Total cpu time\n"
	"}\n"
	"\nExamples:\n"
	+ HelpExampleCli("getnettotals", "")
	+ HelpExampleRpc("getnettotals", "")
	);

	UniValue obj(UniValue::VOBJ);
	obj.push_back(Pair("totalbytesrecv", CNode::GetTotalBytesRecv()));
	obj.push_back(Pair("totalbytessent", CNode::GetTotalBytesSent()));
	obj.push_back(Pair("timemillis", GetTimeMillis()));
	return obj;
	}

	static UniValue GetNetworksInfo()
	{
	UniValue networks(UniValue::VARR);
	for(int n=0; n<NET_MAX; ++n)
	{
	enum Network network = static_cast<enum Network>(n);
	if(network == NET_UNROUTABLE)
	continue;
	proxyType proxy;
	UniValue obj(UniValue::VOBJ);
	GetProxy(network, proxy);
	obj.push_back(Pair("name", GetNetworkName(network)));
	obj.push_back(Pair("limited", IsLimited(network)));
	obj.push_back(Pair("reachable", IsReachable(network)));
	obj.push_back(Pair("proxy", proxy.IsValid() ? proxy.proxy.ToStringIPPort() : string()));
	obj.push_back(Pair("proxy_randomize_credentials", proxy.randomize_credentials));
	networks.push_back(obj);
	}
	return networks;
	}

	UniValue getnetworkinfo(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() != 0)
	throw runtime_error(
	"getnetworkinfo\n"
	"Returns an object containing various state info regarding P2P networking.\n"
	"\nResult:\n"
	"{\n"
	" \"version\": xxxxx, (numeric) the server version\n"
	" \"subversion\": \"/Satoshi:x.x.x/\", (string) the server subversion string\n"
	" \"protocolversion\": xxxxx, (numeric) the protocol version\n"
	" \"localservices\": \"xxxxxxxxxxxxxxxx\", (string) the services we offer to the network\n"
	" \"timeoffset\": xxxxx, (numeric) the time offset\n"
	" \"connections\": xxxxx, (numeric) the number of connections\n"
	" \"networks\": [ (array) information per network\n"
	" {\n"
	" \"name\": \"xxx\", (string) network (ipv4, ipv6 or onion)\n"
	" \"limited\": true\|false, (boolean) is the network limited using -onlynet?\n"
	" \"reachable\": true\|false, (boolean) is the network reachable?\n"
	" \"proxy\": \"host:port\" (string) the proxy that is used for this network, or empty if none\n"
	" }\n"
	" ,...\n"
	" ],\n"
	- " \"relayfee\": x.xxxxxxxx, (numeric) minimum relay fee for non-free transactions in btc/kb\n"
	+ " \"relayfee\": x.xxxxxxxx, (numeric) minimum relay fee for non-free transactions in " + CURRENCY_UNIT + "/kB\n"
	" \"localaddresses\": [ (array) list of local addresses\n"
	" {\n"
	" \"address\": \"xxxx\", (string) network address\n"
	" \"port\": xxx, (numeric) network port\n"
	" \"score\": xxx (numeric) relative score\n"
	" }\n"
	" ,...\n"
	" ]\n"
	" \"warnings\": \"...\" (string) any network warnings (such as alert messages) \n"
	"}\n"
	"\nExamples:\n"
	+ HelpExampleCli("getnetworkinfo", "")
	+ HelpExampleRpc("getnetworkinfo", "")
	);

	LOCK(cs_main);

	UniValue obj(UniValue::VOBJ);
	obj.push_back(Pair("version", CLIENT_VERSION));
	obj.push_back(Pair("subversion",
	FormatSubVersion(CLIENT_NAME, CLIENT_VERSION, std::vector<string>())));
	obj.push_back(Pair("protocolversion",PROTOCOL_VERSION));
	obj.push_back(Pair("localservices", strprintf("%016x", nLocalServices)));
	obj.push_back(Pair("timeoffset", GetTimeOffset()));
	obj.push_back(Pair("connections", (int)vNodes.size()));
	obj.push_back(Pair("networks", GetNetworksInfo()));
	obj.push_back(Pair("relayfee", ValueFromAmount(::minRelayTxFee.GetFeePerK())));
	UniValue localAddresses(UniValue::VARR);
	{
	LOCK(cs_mapLocalHost);
	BOOST_FOREACH(const PAIRTYPE(CNetAddr, LocalServiceInfo) &item, mapLocalHost)
	{
	UniValue rec(UniValue::VOBJ);
	rec.push_back(Pair("address", item.first.ToString()));
	rec.push_back(Pair("port", item.second.nPort));
	rec.push_back(Pair("score", item.second.nScore));
	localAddresses.push_back(rec);
	}
	}
	obj.push_back(Pair("localaddresses", localAddresses));
	obj.push_back(Pair("warnings", GetWarnings("statusbar")));
	return obj;
	}

	UniValue setban(const UniValue& params, bool fHelp)
	{
	string strCommand;
	if (params.size() >= 2)
	strCommand = params[1].get_str();
	if (fHelp \|\| params.size() < 2 \|\|
	(strCommand != "add" && strCommand != "remove"))
	throw runtime_error(
	"setban \"ip(/netmask)\" \"add\|remove\" (bantime) (absolute)\n"
	"\nAttempts add or remove a IP/Subnet from the banned list.\n"
	"\nArguments:\n"
	"1. \"ip(/netmask)\" (string, required) The IP/Subnet (see getpeerinfo for nodes ip) with a optional netmask (default is /32 = single ip)\n"
	"2. \"command\" (string, required) 'add' to add a IP/Subnet to the list, 'remove' to remove a IP/Subnet from the list\n"
	"3. \"bantime\" (numeric, optional) time in seconds how long (or until when if [absolute] is set) the ip is banned (0 or empty means using the default time of 24h which can also be overwritten by the -bantime startup argument)\n"
	"4. \"absolute\" (boolean, optional) If set, the bantime must be a absolute timestamp in seconds since epoch (Jan 1 1970 GMT)\n"
	"\nExamples:\n"
	+ HelpExampleCli("setban", "\"192.168.0.6\" \"add\" 86400")
	+ HelpExampleCli("setban", "\"192.168.0.0/24\" \"add\"")
	+ HelpExampleRpc("setban", "\"192.168.0.6\", \"add\" 86400")
	);

	CSubNet subNet;
	CNetAddr netAddr;
	bool isSubnet = false;

	if (params[0].get_str().find("/") != string::npos)
	isSubnet = true;

	if (!isSubnet)
	netAddr = CNetAddr(params[0].get_str());
	else
	subNet = CSubNet(params[0].get_str());

	if (! (isSubnet ? subNet.IsValid() : netAddr.IsValid()) )
	throw JSONRPCError(RPC_CLIENT_NODE_ALREADY_ADDED, "Error: Invalid IP/Subnet");

	if (strCommand == "add")
	{
	if (isSubnet ? CNode::IsBanned(subNet) : CNode::IsBanned(netAddr))
	throw JSONRPCError(RPC_CLIENT_NODE_ALREADY_ADDED, "Error: IP/Subnet already banned");

	int64_t banTime = 0; //use standard bantime if not specified
	if (params.size() >= 3 && !params[2].isNull())
	banTime = params[2].get_int64();

	bool absolute = false;
	if (params.size() == 4 && params[3].isTrue())
	absolute = true;

	isSubnet ? CNode::Ban(subNet, BanReasonManuallyAdded, banTime, absolute) : CNode::Ban(netAddr, BanReasonManuallyAdded, banTime, absolute);

	//disconnect possible nodes
	while(CNode *bannedNode = (isSubnet ? FindNode(subNet) : FindNode(netAddr)))
	bannedNode->fDisconnect = true;
	}
	else if(strCommand == "remove")
	{
	if (!( isSubnet ? CNode::Unban(subNet) : CNode::Unban(netAddr) ))
	throw JSONRPCError(RPC_MISC_ERROR, "Error: Unban failed");
	}

	DumpBanlist(); //store banlist to disk
	return NullUniValue;
	}

	UniValue listbanned(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() != 0)
	throw runtime_error(
	"listbanned\n"
	"\nList all banned IPs/Subnets.\n"
	"\nExamples:\n"
	+ HelpExampleCli("listbanned", "")
	+ HelpExampleRpc("listbanned", "")
	);

	banmap_t banMap;
	CNode::GetBanned(banMap);

	UniValue bannedAddresses(UniValue::VARR);
	for (banmap_t::iterator it = banMap.begin(); it != banMap.end(); it++)
	{
	CBanEntry banEntry = (*it).second;
	UniValue rec(UniValue::VOBJ);
	rec.push_back(Pair("address", (*it).first.ToString()));
	rec.push_back(Pair("banned_until", banEntry.nBanUntil));
	rec.push_back(Pair("ban_created", banEntry.nCreateTime));
	rec.push_back(Pair("ban_reason", banEntry.banReasonToString()));

	bannedAddresses.push_back(rec);
	}

	return bannedAddresses;
	}

	UniValue clearbanned(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() != 0)
	throw runtime_error(
	"clearbanned\n"
	"\nClear all banned IPs.\n"
	"\nExamples:\n"
	+ HelpExampleCli("clearbanned", "")
	+ HelpExampleRpc("clearbanned", "")
	);

	CNode::ClearBanned();
	DumpBanlist(); //store banlist to disk

	return NullUniValue;
	}
	diff --git a/src/rpcrawtransaction.cpp b/src/rpcrawtransaction.cpp
	index 62d2ef69ef..a3246b41fb 100644
	--- a/src/rpcrawtransaction.cpp
	+++ b/src/rpcrawtransaction.cpp
	@@ -1,817 +1,817 @@
	// 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 "base58.h"
	#include "chain.h"
	#include "coins.h"
	#include "consensus/validation.h"
	#include "core_io.h"
	#include "init.h"
	#include "keystore.h"
	#include "main.h"
	#include "merkleblock.h"
	#include "net.h"
	#include "policy/policy.h"
	#include "primitives/transaction.h"
	#include "rpcserver.h"
	#include "script/script.h"
	#include "script/script_error.h"
	#include "script/sign.h"
	#include "script/standard.h"
	#include "txmempool.h"
	#include "uint256.h"
	#include "utilstrencodings.h"
	#ifdef ENABLE_WALLET
	#include "wallet/wallet.h"
	#endif

	#include <stdint.h>

	#include <boost/assign/list_of.hpp>

	#include "univalue/univalue.h"

	using namespace std;

	void ScriptPubKeyToJSON(const CScript& scriptPubKey, UniValue& out, bool fIncludeHex)
	{
	txnouttype type;
	vector<CTxDestination> addresses;
	int nRequired;

	out.push_back(Pair("asm", scriptPubKey.ToString()));
	if (fIncludeHex)
	out.push_back(Pair("hex", HexStr(scriptPubKey.begin(), scriptPubKey.end())));

	if (!ExtractDestinations(scriptPubKey, type, addresses, nRequired)) {
	out.push_back(Pair("type", GetTxnOutputType(type)));
	return;
	}

	out.push_back(Pair("reqSigs", nRequired));
	out.push_back(Pair("type", GetTxnOutputType(type)));

	UniValue a(UniValue::VARR);
	BOOST_FOREACH(const CTxDestination& addr, addresses)
	a.push_back(CBitcoinAddress(addr).ToString());
	out.push_back(Pair("addresses", a));
	}

	void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue& entry)
	{
	entry.push_back(Pair("txid", tx.GetHash().GetHex()));
	entry.push_back(Pair("version", tx.nVersion));
	entry.push_back(Pair("locktime", (int64_t)tx.nLockTime));
	UniValue vin(UniValue::VARR);
	BOOST_FOREACH(const CTxIn& txin, tx.vin) {
	UniValue in(UniValue::VOBJ);
	if (tx.IsCoinBase())
	in.push_back(Pair("coinbase", HexStr(txin.scriptSig.begin(), txin.scriptSig.end())));
	else {
	in.push_back(Pair("txid", txin.prevout.hash.GetHex()));
	in.push_back(Pair("vout", (int64_t)txin.prevout.n));
	UniValue o(UniValue::VOBJ);
	o.push_back(Pair("asm", txin.scriptSig.ToString()));
	o.push_back(Pair("hex", HexStr(txin.scriptSig.begin(), txin.scriptSig.end())));
	in.push_back(Pair("scriptSig", o));
	}
	in.push_back(Pair("sequence", (int64_t)txin.nSequence));
	vin.push_back(in);
	}
	entry.push_back(Pair("vin", vin));
	UniValue vout(UniValue::VARR);
	for (unsigned int i = 0; i < tx.vout.size(); i++) {
	const CTxOut& txout = tx.vout[i];
	UniValue out(UniValue::VOBJ);
	out.push_back(Pair("value", ValueFromAmount(txout.nValue)));
	out.push_back(Pair("n", (int64_t)i));
	UniValue o(UniValue::VOBJ);
	ScriptPubKeyToJSON(txout.scriptPubKey, o, true);
	out.push_back(Pair("scriptPubKey", o));
	vout.push_back(out);
	}
	entry.push_back(Pair("vout", vout));

	if (!hashBlock.IsNull()) {
	entry.push_back(Pair("blockhash", hashBlock.GetHex()));
	BlockMap::iterator mi = mapBlockIndex.find(hashBlock);
	if (mi != mapBlockIndex.end() && (*mi).second) {
	CBlockIndex* pindex = (*mi).second;
	if (chainActive.Contains(pindex)) {
	entry.push_back(Pair("confirmations", 1 + chainActive.Height() - pindex->nHeight));
	entry.push_back(Pair("time", pindex->GetBlockTime()));
	entry.push_back(Pair("blocktime", pindex->GetBlockTime()));
	}
	else
	entry.push_back(Pair("confirmations", 0));
	}
	}
	}

	UniValue getrawtransaction(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() < 1 \|\| params.size() > 2)
	throw runtime_error(
	"getrawtransaction \"txid\" ( verbose )\n"
	"\nNOTE: By default this function only works sometimes. This is when the tx is in the mempool\n"
	"or there is an unspent output in the utxo for this transaction. To make it always work,\n"
	"you need to maintain a transaction index, using the -txindex command line option.\n"
	"\nReturn the raw transaction data.\n"
	"\nIf verbose=0, returns a string that is serialized, hex-encoded data for 'txid'.\n"
	"If verbose is non-zero, returns an Object with information about 'txid'.\n"

	"\nArguments:\n"
	"1. \"txid\" (string, required) The transaction id\n"
	"2. verbose (numeric, optional, default=0) If 0, return a string, other return a json object\n"

	"\nResult (if verbose is not set or set to 0):\n"
	"\"data\" (string) The serialized, hex-encoded data for 'txid'\n"

	"\nResult (if verbose > 0):\n"
	"{\n"
	" \"hex\" : \"data\", (string) The serialized, hex-encoded data for 'txid'\n"
	" \"txid\" : \"id\", (string) The transaction id (same as provided)\n"
	" \"version\" : n, (numeric) The version\n"
	" \"locktime\" : ttt, (numeric) The lock time\n"
	" \"vin\" : [ (array of json objects)\n"
	" {\n"
	" \"txid\": \"id\", (string) The transaction id\n"
	" \"vout\": n, (numeric) \n"
	" \"scriptSig\": { (json object) The script\n"
	" \"asm\": \"asm\", (string) asm\n"
	" \"hex\": \"hex\" (string) hex\n"
	" },\n"
	" \"sequence\": n (numeric) The script sequence number\n"
	" }\n"
	" ,...\n"
	" ],\n"
	" \"vout\" : [ (array of json objects)\n"
	" {\n"
	- " \"value\" : x.xxx, (numeric) The value in btc\n"
	+ " \"value\" : x.xxx, (numeric) The value in " + CURRENCY_UNIT + "\n"
	" \"n\" : n, (numeric) index\n"
	" \"scriptPubKey\" : { (json object)\n"
	" \"asm\" : \"asm\", (string) the asm\n"
	" \"hex\" : \"hex\", (string) the hex\n"
	" \"reqSigs\" : n, (numeric) The required sigs\n"
	" \"type\" : \"pubkeyhash\", (string) The type, eg 'pubkeyhash'\n"
	" \"addresses\" : [ (json array of string)\n"
	" \"bitcoinaddress\" (string) bitcoin address\n"
	" ,...\n"
	" ]\n"
	" }\n"
	" }\n"
	" ,...\n"
	" ],\n"
	" \"blockhash\" : \"hash\", (string) the block hash\n"
	" \"confirmations\" : n, (numeric) The confirmations\n"
	" \"time\" : ttt, (numeric) The transaction time in seconds since epoch (Jan 1 1970 GMT)\n"
	" \"blocktime\" : ttt (numeric) The block time in seconds since epoch (Jan 1 1970 GMT)\n"
	"}\n"

	"\nExamples:\n"
	+ HelpExampleCli("getrawtransaction", "\"mytxid\"")
	+ HelpExampleCli("getrawtransaction", "\"mytxid\" 1")
	+ HelpExampleRpc("getrawtransaction", "\"mytxid\", 1")
	);

	LOCK(cs_main);

	uint256 hash = ParseHashV(params[0], "parameter 1");

	bool fVerbose = false;
	if (params.size() > 1)
	fVerbose = (params[1].get_int() != 0);

	CTransaction tx;
	uint256 hashBlock;
	if (!GetTransaction(hash, tx, hashBlock, true))
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available about transaction");

	string strHex = EncodeHexTx(tx);

	if (!fVerbose)
	return strHex;

	UniValue result(UniValue::VOBJ);
	result.push_back(Pair("hex", strHex));
	TxToJSON(tx, hashBlock, result);
	return result;
	}

	UniValue gettxoutproof(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| (params.size() != 1 && params.size() != 2))
	throw runtime_error(
	"gettxoutproof [\"txid\",...] ( blockhash )\n"
	"\nReturns a hex-encoded proof that \"txid\" was included in a block.\n"
	"\nNOTE: By default this function only works sometimes. This is when there is an\n"
	"unspent output in the utxo for this transaction. To make it always work,\n"
	"you need to maintain a transaction index, using the -txindex command line option or\n"
	"specify the block in which the transaction is included in manually (by blockhash).\n"
	"\nReturn the raw transaction data.\n"
	"\nArguments:\n"
	"1. \"txids\" (string) A json array of txids to filter\n"
	" [\n"
	" \"txid\" (string) A transaction hash\n"
	" ,...\n"
	" ]\n"
	"2. \"block hash\" (string, optional) If specified, looks for txid in the block with this hash\n"
	"\nResult:\n"
	"\"data\" (string) A string that is a serialized, hex-encoded data for the proof.\n"
	);

	set<uint256> setTxids;
	uint256 oneTxid;
	UniValue txids = params[0].get_array();
	for (unsigned int idx = 0; idx < txids.size(); idx++) {
	const UniValue& txid = txids[idx];
	if (txid.get_str().length() != 64 \|\| !IsHex(txid.get_str()))
	throw JSONRPCError(RPC_INVALID_PARAMETER, string("Invalid txid ")+txid.get_str());
	uint256 hash(uint256S(txid.get_str()));
	if (setTxids.count(hash))
	throw JSONRPCError(RPC_INVALID_PARAMETER, string("Invalid parameter, duplicated txid: ")+txid.get_str());
	setTxids.insert(hash);
	oneTxid = hash;
	}

	LOCK(cs_main);

	CBlockIndex* pblockindex = NULL;

	uint256 hashBlock;
	if (params.size() > 1)
	{
	hashBlock = uint256S(params[1].get_str());
	if (!mapBlockIndex.count(hashBlock))
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
	pblockindex = mapBlockIndex[hashBlock];
	} else {
	CCoins coins;
	if (pcoinsTip->GetCoins(oneTxid, coins) && coins.nHeight > 0 && coins.nHeight <= chainActive.Height())
	pblockindex = chainActive[coins.nHeight];
	}

	if (pblockindex == NULL)
	{
	CTransaction tx;
	if (!GetTransaction(oneTxid, tx, hashBlock, false) \|\| hashBlock.IsNull())
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Transaction not yet in block");
	if (!mapBlockIndex.count(hashBlock))
	throw JSONRPCError(RPC_INTERNAL_ERROR, "Transaction index corrupt");
	pblockindex = mapBlockIndex[hashBlock];
	}

	CBlock block;
	if(!ReadBlockFromDisk(block, pblockindex))
	throw JSONRPCError(RPC_INTERNAL_ERROR, "Can't read block from disk");

	unsigned int ntxFound = 0;
	BOOST_FOREACH(const CTransaction&tx, block.vtx)
	if (setTxids.count(tx.GetHash()))
	ntxFound++;
	if (ntxFound != setTxids.size())
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "(Not all) transactions not found in specified block");

	CDataStream ssMB(SER_NETWORK, PROTOCOL_VERSION);
	CMerkleBlock mb(block, setTxids);
	ssMB << mb;
	std::string strHex = HexStr(ssMB.begin(), ssMB.end());
	return strHex;
	}

	UniValue verifytxoutproof(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() != 1)
	throw runtime_error(
	"verifytxoutproof \"proof\"\n"
	"\nVerifies that a proof points to a transaction in a block, returning the transaction it commits to\n"
	"and throwing an RPC error if the block is not in our best chain\n"
	"\nArguments:\n"
	"1. \"proof\" (string, required) The hex-encoded proof generated by gettxoutproof\n"
	"\nResult:\n"
	"[\"txid\"] (array, strings) The txid(s) which the proof commits to, or empty array if the proof is invalid\n"
	);

	CDataStream ssMB(ParseHexV(params[0], "proof"), SER_NETWORK, PROTOCOL_VERSION);
	CMerkleBlock merkleBlock;
	ssMB >> merkleBlock;

	UniValue res(UniValue::VARR);

	vector<uint256> vMatch;
	if (merkleBlock.txn.ExtractMatches(vMatch) != merkleBlock.header.hashMerkleRoot)
	return res;

	LOCK(cs_main);

	if (!mapBlockIndex.count(merkleBlock.header.GetHash()) \|\| !chainActive.Contains(mapBlockIndex[merkleBlock.header.GetHash()]))
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found in chain");

	BOOST_FOREACH(const uint256& hash, vMatch)
	res.push_back(hash.GetHex());
	return res;
	}

	UniValue createrawtransaction(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() != 2)
	throw runtime_error(
	"createrawtransaction [{\"txid\":\"id\",\"vout\":n},...] {\"address\":amount,...}\n"
	"\nCreate a transaction spending the given inputs and sending to the given addresses.\n"
	"Returns hex-encoded raw transaction.\n"
	"Note that the transaction's inputs are not signed, and\n"
	"it is not stored in the wallet or transmitted to the network.\n"

	"\nArguments:\n"
	"1. \"transactions\" (string, required) A json array of json objects\n"
	" [\n"
	" {\n"
	" \"txid\":\"id\", (string, required) The transaction id\n"
	" \"vout\":n (numeric, required) The output number\n"
	" }\n"
	" ,...\n"
	" ]\n"
	"2. \"addresses\" (string, required) a json object with addresses as keys and amounts as values\n"
	" {\n"
	- " \"address\": x.xxx (numeric, required) The key is the bitcoin address, the value is the btc amount\n"
	+ " \"address\": x.xxx (numeric, required) The key is the bitcoin address, the value is the " + CURRENCY_UNIT + " amount\n"
	" ,...\n"
	" }\n"

	"\nResult:\n"
	"\"transaction\" (string) hex string of the transaction\n"

	"\nExamples\n"
	+ HelpExampleCli("createrawtransaction", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"{\\\"address\\\":0.01}\"")
	+ HelpExampleRpc("createrawtransaction", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\", \"{\\\"address\\\":0.01}\"")
	);

	LOCK(cs_main);
	RPCTypeCheck(params, boost::assign::list_of(UniValue::VARR)(UniValue::VOBJ));

	UniValue inputs = params[0].get_array();
	UniValue sendTo = params[1].get_obj();

	CMutableTransaction rawTx;

	for (unsigned int idx = 0; idx < inputs.size(); idx++) {
	const UniValue& input = inputs[idx];
	const UniValue& o = input.get_obj();

	uint256 txid = ParseHashO(o, "txid");

	const UniValue& vout_v = find_value(o, "vout");
	if (!vout_v.isNum())
	throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, missing vout key");
	int nOutput = vout_v.get_int();
	if (nOutput < 0)
	throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, vout must be positive");

	CTxIn in(COutPoint(txid, nOutput));
	rawTx.vin.push_back(in);
	}

	set<CBitcoinAddress> setAddress;
	vector<string> addrList = sendTo.getKeys();
	BOOST_FOREACH(const string& name_, addrList) {
	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_]);

	CTxOut out(nAmount, scriptPubKey);
	rawTx.vout.push_back(out);
	}

	return EncodeHexTx(rawTx);
	}

	UniValue decoderawtransaction(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() != 1)
	throw runtime_error(
	"decoderawtransaction \"hexstring\"\n"
	"\nReturn a JSON object representing the serialized, hex-encoded transaction.\n"

	"\nArguments:\n"
	"1. \"hex\" (string, required) The transaction hex string\n"

	"\nResult:\n"
	"{\n"
	" \"txid\" : \"id\", (string) The transaction id\n"
	" \"version\" : n, (numeric) The version\n"
	" \"locktime\" : ttt, (numeric) The lock time\n"
	" \"vin\" : [ (array of json objects)\n"
	" {\n"
	" \"txid\": \"id\", (string) The transaction id\n"
	" \"vout\": n, (numeric) The output number\n"
	" \"scriptSig\": { (json object) The script\n"
	" \"asm\": \"asm\", (string) asm\n"
	" \"hex\": \"hex\" (string) hex\n"
	" },\n"
	" \"sequence\": n (numeric) The script sequence number\n"
	" }\n"
	" ,...\n"
	" ],\n"
	" \"vout\" : [ (array of json objects)\n"
	" {\n"
	- " \"value\" : x.xxx, (numeric) The value in btc\n"
	+ " \"value\" : x.xxx, (numeric) The value in " + CURRENCY_UNIT + "\n"
	" \"n\" : n, (numeric) index\n"
	" \"scriptPubKey\" : { (json object)\n"
	" \"asm\" : \"asm\", (string) the asm\n"
	" \"hex\" : \"hex\", (string) the hex\n"
	" \"reqSigs\" : n, (numeric) The required sigs\n"
	" \"type\" : \"pubkeyhash\", (string) The type, eg 'pubkeyhash'\n"
	" \"addresses\" : [ (json array of string)\n"
	" \"12tvKAXCxZjSmdNbao16dKXC8tRWfcF5oc\" (string) bitcoin address\n"
	" ,...\n"
	" ]\n"
	" }\n"
	" }\n"
	" ,...\n"
	" ],\n"
	"}\n"

	"\nExamples:\n"
	+ HelpExampleCli("decoderawtransaction", "\"hexstring\"")
	+ HelpExampleRpc("decoderawtransaction", "\"hexstring\"")
	);

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

	CTransaction tx;

	if (!DecodeHexTx(tx, params[0].get_str()))
	throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");

	UniValue result(UniValue::VOBJ);
	TxToJSON(tx, uint256(), result);

	return result;
	}

	UniValue decodescript(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() != 1)
	throw runtime_error(
	"decodescript \"hex\"\n"
	"\nDecode a hex-encoded script.\n"
	"\nArguments:\n"
	"1. \"hex\" (string) the hex encoded script\n"
	"\nResult:\n"
	"{\n"
	" \"asm\":\"asm\", (string) Script public key\n"
	" \"hex\":\"hex\", (string) hex encoded public key\n"
	" \"type\":\"type\", (string) The output type\n"
	" \"reqSigs\": n, (numeric) The required signatures\n"
	" \"addresses\": [ (json array of string)\n"
	" \"address\" (string) bitcoin address\n"
	" ,...\n"
	" ],\n"
	" \"p2sh\",\"address\" (string) script address\n"
	"}\n"
	"\nExamples:\n"
	+ HelpExampleCli("decodescript", "\"hexstring\"")
	+ HelpExampleRpc("decodescript", "\"hexstring\"")
	);

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

	UniValue r(UniValue::VOBJ);
	CScript script;
	if (params[0].get_str().size() > 0){
	vector<unsigned char> scriptData(ParseHexV(params[0], "argument"));
	script = CScript(scriptData.begin(), scriptData.end());
	} else {
	// Empty scripts are valid
	}
	ScriptPubKeyToJSON(script, r, false);

	r.push_back(Pair("p2sh", CBitcoinAddress(CScriptID(script)).ToString()));
	return r;
	}

	/** Pushes a JSON object for script verification or signing errors to vErrorsRet. */
	static void TxInErrorToJSON(const CTxIn& txin, UniValue& vErrorsRet, const std::string& strMessage)
	{
	UniValue entry(UniValue::VOBJ);
	entry.push_back(Pair("txid", txin.prevout.hash.ToString()));
	entry.push_back(Pair("vout", (uint64_t)txin.prevout.n));
	entry.push_back(Pair("scriptSig", HexStr(txin.scriptSig.begin(), txin.scriptSig.end())));
	entry.push_back(Pair("sequence", (uint64_t)txin.nSequence));
	entry.push_back(Pair("error", strMessage));
	vErrorsRet.push_back(entry);
	}

	UniValue signrawtransaction(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() < 1 \|\| params.size() > 4)
	throw runtime_error(
	"signrawtransaction \"hexstring\" ( [{\"txid\":\"id\",\"vout\":n,\"scriptPubKey\":\"hex\",\"redeemScript\":\"hex\"},...] [\"privatekey1\",...] sighashtype )\n"
	"\nSign inputs for raw transaction (serialized, hex-encoded).\n"
	"The second optional argument (may be null) is an array of previous transaction outputs that\n"
	"this transaction depends on but may not yet be in the block chain.\n"
	"The third optional argument (may be null) is an array of base58-encoded private\n"
	"keys that, if given, will be the only keys used to sign the transaction.\n"
	#ifdef ENABLE_WALLET
	+ HelpRequiringPassphrase() + "\n"
	#endif

	"\nArguments:\n"
	"1. \"hexstring\" (string, required) The transaction hex string\n"
	"2. \"prevtxs\" (string, optional) An json array of previous dependent transaction outputs\n"
	" [ (json array of json objects, or 'null' if none provided)\n"
	" {\n"
	" \"txid\":\"id\", (string, required) The transaction id\n"
	" \"vout\":n, (numeric, required) The output number\n"
	" \"scriptPubKey\": \"hex\", (string, required) script key\n"
	" \"redeemScript\": \"hex\" (string, required for P2SH) redeem script\n"
	" }\n"
	" ,...\n"
	" ]\n"
	"3. \"privatekeys\" (string, optional) A json array of base58-encoded private keys for signing\n"
	" [ (json array of strings, or 'null' if none provided)\n"
	" \"privatekey\" (string) private key in base58-encoding\n"
	" ,...\n"
	" ]\n"
	"4. \"sighashtype\" (string, optional, default=ALL) The signature hash type. Must be one of\n"
	" \"ALL\"\n"
	" \"NONE\"\n"
	" \"SINGLE\"\n"
	" \"ALL\|ANYONECANPAY\"\n"
	" \"NONE\|ANYONECANPAY\"\n"
	" \"SINGLE\|ANYONECANPAY\"\n"

	"\nResult:\n"
	"{\n"
	" \"hex\" : \"value\", (string) The hex-encoded raw transaction with signature(s)\n"
	" \"complete\" : true\|false, (boolean) If the transaction has a complete set of signatures\n"
	" \"errors\" : [ (json array of objects) Script verification errors (if there are any)\n"
	" {\n"
	" \"txid\" : \"hash\", (string) The hash of the referenced, previous transaction\n"
	" \"vout\" : n, (numeric) The index of the output to spent and used as input\n"
	" \"scriptSig\" : \"hex\", (string) The hex-encoded signature script\n"
	" \"sequence\" : n, (numeric) Script sequence number\n"
	" \"error\" : \"text\" (string) Verification or signing error related to the input\n"
	" }\n"
	" ,...\n"
	" ]\n"
	"}\n"

	"\nExamples:\n"
	+ HelpExampleCli("signrawtransaction", "\"myhex\"")
	+ HelpExampleRpc("signrawtransaction", "\"myhex\"")
	);

	#ifdef ENABLE_WALLET
	LOCK2(cs_main, pwalletMain ? &pwalletMain->cs_wallet : NULL);
	#else
	LOCK(cs_main);
	#endif
	RPCTypeCheck(params, boost::assign::list_of(UniValue::VSTR)(UniValue::VARR)(UniValue::VARR)(UniValue::VSTR), true);

	vector<unsigned char> txData(ParseHexV(params[0], "argument 1"));
	CDataStream ssData(txData, SER_NETWORK, PROTOCOL_VERSION);
	vector<CMutableTransaction> txVariants;
	while (!ssData.empty()) {
	try {
	CMutableTransaction tx;
	ssData >> tx;
	txVariants.push_back(tx);
	}
	catch (const std::exception&) {
	throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
	}
	}

	if (txVariants.empty())
	throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Missing transaction");

	// mergedTx will end up with all the signatures; it
	// starts as a clone of the rawtx:
	CMutableTransaction mergedTx(txVariants[0]);

	// Fetch previous transactions (inputs):
	CCoinsView viewDummy;
	CCoinsViewCache view(&viewDummy);
	{
	LOCK(mempool.cs);
	CCoinsViewCache &viewChain = *pcoinsTip;
	CCoinsViewMemPool viewMempool(&viewChain, mempool);
	view.SetBackend(viewMempool); // temporarily switch cache backend to db+mempool view

	BOOST_FOREACH(const CTxIn& txin, mergedTx.vin) {
	const uint256& prevHash = txin.prevout.hash;
	CCoins coins;
	view.AccessCoins(prevHash); // this is certainly allowed to fail
	}

	view.SetBackend(viewDummy); // switch back to avoid locking mempool for too long
	}

	bool fGivenKeys = false;
	CBasicKeyStore tempKeystore;
	if (params.size() > 2 && !params[2].isNull()) {
	fGivenKeys = true;
	UniValue keys = params[2].get_array();
	for (unsigned int idx = 0; idx < keys.size(); idx++) {
	UniValue k = keys[idx];
	CBitcoinSecret vchSecret;
	bool fGood = vchSecret.SetString(k.get_str());
	if (!fGood)
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid private key");
	CKey key = vchSecret.GetKey();
	if (!key.IsValid())
	throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Private key outside allowed range");
	tempKeystore.AddKey(key);
	}
	}
	#ifdef ENABLE_WALLET
	else if (pwalletMain)
	EnsureWalletIsUnlocked();
	#endif

	// Add previous txouts given in the RPC call:
	if (params.size() > 1 && !params[1].isNull()) {
	UniValue prevTxs = params[1].get_array();
	for (unsigned int idx = 0; idx < prevTxs.size(); idx++) {
	const UniValue& p = prevTxs[idx];
	if (!p.isObject())
	throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "expected object with {\"txid'\",\"vout\",\"scriptPubKey\"}");

	UniValue prevOut = p.get_obj();

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

	uint256 txid = ParseHashO(prevOut, "txid");

	int nOut = find_value(prevOut, "vout").get_int();
	if (nOut < 0)
	throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "vout must be positive");

	vector<unsigned char> pkData(ParseHexO(prevOut, "scriptPubKey"));
	CScript scriptPubKey(pkData.begin(), pkData.end());

	{
	CCoinsModifier coins = view.ModifyCoins(txid);
	if (coins->IsAvailable(nOut) && coins->vout[nOut].scriptPubKey != scriptPubKey) {
	string err("Previous output scriptPubKey mismatch:\n");
	err = err + coins->vout[nOut].scriptPubKey.ToString() + "\nvs:\n"+
	scriptPubKey.ToString();
	throw JSONRPCError(RPC_DESERIALIZATION_ERROR, err);
	}
	if ((unsigned int)nOut >= coins->vout.size())
	coins->vout.resize(nOut+1);
	coins->vout[nOut].scriptPubKey = scriptPubKey;
	coins->vout[nOut].nValue = 0; // we don't know the actual output value
	}

	// if redeemScript given and not using the local wallet (private keys
	// given), add redeemScript to the tempKeystore so it can be signed:
	if (fGivenKeys && scriptPubKey.IsPayToScriptHash()) {
	RPCTypeCheckObj(prevOut, boost::assign::map_list_of("txid", UniValue::VSTR)("vout", UniValue::VNUM)("scriptPubKey", UniValue::VSTR)("redeemScript",UniValue::VSTR));
	UniValue v = find_value(prevOut, "redeemScript");
	if (!v.isNull()) {
	vector<unsigned char> rsData(ParseHexV(v, "redeemScript"));
	CScript redeemScript(rsData.begin(), rsData.end());
	tempKeystore.AddCScript(redeemScript);
	}
	}
	}
	}

	#ifdef ENABLE_WALLET
	const CKeyStore& keystore = ((fGivenKeys \|\| !pwalletMain) ? tempKeystore : *pwalletMain);
	#else
	const CKeyStore& keystore = tempKeystore;
	#endif

	int nHashType = SIGHASH_ALL;
	if (params.size() > 3 && !params[3].isNull()) {
	static map<string, int> mapSigHashValues =
	boost::assign::map_list_of
	(string("ALL"), int(SIGHASH_ALL))
	(string("ALL\|ANYONECANPAY"), int(SIGHASH_ALL\|SIGHASH_ANYONECANPAY))
	(string("NONE"), int(SIGHASH_NONE))
	(string("NONE\|ANYONECANPAY"), int(SIGHASH_NONE\|SIGHASH_ANYONECANPAY))
	(string("SINGLE"), int(SIGHASH_SINGLE))
	(string("SINGLE\|ANYONECANPAY"), int(SIGHASH_SINGLE\|SIGHASH_ANYONECANPAY))
	;
	string strHashType = params[3].get_str();
	if (mapSigHashValues.count(strHashType))
	nHashType = mapSigHashValues[strHashType];
	else
	throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid sighash param");
	}

	bool fHashSingle = ((nHashType & ~SIGHASH_ANYONECANPAY) == SIGHASH_SINGLE);

	// Script verification errors
	UniValue vErrors(UniValue::VARR);

	// Sign what we can:
	for (unsigned int i = 0; i < mergedTx.vin.size(); i++) {
	CTxIn& txin = mergedTx.vin[i];
	const CCoins* coins = view.AccessCoins(txin.prevout.hash);
	if (coins == NULL \|\| !coins->IsAvailable(txin.prevout.n)) {
	TxInErrorToJSON(txin, vErrors, "Input not found or already spent");
	continue;
	}
	const CScript& prevPubKey = coins->vout[txin.prevout.n].scriptPubKey;

	txin.scriptSig.clear();
	// Only sign SIGHASH_SINGLE if there's a corresponding output:
	if (!fHashSingle \|\| (i < mergedTx.vout.size()))
	SignSignature(keystore, prevPubKey, mergedTx, i, nHashType);

	// ... and merge in other signatures:
	BOOST_FOREACH(const CMutableTransaction& txv, txVariants) {
	txin.scriptSig = CombineSignatures(prevPubKey, mergedTx, i, txin.scriptSig, txv.vin[i].scriptSig);
	}
	ScriptError serror = SCRIPT_ERR_OK;
	if (!VerifyScript(txin.scriptSig, prevPubKey, STANDARD_SCRIPT_VERIFY_FLAGS, MutableTransactionSignatureChecker(&mergedTx, i), &serror)) {
	TxInErrorToJSON(txin, vErrors, ScriptErrorString(serror));
	}
	}
	bool fComplete = vErrors.empty();

	UniValue result(UniValue::VOBJ);
	result.push_back(Pair("hex", EncodeHexTx(mergedTx)));
	result.push_back(Pair("complete", fComplete));
	if (!vErrors.empty()) {
	result.push_back(Pair("errors", vErrors));
	}

	return result;
	}

	UniValue sendrawtransaction(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() < 1 \|\| params.size() > 2)
	throw runtime_error(
	"sendrawtransaction \"hexstring\" ( allowhighfees )\n"
	"\nSubmits raw transaction (serialized, hex-encoded) to local node and network.\n"
	"\nAlso see createrawtransaction and signrawtransaction calls.\n"
	"\nArguments:\n"
	"1. \"hexstring\" (string, required) The hex string of the raw transaction)\n"
	"2. allowhighfees (boolean, optional, default=false) Allow high fees\n"
	"\nResult:\n"
	"\"hex\" (string) The transaction hash in hex\n"
	"\nExamples:\n"
	"\nCreate a transaction\n"
	+ HelpExampleCli("createrawtransaction", "\"[{\\\"txid\\\" : \\\"mytxid\\\",\\\"vout\\\":0}]\" \"{\\\"myaddress\\\":0.01}\"") +
	"Sign the transaction, and get back the hex\n"
	+ HelpExampleCli("signrawtransaction", "\"myhex\"") +
	"\nSend the transaction (signed hex)\n"
	+ HelpExampleCli("sendrawtransaction", "\"signedhex\"") +
	"\nAs a json rpc call\n"
	+ HelpExampleRpc("sendrawtransaction", "\"signedhex\"")
	);

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

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

	bool fOverrideFees = false;
	if (params.size() > 1)
	fOverrideFees = params[1].get_bool();

	CCoinsViewCache &view = *pcoinsTip;
	const CCoins* existingCoins = view.AccessCoins(hashTx);
	bool fHaveMempool = mempool.exists(hashTx);
	bool fHaveChain = existingCoins && existingCoins->nHeight < 1000000000;
	if (!fHaveMempool && !fHaveChain) {
	// push to local node and sync with wallets
	CValidationState state;
	bool fMissingInputs;
	if (!AcceptToMemoryPool(mempool, state, tx, false, &fMissingInputs, !fOverrideFees)) {
	if (state.IsInvalid()) {
	throw JSONRPCError(RPC_TRANSACTION_REJECTED, strprintf("%i: %s", state.GetRejectCode(), state.GetRejectReason()));
	} else {
	if (fMissingInputs) {
	throw JSONRPCError(RPC_TRANSACTION_ERROR, "Missing inputs");
	}
	throw JSONRPCError(RPC_TRANSACTION_ERROR, state.GetRejectReason());
	}
	}
	} else if (fHaveChain) {
	throw JSONRPCError(RPC_TRANSACTION_ALREADY_IN_CHAIN, "transaction already in block chain");
	}
	RelayTransaction(tx);

	return hashTx.GetHex();
	}
	diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
	index 342ce13af1..198b5baf60 100644
	--- a/src/wallet/rpcwallet.cpp
	+++ b/src/wallet/rpcwallet.cpp
	@@ -1,2417 +1,2418 @@
	// Copyright (c) 2010 Satoshi Nakamoto
	// Copyright (c) 2009-2014 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 "rpcserver.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/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()));
	}
	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));
	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);

	bool bKeyUsed = false;

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

	// Generate a new key
	if (!account.vchPubKey.IsValid() \|\| bForceNew \|\| bKeyUsed)
	{
	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 wallet.dat 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. The amount is a real and is rounded to the nearest 0.00000001\n"
	+ HelpRequiringPassphrase() +
	"\nArguments:\n"
	"1. \"bitcoinaddress\" (string, required) The bitcoin address to send to.\n"
	- "2. \"amount\" (numeric, required) The amount in btc to send. eg 0.1\n"
	+ "2. \"amount\" (numeric, 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 btc\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 btc received at this address.\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 btc received for this account.\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;
	}


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

	// Tally wallet transactions
	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 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;
	}

	CAmount GetAccountBalance(const string& strAccount, int nMinDepth, const isminefilter& filter)
	{
	CWalletDB walletdb(pwalletMain->strWalletFile);
	return GetAccountBalance(walletdb, strAccount, nMinDepth, filter);
	}


	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 btc received for this account.\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 = 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. minconf (numeric, optional, default=1) Only use funds with at least this many confirmations.\n"
	- "4. \"comment\" (string, optional) An optional comment, stored in the wallet only.\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 successfull.\n"
	"\nExamples:\n"
	- "\nMove 0.01 btc from the default account to the account named tabby\n"
	+ "\nMove 0.01 " + CURRENCY_UNIT + " from the default account to the account named tabby\n"
	+ HelpExampleCli("move", "\"\" \"tabby\" 0.01") +
	- "\nMove 0.01 btc timotei to akiko with a comment and funds have 6 confirmations\n"
	+ "\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;
	walletdb.WriteAccountingEntry(debit);

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

	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.\n"
	"The amount is a real and is rounded to the nearest 0.00000001."
	+ 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, required) The amount in btc. (transaction fee is added on top).\n"
	+ "3. amount (numeric, 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 btc from the default account to the address, must have at least 1 confirmation\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 = 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) The bitcoin address is the key, the numeric amount in btc is the value\n"
	+ " \"address\":amount (numeric) The bitcoin address is the key, the numeric amount 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 = 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 rpcmisc.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)));
	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 (numeric, 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 btc received by the address\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"
	" }\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 (boolean, 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"
	" }\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)));
	entry.push_back(Pair("vout", s.vout));
	entry.push_back(Pair("fee", ValueFromAmount(-nFee)));
	if (fLong)
	WalletTxToJSON(wtx, entry);
	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)));
	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 btc. This is negative for the 'send' category, and for the\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 btc. This is negative and only available for the \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"
	" \"confirmations\": n, (numeric) The number of confirmations for the transaction. Available for 'send' and \n"
	" 'receive' category of transactions.\n"
	" \"blockhash\": \"hashvalue\", (string) The block hash containing the transaction. Available for 'send' and 'receive'\n"
	" category of transactions.\n"
	" \"blockindex\": n, (numeric) The block index containing the transaction. Available for 'send' and 'receive'\n"
	" category of transactions.\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"
	" \"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"
	" }\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);

	std::list<CAccountingEntry> acentries;
	CWallet::TxItems txOrdered = pwalletMain->OrderedTxItems(acentries, strAccount);

	// iterate backwards until we have nCount items to return:
	for (CWallet::TxItems::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;
	}
	}

	list<CAccountingEntry> acentries;
	CWalletDB(pwalletMain->strWalletFile).ListAccountCreditDebit("*", acentries);
	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 btc. This is negative for the 'send' category, and for the 'move' category for moves \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 btc. This is negative and only available for the 'send' category of transactions.\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 block index containing the transaction. 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"
	" \"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 btc\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 block index\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"
	" \"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 btc\n"
	+ " \"amount\" : x.xxx (numeric) The amount in " + CURRENCY_UNIT + "\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 backupwallet(const UniValue& params, bool fHelp)
	{
	if (!EnsureWalletIsAvailable(fHelp))
	return NullUniValue;

	if (fHelp \|\| params.size() != 1)
	throw runtime_error(
	"backupwallet \"destination\"\n"
	"\nSafely copies wallet.dat 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))
	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"
	"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, required) 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.\n"
	"\nArguments:\n"
	- "1. amount (numeric, required) The transaction fee in BTC/kB rounded to the nearest 0.00000001\n"
	+ "1. amount (numeric, required) The transaction fee in " + CURRENCY_UNIT + "/kB rounded to the nearest 0.00000001\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 bitcoin balance of the wallet\n"
	- " \"unconfirmed_balance\": xxx, (numeric) the total unconfirmed bitcoin balance of the wallet\n"
	- " \"immature_balance\": xxxxxx, (numeric) the total immature balance of the wallet\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 btc/kb\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 btc\n"
	+ " \"amount\" : x.xxx, (numeric) the transaction amount in " + CURRENCY_UNIT + "\n"
	" \"confirmations\" : n (numeric) The number of confirmations\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));
	results.push_back(entry);
	}

	return results;
	}

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

	if (fHelp \|\| params.size() != 1)
	throw runtime_error(
	"fundrawtransaction \"hexstring\"\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"
	"\nArguments:\n"
	"1. \"hexstring\" (string, required) The hex string of the raw transaction\n"
	"\nResult:\n"
	"{\n"
	" \"hex\": \"value\", (string) The resulting raw transaction (hex-encoded string)\n"
	" \"fee\": n, (numeric) The fee added to the transaction\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));

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

	CMutableTransaction tx(origTx);
	CAmount nFee;
	string strFailReason;
	int nChangePos = -1;
	if(!pwalletMain->FundTransaction(tx, nFee, nChangePos, strFailReason))
	throw JSONRPCError(RPC_INTERNAL_ERROR, strFailReason);

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

	return result;
	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Mar 2, 10:07 (1 d, 7 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5187297
Default Alt Text: (297 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions