No OneTemporary
Actions

Size

105 KB

Subscribers

None

View Options

	diff --git a/src/chainparams.cpp b/src/chainparams.cpp
	index 1749dd6ff..47136eeee 100644
	--- a/src/chainparams.cpp
	+++ b/src/chainparams.cpp
	@@ -1,313 +1,316 @@
	// Copyright (c) 2010 Satoshi Nakamoto
	// Copyright (c) 2009-2014 The Bitcoin developers
	// Distributed under the MIT/X11 software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include "chainparams.h"

	#include "assert.h"
	#include "util.h"

	#include <boost/assign/list_of.hpp>

	using namespace boost::assign;

	//
	// Main network
	//

	unsigned int pnSeed[] =
	{
	0x7e6a692e, 0x7d04d1a2, 0x6c0c17d9, 0xdb330ab9, 0xc649c7c6, 0x7895484d, 0x047109b0, 0xb90ca5bc,
	0xd130805f, 0xbd074ea6, 0x578ff1c0, 0x286e09b0, 0xd4dcaf42, 0x529b6bb8, 0x635cc6c0, 0xedde892e,
	0xa976d9c7, 0xea91a4b8, 0x03fa4eb2, 0x6ca9008d, 0xaf62c825, 0x93f3ba51, 0xc2c9efd5, 0x0ed5175e,
	0x487028bc, 0x7297c225, 0x8af0c658, 0x2e57ba1f, 0xd0098abc, 0x46a8853e, 0xcc92dc3e, 0xeb6f1955,
	0x8cce175e, 0x237281ae, 0x9d42795b, 0x4f4f0905, 0xc50151d0, 0xb1ba90c6, 0xaed7175e, 0x204de55b,
	0x4bb03245, 0x932b28bc, 0x2dcce65b, 0xe2708abc, 0x1b08b8d5, 0x12a3dc5b, 0x8a884c90, 0xa386a8b8,
	0x18e417c6, 0x2e709ac3, 0xeb62e925, 0x6f6503ae, 0x05d0814e, 0x8a9ac545, 0x946fd65e, 0x3f57495d,
	0x4a29c658, 0xad454c90, 0x15340905, 0x4c3f3b25, 0x01fe19b9, 0x5620595b, 0x443c795b, 0x44f24ac8,
	0x0442464e, 0xc8665882, 0xed3f3ec3, 0xf585bf5d, 0x5dd141da, 0xf93a084e, 0x1264dd52, 0x0711c658,
	0xf12e7bbe, 0x5b02b740, 0x7d526dd5, 0x0cb04c90, 0x2abe1132, 0x61a39f58, 0x044a0618, 0xf3af7dce,
	0xb994c96d, 0x361c5058, 0xca735d53, 0xeca743b0, 0xec790905, 0xc4d37845, 0xa1c4a2b2, 0x726fd453,
	0x625cc6c0, 0x6c20132e, 0xb7aa0c79, 0xc6ed983d, 0x47e4cbc0, 0xa4ac75d4, 0xe2e59345, 0x4d784ad0,
	0x18a5ec5e, 0x481cc85b, 0x7c6c2fd5, 0x5e4d6018, 0x5b4b6c18, 0xd99b4c90, 0xe63987dc, 0xb817bb25,
	0x141cfeb2, 0x5f005058, 0x0d987f47, 0x242a496d, 0x3e519bc0, 0x02b2454b, 0xdfaf3dc6, 0x888128bc,
	0x1165bb25, 0xabfeca5b, 0x2ef63540, 0x5773c7c6, 0x1280dd52, 0x8ebcacd9, 0x81c439c6, 0x39fcfa45,
	0x62177d41, 0xc975ed62, 0x05cff476, 0xdabda743, 0xaa1ac24e, 0xe255a22e, 0x88aac705, 0xe707c658,
	0xa9e94b5e, 0x2893484b, 0x99512705, 0xd63970ca, 0x45994f32, 0xe519a8ad, 0x92e25f5d, 0x8b84a9c1,
	0x5eaa0a05, 0xa74de55b, 0xb090ff62, 0x5eee326c, 0xc331a679, 0xc1d9b72e, 0x0c6ab982, 0x7362bb25,
	0x4cfedd42, 0x1e09a032, 0xa4c34c5e, 0x3777d9c7, 0x5edcf260, 0x3ce2b548, 0xd2ac0360, 0x2f80b992,
	0x3e4cbb25, 0x3995e236, 0xd03977ae, 0x953cf054, 0x3c654ed0, 0x74024c90, 0xa14f1155, 0x14ce0125,
	0xc15ebb6a, 0x2c08c452, 0xc7fd0652, 0x7604f8ce, 0xffb38332, 0xa4c2efd5, 0xe9614018, 0xab49e557,
	0x1648c052, 0x36024047, 0x0e8cffad, 0x21918953, 0xb61f50ad, 0x9b406b59, 0xaf282218, 0x7f1d164e,
	0x1f560da2, 0xe237be58, 0xbdeb1955, 0x6c0717d9, 0xdaf8ce62, 0x0f74246c, 0xdee95243, 0xf23f1a56,
	0x61bdf867, 0xd254c854, 0xc4422e4e, 0xae0563c0, 0xbdb9a95f, 0xa9eb32c6, 0xd9943950, 0x116add52,
	0x73a54c90, 0xb36b525e, 0xd734175e, 0x333d7f76, 0x51431bc6, 0x084ae5cf, 0xa60a236c, 0x5c67692e,
	0x0177cf45, 0xa6683ac6, 0x7ff4ea47, 0x2192fab2, 0xa03a0f46, 0xfe3e39ae, 0x2cce5fc1, 0xc8a6c148,
	0x96fb7e4c, 0x0a66c752, 0x6b4d2705, 0xeba0c118, 0x3ba0795b, 0x1dccd23e, 0x6912f3a2, 0x22f23c41,
	0x65646b4a, 0x8b9f8705, 0xeb9b9a95, 0x79fe6b4e, 0x0536f447, 0x23224d61, 0x5d952ec6, 0x0cb4f736,
	0xdc14be6d, 0xb24609b0, 0xd3f79b62, 0x6518c836, 0x83a3cf42, 0x9b641fb0, 0x17fef1c0, 0xd508cc82,
	0x91a4369b, 0x39cb4a4c, 0xbbc9536c, 0xaf64c44a, 0x605eca50, 0x0c6a6805, 0xd07e9d4e, 0x78e6d3a2,
	0x1b31eb6d, 0xaa01feb2, 0x4603c236, 0x1ecba3b6, 0x0effe336, 0xc3fdcb36, 0xc290036f, 0x4464692e,
	0x1aca7589, 0x59a9e52e, 0x19aa7489, 0x2622c85e, 0xa598d318, 0x438ec345, 0xc79619b9, 0xaf570360,
	0x5098e289, 0x36add862, 0x83c1a2b2, 0x969d0905, 0xcf3d156c, 0x49c1a445, 0xbd0b7562, 0x8fff1955,
	0x1e51fe53, 0x28d6efd5, 0x2837cc62, 0x02f42d42, 0x070e3fb2, 0xbcb18705, 0x14a4e15b, 0x82096844,
	0xcfcb1c2e, 0x37e27fc7, 0x07923748, 0x0c14bc2e, 0x26100905, 0xcb7cd93e, 0x3bc0d2c0, 0x97131b4c,
	0x6f1e5c17, 0xa7939f43, 0xb7a0bf58, 0xafa83a47, 0xcbb83f32, 0x5f321cb0, 0x52d6c3c7, 0xdeac5bc7,
	0x2cf310cc, 0x108a2bc3, 0x726fa14f, 0x85bad2cc, 0x459e4c90, 0x1a08b8d8, 0xcd7048c6, 0x6d5b4c90,
	0xa66cfe7b, 0xad730905, 0xdaac5bc7, 0x8417fd9f, 0x41377432, 0x1f138632, 0x295a12b2, 0x7ac031b2,
	0x3a87d295, 0xe219bc2e, 0xf485d295, 0x137b6405, 0xcfffd9ad, 0xafe20844, 0x32679a5f, 0xa431c644,
	0x0e5fce8c, 0x305ef853, 0xad26ca32, 0xd9d21a54, 0xddd0d736, 0xc24ec0c7, 0x4aadcd5b, 0x49109852,
	0x9d6b3ac6, 0xf0aa1e8b, 0xf1bfa343, 0x8a30c0ad, 0x260f93d4, 0x2339e760, 0x8869959f, 0xc207216c,
	0x29453448, 0xb651ec36, 0x45496259, 0xa23d1bcc, 0xb39bcf43, 0xa1d29432, 0x3507c658, 0x4a88dd62,
	0x27aff363, 0x7498ea6d, 0x4a6785d5, 0x5e6d47c2, 0x3baba542, 0x045a37ae, 0xa24dc0c7, 0xe981ea4d,
	0xed6ce217, 0x857214c6, 0x6b6c0464, 0x5a4945b8, 0x12f24742, 0xf35f42ad, 0xfd0f5a4e, 0xfb081556,
	0xb24b5861, 0x2e114146, 0xb7780905, 0x33bb0e48, 0x39e26556, 0xa794484d, 0x4225424d, 0x3003795b,
	0x31c8cf44, 0xd65bad59, 0x127bc648, 0xf2bc4d4c, 0x0273dc50, 0x4572d736, 0x064bf653, 0xcdcd126c,
	0x608281ae, 0x4d130087, 0x1016f725, 0xba185fc0, 0x16c1a84f, 0xfb697252, 0xa2942360, 0x53083b6c,
	0x0583f1c0, 0x2d5a2441, 0xc172aa43, 0xcd11cf36, 0x7b14ed62, 0x5c94f1c0, 0x7c23132e, 0x39965a6f,
	0x7890e24e, 0xa38ec447, 0xc187f1c0, 0xef80b647, 0xf20a7432, 0x7ad1d8d2, 0x869e2ec6, 0xccdb5c5d,
	0x9d11f636, 0x2161bb25, 0x7599f889, 0x2265ecad, 0x0f4f0e55, 0x7d25854a, 0xf857e360, 0xf83f3d6c,
	0x9cc93bb8, 0x02716857, 0x5dd8a177, 0x8adc6cd4, 0xe5613d46, 0x6a734f50, 0x2a5c3bae, 0x4a04c3d1,
	0xe4613d46, 0x8426f4bc, 0x3e1b5fc0, 0x0d5a3c18, 0xd0f6d154, 0x21c7ff5e, 0xeb3f3d6c, 0x9da5edc0,
	0x5d753b81, 0x0d8d53d4, 0x2613f018, 0x4443698d, 0x8ca1edcd, 0x10ed3f4e, 0x789b403a, 0x7b984a4b,
	0x964ebc25, 0x7520ee60, 0x4f4828bc, 0x115c407d, 0x32dd0667, 0xa741715e, 0x1d3f3532, 0x817d1f56,
	0x2f99a552, 0x6b2a5956, 0x8d4f4f05, 0xd23c1e17, 0x98993748, 0x2c92e536, 0x237ebdc3, 0xa762fb43,
	0x32016b71, 0xd0e7cf79, 0x7d35bdd5, 0x53dac3d2, 0x31016b71, 0x7fb8f8ce, 0x9a38c232, 0xefaa42ad,
	0x876b823d, 0x18175347, 0xdb46597d, 0xd2c168da, 0xcd6fe9dc, 0x45272e4e, 0x8d4bca5b, 0xa4043d47,
	0xaab7aa47, 0x202881ae, 0xa4aef160, 0xecd7e6bc, 0x391359ad, 0xd8cc9318, 0xbbeee52e, 0x077067b0,
	0xebd39d62, 0x0cedc547, 0x23d3e15e, 0xa5a81318, 0x179a32c6, 0xe4d3483d, 0x03680905, 0xe8018abc,
	0xdde9ef5b, 0x438b8705, 0xb48224a0, 0xcbd69218, 0x9075795b, 0xc6411c3e, 0x03833f5c, 0xf33f8b5e,
	0x495e464b, 0x83c8e65b, 0xac09cd25, 0xdaabc547, 0x7665a553, 0xc5263718, 0x2fd0c5cd, 0x22224d61,
	0x3e954048, 0xfaa37557, 0x36dbc658, 0xa81453d0, 0x5a941f5d, 0xa598ea60, 0x65384ac6, 0x10aaa545,
	0xaaab795b, 0xdda7024c, 0x0966f4c6, 0x68571c08, 0x8b40ee59, 0x33ac096c, 0x844b4c4b, 0xd392254d,
	0xba4d5a46, 0x63029653, 0xf655f636, 0xbe4c4bb1, 0x45dad036, 0x204bc052, 0x06c3a2b2, 0xf31fba6a,
	0xb21f09b0, 0x540d0751, 0xc7b46a57, 0x6a11795b, 0x3d514045, 0x0318aa6d, 0x30306ec3, 0x5c077432,
	0x259ae46d, 0x82bbd35f, 0xae4222c0, 0x254415d4, 0xbd5f574b, 0xd8fd175e, 0x0a3f38c3, 0x2dce6bb8,
	0xc201d058, 0x17fca5bc, 0xe8453cca, 0xd361f636, 0xa0d9edc0, 0x2f232e4e, 0x134e116c, 0x61ddc058,
	0x05ba7283, 0xe1f7ed5b, 0x040ec452, 0x4b672e4e, 0xe4efa36d, 0x47dca52e, 0xe9332e4e, 0xa3acb992,
	0x24714c90, 0xa8cc8632, 0x26b1ce6d, 0x264e53d4, 0xd3d2718c, 0x225534ad, 0xe289f3a2, 0x87341717,
	0x9255ad4f, 0x184bbb25, 0x885c7abc, 0x3a6e9ac6, 0x1924185e, 0xb73d4c90, 0x946d807a, 0xa0d78e3f,
	0x5a16bb25, 0xcb09795b, 0x8d0de657, 0x630b8b25, 0xe572c6cf, 0x2b3f1118, 0x4242a91f, 0x32990905,
	0x058b0905, 0xe266fc60, 0xbe66c5b0, 0xcc98e46d, 0x698c943e, 0x44bd0cc3, 0x865c7abc, 0x771764d3,
	0x4675d655, 0x354e4826, 0xb67ac152, 0xaeccf285, 0xea625b4e, 0xbcd6031f, 0x5e81eb18, 0x74b347ce,
	0x3ca56ac1, 0x54ee4546, 0x38a8175e, 0xa3c21155, 0x2f01576d, 0x5d7ade50, 0xa003ae48, 0x2bc1d31f,
	0x13f5094c, 0x7ab32648, 0x542e9fd5, 0x53136bc1, 0x7fdf51c0, 0x802197b2, 0xa2d2cc5b, 0x6b5f4bc0,
	};

	class CMainParams : public CChainParams {
	public:
	CMainParams() {
	networkID = CChainParams::MAIN;
	+ strNetworkID = "main";
	// The message start string is designed to be unlikely to occur in normal data.
	// The characters are rarely used upper ASCII, not valid as UTF-8, and produce
	// a large 4-byte int at any alignment.
	pchMessageStart[0] = 0xf9;
	pchMessageStart[1] = 0xbe;
	pchMessageStart[2] = 0xb4;
	pchMessageStart[3] = 0xd9;
	vAlertPubKey = ParseHex("04fc9702847840aaf195de8442ebecedf5b095cdbb9bc716bda9110971b28a49e0ead8564ff0db22209e0374782c093bb899692d524e9d6a6956e7c5ecbcd68284");
	nDefaultPort = 8333;
	nRPCPort = 8332;
	bnProofOfWorkLimit = ~uint256(0) >> 32;
	nSubsidyHalvingInterval = 210000;
	nEnforceBlockUpgradeMajority = 750;
	nRejectBlockOutdatedMajority = 950;
	nToCheckBlockUpgradeMajority = 1000;
	nMinerThreads = 0;

	// Build the genesis block. Note that the output of the genesis coinbase cannot
	// be spent as it did not originally exist in the database.
	//
	// CBlock(hash=000000000019d6, ver=1, hashPrevBlock=00000000000000, hashMerkleRoot=4a5e1e, nTime=1231006505, nBits=1d00ffff, nNonce=2083236893, vtx=1)
	// CTransaction(hash=4a5e1e, ver=1, vin.size=1, vout.size=1, nLockTime=0)
	// CTxIn(COutPoint(000000, -1), coinbase 04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73)
	// CTxOut(nValue=50.00000000, scriptPubKey=0x5F1DF16B2B704C8A578D0B)
	// vMerkleTree: 4a5e1e
	const char* pszTimestamp = "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks";
	CTransaction txNew;
	txNew.vin.resize(1);
	txNew.vout.resize(1);
	txNew.vin[0].scriptSig = CScript() << 486604799 << CScriptNum(4) << vector<unsigned char>((const unsigned char)pszTimestamp, (const unsigned char)pszTimestamp + strlen(pszTimestamp));
	txNew.vout[0].nValue = 50 * COIN;
	txNew.vout[0].scriptPubKey = CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") << OP_CHECKSIG;
	genesis.vtx.push_back(txNew);
	genesis.hashPrevBlock = 0;
	genesis.hashMerkleRoot = genesis.BuildMerkleTree();
	genesis.nVersion = 1;
	genesis.nTime = 1231006505;
	genesis.nBits = 0x1d00ffff;
	genesis.nNonce = 2083236893;

	hashGenesisBlock = genesis.GetHash();
	assert(hashGenesisBlock == uint256("0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"));
	assert(genesis.hashMerkleRoot == uint256("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));

	vSeeds.push_back(CDNSSeedData("bitcoin.sipa.be", "seed.bitcoin.sipa.be"));
	vSeeds.push_back(CDNSSeedData("bluematt.me", "dnsseed.bluematt.me"));
	vSeeds.push_back(CDNSSeedData("dashjr.org", "dnsseed.bitcoin.dashjr.org"));
	vSeeds.push_back(CDNSSeedData("bitcoinstats.com", "seed.bitcoinstats.com"));
	vSeeds.push_back(CDNSSeedData("bitnodes.io", "seed.bitnodes.io"));
	vSeeds.push_back(CDNSSeedData("xf2.org", "bitseed.xf2.org"));

	base58Prefixes[PUBKEY_ADDRESS] = list_of(0);
	base58Prefixes[SCRIPT_ADDRESS] = list_of(5);
	base58Prefixes[SECRET_KEY] = list_of(128);
	base58Prefixes[EXT_PUBLIC_KEY] = list_of(0x04)(0x88)(0xB2)(0x1E);
	base58Prefixes[EXT_SECRET_KEY] = list_of(0x04)(0x88)(0xAD)(0xE4);

	// Convert the pnSeeds array into usable address objects.
	for (unsigned int i = 0; i < ARRAYLEN(pnSeed); i++)
	{
	// It'll only connect to one or two seed nodes because once it connects,
	// it'll get a pile of addresses with newer timestamps.
	// Seed nodes are given a random 'last seen time' of between one and two
	// weeks ago.
	const int64_t nOneWeek = 72460*60;
	struct in_addr ip;
	memcpy(&ip, &pnSeed[i], sizeof(ip));
	CAddress addr(CService(ip, GetDefaultPort()));
	addr.nTime = GetTime() - GetRand(nOneWeek) - nOneWeek;
	vFixedSeeds.push_back(addr);
	}

	fRequireRPCPassword = true;
	fMiningRequiresPeers = true;
	fDefaultCheckMemPool = false;
	fAllowMinDifficultyBlocks = false;
	fRequireStandard = true;
	fRPCisTestNet = false;
	fMineBlocksOnDemand = false;
	}
	};
	static CMainParams mainParams;

	//
	// Testnet (v3)
	//
	class CTestNetParams : public CMainParams {
	public:
	CTestNetParams() {
	networkID = CChainParams::TESTNET;
	+ strNetworkID = "test";
	// The message start string is designed to be unlikely to occur in normal data.
	// The characters are rarely used upper ASCII, not valid as UTF-8, and produce
	// a large 4-byte int at any alignment.
	pchMessageStart[0] = 0x0b;
	pchMessageStart[1] = 0x11;
	pchMessageStart[2] = 0x09;
	pchMessageStart[3] = 0x07;
	vAlertPubKey = ParseHex("04302390343f91cc401d56d68b123028bf52e5fca1939df127f63c6467cdf9c8e2c14b61104cf817d0b780da337893ecc4aaff1309e536162dabbdb45200ca2b0a");
	nDefaultPort = 18333;
	nRPCPort = 18332;
	nEnforceBlockUpgradeMajority = 51;
	nRejectBlockOutdatedMajority = 75;
	nToCheckBlockUpgradeMajority = 100;
	strDataDir = "testnet3";

	// Modify the testnet genesis block so the timestamp is valid for a later start.
	genesis.nTime = 1296688602;
	genesis.nNonce = 414098458;
	hashGenesisBlock = genesis.GetHash();
	assert(hashGenesisBlock == uint256("0x000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"));

	vFixedSeeds.clear();
	vSeeds.clear();
	vSeeds.push_back(CDNSSeedData("alexykot.me", "testnet-seed.alexykot.me"));
	vSeeds.push_back(CDNSSeedData("bitcoin.petertodd.org", "testnet-seed.bitcoin.petertodd.org"));
	vSeeds.push_back(CDNSSeedData("bluematt.me", "testnet-seed.bluematt.me"));

	base58Prefixes[PUBKEY_ADDRESS] = list_of(111);
	base58Prefixes[SCRIPT_ADDRESS] = list_of(196);
	base58Prefixes[SECRET_KEY] = list_of(239);
	base58Prefixes[EXT_PUBLIC_KEY] = list_of(0x04)(0x35)(0x87)(0xCF);
	base58Prefixes[EXT_SECRET_KEY] = list_of(0x04)(0x35)(0x83)(0x94);

	fRequireRPCPassword = true;
	fMiningRequiresPeers = true;
	fDefaultCheckMemPool = false;
	fAllowMinDifficultyBlocks = true;
	fRequireStandard = false;
	fRPCisTestNet = true;
	fMineBlocksOnDemand = false;
	}
	};
	static CTestNetParams testNetParams;

	//
	// Regression test
	//
	class CRegTestParams : public CTestNetParams {
	public:
	CRegTestParams() {
	networkID = CChainParams::REGTEST;
	+ strNetworkID = "regtest";
	pchMessageStart[0] = 0xfa;
	pchMessageStart[1] = 0xbf;
	pchMessageStart[2] = 0xb5;
	pchMessageStart[3] = 0xda;
	nSubsidyHalvingInterval = 150;
	nEnforceBlockUpgradeMajority = 750;
	nRejectBlockOutdatedMajority = 950;
	nToCheckBlockUpgradeMajority = 1000;
	nMinerThreads = 1;
	bnProofOfWorkLimit = ~uint256(0) >> 1;
	genesis.nTime = 1296688602;
	genesis.nBits = 0x207fffff;
	genesis.nNonce = 2;
	hashGenesisBlock = genesis.GetHash();
	nDefaultPort = 18444;
	strDataDir = "regtest";
	assert(hashGenesisBlock == uint256("0x0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"));

	vSeeds.clear(); // Regtest mode doesn't have any DNS seeds.

	fRequireRPCPassword = false;
	fMiningRequiresPeers = false;
	fDefaultCheckMemPool = true;
	fAllowMinDifficultyBlocks = true;
	fRequireStandard = false;
	fRPCisTestNet = true;
	fMineBlocksOnDemand = true;
	}
	};
	static CRegTestParams regTestParams;

	static CChainParams *pCurrentParams = &mainParams;

	const CChainParams &Params() {
	return *pCurrentParams;
	}

	void SelectParams(CChainParams::Network network) {
	switch (network) {
	case CChainParams::MAIN:
	pCurrentParams = &mainParams;
	break;
	case CChainParams::TESTNET:
	pCurrentParams = &testNetParams;
	break;
	case CChainParams::REGTEST:
	pCurrentParams = &regTestParams;
	break;
	default:
	assert(false && "Unimplemented network");
	return;
	}
	}

	bool SelectParamsFromCommandLine() {
	bool fRegTest = GetBoolArg("-regtest", false);
	bool fTestNet = GetBoolArg("-testnet", false);

	if (fTestNet && fRegTest) {
	return false;
	}

	if (fRegTest) {
	SelectParams(CChainParams::REGTEST);
	} else if (fTestNet) {
	SelectParams(CChainParams::TESTNET);
	} else {
	SelectParams(CChainParams::MAIN);
	}
	return true;
	}
	diff --git a/src/chainparams.h b/src/chainparams.h
	index 8370cc569..6e09a2cba 100644
	--- a/src/chainparams.h
	+++ b/src/chainparams.h
	@@ -1,131 +1,134 @@
	// Copyright (c) 2009-2010 Satoshi Nakamoto
	// Copyright (c) 2009-2013 The Bitcoin developers
	// Distributed under the MIT/X11 software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#ifndef BITCOIN_CHAIN_PARAMS_H
	#define BITCOIN_CHAIN_PARAMS_H

	#include "core.h"
	#include "protocol.h"
	#include "uint256.h"

	#include <vector>

	using namespace std;

	typedef unsigned char MessageStartChars[MESSAGE_START_SIZE];

	struct CDNSSeedData {
	string name, host;
	CDNSSeedData(const string &strName, const string &strHost) : name(strName), host(strHost) {}
	};

	/**
	* CChainParams defines various tweakable parameters of a given instance of the
	* Bitcoin system. There are three: the main network on which people trade goods
	* and services, the public test network which gets reset from time to time and
	* a regression test mode which is intended for private networks only. It has
	* minimal difficulty to ensure that blocks can be found instantly.
	*/
	class CChainParams
	{
	public:
	enum Network {
	MAIN,
	TESTNET,
	REGTEST,

	MAX_NETWORK_TYPES
	};

	enum Base58Type {
	PUBKEY_ADDRESS,
	SCRIPT_ADDRESS,
	SECRET_KEY,
	EXT_PUBLIC_KEY,
	EXT_SECRET_KEY,

	MAX_BASE58_TYPES
	};

	const uint256& HashGenesisBlock() const { return hashGenesisBlock; }
	const MessageStartChars& MessageStart() const { return pchMessageStart; }
	const vector<unsigned char>& AlertKey() const { return vAlertPubKey; }
	int GetDefaultPort() const { return nDefaultPort; }
	const uint256& ProofOfWorkLimit() const { return bnProofOfWorkLimit; }
	int SubsidyHalvingInterval() const { return nSubsidyHalvingInterval; }
	/* Used to check majorities for block version upgrade */
	int EnforceBlockUpgradeMajority() const { return nEnforceBlockUpgradeMajority; }
	int RejectBlockOutdatedMajority() const { return nRejectBlockOutdatedMajority; }
	int ToCheckBlockUpgradeMajority() const { return nToCheckBlockUpgradeMajority; }

	/* Used if GenerateBitcoins is called with a negative number of threads */
	int DefaultMinerThreads() const { return nMinerThreads; }
	const CBlock& GenesisBlock() const { return genesis; }
	bool RequireRPCPassword() const { return fRequireRPCPassword; }
	/* Make miner wait to have peers to avoid wasting work */
	bool MiningRequiresPeers() const { return fMiningRequiresPeers; }
	/* Default value for -checkmempool argument */
	bool DefaultCheckMemPool() const { return fDefaultCheckMemPool; }
	/* Allow mining of a min-difficulty block */
	bool AllowMinDifficultyBlocks() const { return fAllowMinDifficultyBlocks; }
	/* Make standard checks */
	bool RequireStandard() const { return fRequireStandard; }
	/* Make standard checks */
	bool RPCisTestNet() const { return fRPCisTestNet; }
	const string& DataDir() const { return strDataDir; }
	/* Make miner stop after a block is found. In RPC, don't return
	* until nGenProcLimit blocks are generated */
	bool MineBlocksOnDemand() const { return fMineBlocksOnDemand; }
	Network NetworkID() const { return networkID; }
	+ /* Return the BIP70 network string (main, test or regtest) */
	+ std::string NetworkIDString() const { return strNetworkID; }
	const vector<CDNSSeedData>& DNSSeeds() const { return vSeeds; }
	const std::vector<unsigned char>& Base58Prefix(Base58Type type) const { return base58Prefixes[type]; }
	const vector<CAddress>& FixedSeeds() const { return vFixedSeeds; }
	int RPCPort() const { return nRPCPort; }
	protected:
	CChainParams() {}

	uint256 hashGenesisBlock;
	MessageStartChars pchMessageStart;
	// Raw pub key bytes for the broadcast alert signing key.
	vector<unsigned char> vAlertPubKey;
	int nDefaultPort;
	int nRPCPort;
	uint256 bnProofOfWorkLimit;
	int nSubsidyHalvingInterval;
	int nEnforceBlockUpgradeMajority;
	int nRejectBlockOutdatedMajority;
	int nToCheckBlockUpgradeMajority;
	string strDataDir;
	int nMinerThreads;
	vector<CDNSSeedData> vSeeds;
	std::vector<unsigned char> base58Prefixes[MAX_BASE58_TYPES];
	Network networkID;
	+ std::string strNetworkID;
	CBlock genesis;
	vector<CAddress> vFixedSeeds;
	bool fRequireRPCPassword;
	bool fMiningRequiresPeers;
	bool fDefaultCheckMemPool;
	bool fAllowMinDifficultyBlocks;
	bool fRequireStandard;
	bool fRPCisTestNet;
	bool fMineBlocksOnDemand;
	};

	/**
	* Return the currently selected parameters. This won't change after app startup
	* outside of the unit tests.
	*/
	const CChainParams &Params();

	/** Sets the params returned by Params() to those for the given network. */
	void SelectParams(CChainParams::Network network);

	/**
	* Looks for -regtest or -testnet and then calls SelectParams as appropriate.
	* Returns false if an invalid combination is given.
	*/
	bool SelectParamsFromCommandLine();

	#endif
	diff --git a/src/qt/clientmodel.cpp b/src/qt/clientmodel.cpp
	index 403b03378..9c9565be6 100644
	--- a/src/qt/clientmodel.cpp
	+++ b/src/qt/clientmodel.cpp
	@@ -1,256 +1,248 @@
	// Copyright (c) 2011-2013 The Bitcoin developers
	// Distributed under the MIT/X11 software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include "clientmodel.h"

	#include "guiconstants.h"
	#include "peertablemodel.h"

	#include "alert.h"
	#include "chainparams.h"
	#include "checkpoints.h"
	#include "main.h"
	#include "net.h"
	#include "ui_interface.h"

	#include <stdint.h>

	#include <QDateTime>
	#include <QDebug>
	#include <QTimer>

	static const int64_t nClientStartupTime = GetTime();

	ClientModel::ClientModel(OptionsModel optionsModel, QObject parent) :
	QObject(parent),
	optionsModel(optionsModel),
	peerTableModel(0),
	cachedNumBlocks(0),
	cachedReindexing(0), cachedImporting(0),
	numBlocksAtStartup(-1), pollTimer(0)
	{
	peerTableModel = new PeerTableModel(this);
	pollTimer = new QTimer(this);
	connect(pollTimer, SIGNAL(timeout()), this, SLOT(updateTimer()));
	pollTimer->start(MODEL_UPDATE_DELAY);

	subscribeToCoreSignals();
	}

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

	int ClientModel::getNumConnections(unsigned int flags) const
	{
	LOCK(cs_vNodes);
	if (flags == CONNECTIONS_ALL) // Shortcut if we want total
	return vNodes.size();

	int nNum = 0;
	BOOST_FOREACH(CNode* pnode, vNodes)
	if (flags & (pnode->fInbound ? CONNECTIONS_IN : CONNECTIONS_OUT))
	nNum++;

	return nNum;
	}

	int ClientModel::getNumBlocks() const
	{
	LOCK(cs_main);
	return chainActive.Height();
	}

	int ClientModel::getNumBlocksAtStartup()
	{
	if (numBlocksAtStartup == -1) numBlocksAtStartup = getNumBlocks();
	return numBlocksAtStartup;
	}

	quint64 ClientModel::getTotalBytesRecv() const
	{
	return CNode::GetTotalBytesRecv();
	}

	quint64 ClientModel::getTotalBytesSent() const
	{
	return CNode::GetTotalBytesSent();
	}

	QDateTime ClientModel::getLastBlockDate() const
	{
	LOCK(cs_main);
	if (chainActive.Tip())
	return QDateTime::fromTime_t(chainActive.Tip()->GetBlockTime());
	else
	return QDateTime::fromTime_t(Params().GenesisBlock().nTime); // Genesis block's time of current network
	}

	double ClientModel::getVerificationProgress() const
	{
	LOCK(cs_main);
	return Checkpoints::GuessVerificationProgress(chainActive.Tip());
	}

	void ClientModel::updateTimer()
	{
	// Get required lock upfront. This avoids the GUI from getting stuck on
	// periodical polls if the core is holding the locks for a longer time -
	// for example, during a wallet rescan.
	TRY_LOCK(cs_main, lockMain);
	if(!lockMain)
	return;
	// Some quantities (such as number of blocks) change so fast that we don't want to be notified for each change.
	// Periodically check and update with a timer.
	int newNumBlocks = getNumBlocks();

	// check for changed number of blocks we have, number of blocks peers claim to have, reindexing state and importing state
	if (cachedNumBlocks != newNumBlocks \|\|
	cachedReindexing != fReindex \|\| cachedImporting != fImporting)
	{
	cachedNumBlocks = newNumBlocks;
	cachedReindexing = fReindex;
	cachedImporting = fImporting;

	emit numBlocksChanged(newNumBlocks);
	}

	emit bytesChanged(getTotalBytesRecv(), getTotalBytesSent());
	}

	void ClientModel::updateNumConnections(int numConnections)
	{
	emit numConnectionsChanged(numConnections);
	}

	void ClientModel::updateAlert(const QString &hash, int status)
	{
	// Show error message notification for new alert
	if(status == CT_NEW)
	{
	uint256 hash_256;
	hash_256.SetHex(hash.toStdString());
	CAlert alert = CAlert::getAlertByHash(hash_256);
	if(!alert.IsNull())
	{
	emit message(tr("Network Alert"), QString::fromStdString(alert.strStatusBar), CClientUIInterface::ICON_ERROR);
	}
	}

	emit alertsChanged(getStatusBarWarnings());
	}

	-QString ClientModel::getNetworkName() const
	-{
	- QString netname(QString::fromStdString(Params().DataDir()));
	- if(netname.isEmpty())
	- netname = "main";
	- return netname;
	-}
	-
	bool ClientModel::inInitialBlockDownload() const
	{
	return IsInitialBlockDownload();
	}

	enum BlockSource ClientModel::getBlockSource() const
	{
	if (fReindex)
	return BLOCK_SOURCE_REINDEX;
	else if (fImporting)
	return BLOCK_SOURCE_DISK;
	else if (getNumConnections() > 0)
	return BLOCK_SOURCE_NETWORK;

	return BLOCK_SOURCE_NONE;
	}

	QString ClientModel::getStatusBarWarnings() const
	{
	return QString::fromStdString(GetWarnings("statusbar"));
	}

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

	PeerTableModel *ClientModel::getPeerTableModel()
	{
	return peerTableModel;
	}

	QString ClientModel::formatFullVersion() const
	{
	return QString::fromStdString(FormatFullVersion());
	}

	QString ClientModel::formatBuildDate() const
	{
	return QString::fromStdString(CLIENT_DATE);
	}

	bool ClientModel::isReleaseVersion() const
	{
	return CLIENT_VERSION_IS_RELEASE;
	}

	QString ClientModel::clientName() const
	{
	return QString::fromStdString(CLIENT_NAME);
	}

	QString ClientModel::formatClientStartupTime() const
	{
	return QDateTime::fromTime_t(nClientStartupTime).toString();
	}

	// Handlers for core signals
	static void ShowProgress(ClientModel *clientmodel, const std::string &title, int nProgress)
	{
	// emits signal "showProgress"
	QMetaObject::invokeMethod(clientmodel, "showProgress", Qt::QueuedConnection,
	Q_ARG(QString, QString::fromStdString(title)),
	Q_ARG(int, nProgress));
	}

	static void NotifyBlocksChanged(ClientModel *clientmodel)
	{
	// This notification is too frequent. Don't trigger a signal.
	// Don't remove it, though, as it might be useful later.
	}

	static void NotifyNumConnectionsChanged(ClientModel *clientmodel, int newNumConnections)
	{
	// Too noisy: qDebug() << "NotifyNumConnectionsChanged : " + QString::number(newNumConnections);
	QMetaObject::invokeMethod(clientmodel, "updateNumConnections", Qt::QueuedConnection,
	Q_ARG(int, newNumConnections));
	}

	static void NotifyAlertChanged(ClientModel *clientmodel, const uint256 &hash, ChangeType status)
	{
	qDebug() << "NotifyAlertChanged : " + QString::fromStdString(hash.GetHex()) + " status=" + QString::number(status);
	QMetaObject::invokeMethod(clientmodel, "updateAlert", Qt::QueuedConnection,
	Q_ARG(QString, QString::fromStdString(hash.GetHex())),
	Q_ARG(int, status));
	}

	void ClientModel::subscribeToCoreSignals()
	{
	// Connect signals to client
	uiInterface.ShowProgress.connect(boost::bind(ShowProgress, this, _1, _2));
	uiInterface.NotifyBlocksChanged.connect(boost::bind(NotifyBlocksChanged, this));
	uiInterface.NotifyNumConnectionsChanged.connect(boost::bind(NotifyNumConnectionsChanged, this, _1));
	uiInterface.NotifyAlertChanged.connect(boost::bind(NotifyAlertChanged, this, _1, _2));
	}

	void ClientModel::unsubscribeFromCoreSignals()
	{
	// Disconnect signals from client
	uiInterface.ShowProgress.disconnect(boost::bind(ShowProgress, this, _1, _2));
	uiInterface.NotifyBlocksChanged.disconnect(boost::bind(NotifyBlocksChanged, this));
	uiInterface.NotifyNumConnectionsChanged.disconnect(boost::bind(NotifyNumConnectionsChanged, this, _1));
	uiInterface.NotifyAlertChanged.disconnect(boost::bind(NotifyAlertChanged, this, _1, _2));
	}
	diff --git a/src/qt/clientmodel.h b/src/qt/clientmodel.h
	index 9c9a35b65..c7bd60bd4 100644
	--- a/src/qt/clientmodel.h
	+++ b/src/qt/clientmodel.h
	@@ -1,107 +1,105 @@
	// Copyright (c) 2011-2013 The Bitcoin developers
	// Distributed under the MIT/X11 software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#ifndef CLIENTMODEL_H
	#define CLIENTMODEL_H

	#include <QObject>

	class AddressTableModel;
	class OptionsModel;
	class PeerTableModel;
	class TransactionTableModel;

	class CWallet;

	QT_BEGIN_NAMESPACE
	class QDateTime;
	class QTimer;
	QT_END_NAMESPACE

	enum BlockSource {
	BLOCK_SOURCE_NONE,
	BLOCK_SOURCE_REINDEX,
	BLOCK_SOURCE_DISK,
	BLOCK_SOURCE_NETWORK
	};

	enum NumConnections {
	CONNECTIONS_NONE = 0,
	CONNECTIONS_IN = (1U << 0),
	CONNECTIONS_OUT = (1U << 1),
	CONNECTIONS_ALL = (CONNECTIONS_IN \| CONNECTIONS_OUT),
	};

	/** Model for Bitcoin network client. */
	class ClientModel : public QObject
	{
	Q_OBJECT

	public:
	explicit ClientModel(OptionsModel optionsModel, QObject parent = 0);
	~ClientModel();

	OptionsModel *getOptionsModel();
	PeerTableModel *getPeerTableModel();

	//! Return number of connections, default is in- and outbound (total)
	int getNumConnections(unsigned int flags = CONNECTIONS_ALL) const;
	int getNumBlocks() const;
	int getNumBlocksAtStartup();

	quint64 getTotalBytesRecv() const;
	quint64 getTotalBytesSent() const;

	double getVerificationProgress() const;
	QDateTime getLastBlockDate() const;

	- //! Return network (main, testnet3, regtest)
	- QString getNetworkName() const;
	//! Return true if core is doing initial block download
	bool inInitialBlockDownload() const;
	//! Return true if core is importing blocks
	enum BlockSource getBlockSource() const;
	//! Return warnings to be displayed in status bar
	QString getStatusBarWarnings() const;

	QString formatFullVersion() const;
	QString formatBuildDate() const;
	bool isReleaseVersion() const;
	QString clientName() const;
	QString formatClientStartupTime() const;

	private:
	OptionsModel *optionsModel;
	PeerTableModel *peerTableModel;

	int cachedNumBlocks;
	bool cachedReindexing;
	bool cachedImporting;

	int numBlocksAtStartup;

	QTimer *pollTimer;

	void subscribeToCoreSignals();
	void unsubscribeFromCoreSignals();

	signals:
	void numConnectionsChanged(int count);
	void numBlocksChanged(int count);
	void alertsChanged(const QString &warnings);
	void bytesChanged(quint64 totalBytesIn, quint64 totalBytesOut);

	//! Fired when a message should be reported to the user
	void message(const QString &title, const QString &message, unsigned int style);

	// Show progress dialog e.g. for verifychain
	void showProgress(const QString &title, int nProgress);

	public slots:
	void updateTimer();
	void updateNumConnections(int numConnections);
	void updateAlert(const QString &hash, int status);
	};

	#endif // CLIENTMODEL_H
	diff --git a/src/qt/paymentserver.cpp b/src/qt/paymentserver.cpp
	index 9241f9dc3..eb6ab879a 100644
	--- a/src/qt/paymentserver.cpp
	+++ b/src/qt/paymentserver.cpp
	@@ -1,725 +1,714 @@
	// Copyright (c) 2011-2013 The Bitcoin developers
	// Distributed under the MIT/X11 software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include "paymentserver.h"

	#include "bitcoinunits.h"
	#include "guiconstants.h"
	#include "guiutil.h"
	#include "optionsmodel.h"

	#include "base58.h"
	#include "ui_interface.h"
	#include "wallet.h"

	#include <cstdlib>

	#include <openssl/x509.h>
	#include <openssl/x509_vfy.h>
	#include <QApplication>
	#include <QByteArray>
	#include <QDataStream>
	#include <QDateTime>
	#include <QDebug>
	#include <QFile>
	#include <QFileOpenEvent>
	#include <QHash>
	#include <QList>
	#include <QLocalServer>
	#include <QLocalSocket>
	#include <QNetworkAccessManager>
	#include <QNetworkProxy>
	#include <QNetworkReply>
	#include <QNetworkRequest>
	#include <QSslCertificate>
	#include <QSslError>
	#include <QSslSocket>
	#include <QStringList>
	#include <QTextDocument>

	#if QT_VERSION < 0x050000
	#include <QUrl>
	#else
	#include <QUrlQuery>
	#endif

	using namespace boost;

	const int BITCOIN_IPC_CONNECT_TIMEOUT = 1000; // milliseconds
	const QString BITCOIN_IPC_PREFIX("bitcoin:");
	const char* BITCOIN_REQUEST_MIMETYPE = "application/bitcoin-paymentrequest";
	const char* BITCOIN_PAYMENTACK_MIMETYPE = "application/bitcoin-paymentack";
	const char* BITCOIN_PAYMENTACK_CONTENTTYPE = "application/bitcoin-payment";

	X509_STORE* PaymentServer::certStore = NULL;
	void PaymentServer::freeCertStore()
	{
	if (PaymentServer::certStore != NULL)
	{
	X509_STORE_free(PaymentServer::certStore);
	PaymentServer::certStore = NULL;
	}
	}

	//
	// Create a name that is unique for:
	// testnet / non-testnet
	// data directory
	//
	static QString ipcServerName()
	{
	QString name("BitcoinQt");

	// Append a simple hash of the datadir
	// Note that GetDataDir(true) returns a different path
	// for -testnet versus main net
	QString ddir(QString::fromStdString(GetDataDir(true).string()));
	name.append(QString::number(qHash(ddir)));

	return name;
	}

	//
	// We store payment URIs and requests received before
	// the main GUI window is up and ready to ask the user
	// to send payment.

	static QList<QString> savedPaymentRequests;

	static void ReportInvalidCertificate(const QSslCertificate& cert)
	{
	qDebug() << "ReportInvalidCertificate : Payment server found an invalid certificate: " << cert.subjectInfo(QSslCertificate::CommonName);
	}

	//
	// Load OpenSSL's list of root certificate authorities
	//
	void PaymentServer::LoadRootCAs(X509_STORE* _store)
	{
	if (PaymentServer::certStore == NULL)
	atexit(PaymentServer::freeCertStore);
	else
	freeCertStore();

	// Unit tests mostly use this, to pass in fake root CAs:
	if (_store)
	{
	PaymentServer::certStore = _store;
	return;
	}

	// Normal execution, use either -rootcertificates or system certs:
	PaymentServer::certStore = X509_STORE_new();

	// Note: use "-system-" default here so that users can pass -rootcertificates=""
	// and get 'I don't like X.509 certificates, don't trust anybody' behavior:
	QString certFile = QString::fromStdString(GetArg("-rootcertificates", "-system-"));

	if (certFile.isEmpty())
	return; // Empty store

	QList<QSslCertificate> certList;

	if (certFile != "-system-")
	{
	certList = QSslCertificate::fromPath(certFile);
	// Use those certificates when fetching payment requests, too:
	QSslSocket::setDefaultCaCertificates(certList);
	}
	else
	certList = QSslSocket::systemCaCertificates ();

	int nRootCerts = 0;
	const QDateTime currentTime = QDateTime::currentDateTime();
	foreach (const QSslCertificate& cert, certList)
	{
	if (currentTime < cert.effectiveDate() \|\| currentTime > cert.expiryDate()) {
	ReportInvalidCertificate(cert);
	continue;
	}
	#if QT_VERSION >= 0x050000
	if (cert.isBlacklisted()) {
	ReportInvalidCertificate(cert);
	continue;
	}
	#endif
	QByteArray certData = cert.toDer();
	const unsigned char data = (const unsigned char )certData.data();

	X509* x509 = d2i_X509(0, &data, certData.size());
	if (x509 && X509_STORE_add_cert(PaymentServer::certStore, x509))
	{
	// Note: X509_STORE_free will free the X509* objects when
	// the PaymentServer is destroyed
	++nRootCerts;
	}
	else
	{
	ReportInvalidCertificate(cert);
	continue;
	}
	}
	qDebug() << "PaymentServer::LoadRootCAs : Loaded " << nRootCerts << " root certificates";

	// Project for another day:
	// Fetch certificate revocation lists, and add them to certStore.
	// Issues to consider:
	// performance (start a thread to fetch in background?)
	// privacy (fetch through tor/proxy so IP address isn't revealed)
	// would it be easier to just use a compiled-in blacklist?
	// or use Qt's blacklist?
	// "certificate stapling" with server-side caching is more efficient
	}

	//
	// Sending to the server is done synchronously, at startup.
	// If the server isn't already running, startup continues,
	// and the items in savedPaymentRequest will be handled
	// when uiReady() is called.
	//
	// Warning: ipcSendCommandLine() is called early in init,
	// so don't use "emit message()", but "QMessageBox::"!
	//
	bool PaymentServer::ipcParseCommandLine(int argc, char* argv[])
	{
	for (int i = 1; i < argc; i++)
	{
	QString arg(argv[i]);
	if (arg.startsWith("-"))
	continue;

	if (arg.startsWith(BITCOIN_IPC_PREFIX, Qt::CaseInsensitive)) // bitcoin: URI
	{
	savedPaymentRequests.append(arg);

	SendCoinsRecipient r;
	if (GUIUtil::parseBitcoinURI(arg, &r))
	{
	CBitcoinAddress address(r.address.toStdString());

	SelectParams(CChainParams::MAIN);
	if (!address.IsValid())
	{
	SelectParams(CChainParams::TESTNET);
	}
	}
	}
	else if (QFile::exists(arg)) // Filename
	{
	savedPaymentRequests.append(arg);

	PaymentRequestPlus request;
	if (readPaymentRequest(arg, request))
	{
	if (request.getDetails().network() == "main")
	SelectParams(CChainParams::MAIN);
	else
	SelectParams(CChainParams::TESTNET);
	}
	}
	else
	{
	// Printing to debug.log is about the best we can do here, the
	// GUI hasn't started yet so we can't pop up a message box.
	qDebug() << "PaymentServer::ipcSendCommandLine : Payment request file does not exist: " << arg;
	}
	}
	return true;
	}

	//
	// Sending to the server is done synchronously, at startup.
	// If the server isn't already running, startup continues,
	// and the items in savedPaymentRequest will be handled
	// when uiReady() is called.
	//
	bool PaymentServer::ipcSendCommandLine()
	{
	bool fResult = false;
	foreach (const QString& r, savedPaymentRequests)
	{
	QLocalSocket* socket = new QLocalSocket();
	socket->connectToServer(ipcServerName(), QIODevice::WriteOnly);
	if (!socket->waitForConnected(BITCOIN_IPC_CONNECT_TIMEOUT))
	{
	delete socket;
	return false;
	}

	QByteArray block;
	QDataStream out(&block, QIODevice::WriteOnly);
	out.setVersion(QDataStream::Qt_4_0);
	out << r;
	out.device()->seek(0);
	socket->write(block);
	socket->flush();

	socket->waitForBytesWritten(BITCOIN_IPC_CONNECT_TIMEOUT);
	socket->disconnectFromServer();
	delete socket;
	fResult = true;
	}

	return fResult;
	}

	PaymentServer::PaymentServer(QObject* parent, bool startLocalServer) :
	QObject(parent),
	saveURIs(true),
	uriServer(0),
	netManager(0),
	optionsModel(0)
	{
	// Verify that the version of the library that we linked against is
	// compatible with the version of the headers we compiled against.
	GOOGLE_PROTOBUF_VERIFY_VERSION;

	// Install global event filter to catch QFileOpenEvents
	// on Mac: sent when you click bitcoin: links
	// other OSes: helpful when dealing with payment request files (in the future)
	if (parent)
	parent->installEventFilter(this);

	QString name = ipcServerName();

	// Clean up old socket leftover from a crash:
	QLocalServer::removeServer(name);

	if (startLocalServer)
	{
	uriServer = new QLocalServer(this);

	if (!uriServer->listen(name)) {
	// constructor is called early in init, so don't use "emit message()" here
	QMessageBox::critical(0, tr("Payment request error"),
	tr("Cannot start bitcoin: click-to-pay handler"));
	}
	else {
	connect(uriServer, SIGNAL(newConnection()), this, SLOT(handleURIConnection()));
	connect(this, SIGNAL(receivedPaymentACK(QString)), this, SLOT(handlePaymentACK(QString)));
	}
	}
	}

	PaymentServer::~PaymentServer()
	{
	google::protobuf::ShutdownProtobufLibrary();
	}

	//
	// OSX-specific way of handling bitcoin: URIs and
	// PaymentRequest mime types
	//
	bool PaymentServer::eventFilter(QObject object, QEvent event)
	{
	// clicking on bitcoin: URIs creates FileOpen events on the Mac
	if (event->type() == QEvent::FileOpen)
	{
	QFileOpenEvent fileEvent = static_cast<QFileOpenEvent>(event);
	if (!fileEvent->file().isEmpty())
	handleURIOrFile(fileEvent->file());
	else if (!fileEvent->url().isEmpty())
	handleURIOrFile(fileEvent->url().toString());

	return true;
	}

	return QObject::eventFilter(object, event);
	}

	void PaymentServer::initNetManager()
	{
	if (!optionsModel)
	return;
	if (netManager != NULL)
	delete netManager;

	// netManager is used to fetch paymentrequests given in bitcoin: URIs
	netManager = new QNetworkAccessManager(this);

	QNetworkProxy proxy;

	// Query active proxy (fails if no SOCKS5 proxy)
	if (optionsModel->getProxySettings(proxy)) {
	if (proxy.type() == QNetworkProxy::Socks5Proxy) {
	netManager->setProxy(proxy);

	qDebug() << "PaymentServer::initNetManager : Using SOCKS5 proxy" << proxy.hostName() << ":" << proxy.port();
	}
	else
	qDebug() << "PaymentServer::initNetManager : No active proxy server found.";
	}
	else
	emit message(tr("Net manager warning"),
	tr("Your active proxy doesn't support SOCKS5, which is required for payment requests via proxy."),
	CClientUIInterface::MSG_WARNING);

	connect(netManager, SIGNAL(finished(QNetworkReply*)),
	this, SLOT(netRequestFinished(QNetworkReply*)));
	connect(netManager, SIGNAL(sslErrors(QNetworkReply*, const QList<QSslError> &)),
	this, SLOT(reportSslErrors(QNetworkReply*, const QList<QSslError> &)));
	}

	void PaymentServer::uiReady()
	{
	initNetManager();

	saveURIs = false;
	foreach (const QString& s, savedPaymentRequests)
	{
	handleURIOrFile(s);
	}
	savedPaymentRequests.clear();
	}

	void PaymentServer::handleURIOrFile(const QString& s)
	{
	if (saveURIs)
	{
	savedPaymentRequests.append(s);
	return;
	}

	if (s.startsWith(BITCOIN_IPC_PREFIX, Qt::CaseInsensitive)) // bitcoin: URI
	{
	#if QT_VERSION < 0x050000
	QUrl uri(s);
	#else
	QUrlQuery uri((QUrl(s)));
	#endif
	if (uri.hasQueryItem("r")) // payment request URI
	{
	QByteArray temp;
	temp.append(uri.queryItemValue("r"));
	QString decoded = QUrl::fromPercentEncoding(temp);
	QUrl fetchUrl(decoded, QUrl::StrictMode);

	if (fetchUrl.isValid())
	{
	qDebug() << "PaymentServer::handleURIOrFile : fetchRequest(" << fetchUrl << ")";
	fetchRequest(fetchUrl);
	}
	else
	{
	qDebug() << "PaymentServer::handleURIOrFile : Invalid URL: " << fetchUrl;
	emit message(tr("URI handling"),
	tr("Payment request fetch URL is invalid: %1").arg(fetchUrl.toString()),
	CClientUIInterface::ICON_WARNING);
	}

	return;
	}
	else // normal URI
	{
	SendCoinsRecipient recipient;
	if (GUIUtil::parseBitcoinURI(s, &recipient))
	{
	CBitcoinAddress address(recipient.address.toStdString());
	if (!address.IsValid()) {
	emit message(tr("URI handling"), tr("Invalid payment address %1").arg(recipient.address),
	CClientUIInterface::MSG_ERROR);
	}
	else
	emit receivedPaymentRequest(recipient);
	}
	else
	emit message(tr("URI handling"),
	tr("URI can not be parsed! This can be caused by an invalid Bitcoin address or malformed URI parameters."),
	CClientUIInterface::ICON_WARNING);

	return;
	}
	}

	if (QFile::exists(s)) // payment request file
	{
	PaymentRequestPlus request;
	SendCoinsRecipient recipient;
	if (!readPaymentRequest(s, request))
	{
	emit message(tr("Payment request file handling"),
	tr("Payment request file can not be read! This can be caused by an invalid payment request file."),
	CClientUIInterface::ICON_WARNING);
	}
	else if (processPaymentRequest(request, recipient))
	emit receivedPaymentRequest(recipient);

	return;
	}
	}

	void PaymentServer::handleURIConnection()
	{
	QLocalSocket *clientConnection = uriServer->nextPendingConnection();

	while (clientConnection->bytesAvailable() < (int)sizeof(quint32))
	clientConnection->waitForReadyRead();

	connect(clientConnection, SIGNAL(disconnected()),
	clientConnection, SLOT(deleteLater()));

	QDataStream in(clientConnection);
	in.setVersion(QDataStream::Qt_4_0);
	if (clientConnection->bytesAvailable() < (int)sizeof(quint16)) {
	return;
	}
	QString msg;
	in >> msg;

	handleURIOrFile(msg);
	}

	bool PaymentServer::readPaymentRequest(const QString& filename, PaymentRequestPlus& request)
	{
	QFile f(filename);
	if (!f.open(QIODevice::ReadOnly))
	{
	qDebug() << "PaymentServer::readPaymentRequest : Failed to open " << filename;
	return false;
	}

	if (f.size() > MAX_PAYMENT_REQUEST_SIZE)
	{
	qDebug() << "PaymentServer::readPaymentRequest : " << filename << " too large";
	return false;
	}

	QByteArray data = f.readAll();

	return request.parse(data);
	}

	-std::string PaymentServer::mapNetworkIdToName(CChainParams::Network networkId)
	-{
	- if (networkId == CChainParams::MAIN)
	- return "main";
	- if (networkId == CChainParams::TESTNET)
	- return "test";
	- if (networkId == CChainParams::REGTEST)
	- return "regtest";
	- return "";
	-}
	-
	bool PaymentServer::processPaymentRequest(PaymentRequestPlus& request, SendCoinsRecipient& recipient)
	{
	if (!optionsModel)
	return false;

	if (request.IsInitialized()) {
	const payments::PaymentDetails& details = request.getDetails();

	// Payment request network matches client network?
	- if (details.network() != mapNetworkIdToName(Params().NetworkID()))
	+ if (details.network() != Params().NetworkIDString())
	{
	emit message(tr("Payment request rejected"), tr("Payment request network doesn't match client network."),
	CClientUIInterface::MSG_ERROR);

	return false;
	}

	// Expired payment request?
	if (details.has_expires() && (int64_t)details.expires() < GetTime())
	{
	emit message(tr("Payment request rejected"), tr("Payment request has expired."),
	CClientUIInterface::MSG_ERROR);

	return false;
	}
	}
	else {
	emit message(tr("Payment request error"), tr("Payment request is not initialized."),
	CClientUIInterface::MSG_ERROR);

	return false;
	}

	recipient.paymentRequest = request;
	recipient.message = GUIUtil::HtmlEscape(request.getDetails().memo());

	request.getMerchant(PaymentServer::certStore, recipient.authenticatedMerchant);

	QList<std::pair<CScript, qint64> > sendingTos = request.getPayTo();
	QStringList addresses;

	foreach(const PAIRTYPE(CScript, qint64)& sendingTo, sendingTos) {
	// Extract and check destination addresses
	CTxDestination dest;
	if (ExtractDestination(sendingTo.first, dest)) {
	// Append destination address
	addresses.append(QString::fromStdString(CBitcoinAddress(dest).ToString()));
	}
	else if (!recipient.authenticatedMerchant.isEmpty()) {
	// Insecure payments to custom bitcoin addresses are not supported
	// (there is no good way to tell the user where they are paying in a way
	// they'd have a chance of understanding).
	emit message(tr("Payment request rejected"),
	tr("Unverified payment requests to custom payment scripts are unsupported."),
	CClientUIInterface::MSG_ERROR);
	return false;
	}

	// Extract and check amounts
	CTxOut txOut(sendingTo.second, sendingTo.first);
	if (txOut.IsDust(CTransaction::minRelayTxFee)) {
	emit message(tr("Payment request error"), tr("Requested payment amount of %1 is too small (considered dust).")
	.arg(BitcoinUnits::formatWithUnit(optionsModel->getDisplayUnit(), sendingTo.second)),
	CClientUIInterface::MSG_ERROR);

	return false;
	}

	recipient.amount += sendingTo.second;
	}
	// Store addresses and format them to fit nicely into the GUI
	recipient.address = addresses.join("<br />");

	if (!recipient.authenticatedMerchant.isEmpty()) {
	qDebug() << "PaymentServer::processPaymentRequest : Secure payment request from " << recipient.authenticatedMerchant;
	}
	else {
	qDebug() << "PaymentServer::processPaymentRequest : Insecure payment request to " << addresses.join(", ");
	}

	return true;
	}

	void PaymentServer::fetchRequest(const QUrl& url)
	{
	QNetworkRequest netRequest;
	netRequest.setAttribute(QNetworkRequest::User, "PaymentRequest");
	netRequest.setUrl(url);
	netRequest.setRawHeader("User-Agent", CLIENT_NAME.c_str());
	netRequest.setRawHeader("Accept", BITCOIN_REQUEST_MIMETYPE);
	netManager->get(netRequest);
	}

	void PaymentServer::fetchPaymentACK(CWallet* wallet, SendCoinsRecipient recipient, QByteArray transaction)
	{
	const payments::PaymentDetails& details = recipient.paymentRequest.getDetails();
	if (!details.has_payment_url())
	return;

	QNetworkRequest netRequest;
	netRequest.setAttribute(QNetworkRequest::User, "PaymentACK");
	netRequest.setUrl(QString::fromStdString(details.payment_url()));
	netRequest.setHeader(QNetworkRequest::ContentTypeHeader, BITCOIN_PAYMENTACK_CONTENTTYPE);
	netRequest.setRawHeader("User-Agent", CLIENT_NAME.c_str());
	netRequest.setRawHeader("Accept", BITCOIN_PAYMENTACK_MIMETYPE);

	payments::Payment payment;
	payment.set_merchant_data(details.merchant_data());
	payment.add_transactions(transaction.data(), transaction.size());

	// Create a new refund address, or re-use:
	QString account = tr("Refund from %1").arg(recipient.authenticatedMerchant);
	std::string strAccount = account.toStdString();
	set<CTxDestination> refundAddresses = wallet->GetAccountAddresses(strAccount);
	if (!refundAddresses.empty()) {
	CScript s; s.SetDestination(*refundAddresses.begin());
	payments::Output* refund_to = payment.add_refund_to();
	refund_to->set_script(&s[0], s.size());
	}
	else {
	CPubKey newKey;
	if (wallet->GetKeyFromPool(newKey)) {
	LOCK(wallet->cs_wallet); // SetAddressBook
	CKeyID keyID = newKey.GetID();
	wallet->SetAddressBook(keyID, strAccount, "refund");

	CScript s; s.SetDestination(keyID);
	payments::Output* refund_to = payment.add_refund_to();
	refund_to->set_script(&s[0], s.size());
	}
	else {
	// This should never happen, because sending coins should have
	// just unlocked the wallet and refilled the keypool.
	qDebug() << "PaymentServer::fetchPaymentACK : Error getting refund key, refund_to not set";
	}
	}

	int length = payment.ByteSize();
	netRequest.setHeader(QNetworkRequest::ContentLengthHeader, length);
	QByteArray serData(length, '\0');
	if (payment.SerializeToArray(serData.data(), length)) {
	netManager->post(netRequest, serData);
	}
	else {
	// This should never happen, either.
	qDebug() << "PaymentServer::fetchPaymentACK : Error serializing payment message";
	}
	}

	void PaymentServer::netRequestFinished(QNetworkReply* reply)
	{
	reply->deleteLater();
	if (reply->error() != QNetworkReply::NoError)
	{
	QString msg = tr("Error communicating with %1: %2")
	.arg(reply->request().url().toString())
	.arg(reply->errorString());

	qDebug() << "PaymentServer::netRequestFinished : " << msg;
	emit message(tr("Payment request error"), msg, CClientUIInterface::MSG_ERROR);
	return;
	}

	QByteArray data = reply->readAll();

	QString requestType = reply->request().attribute(QNetworkRequest::User).toString();
	if (requestType == "PaymentRequest")
	{
	PaymentRequestPlus request;
	SendCoinsRecipient recipient;
	if (!request.parse(data))
	{
	qDebug() << "PaymentServer::netRequestFinished : Error parsing payment request";
	emit message(tr("Payment request error"),
	tr("Payment request can not be parsed!"),
	CClientUIInterface::MSG_ERROR);
	}
	else if (processPaymentRequest(request, recipient))
	emit receivedPaymentRequest(recipient);

	return;
	}
	else if (requestType == "PaymentACK")
	{
	payments::PaymentACK paymentACK;
	if (!paymentACK.ParseFromArray(data.data(), data.size()))
	{
	QString msg = tr("Bad response from server %1")
	.arg(reply->request().url().toString());

	qDebug() << "PaymentServer::netRequestFinished : " << msg;
	emit message(tr("Payment request error"), msg, CClientUIInterface::MSG_ERROR);
	}
	else
	{
	emit receivedPaymentACK(GUIUtil::HtmlEscape(paymentACK.memo()));
	}
	}
	}

	void PaymentServer::reportSslErrors(QNetworkReply* reply, const QList<QSslError> &errs)
	{
	Q_UNUSED(reply);

	QString errString;
	foreach (const QSslError& err, errs) {
	qDebug() << "PaymentServer::reportSslErrors : " << err;
	errString += err.errorString() + "\n";
	}
	emit message(tr("Network request error"), errString, CClientUIInterface::MSG_ERROR);
	}

	void PaymentServer::setOptionsModel(OptionsModel *optionsModel)
	{
	this->optionsModel = optionsModel;
	}

	void PaymentServer::handlePaymentACK(const QString& paymentACKMsg)
	{
	// currently we don't futher process or store the paymentACK message
	emit message(tr("Payment acknowledged"), paymentACKMsg, CClientUIInterface::ICON_INFORMATION \| CClientUIInterface::MODAL);
	}
	diff --git a/src/qt/paymentserver.h b/src/qt/paymentserver.h
	index d6949a47c..d84d09c57 100644
	--- a/src/qt/paymentserver.h
	+++ b/src/qt/paymentserver.h
	@@ -1,139 +1,138 @@
	// Copyright (c) 2011-2014 The Bitcoin developers
	// Distributed under the MIT/X11 software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#ifndef PAYMENTSERVER_H
	#define PAYMENTSERVER_H
	// This class handles payment requests from clicking on
	// bitcoin: URIs
	//
	// This is somewhat tricky, because we have to deal with
	// the situation where the user clicks on a link during
	// startup/initialization, when the splash-screen is up
	// but the main window (and the Send Coins tab) is not.
	//
	// So, the strategy is:
	//
	// Create the server, and register the event handler,
	// when the application is created. Save any URIs
	// received at or during startup in a list.
	//
	// When startup is finished and the main window is
	// shown, a signal is sent to slot uiReady(), which
	// emits a receivedURL() signal for any payment
	// requests that happened during startup.
	//
	// After startup, receivedURL() happens as usual.
	//
	// This class has one more feature: a static
	// method that finds URIs passed in the command line
	// and, if a server is running in another process,
	// sends them to the server.
	//

	#include "paymentrequestplus.h"
	#include "walletmodel.h"

	#include <QObject>
	#include <QString>

	class OptionsModel;

	QT_BEGIN_NAMESPACE
	class QApplication;
	class QByteArray;
	class QLocalServer;
	class QNetworkAccessManager;
	class QNetworkReply;
	class QSslError;
	class QUrl;
	QT_END_NAMESPACE

	class CWallet;

	class PaymentServer : public QObject
	{
	Q_OBJECT

	public:
	// Parse URIs on command line
	// Returns false on error
	static bool ipcParseCommandLine(int argc, char *argv[]);

	// Returns true if there were URIs on the command line
	// which were successfully sent to an already-running
	// process.
	// Note: if a payment request is given, SelectParams(MAIN/TESTNET)
	// will be called so we startup in the right mode.
	static bool ipcSendCommandLine();

	// parent should be QApplication object
	PaymentServer(QObject* parent, bool startLocalServer = true);
	~PaymentServer();

	// Load root certificate authorities. Pass NULL (default)
	// to read from the file specified in the -rootcertificates setting,
	// or, if that's not set, to use the system default root certificates.
	// If you pass in a store, you should not X509_STORE_free it: it will be
	// freed either at exit or when another set of CAs are loaded.
	static void LoadRootCAs(X509_STORE* store = NULL);

	// Return certificate store
	static X509_STORE* getCertStore() { return certStore; }

	// OptionsModel is used for getting proxy settings and display unit
	void setOptionsModel(OptionsModel *optionsModel);

	signals:
	// Fired when a valid payment request is received
	void receivedPaymentRequest(SendCoinsRecipient);

	// Fired when a valid PaymentACK is received
	void receivedPaymentACK(const QString &paymentACKMsg);

	// Fired when a message should be reported to the user
	void message(const QString &title, const QString &message, unsigned int style);

	public slots:
	// Signal this when the main window's UI is ready
	// to display payment requests to the user
	void uiReady();

	// Submit Payment message to a merchant, get back PaymentACK:
	void fetchPaymentACK(CWallet* wallet, SendCoinsRecipient recipient, QByteArray transaction);

	// Handle an incoming URI, URI with local file scheme or file
	void handleURIOrFile(const QString& s);

	private slots:
	void handleURIConnection();
	void netRequestFinished(QNetworkReply*);
	void reportSslErrors(QNetworkReply*, const QList<QSslError> &);
	void handlePaymentACK(const QString& paymentACKMsg);

	protected:
	// Constructor registers this on the parent QApplication to
	// receive QEvent::FileOpen and QEvent:Drop events
	bool eventFilter(QObject object, QEvent event);

	private:
	static bool readPaymentRequest(const QString& filename, PaymentRequestPlus& request);
	- std::string mapNetworkIdToName(CChainParams::Network networkId);
	bool processPaymentRequest(PaymentRequestPlus& request, SendCoinsRecipient& recipient);
	void fetchRequest(const QUrl& url);

	// Setup networking
	void initNetManager();

	bool saveURIs; // true during startup
	QLocalServer* uriServer;

	static X509_STORE* certStore; // Trusted root certificates
	static void freeCertStore();

	QNetworkAccessManager* netManager; // Used to fetch payment requests

	OptionsModel *optionsModel;
	};

	#endif // PAYMENTSERVER_H
	diff --git a/src/qt/rpcconsole.cpp b/src/qt/rpcconsole.cpp
	index 199050cc5..f7491f4a4 100644
	--- a/src/qt/rpcconsole.cpp
	+++ b/src/qt/rpcconsole.cpp
	@@ -1,675 +1,675 @@
	// Copyright (c) 2011-2014 The Bitcoin developers
	// Distributed under the MIT/X11 software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include "rpcconsole.h"
	#include "ui_rpcconsole.h"

	#include "clientmodel.h"
	#include "guiutil.h"
	#include "peertablemodel.h"

	#include "main.h"
	#include "rpcserver.h"
	#include "rpcclient.h"
	#include "util.h"

	#include "json/json_spirit_value.h"
	#ifdef ENABLE_WALLET
	#include <db_cxx.h>
	#endif
	#include <openssl/crypto.h>

	#include <QKeyEvent>
	#include <QScrollBar>
	#include <QThread>
	#include <QTime>

	#if QT_VERSION < 0x050000
	#include <QUrl>
	#endif

	// TODO: add a scrollback limit, as there is currently none
	// TODO: make it possible to filter out categories (esp debug messages when implemented)
	// TODO: receive errors and debug messages through ClientModel

	const int CONSOLE_HISTORY = 50;
	const QSize ICON_SIZE(24, 24);

	const int INITIAL_TRAFFIC_GRAPH_MINS = 30;

	const struct {
	const char *url;
	const char *source;
	} ICON_MAPPING[] = {
	{"cmd-request", ":/icons/tx_input"},
	{"cmd-reply", ":/icons/tx_output"},
	{"cmd-error", ":/icons/tx_output"},
	{"misc", ":/icons/tx_inout"},
	{NULL, NULL}
	};

	/* Object for executing console RPC commands in a separate thread.
	*/
	class RPCExecutor : public QObject
	{
	Q_OBJECT

	public slots:
	void request(const QString &command);

	signals:
	void reply(int category, const QString &command);
	};

	#include "rpcconsole.moc"

	/**
	* Split shell command line into a list of arguments. Aims to emulate \c bash and friends.
	*
	* - Arguments are delimited with whitespace
	* - Extra whitespace at the beginning and end and between arguments will be ignored
	* - Text can be "double" or 'single' quoted
	* - The backslash \c \ is used as escape character
	* - Outside quotes, any character can be escaped
	* - Within double quotes, only escape \c " and backslashes before a \c " or another backslash
	* - Within single quotes, no escaping is possible and no special interpretation takes place
	*
	* @param[out] args Parsed arguments will be appended to this list
	* @param[in] strCommand Command line to split
	*/
	bool parseCommandLine(std::vector<std::string> &args, const std::string &strCommand)
	{
	enum CmdParseState
	{
	STATE_EATING_SPACES,
	STATE_ARGUMENT,
	STATE_SINGLEQUOTED,
	STATE_DOUBLEQUOTED,
	STATE_ESCAPE_OUTER,
	STATE_ESCAPE_DOUBLEQUOTED
	} state = STATE_EATING_SPACES;
	std::string curarg;
	foreach(char ch, strCommand)
	{
	switch(state)
	{
	case STATE_ARGUMENT: // In or after argument
	case STATE_EATING_SPACES: // Handle runs of whitespace
	switch(ch)
	{
	case '"': state = STATE_DOUBLEQUOTED; break;
	case '\'': state = STATE_SINGLEQUOTED; break;
	case '\\': state = STATE_ESCAPE_OUTER; break;
	case ' ': case '\n': case '\t':
	if(state == STATE_ARGUMENT) // Space ends argument
	{
	args.push_back(curarg);
	curarg.clear();
	}
	state = STATE_EATING_SPACES;
	break;
	default: curarg += ch; state = STATE_ARGUMENT;
	}
	break;
	case STATE_SINGLEQUOTED: // Single-quoted string
	switch(ch)
	{
	case '\'': state = STATE_ARGUMENT; break;
	default: curarg += ch;
	}
	break;
	case STATE_DOUBLEQUOTED: // Double-quoted string
	switch(ch)
	{
	case '"': state = STATE_ARGUMENT; break;
	case '\\': state = STATE_ESCAPE_DOUBLEQUOTED; break;
	default: curarg += ch;
	}
	break;
	case STATE_ESCAPE_OUTER: // '\' outside quotes
	curarg += ch; state = STATE_ARGUMENT;
	break;
	case STATE_ESCAPE_DOUBLEQUOTED: // '\' in double-quoted text
	if(ch != '"' && ch != '\\') curarg += '\\'; // keep '\' for everything but the quote and '\' itself
	curarg += ch; state = STATE_DOUBLEQUOTED;
	break;
	}
	}
	switch(state) // final state
	{
	case STATE_EATING_SPACES:
	return true;
	case STATE_ARGUMENT:
	args.push_back(curarg);
	return true;
	default: // ERROR to end in one of the other states
	return false;
	}
	}

	void RPCExecutor::request(const QString &command)
	{
	std::vector<std::string> args;
	if(!parseCommandLine(args, command.toStdString()))
	{
	emit reply(RPCConsole::CMD_ERROR, QString("Parse error: unbalanced ' or \""));
	return;
	}
	if(args.empty())
	return; // Nothing to do
	try
	{
	std::string strPrint;
	// Convert argument list to JSON objects in method-dependent way,
	// and pass it along with the method name to the dispatcher.
	json_spirit::Value result = tableRPC.execute(
	args[0],
	RPCConvertValues(args[0], std::vector<std::string>(args.begin() + 1, args.end())));

	// Format result reply
	if (result.type() == json_spirit::null_type)
	strPrint = "";
	else if (result.type() == json_spirit::str_type)
	strPrint = result.get_str();
	else
	strPrint = write_string(result, true);

	emit reply(RPCConsole::CMD_REPLY, QString::fromStdString(strPrint));
	}
	catch (json_spirit::Object& objError)
	{
	try // Nice formatting for standard-format error
	{
	int code = find_value(objError, "code").get_int();
	std::string message = find_value(objError, "message").get_str();
	emit reply(RPCConsole::CMD_ERROR, QString::fromStdString(message) + " (code " + QString::number(code) + ")");
	}
	catch(std::runtime_error &) // raised when converting to invalid type, i.e. missing code or message
	{ // Show raw JSON object
	emit reply(RPCConsole::CMD_ERROR, QString::fromStdString(write_string(json_spirit::Value(objError), false)));
	}
	}
	catch (std::exception& e)
	{
	emit reply(RPCConsole::CMD_ERROR, QString("Error: ") + QString::fromStdString(e.what()));
	}
	}

	RPCConsole::RPCConsole(QWidget *parent) :
	QDialog(parent),
	ui(new Ui::RPCConsole),
	clientModel(0),
	historyPtr(0)
	{
	detailNodeStats = CNodeCombinedStats();
	detailNodeStats.nodestats.nodeid = -1;
	detailNodeStats.statestats.nMisbehavior = -1;

	ui->setupUi(this);
	GUIUtil::restoreWindowGeometry("nRPCConsoleWindow", this->size(), this);

	#ifndef Q_OS_MAC
	ui->openDebugLogfileButton->setIcon(QIcon(":/icons/export"));
	#endif

	// Install event filter for up and down arrow
	ui->lineEdit->installEventFilter(this);
	ui->messagesWidget->installEventFilter(this);

	connect(ui->clearButton, SIGNAL(clicked()), this, SLOT(clear()));
	connect(ui->btnClearTrafficGraph, SIGNAL(clicked()), ui->trafficGraph, SLOT(clear()));

	// set library version labels
	ui->openSSLVersion->setText(SSLeay_version(SSLEAY_VERSION));
	#ifdef ENABLE_WALLET
	ui->berkeleyDBVersion->setText(DbEnv::version(0, 0, 0));
	#else
	ui->label_berkeleyDBVersion->hide();
	ui->berkeleyDBVersion->hide();
	#endif

	startExecutor();
	setTrafficGraphRange(INITIAL_TRAFFIC_GRAPH_MINS);
	ui->detailWidget->hide();

	clear();
	}

	RPCConsole::~RPCConsole()
	{
	GUIUtil::saveWindowGeometry("nRPCConsoleWindow", this);
	emit stopExecutor();
	delete ui;
	}

	bool RPCConsole::eventFilter(QObject* obj, QEvent *event)
	{
	if(event->type() == QEvent::KeyPress) // Special key handling
	{
	QKeyEvent keyevt = static_cast<QKeyEvent>(event);
	int key = keyevt->key();
	Qt::KeyboardModifiers mod = keyevt->modifiers();
	switch(key)
	{
	case Qt::Key_Up: if(obj == ui->lineEdit) { browseHistory(-1); return true; } break;
	case Qt::Key_Down: if(obj == ui->lineEdit) { browseHistory(1); return true; } break;
	case Qt::Key_PageUp: /* pass paging keys to messages widget */
	case Qt::Key_PageDown:
	if(obj == ui->lineEdit)
	{
	QApplication::postEvent(ui->messagesWidget, new QKeyEvent(*keyevt));
	return true;
	}
	break;
	default:
	// Typing in messages widget brings focus to line edit, and redirects key there
	// Exclude most combinations and keys that emit no text, except paste shortcuts
	if(obj == ui->messagesWidget && (
	(!mod && !keyevt->text().isEmpty() && key != Qt::Key_Tab) \|\|
	((mod & Qt::ControlModifier) && key == Qt::Key_V) \|\|
	((mod & Qt::ShiftModifier) && key == Qt::Key_Insert)))
	{
	ui->lineEdit->setFocus();
	QApplication::postEvent(ui->lineEdit, new QKeyEvent(*keyevt));
	return true;
	}
	}
	}
	return QDialog::eventFilter(obj, event);
	}

	void RPCConsole::setClientModel(ClientModel *model)
	{
	clientModel = model;
	ui->trafficGraph->setClientModel(model);
	if(model)
	{
	// Keep up to date with client
	setNumConnections(model->getNumConnections());
	connect(model, SIGNAL(numConnectionsChanged(int)), this, SLOT(setNumConnections(int)));

	setNumBlocks(model->getNumBlocks());
	connect(model, SIGNAL(numBlocksChanged(int)), this, SLOT(setNumBlocks(int)));

	updateTrafficStats(model->getTotalBytesRecv(), model->getTotalBytesSent());
	connect(model, SIGNAL(bytesChanged(quint64,quint64)), this, SLOT(updateTrafficStats(quint64, quint64)));

	// set up peer table
	ui->peerWidget->setModel(model->getPeerTableModel());
	ui->peerWidget->verticalHeader()->hide();
	ui->peerWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
	ui->peerWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
	ui->peerWidget->setSelectionMode(QAbstractItemView::SingleSelection);
	ui->peerWidget->setColumnWidth(PeerTableModel::Address, ADDRESS_COLUMN_WIDTH);
	columnResizingFixer = new GUIUtil::TableViewLastColumnResizingFixer(ui->peerWidget, MINIMUM_COLUMN_WIDTH, MINIMUM_COLUMN_WIDTH);

	// connect the peerWidget's selection model to our peerSelected() handler
	QItemSelectionModel *peerSelectModel = ui->peerWidget->selectionModel();
	connect(peerSelectModel, SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)),
	this, SLOT(peerSelected(const QItemSelection &, const QItemSelection &)));
	connect(model->getPeerTableModel(), SIGNAL(layoutChanged()), this, SLOT(peerLayoutChanged()));

	// Provide initial values
	ui->clientVersion->setText(model->formatFullVersion());
	ui->clientName->setText(model->clientName());
	ui->buildDate->setText(model->formatBuildDate());
	ui->startupTime->setText(model->formatClientStartupTime());

	- ui->networkName->setText(model->getNetworkName());
	+ ui->networkName->setText(QString::fromStdString(Params().NetworkIDString()));
	}
	}

	static QString categoryClass(int category)
	{
	switch(category)
	{
	case RPCConsole::CMD_REQUEST: return "cmd-request"; break;
	case RPCConsole::CMD_REPLY: return "cmd-reply"; break;
	case RPCConsole::CMD_ERROR: return "cmd-error"; break;
	default: return "misc";
	}
	}

	void RPCConsole::clear()
	{
	ui->messagesWidget->clear();
	history.clear();
	historyPtr = 0;
	ui->lineEdit->clear();
	ui->lineEdit->setFocus();

	// Add smoothly scaled icon images.
	// (when using width/height on an img, Qt uses nearest instead of linear interpolation)
	for(int i=0; ICON_MAPPING[i].url; ++i)
	{
	ui->messagesWidget->document()->addResource(
	QTextDocument::ImageResource,
	QUrl(ICON_MAPPING[i].url),
	QImage(ICON_MAPPING[i].source).scaled(ICON_SIZE, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
	}

	// Set default style sheet
	ui->messagesWidget->document()->setDefaultStyleSheet(
	"table { }"
	"td.time { color: #808080; padding-top: 3px; } "
	"td.message { font-family: monospace; font-size: 12px; } " // Todo: Remove fixed font-size
	"td.cmd-request { color: #006060; } "
	"td.cmd-error { color: red; } "
	"b { color: #006060; } "
	);

	message(CMD_REPLY, (tr("Welcome to the Bitcoin RPC console.") + "<br>" +
	tr("Use up and down arrows to navigate history, and <b>Ctrl-L</b> to clear screen.") + "<br>" +
	tr("Type <b>help</b> for an overview of available commands.")), true);
	}

	void RPCConsole::reject()
	{
	// Ignore escape keypress if this is not a seperate window
	if(windowType() != Qt::Widget)
	QDialog::reject();
	}

	void RPCConsole::message(int category, const QString &message, bool html)
	{
	QTime time = QTime::currentTime();
	QString timeString = time.toString();
	QString out;
	out += "<table><tr><td class=\"time\" width=\"65\">" + timeString + "</td>";
	out += "<td class=\"icon\" width=\"32\"><img src=\"" + categoryClass(category) + "\"></td>";
	out += "<td class=\"message " + categoryClass(category) + "\" valign=\"middle\">";
	if(html)
	out += message;
	else
	out += GUIUtil::HtmlEscape(message, true);
	out += "</td></tr></table>";
	ui->messagesWidget->append(out);
	}

	void RPCConsole::setNumConnections(int count)
	{
	if (!clientModel)
	return;

	QString connections = QString::number(count) + " (";
	connections += tr("In:") + " " + QString::number(clientModel->getNumConnections(CONNECTIONS_IN)) + " / ";
	connections += tr("Out:") + " " + QString::number(clientModel->getNumConnections(CONNECTIONS_OUT)) + ")";

	ui->numberOfConnections->setText(connections);
	}

	void RPCConsole::setNumBlocks(int count)
	{
	ui->numberOfBlocks->setText(QString::number(count));
	if(clientModel)
	ui->lastBlockTime->setText(clientModel->getLastBlockDate().toString());
	}

	void RPCConsole::on_lineEdit_returnPressed()
	{
	QString cmd = ui->lineEdit->text();
	ui->lineEdit->clear();

	if(!cmd.isEmpty())
	{
	message(CMD_REQUEST, cmd);
	emit cmdRequest(cmd);
	// Remove command, if already in history
	history.removeOne(cmd);
	// Append command to history
	history.append(cmd);
	// Enforce maximum history size
	while(history.size() > CONSOLE_HISTORY)
	history.removeFirst();
	// Set pointer to end of history
	historyPtr = history.size();
	// Scroll console view to end
	scrollToEnd();
	}
	}

	void RPCConsole::browseHistory(int offset)
	{
	historyPtr += offset;
	if(historyPtr < 0)
	historyPtr = 0;
	if(historyPtr > history.size())
	historyPtr = history.size();
	QString cmd;
	if(historyPtr < history.size())
	cmd = history.at(historyPtr);
	ui->lineEdit->setText(cmd);
	}

	void RPCConsole::startExecutor()
	{
	QThread *thread = new QThread;
	RPCExecutor *executor = new RPCExecutor();
	executor->moveToThread(thread);

	// Replies from executor object must go to this object
	connect(executor, SIGNAL(reply(int,QString)), this, SLOT(message(int,QString)));
	// Requests from this object must go to executor
	connect(this, SIGNAL(cmdRequest(QString)), executor, SLOT(request(QString)));

	// On stopExecutor signal
	// - queue executor for deletion (in execution thread)
	// - quit the Qt event loop in the execution thread
	connect(this, SIGNAL(stopExecutor()), executor, SLOT(deleteLater()));
	connect(this, SIGNAL(stopExecutor()), thread, SLOT(quit()));
	// Queue the thread for deletion (in this thread) when it is finished
	connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));

	// Default implementation of QThread::run() simply spins up an event loop in the thread,
	// which is what we want.
	thread->start();
	}

	void RPCConsole::on_tabWidget_currentChanged(int index)
	{
	if(ui->tabWidget->widget(index) == ui->tab_console)
	{
	ui->lineEdit->setFocus();
	}
	}

	void RPCConsole::on_openDebugLogfileButton_clicked()
	{
	GUIUtil::openDebugLogfile();
	}

	void RPCConsole::scrollToEnd()
	{
	QScrollBar *scrollbar = ui->messagesWidget->verticalScrollBar();
	scrollbar->setValue(scrollbar->maximum());
	}

	void RPCConsole::on_sldGraphRange_valueChanged(int value)
	{
	const int multiplier = 5; // each position on the slider represents 5 min
	int mins = value * multiplier;
	setTrafficGraphRange(mins);
	}

	QString RPCConsole::FormatBytes(quint64 bytes)
	{
	if(bytes < 1024)
	return QString(tr("%1 B")).arg(bytes);
	if(bytes < 1024 * 1024)
	return QString(tr("%1 KB")).arg(bytes / 1024);
	if(bytes < 1024 * 1024 * 1024)
	return QString(tr("%1 MB")).arg(bytes / 1024 / 1024);

	return QString(tr("%1 GB")).arg(bytes / 1024 / 1024 / 1024);
	}

	void RPCConsole::setTrafficGraphRange(int mins)
	{
	ui->trafficGraph->setGraphRangeMins(mins);
	ui->lblGraphRange->setText(GUIUtil::formatDurationStr(mins * 60));
	}

	void RPCConsole::updateTrafficStats(quint64 totalBytesIn, quint64 totalBytesOut)
	{
	ui->lblBytesIn->setText(FormatBytes(totalBytesIn));
	ui->lblBytesOut->setText(FormatBytes(totalBytesOut));
	}

	void RPCConsole::peerSelected(const QItemSelection &selected, const QItemSelection &deselected)
	{
	Q_UNUSED(deselected);

	if (selected.indexes().isEmpty())
	return;

	// mark the cached banscore as unknown
	detailNodeStats.statestats.nMisbehavior = -1;

	const CNodeCombinedStats *stats = clientModel->getPeerTableModel()->getNodeStats(selected.indexes().first().row());

	if (stats)
	{
	detailNodeStats.nodestats.nodeid = stats->nodestats.nodeid;
	updateNodeDetail(stats);
	ui->detailWidget->show();
	ui->detailWidget->setDisabled(false);
	}
	}

	void RPCConsole::peerLayoutChanged()
	{
	const CNodeCombinedStats *stats = NULL;
	bool fUnselect = false, fReselect = false, fDisconnected = false;

	if (detailNodeStats.nodestats.nodeid == -1)
	// no node selected yet
	return;

	// find the currently selected row
	int selectedRow;
	QModelIndexList selectedModelIndex = ui->peerWidget->selectionModel()->selectedIndexes();
	if (selectedModelIndex.isEmpty())
	selectedRow = -1;
	else
	selectedRow = selectedModelIndex.first().row();

	// check if our detail node has a row in the table (it may not necessarily
	// be at selectedRow since its position can change after a layout change)
	int detailNodeRow = clientModel->getPeerTableModel()->getRowByNodeId(detailNodeStats.nodestats.nodeid);

	if (detailNodeRow < 0)
	{
	// detail node dissapeared from table (node disconnected)
	fUnselect = true;
	fDisconnected = true;
	detailNodeStats.nodestats.nodeid = 0;
	}
	else
	{
	if (detailNodeRow != selectedRow)
	{
	// detail node moved position
	fUnselect = true;
	fReselect = true;
	}

	// get fresh stats on the detail node.
	stats = clientModel->getPeerTableModel()->getNodeStats(detailNodeRow);
	}

	if (fUnselect && selectedRow >= 0)
	{
	ui->peerWidget->selectionModel()->select(QItemSelection(selectedModelIndex.first(), selectedModelIndex.last()),
	QItemSelectionModel::Deselect);
	}

	if (fReselect)
	{
	ui->peerWidget->selectRow(detailNodeRow);
	}

	if (stats)
	updateNodeDetail(stats);

	if (fDisconnected)
	{
	ui->peerHeading->setText(QString(tr("Peer Disconnected")));
	ui->detailWidget->setDisabled(true);
	QDateTime dt = QDateTime::fromTime_t(detailNodeStats.nodestats.nLastSend);
	if (detailNodeStats.nodestats.nLastSend)
	ui->peerLastSend->setText(dt.toString("yyyy-MM-dd hh:mm:ss"));
	dt.setTime_t(detailNodeStats.nodestats.nLastRecv);
	if (detailNodeStats.nodestats.nLastRecv)
	ui->peerLastRecv->setText(dt.toString("yyyy-MM-dd hh:mm:ss"));
	dt.setTime_t(detailNodeStats.nodestats.nTimeConnected);
	ui->peerConnTime->setText(dt.toString("yyyy-MM-dd hh:mm:ss"));
	}
	}

	void RPCConsole::updateNodeDetail(const CNodeCombinedStats *combinedStats)
	{
	CNodeStats stats = combinedStats->nodestats;

	// keep a copy of timestamps, used to display dates upon disconnect
	detailNodeStats.nodestats.nLastSend = stats.nLastSend;
	detailNodeStats.nodestats.nLastRecv = stats.nLastRecv;
	detailNodeStats.nodestats.nTimeConnected = stats.nTimeConnected;

	// update the detail ui with latest node information
	ui->peerHeading->setText(QString("<b>%1</b>").arg(tr("Node Detail")));
	ui->peerAddr->setText(QString(stats.addrName.c_str()));
	ui->peerServices->setText(GUIUtil::formatServicesStr(stats.nServices));
	ui->peerLastSend->setText(stats.nLastSend ? GUIUtil::formatDurationStr(GetTime() - stats.nLastSend) : tr("never"));
	ui->peerLastRecv->setText(stats.nLastRecv ? GUIUtil::formatDurationStr(GetTime() - stats.nLastRecv) : tr("never"));
	ui->peerBytesSent->setText(FormatBytes(stats.nSendBytes));
	ui->peerBytesRecv->setText(FormatBytes(stats.nRecvBytes));
	ui->peerConnTime->setText(GUIUtil::formatDurationStr(GetTime() - stats.nTimeConnected));
	ui->peerPingTime->setText(stats.dPingTime == 0 ? tr("N/A") : QString(tr("%1 secs")).arg(QString::number(stats.dPingTime, 'f', 3)));
	ui->peerVersion->setText(QString("%1").arg(stats.nVersion));
	ui->peerSubversion->setText(QString(stats.cleanSubVer.c_str()));
	ui->peerDirection->setText(stats.fInbound ? tr("Inbound") : tr("Outbound"));
	ui->peerHeight->setText(QString("%1").arg(stats.nStartingHeight));
	ui->peerSyncNode->setText(stats.fSyncNode ? tr("Yes") : tr("No"));

	// if we can, display the peer's ban score
	CNodeStateStats statestats = combinedStats->statestats;
	if (statestats.nMisbehavior >= 0)
	{
	// we have a new nMisbehavor value - update the cache
	detailNodeStats.statestats.nMisbehavior = statestats.nMisbehavior;
	}

	// pull the ban score from cache. -1 means it hasn't been retrieved yet (lock busy).
	if (detailNodeStats.statestats.nMisbehavior >= 0)
	ui->peerBanScore->setText(QString("%1").arg(detailNodeStats.statestats.nMisbehavior));
	else
	ui->peerBanScore->setText(tr("Fetching..."));
	}

	// We override the virtual resizeEvent of the QWidget to adjust tables column
	// sizes as the tables width is proportional to the dialogs width.
	void RPCConsole::resizeEvent(QResizeEvent *event)
	{
	QWidget::resizeEvent(event);
	columnResizingFixer->stretchColumnWidth(PeerTableModel::Address);
	}

	void RPCConsole::showEvent(QShowEvent *event)
	{
	QWidget::showEvent(event);

	// peerWidget needs a resize in case the dialog has non-default geometry
	columnResizingFixer->stretchColumnWidth(PeerTableModel::Address);

	// start PeerTableModel auto refresh
	clientModel->getPeerTableModel()->startAutoRefresh(1000);
	}

	void RPCConsole::hideEvent(QHideEvent *event)
	{
	QWidget::hideEvent(event);

	// stop PeerTableModel auto refresh
	clientModel->getPeerTableModel()->stopAutoRefresh();
	}
	diff --git a/src/rpcblockchain.cpp b/src/rpcblockchain.cpp
	index 2a21fb462..0fabc8687 100644
	--- a/src/rpcblockchain.cpp
	+++ b/src/rpcblockchain.cpp
	@@ -1,464 +1,461 @@
	// Copyright (c) 2010 Satoshi Nakamoto
	// Copyright (c) 2009-2013 The Bitcoin developers
	// Distributed under the MIT/X11 software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include "checkpoints.h"
	#include "main.h"
	#include "rpcserver.h"
	#include "sync.h"

	#include <stdint.h>

	#include "json/json_spirit_value.h"

	using namespace json_spirit;
	using namespace std;

	void ScriptPubKeyToJSON(const CScript& scriptPubKey, Object& 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;
	}


	Object blockToJSON(const CBlock& block, const CBlockIndex* blockindex)
	{
	Object result;
	result.push_back(Pair("hash", block.GetHash().GetHex()));
	CMerkleTx txGen(block.vtx[0]);
	txGen.SetMerkleBranch(&block);
	result.push_back(Pair("confirmations", (int)txGen.GetDepthInMainChain()));
	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()));
	Array txs;
	BOOST_FOREACH(const CTransaction&tx, block.vtx)
	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", HexBits(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;
	}


	Value getblockcount(const Array& 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", "")
	);

	return chainActive.Height();
	}

	Value getbestblockhash(const Array& 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", "")
	);

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

	Value getdifficulty(const Array& 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", "")
	);

	return GetDifficulty();
	}


	Value getrawmempool(const Array& 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"
	" \"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")
	);

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

	if (fVerbose)
	{
	LOCK(mempool.cs);
	Object o;
	BOOST_FOREACH(const PAIRTYPE(uint256, CTxMemPoolEntry)& entry, mempool.mapTx)
	{
	const uint256& hash = entry.first;
	const CTxMemPoolEntry& e = entry.second;
	Object info;
	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());
	}
	Array depends(setDepends.begin(), setDepends.end());
	info.push_back(Pair("depends", depends));
	o.push_back(Pair(hash.ToString(), info));
	}
	return o;
	}
	else
	{
	vector<uint256> vtxid;
	mempool.queryHashes(vtxid);

	Array a;
	BOOST_FOREACH(const uint256& hash, vtxid)
	a.push_back(hash.ToString());

	return a;
	}
	}

	Value getblockhash(const Array& 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")
	);

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

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

	Value getblock(const Array& 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\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\"")
	);

	std::string strHash = params[0].get_str();
	uint256 hash(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];
	ReadBlockFromDisk(block, pblockindex);

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

	return blockToJSON(block, pblockindex);
	}

	Value gettxoutsetinfo(const Array& 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", "")
	);

	Object ret;

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

	Value gettxout(const Array& 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"
	" \"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")
	);

	Object ret;

	std::string strHash = params[0].get_str();
	uint256 hash(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 Value::null;
	mempool.pruneSpent(hash, coins); // TODO: this should be done by the CCoinsViewMemPool
	} else {
	if (!pcoinsTip->GetCoins(hash, coins))
	return Value::null;
	}
	if (n<0 \|\| (unsigned int)n>=coins.vout.size() \|\| coins.vout[n].IsNull())
	return Value::null;

	std::map<uint256, CBlockIndex*>::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)));
	Object o;
	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;
	}

	Value verifychain(const Array& 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", "")
	);

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

	Value getblockchaininfo(const Array& 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 chain (main, testnet3, regtest)\n"
	" \"blocks\": xxxxxx, (numeric) the current number of blocks processed in the server\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"
	"}\n"
	"\nExamples:\n"
	+ HelpExampleCli("getblockchaininfo", "")
	+ HelpExampleRpc("getblockchaininfo", "")
	);

	Object obj;
	- std::string chain = Params().DataDir();
	- if(chain.empty())
	- chain = "main";
	- obj.push_back(Pair("chain", chain));
	- obj.push_back(Pair("blocks", (int)chainActive.Height()));
	- obj.push_back(Pair("bestblockhash", chainActive.Tip()->GetBlockHash().GetHex()));
	- obj.push_back(Pair("difficulty", (double)GetDifficulty()));
	- obj.push_back(Pair("verificationprogress", Checkpoints::GuessVerificationProgress(chainActive.Tip())));
	- obj.push_back(Pair("chainwork", chainActive.Tip()->nChainWork.GetHex()));
	+ obj.push_back(Pair("chain", Params().NetworkIDString()));
	+ obj.push_back(Pair("blocks", (int)chainActive.Height()));
	+ obj.push_back(Pair("bestblockhash", chainActive.Tip()->GetBlockHash().GetHex()));
	+ obj.push_back(Pair("difficulty", (double)GetDifficulty()));
	+ obj.push_back(Pair("verificationprogress", Checkpoints::GuessVerificationProgress(chainActive.Tip())));
	+ obj.push_back(Pair("chainwork", chainActive.Tip()->nChainWork.GetHex()));
	return obj;
	}

File Metadata

Mime Type: text/x-diff
Expires: Wed, May 21, 23:36 (1 d, 28 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5866159
Default Alt Text: (105 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions