No OneTemporary
Actions

Size

40 KB

Subscribers

None

View Options

	diff --git a/src/chainparams.cpp b/src/chainparams.cpp
	index 1fd3b0168..c48ccbc08 100644
	--- a/src/chainparams.cpp
	+++ b/src/chainparams.cpp
	@@ -1,363 +1,318 @@
	// Copyright (c) 2010 Satoshi Nakamoto
	// Copyright (c) 2009-2014 The Bitcoin Core developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include "chainparams.h"

	#include "random.h"
	#include "util.h"
	#include "utilstrencodings.h"

	#include <assert.h>

	#include <boost/assign/list_of.hpp>

	using namespace std;

	struct SeedSpec6 {
	uint8_t addr[16];
	uint16_t port;
	};

	#include "chainparamsseeds.h"

	/**
	* Main network
	*/

	//! Convert the pnSeeds6 array into usable address objects.
	static void convertSeed6(std::vector<CAddress> &vSeedsOut, const SeedSpec6 *data, unsigned int count)
	{
	// 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;
	for (unsigned int i = 0; i < count; i++)
	{
	struct in6_addr ip;
	memcpy(&ip, data[i].addr, sizeof(ip));
	CAddress addr(CService(ip, data[i].port));
	addr.nTime = GetTime() - GetRand(nOneWeek) - nOneWeek;
	vSeedsOut.push_back(addr);
	}
	}

	/**
	* What makes a good checkpoint block?
	* + Is surrounded by blocks with reasonable timestamps
	* (no blocks before with a timestamp after, none after with
	* timestamp before)
	* + Contains no strange transactions
	*/
	static Checkpoints::MapCheckpoints mapCheckpoints =
	boost::assign::map_list_of
	( 11111, uint256S("0x0000000069e244f73d78e8fd29ba2fd2ed618bd6fa2ee92559f542fdb26e7c1d"))
	( 33333, uint256S("0x000000002dd5588a74784eaa7ab0507a18ad16a236e7b1ce69f00d7ddfb5d0a6"))
	( 74000, uint256S("0x0000000000573993a3c9e41ce34471c079dcf5f52a0e824a81e7f953b8661a20"))
	(105000, uint256S("0x00000000000291ce28027faea320c8d2b054b2e0fe44a773f3eefb151d6bdc97"))
	(134444, uint256S("0x00000000000005b12ffd4cd315cd34ffd4a594f430ac814c91184a0d42d2b0fe"))
	(168000, uint256S("0x000000000000099e61ea72015e79632f216fe6cb33d7899acb35b75c8303b763"))
	(193000, uint256S("0x000000000000059f452a5f7340de6682a977387c17010ff6e6c3bd83ca8b1317"))
	(210000, uint256S("0x000000000000048b95347e83192f69cf0366076336c639f9b7228e9ba171342e"))
	(216116, uint256S("0x00000000000001b4f4b433e81ee46494af945cf96014816a4e2370f11b23df4e"))
	(225430, uint256S("0x00000000000001c108384350f74090433e7fcf79a606b8e797f065b130575932"))
	(250000, uint256S("0x000000000000003887df1f29024b06fc2200b55f8af8f35453d7be294df2d214"))
	(279000, uint256S("0x0000000000000001ae8c72a0b0c301f67e3afca10e819efa9041e458e9bd7e40"))
	(295000, uint256S("0x00000000000000004d9b4ef50f0f9d686fd69db2e03af35a100370c64632a983"))
	;
	static const Checkpoints::CCheckpointData data = {
	&mapCheckpoints,
	1397080064, // * UNIX timestamp of last checkpoint block
	36544669, // * total number of transactions between genesis and last checkpoint
	// (the tx=... number in the SetBestChain debug.log lines)
	60000.0 // * estimated number of transactions per day after checkpoint
	};

	static Checkpoints::MapCheckpoints mapCheckpointsTestnet =
	boost::assign::map_list_of
	( 546, uint256S("000000002a936ca763904c3c35fce2f3556c559c0214345d31b1bcebf76acb70"))
	;
	static const Checkpoints::CCheckpointData dataTestnet = {
	&mapCheckpointsTestnet,
	1337966069,
	1488,
	300
	};

	static Checkpoints::MapCheckpoints mapCheckpointsRegtest =
	boost::assign::map_list_of
	( 0, uint256S("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"))
	;
	static const Checkpoints::CCheckpointData dataRegtest = {
	&mapCheckpointsRegtest,
	0,
	0,
	0
	};

	class CMainParams : public CChainParams {
	public:
	CMainParams() {
	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;
	bnProofOfWorkLimit = ~arith_uint256(0) >> 32;
	nSubsidyHalvingInterval = 210000;
	nEnforceBlockUpgradeMajority = 750;
	nRejectBlockOutdatedMajority = 950;
	nToCheckBlockUpgradeMajority = 1000;
	nMinerThreads = 0;
	nTargetTimespan = 14 * 24 * 60 * 60; // two weeks
	nTargetSpacing = 10 * 60;

	/**
	* 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";
	CMutableTransaction 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.SetNull();
	genesis.hashMerkleRoot = genesis.BuildMerkleTree();
	genesis.nVersion = 1;
	genesis.nTime = 1231006505;
	genesis.nBits = 0x1d00ffff;
	genesis.nNonce = 2083236893;

	hashGenesisBlock = genesis.GetHash();
	assert(hashGenesisBlock == uint256S("0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"));
	assert(genesis.hashMerkleRoot == uint256S("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("xf2.org", "bitseed.xf2.org"));

	base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,0);
	base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,5);
	base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,128);
	base58Prefixes[EXT_PUBLIC_KEY] = boost::assign::list_of(0x04)(0x88)(0xB2)(0x1E).convert_to_container<std::vector<unsigned char> >();
	base58Prefixes[EXT_SECRET_KEY] = boost::assign::list_of(0x04)(0x88)(0xAD)(0xE4).convert_to_container<std::vector<unsigned char> >();

	convertSeed6(vFixedSeeds, pnSeed6_main, ARRAYLEN(pnSeed6_main));

	fRequireRPCPassword = true;
	fMiningRequiresPeers = true;
	fDefaultCheckMemPool = false;
	fAllowMinDifficultyBlocks = false;
	fRequireStandard = true;
	fMineBlocksOnDemand = false;
	fSkipProofOfWorkCheck = false;
	fTestnetToBeDeprecatedFieldRPC = false;
	}

	const Checkpoints::CCheckpointData& Checkpoints() const
	{
	return data;
	}
	};
	static CMainParams mainParams;

	/**
	* Testnet (v3)
	*/
	class CTestNetParams : public CMainParams {
	public:
	CTestNetParams() {
	strNetworkID = "test";
	pchMessageStart[0] = 0x0b;
	pchMessageStart[1] = 0x11;
	pchMessageStart[2] = 0x09;
	pchMessageStart[3] = 0x07;
	vAlertPubKey = ParseHex("04302390343f91cc401d56d68b123028bf52e5fca1939df127f63c6467cdf9c8e2c14b61104cf817d0b780da337893ecc4aaff1309e536162dabbdb45200ca2b0a");
	nDefaultPort = 18333;
	nEnforceBlockUpgradeMajority = 51;
	nRejectBlockOutdatedMajority = 75;
	nToCheckBlockUpgradeMajority = 100;
	nMinerThreads = 0;
	nTargetTimespan = 14 * 24 * 60 * 60; //! two weeks
	nTargetSpacing = 10 * 60;

	//! 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 == uint256S("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"));
	vSeeds.push_back(CDNSSeedData("bitcoin.schildbach.de", "testnet-seed.bitcoin.schildbach.de"));

	base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
	base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
	base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,239);
	base58Prefixes[EXT_PUBLIC_KEY] = boost::assign::list_of(0x04)(0x35)(0x87)(0xCF).convert_to_container<std::vector<unsigned char> >();
	base58Prefixes[EXT_SECRET_KEY] = boost::assign::list_of(0x04)(0x35)(0x83)(0x94).convert_to_container<std::vector<unsigned char> >();

	convertSeed6(vFixedSeeds, pnSeed6_test, ARRAYLEN(pnSeed6_test));

	fRequireRPCPassword = true;
	fMiningRequiresPeers = true;
	fDefaultCheckMemPool = false;
	fAllowMinDifficultyBlocks = true;
	fRequireStandard = false;
	fMineBlocksOnDemand = false;
	fTestnetToBeDeprecatedFieldRPC = true;
	}
	const Checkpoints::CCheckpointData& Checkpoints() const
	{
	return dataTestnet;
	}
	};
	static CTestNetParams testNetParams;

	/**
	* Regression test
	*/
	class CRegTestParams : public CTestNetParams {
	public:
	CRegTestParams() {
	strNetworkID = "regtest";
	pchMessageStart[0] = 0xfa;
	pchMessageStart[1] = 0xbf;
	pchMessageStart[2] = 0xb5;
	pchMessageStart[3] = 0xda;
	nSubsidyHalvingInterval = 150;
	nEnforceBlockUpgradeMajority = 750;
	nRejectBlockOutdatedMajority = 950;
	nToCheckBlockUpgradeMajority = 1000;
	nMinerThreads = 1;
	nTargetTimespan = 14 * 24 * 60 * 60; //! two weeks
	nTargetSpacing = 10 * 60;
	bnProofOfWorkLimit = ~arith_uint256(0) >> 1;
	genesis.nTime = 1296688602;
	genesis.nBits = 0x207fffff;
	genesis.nNonce = 2;
	hashGenesisBlock = genesis.GetHash();
	nDefaultPort = 18444;
	assert(hashGenesisBlock == uint256S("0x0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"));

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

	fRequireRPCPassword = false;
	fMiningRequiresPeers = false;
	fDefaultCheckMemPool = true;
	fAllowMinDifficultyBlocks = true;
	fRequireStandard = false;
	fMineBlocksOnDemand = true;
	fTestnetToBeDeprecatedFieldRPC = false;
	}
	const Checkpoints::CCheckpointData& Checkpoints() const
	{
	return dataRegtest;
	}
	};
	static CRegTestParams regTestParams;

	-/**
	- * Unit test
	- */
	-class CUnitTestParams : public CMainParams, public CModifiableParams {
	-public:
	- CUnitTestParams() {
	- strNetworkID = "unittest";
	- nDefaultPort = 18445;
	- vFixedSeeds.clear(); //! Unit test mode doesn't have any fixed seeds.
	- vSeeds.clear(); //! Unit test mode doesn't have any DNS seeds.
	-
	- fRequireRPCPassword = false;
	- fMiningRequiresPeers = false;
	- fDefaultCheckMemPool = true;
	- fAllowMinDifficultyBlocks = false;
	- fMineBlocksOnDemand = true;
	- }
	-
	- const Checkpoints::CCheckpointData& Checkpoints() const
	- {
	- // UnitTest share the same checkpoints as MAIN
	- return data;
	- }
	-
	- //! Published setters to allow changing values in unit test cases
	- virtual void setSubsidyHalvingInterval(int anSubsidyHalvingInterval) { nSubsidyHalvingInterval=anSubsidyHalvingInterval; }
	- virtual void setEnforceBlockUpgradeMajority(int anEnforceBlockUpgradeMajority) { nEnforceBlockUpgradeMajority=anEnforceBlockUpgradeMajority; }
	- virtual void setRejectBlockOutdatedMajority(int anRejectBlockOutdatedMajority) { nRejectBlockOutdatedMajority=anRejectBlockOutdatedMajority; }
	- virtual void setToCheckBlockUpgradeMajority(int anToCheckBlockUpgradeMajority) { nToCheckBlockUpgradeMajority=anToCheckBlockUpgradeMajority; }
	- virtual void setDefaultCheckMemPool(bool afDefaultCheckMemPool) { fDefaultCheckMemPool=afDefaultCheckMemPool; }
	- virtual void setAllowMinDifficultyBlocks(bool afAllowMinDifficultyBlocks) { fAllowMinDifficultyBlocks=afAllowMinDifficultyBlocks; }
	- virtual void setSkipProofOfWorkCheck(bool afSkipProofOfWorkCheck) { fSkipProofOfWorkCheck = afSkipProofOfWorkCheck; }
	-};
	-static CUnitTestParams unitTestParams;
	-
	-
	static CChainParams *pCurrentParams = 0;

	-CModifiableParams *ModifiableParams()
	-{
	- assert(pCurrentParams);
	- assert(pCurrentParams==&unitTestParams);
	- return (CModifiableParams*)&unitTestParams;
	-}
	-
	const CChainParams &Params() {
	assert(pCurrentParams);
	return *pCurrentParams;
	}

	CChainParams &Params(CBaseChainParams::Network network) {
	switch (network) {
	case CBaseChainParams::MAIN:
	return mainParams;
	case CBaseChainParams::TESTNET:
	return testNetParams;
	case CBaseChainParams::REGTEST:
	return regTestParams;
	- case CBaseChainParams::UNITTEST:
	- return unitTestParams;
	default:
	assert(false && "Unimplemented network");
	return mainParams;
	}
	}

	void SelectParams(CBaseChainParams::Network network) {
	SelectBaseParams(network);
	pCurrentParams = &Params(network);
	}

	bool SelectParamsFromCommandLine()
	{
	CBaseChainParams::Network network = NetworkIdFromCommandLine();
	if (network == CBaseChainParams::MAX_NETWORK_TYPES)
	return false;

	SelectParams(network);
	return true;
	}
	diff --git a/src/chainparams.h b/src/chainparams.h
	index 78b575d8f..48b1383a6 100644
	--- a/src/chainparams.h
	+++ b/src/chainparams.h
	@@ -1,151 +1,129 @@
	// Copyright (c) 2009-2010 Satoshi Nakamoto
	// Copyright (c) 2009-2014 The Bitcoin Core developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#ifndef BITCOIN_CHAINPARAMS_H
	#define BITCOIN_CHAINPARAMS_H

	#include "chainparamsbase.h"
	#include "checkpoints.h"
	#include "primitives/block.h"
	#include "protocol.h"
	#include "arith_uint256.h"

	#include <vector>

	struct CDNSSeedData {
	std::string name, host;
	CDNSSeedData(const std::string &strName, const std::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 Base58Type {
	PUBKEY_ADDRESS,
	SCRIPT_ADDRESS,
	SECRET_KEY,
	EXT_PUBLIC_KEY,
	EXT_SECRET_KEY,

	MAX_BASE58_TYPES
	};

	const uint256& HashGenesisBlock() const { return hashGenesisBlock; }
	const CMessageHeader::MessageStartChars& MessageStart() const { return pchMessageStart; }
	const std::vector<unsigned char>& AlertKey() const { return vAlertPubKey; }
	int GetDefaultPort() const { return nDefaultPort; }
	const arith_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; }
	/** Skip proof-of-work check: allow mining of any difficulty block */
	bool SkipProofOfWorkCheck() const { return fSkipProofOfWorkCheck; }
	/** Make standard checks */
	bool RequireStandard() const { return fRequireStandard; }
	int64_t TargetTimespan() const { return nTargetTimespan; }
	int64_t TargetSpacing() const { return nTargetSpacing; }
	int64_t DifficultyAdjustmentInterval() const { return nTargetTimespan / nTargetSpacing; }
	/** Make miner stop after a block is found. In RPC, don't return until nGenProcLimit blocks are generated */
	bool MineBlocksOnDemand() const { return fMineBlocksOnDemand; }
	/** In the future use NetworkIDString() for RPC fields */
	bool TestnetToBeDeprecatedFieldRPC() const { return fTestnetToBeDeprecatedFieldRPC; }
	/** Return the BIP70 network string (main, test or regtest) */
	std::string NetworkIDString() const { return strNetworkID; }
	const std::vector<CDNSSeedData>& DNSSeeds() const { return vSeeds; }
	const std::vector<unsigned char>& Base58Prefix(Base58Type type) const { return base58Prefixes[type]; }
	const std::vector<CAddress>& FixedSeeds() const { return vFixedSeeds; }
	virtual const Checkpoints::CCheckpointData& Checkpoints() const = 0;
	protected:
	CChainParams() {}

	uint256 hashGenesisBlock;
	CMessageHeader::MessageStartChars pchMessageStart;
	//! Raw pub key bytes for the broadcast alert signing key.
	std::vector<unsigned char> vAlertPubKey;
	int nDefaultPort;
	arith_uint256 bnProofOfWorkLimit;
	int nSubsidyHalvingInterval;
	int nEnforceBlockUpgradeMajority;
	int nRejectBlockOutdatedMajority;
	int nToCheckBlockUpgradeMajority;
	int64_t nTargetTimespan;
	int64_t nTargetSpacing;
	int nMinerThreads;
	std::vector<CDNSSeedData> vSeeds;
	std::vector<unsigned char> base58Prefixes[MAX_BASE58_TYPES];
	std::string strNetworkID;
	CBlock genesis;
	std::vector<CAddress> vFixedSeeds;
	bool fRequireRPCPassword;
	bool fMiningRequiresPeers;
	bool fDefaultCheckMemPool;
	bool fAllowMinDifficultyBlocks;
	bool fRequireStandard;
	bool fMineBlocksOnDemand;
	bool fSkipProofOfWorkCheck;
	bool fTestnetToBeDeprecatedFieldRPC;
	};

	-/**
	- * Modifiable parameters interface is used by test cases to adapt the parameters in order
	- * to test specific features more easily. Test cases should always restore the previous
	- * values after finalization.
	- */
	-
	-class CModifiableParams {
	-public:
	- //! Published setters to allow changing values in unit test cases
	- virtual void setSubsidyHalvingInterval(int anSubsidyHalvingInterval) =0;
	- virtual void setEnforceBlockUpgradeMajority(int anEnforceBlockUpgradeMajority)=0;
	- virtual void setRejectBlockOutdatedMajority(int anRejectBlockOutdatedMajority)=0;
	- virtual void setToCheckBlockUpgradeMajority(int anToCheckBlockUpgradeMajority)=0;
	- virtual void setDefaultCheckMemPool(bool aDefaultCheckMemPool)=0;
	- virtual void setAllowMinDifficultyBlocks(bool aAllowMinDifficultyBlocks)=0;
	- virtual void setSkipProofOfWorkCheck(bool aSkipProofOfWorkCheck)=0;
	-};
	-
	-
	/**
	* Return the currently selected parameters. This won't change after app startup
	* outside of the unit tests.
	*/
	const CChainParams &Params();

	/** Return parameters for the given network. */
	CChainParams &Params(CBaseChainParams::Network network);

	-/** Get modifiable network parameters (UNITTEST only) */
	-CModifiableParams *ModifiableParams();
	-
	/** Sets the params returned by Params() to those for the given network. */
	void SelectParams(CBaseChainParams::Network network);

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

	#endif // BITCOIN_CHAINPARAMS_H
	diff --git a/src/chainparamsbase.cpp b/src/chainparamsbase.cpp
	index c42fd106b..7d82d689e 100644
	--- a/src/chainparamsbase.cpp
	+++ b/src/chainparamsbase.cpp
	@@ -1,121 +1,118 @@
	// Copyright (c) 2010 Satoshi Nakamoto
	// Copyright (c) 2009-2014 The Bitcoin Core developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include "chainparamsbase.h"

	#include "util.h"

	#include <assert.h>

	/**
	* Main network
	*/
	class CBaseMainParams : public CBaseChainParams
	{
	public:
	CBaseMainParams()
	{
	nRPCPort = 8332;
	}
	};
	static CBaseMainParams mainParams;

	/**
	* Testnet (v3)
	*/
	class CBaseTestNetParams : public CBaseMainParams
	{
	public:
	CBaseTestNetParams()
	{
	nRPCPort = 18332;
	strDataDir = "testnet3";
	}
	};
	static CBaseTestNetParams testNetParams;

	/*
	* Regression test
	*/
	class CBaseRegTestParams : public CBaseTestNetParams
	{
	public:
	CBaseRegTestParams()
	{
	strDataDir = "regtest";
	}
	};
	static CBaseRegTestParams regTestParams;

	/*
	* Unit test
	*/
	class CBaseUnitTestParams : public CBaseMainParams
	{
	public:
	CBaseUnitTestParams()
	{
	strDataDir = "unittest";
	}
	};
	static CBaseUnitTestParams unitTestParams;

	static CBaseChainParams* pCurrentBaseParams = 0;

	const CBaseChainParams& BaseParams()
	{
	assert(pCurrentBaseParams);
	return *pCurrentBaseParams;
	}

	void SelectBaseParams(CBaseChainParams::Network network)
	{
	switch (network) {
	case CBaseChainParams::MAIN:
	pCurrentBaseParams = &mainParams;
	break;
	case CBaseChainParams::TESTNET:
	pCurrentBaseParams = &testNetParams;
	break;
	case CBaseChainParams::REGTEST:
	pCurrentBaseParams = &regTestParams;
	break;
	- case CBaseChainParams::UNITTEST:
	- pCurrentBaseParams = &unitTestParams;
	- break;
	default:
	assert(false && "Unimplemented network");
	return;
	}
	}

	CBaseChainParams::Network NetworkIdFromCommandLine()
	{
	bool fRegTest = GetBoolArg("-regtest", false);
	bool fTestNet = GetBoolArg("-testnet", false);

	if (fTestNet && fRegTest)
	return CBaseChainParams::MAX_NETWORK_TYPES;
	if (fRegTest)
	return CBaseChainParams::REGTEST;
	if (fTestNet)
	return CBaseChainParams::TESTNET;
	return CBaseChainParams::MAIN;
	}

	bool SelectBaseParamsFromCommandLine()
	{
	CBaseChainParams::Network network = NetworkIdFromCommandLine();
	if (network == CBaseChainParams::MAX_NETWORK_TYPES)
	return false;

	SelectBaseParams(network);
	return true;
	}

	bool AreBaseParamsConfigured()
	{
	return pCurrentBaseParams != NULL;
	}
	diff --git a/src/chainparamsbase.h b/src/chainparamsbase.h
	index cebe7aa01..421a3a06f 100644
	--- a/src/chainparamsbase.h
	+++ b/src/chainparamsbase.h
	@@ -1,64 +1,63 @@
	// Copyright (c) 2014 The Bitcoin Core developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#ifndef BITCOIN_CHAINPARAMSBASE_H
	#define BITCOIN_CHAINPARAMSBASE_H

	#include <string>
	#include <vector>

	/**
	* CBaseChainParams defines the base parameters (shared between bitcoin-cli and bitcoind)
	* of a given instance of the Bitcoin system.
	*/
	class CBaseChainParams
	{
	public:
	enum Network {
	MAIN,
	TESTNET,
	REGTEST,
	- UNITTEST,

	MAX_NETWORK_TYPES
	};

	const std::string& DataDir() const { return strDataDir; }
	int RPCPort() const { return nRPCPort; }

	protected:
	CBaseChainParams() {}

	int nRPCPort;
	std::string strDataDir;
	};

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

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

	/**
	* Looks for -regtest or -testnet and returns the appropriate Network ID.
	* Returns MAX_NETWORK_TYPES if an invalid combination is given.
	*/
	CBaseChainParams::Network NetworkIdFromCommandLine();

	/**
	* Calls NetworkIdFromCommandLine() and then calls SelectParams as appropriate.
	* Returns false if an invalid combination is given.
	*/
	bool SelectBaseParamsFromCommandLine();

	/**
	* Return true if SelectBaseParamsFromCommandLine() has been called to select
	* a network.
	*/
	bool AreBaseParamsConfigured();

	#endif // BITCOIN_CHAINPARAMSBASE_H
	diff --git a/src/test/base58_tests.cpp b/src/test/base58_tests.cpp
	index e7d028188..c242dd26e 100644
	--- a/src/test/base58_tests.cpp
	+++ b/src/test/base58_tests.cpp
	@@ -1,279 +1,279 @@
	// Copyright (c) 2011-2014 The Bitcoin Core developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include "base58.h"

	#include "data/base58_encode_decode.json.h"
	#include "data/base58_keys_invalid.json.h"
	#include "data/base58_keys_valid.json.h"

	#include "key.h"
	#include "script/script.h"
	#include "uint256.h"
	#include "util.h"
	#include "utilstrencodings.h"

	#include <boost/foreach.hpp>
	#include <boost/test/unit_test.hpp>
	#include "json/json_spirit_reader_template.h"
	#include "json/json_spirit_utils.h"
	#include "json/json_spirit_writer_template.h"

	using namespace json_spirit;
	extern Array read_json(const std::string& jsondata);

	BOOST_AUTO_TEST_SUITE(base58_tests)

	// Goal: test low-level base58 encoding functionality
	BOOST_AUTO_TEST_CASE(base58_EncodeBase58)
	{
	Array tests = read_json(std::string(json_tests::base58_encode_decode, json_tests::base58_encode_decode + sizeof(json_tests::base58_encode_decode)));
	BOOST_FOREACH(Value& tv, tests)
	{
	Array test = tv.get_array();
	std::string strTest = write_string(tv, false);
	if (test.size() < 2) // Allow for extra stuff (useful for comments)
	{
	BOOST_ERROR("Bad test: " << strTest);
	continue;
	}
	std::vector<unsigned char> sourcedata = ParseHex(test[0].get_str());
	std::string base58string = test[1].get_str();
	BOOST_CHECK_MESSAGE(
	EncodeBase58(begin_ptr(sourcedata), end_ptr(sourcedata)) == base58string,
	strTest);
	}
	}

	// Goal: test low-level base58 decoding functionality
	BOOST_AUTO_TEST_CASE(base58_DecodeBase58)
	{
	Array tests = read_json(std::string(json_tests::base58_encode_decode, json_tests::base58_encode_decode + sizeof(json_tests::base58_encode_decode)));
	std::vector<unsigned char> result;

	BOOST_FOREACH(Value& tv, tests)
	{
	Array test = tv.get_array();
	std::string strTest = write_string(tv, false);
	if (test.size() < 2) // Allow for extra stuff (useful for comments)
	{
	BOOST_ERROR("Bad test: " << strTest);
	continue;
	}
	std::vector<unsigned char> expected = ParseHex(test[0].get_str());
	std::string base58string = test[1].get_str();
	BOOST_CHECK_MESSAGE(DecodeBase58(base58string, result), strTest);
	BOOST_CHECK_MESSAGE(result.size() == expected.size() && std::equal(result.begin(), result.end(), expected.begin()), strTest);
	}

	BOOST_CHECK(!DecodeBase58("invalid", result));

	// check that DecodeBase58 skips whitespace, but still fails with unexpected non-whitespace at the end.
	BOOST_CHECK(!DecodeBase58(" \t\n\v\f\r skip \r\f\v\n\t a", result));
	BOOST_CHECK( DecodeBase58(" \t\n\v\f\r skip \r\f\v\n\t ", result));
	std::vector<unsigned char> expected = ParseHex("971a55");
	BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());
	}

	// Visitor to check address type
	class TestAddrTypeVisitor : public boost::static_visitor<bool>
	{
	private:
	std::string exp_addrType;
	public:
	TestAddrTypeVisitor(const std::string &exp_addrType) : exp_addrType(exp_addrType) { }
	bool operator()(const CKeyID &id) const
	{
	return (exp_addrType == "pubkey");
	}
	bool operator()(const CScriptID &id) const
	{
	return (exp_addrType == "script");
	}
	bool operator()(const CNoDestination &no) const
	{
	return (exp_addrType == "none");
	}
	};

	// Visitor to check address payload
	class TestPayloadVisitor : public boost::static_visitor<bool>
	{
	private:
	std::vector<unsigned char> exp_payload;
	public:
	TestPayloadVisitor(std::vector<unsigned char> &exp_payload) : exp_payload(exp_payload) { }
	bool operator()(const CKeyID &id) const
	{
	uint160 exp_key(exp_payload);
	return exp_key == id;
	}
	bool operator()(const CScriptID &id) const
	{
	uint160 exp_key(exp_payload);
	return exp_key == id;
	}
	bool operator()(const CNoDestination &no) const
	{
	return exp_payload.size() == 0;
	}
	};

	// Goal: check that parsed keys match test payload
	BOOST_AUTO_TEST_CASE(base58_keys_valid_parse)
	{
	Array tests = read_json(std::string(json_tests::base58_keys_valid, json_tests::base58_keys_valid + sizeof(json_tests::base58_keys_valid)));
	std::vector<unsigned char> result;
	CBitcoinSecret secret;
	CBitcoinAddress addr;
	+ SelectParams(CBaseChainParams::MAIN);

	BOOST_FOREACH(Value& tv, tests)
	{
	Array test = tv.get_array();
	std::string strTest = write_string(tv, false);
	if (test.size() < 3) // Allow for extra stuff (useful for comments)
	{
	BOOST_ERROR("Bad test: " << strTest);
	continue;
	}
	std::string exp_base58string = test[0].get_str();
	std::vector<unsigned char> exp_payload = ParseHex(test[1].get_str());
	const Object &metadata = test[2].get_obj();
	bool isPrivkey = find_value(metadata, "isPrivkey").get_bool();
	bool isTestnet = find_value(metadata, "isTestnet").get_bool();
	if (isTestnet)
	SelectParams(CBaseChainParams::TESTNET);
	else
	SelectParams(CBaseChainParams::MAIN);
	if(isPrivkey)
	{
	bool isCompressed = find_value(metadata, "isCompressed").get_bool();
	// Must be valid private key
	// Note: CBitcoinSecret::SetString tests isValid, whereas CBitcoinAddress does not!
	BOOST_CHECK_MESSAGE(secret.SetString(exp_base58string), "!SetString:"+ strTest);
	BOOST_CHECK_MESSAGE(secret.IsValid(), "!IsValid:" + strTest);
	CKey privkey = secret.GetKey();
	BOOST_CHECK_MESSAGE(privkey.IsCompressed() == isCompressed, "compressed mismatch:" + strTest);
	BOOST_CHECK_MESSAGE(privkey.size() == exp_payload.size() && std::equal(privkey.begin(), privkey.end(), exp_payload.begin()), "key mismatch:" + strTest);

	// Private key must be invalid public key
	addr.SetString(exp_base58string);
	BOOST_CHECK_MESSAGE(!addr.IsValid(), "IsValid privkey as pubkey:" + strTest);
	}
	else
	{
	std::string exp_addrType = find_value(metadata, "addrType").get_str(); // "script" or "pubkey"
	// Must be valid public key
	BOOST_CHECK_MESSAGE(addr.SetString(exp_base58string), "SetString:" + strTest);
	BOOST_CHECK_MESSAGE(addr.IsValid(), "!IsValid:" + strTest);
	BOOST_CHECK_MESSAGE(addr.IsScript() == (exp_addrType == "script"), "isScript mismatch" + strTest);
	CTxDestination dest = addr.Get();
	BOOST_CHECK_MESSAGE(boost::apply_visitor(TestAddrTypeVisitor(exp_addrType), dest), "addrType mismatch" + strTest);

	// Public key must be invalid private key
	secret.SetString(exp_base58string);
	BOOST_CHECK_MESSAGE(!secret.IsValid(), "IsValid pubkey as privkey:" + strTest);
	}
	}
	- SelectParams(CBaseChainParams::UNITTEST);
	}

	// Goal: check that generated keys match test vectors
	BOOST_AUTO_TEST_CASE(base58_keys_valid_gen)
	{
	Array tests = read_json(std::string(json_tests::base58_keys_valid, json_tests::base58_keys_valid + sizeof(json_tests::base58_keys_valid)));
	std::vector<unsigned char> result;
	BOOST_FOREACH(Value& tv, tests)
	{
	Array test = tv.get_array();
	std::string strTest = write_string(tv, false);
	if (test.size() < 3) // Allow for extra stuff (useful for comments)
	{
	BOOST_ERROR("Bad test: " << strTest);
	continue;
	}
	std::string exp_base58string = test[0].get_str();
	std::vector<unsigned char> exp_payload = ParseHex(test[1].get_str());
	const Object &metadata = test[2].get_obj();
	bool isPrivkey = find_value(metadata, "isPrivkey").get_bool();
	bool isTestnet = find_value(metadata, "isTestnet").get_bool();
	if (isTestnet)
	SelectParams(CBaseChainParams::TESTNET);
	else
	SelectParams(CBaseChainParams::MAIN);
	if(isPrivkey)
	{
	bool isCompressed = find_value(metadata, "isCompressed").get_bool();
	CKey key;
	key.Set(exp_payload.begin(), exp_payload.end(), isCompressed);
	assert(key.IsValid());
	CBitcoinSecret secret;
	secret.SetKey(key);
	BOOST_CHECK_MESSAGE(secret.ToString() == exp_base58string, "result mismatch: " + strTest);
	}
	else
	{
	std::string exp_addrType = find_value(metadata, "addrType").get_str();
	CTxDestination dest;
	if(exp_addrType == "pubkey")
	{
	dest = CKeyID(uint160(exp_payload));
	}
	else if(exp_addrType == "script")
	{
	dest = CScriptID(uint160(exp_payload));
	}
	else if(exp_addrType == "none")
	{
	dest = CNoDestination();
	}
	else
	{
	BOOST_ERROR("Bad addrtype: " << strTest);
	continue;
	}
	CBitcoinAddress addrOut;
	BOOST_CHECK_MESSAGE(addrOut.Set(dest), "encode dest: " + strTest);
	BOOST_CHECK_MESSAGE(addrOut.ToString() == exp_base58string, "mismatch: " + strTest);
	}
	}

	// Visiting a CNoDestination must fail
	CBitcoinAddress dummyAddr;
	CTxDestination nodest = CNoDestination();
	BOOST_CHECK(!dummyAddr.Set(nodest));

	- SelectParams(CBaseChainParams::UNITTEST);
	+ SelectParams(CBaseChainParams::MAIN);
	}

	// Goal: check that base58 parsing code is robust against a variety of corrupted data
	BOOST_AUTO_TEST_CASE(base58_keys_invalid)
	{
	Array tests = read_json(std::string(json_tests::base58_keys_invalid, json_tests::base58_keys_invalid + sizeof(json_tests::base58_keys_invalid))); // Negative testcases
	std::vector<unsigned char> result;
	CBitcoinSecret secret;
	CBitcoinAddress addr;

	BOOST_FOREACH(Value& tv, tests)
	{
	Array test = tv.get_array();
	std::string strTest = write_string(tv, false);
	if (test.size() < 1) // Allow for extra stuff (useful for comments)
	{
	BOOST_ERROR("Bad test: " << strTest);
	continue;
	}
	std::string exp_base58string = test[0].get_str();

	// must be invalid as public and as private key
	addr.SetString(exp_base58string);
	BOOST_CHECK_MESSAGE(!addr.IsValid(), "IsValid pubkey:" + strTest);
	secret.SetString(exp_base58string);
	BOOST_CHECK_MESSAGE(!secret.IsValid(), "IsValid privkey:" + strTest);
	}
	}


	BOOST_AUTO_TEST_SUITE_END()

	diff --git a/src/test/test_bitcoin.cpp b/src/test/test_bitcoin.cpp
	index 5df417b8e..a1355ad44 100644
	--- a/src/test/test_bitcoin.cpp
	+++ b/src/test/test_bitcoin.cpp
	@@ -1,91 +1,91 @@
	// Copyright (c) 2011-2013 The Bitcoin Core developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#define BOOST_TEST_MODULE Bitcoin Test Suite

	#include "test_bitcoin.h"

	#include "main.h"
	#include "random.h"
	#include "txdb.h"
	#include "ui_interface.h"
	#include "util.h"
	#ifdef ENABLE_WALLET
	#include "db.h"
	#include "wallet.h"
	#endif

	#include <boost/filesystem.hpp>
	#include <boost/test/unit_test.hpp>
	#include <boost/thread.hpp>

	CClientUIInterface uiInterface;
	CWallet* pwalletMain;

	extern bool fPrintToConsole;
	extern void noui_connect();

	TestingSetup::TestingSetup()
	{
	fPrintToDebugLog = false; // don't want to write to debug.log file
	- SelectParams(CBaseChainParams::UNITTEST);
	+ SelectParams(CBaseChainParams::MAIN);
	noui_connect();
	#ifdef ENABLE_WALLET
	bitdb.MakeMock();
	#endif
	ClearDatadirCache();
	pathTemp = GetTempPath() / strprintf("test_bitcoin_%lu_%i", (unsigned long)GetTime(), (int)(GetRand(100000)));
	boost::filesystem::create_directories(pathTemp);
	mapArgs["-datadir"] = pathTemp.string();
	pblocktree = new CBlockTreeDB(1 << 20, true);
	pcoinsdbview = new CCoinsViewDB(1 << 23, true);
	pcoinsTip = new CCoinsViewCache(pcoinsdbview);
	InitBlockIndex();
	#ifdef ENABLE_WALLET
	bool fFirstRun;
	pwalletMain = new CWallet("wallet.dat");
	pwalletMain->LoadWallet(fFirstRun);
	RegisterValidationInterface(pwalletMain);
	#endif
	nScriptCheckThreads = 3;
	for (int i=0; i < nScriptCheckThreads-1; i++)
	threadGroup.create_thread(&ThreadScriptCheck);
	RegisterNodeSignals(GetNodeSignals());
	}

	TestingSetup::~TestingSetup()
	{
	UnregisterNodeSignals(GetNodeSignals());
	threadGroup.interrupt_all();
	threadGroup.join_all();
	#ifdef ENABLE_WALLET
	UnregisterValidationInterface(pwalletMain);
	delete pwalletMain;
	pwalletMain = NULL;
	#endif
	UnloadBlockIndex();
	delete pcoinsTip;
	delete pcoinsdbview;
	delete pblocktree;
	#ifdef ENABLE_WALLET
	bitdb.Flush(true);
	bitdb.Reset();
	#endif
	boost::filesystem::remove_all(pathTemp);
	}

	void Shutdown(void* parg)
	{
	exit(0);
	}

	void StartShutdown()
	{
	exit(0);
	}

	bool ShutdownRequested()
	{
	return false;
	}

File Metadata

Mime Type: text/x-diff
Expires: Wed, May 21, 20:47 (1 d, 14 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5865919
Default Alt Text: (40 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions