chainparams.cpp
No OneTemporary
Actions

Size

19 KB

Subscribers

None

chainparams.cpp
View Options

	// Copyright (c) 2010 Satoshi Nakamoto
	// Copyright (c) 2009-2016 The Bitcoin Core developers
	// Copyright (c) 2017-2020 The Bitcoin 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 <chainparamsconstants.h>
	#include <chainparamsseeds.h>
	#include <consensus/merkle.h>
	#include <currencyunit.h>
	#include <network.h>
	#include <tinyformat.h>
	#include <util/strencodings.h>
	#include <util/system.h>

	#include <cassert>

	static CBlock CreateGenesisBlock(const char *pszTimestamp,
	const CScript &genesisOutputScript,
	uint32_t nTime, uint32_t nNonce,
	uint32_t nBits, int32_t nVersion,
	const Amount genesisReward) {
	CMutableTransaction txNew;
	txNew.nVersion = 1;
	txNew.vin.resize(1);
	txNew.vout.resize(1);
	txNew.vin[0].scriptSig =
	CScript() << 486604799 << CScriptNum(4)
	<< std::vector<uint8_t>((const uint8_t *)pszTimestamp,
	(const uint8_t *)pszTimestamp +
	strlen(pszTimestamp));
	txNew.vout[0].nValue = genesisReward;
	txNew.vout[0].scriptPubKey = genesisOutputScript;

	CBlock genesis;
	genesis.nTime = nTime;
	genesis.nBits = nBits;
	genesis.nNonce = nNonce;
	genesis.nVersion = nVersion;
	genesis.vtx.push_back(MakeTransactionRef(std::move(txNew)));
	genesis.hashPrevBlock.SetNull();
	genesis.hashMerkleRoot = BlockMerkleRoot(genesis);
	return genesis;
	}

	/**
	* Build the genesis block. Note that the output of its generation transaction
	* cannot be spent since 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
	*/
	CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits,
	int32_t nVersion, const Amount genesisReward) {
	const char *pszTimestamp =
	"The Times 03/Jan/2009 Chancellor on brink of second bailout for banks";
	const CScript genesisOutputScript =
	CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909"
	"a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112"
	"de5c384df7ba0b8d578a4c702b6bf11d5f")
	<< OP_CHECKSIG;
	return CreateGenesisBlock(pszTimestamp, genesisOutputScript, nTime, nNonce,
	nBits, nVersion, genesisReward);
	}

	/**
	* Main network
	*/
	class CMainParams : public CChainParams {
	public:
	CMainParams() {
	strNetworkID = CBaseChainParams::MAIN;
	consensus.nSubsidyHalvingInterval = 210000;
	// 00000000000000ce80a7e057163a4db1d5ad7b20fb6f598c9597b9665c8fb0d4 -
	// April 1, 2012
	consensus.BIP16Height = 173805;
	consensus.BIP34Height = 227931;
	consensus.BIP34Hash = BlockHash::fromHex(
	"000000000000024b89b42a942fe0d9fea3bb44ab7bd1b19115dd6a759c0808b8");
	// 000000000000000004c2b624ed5d7756c508d90fd0da2c7c679febfa6c4735f0
	consensus.BIP65Height = 388381;
	// 00000000000000000379eaa19dce8c9b722d46ae6a57c2f1a988119488b50931
	consensus.BIP66Height = 363725;
	// 000000000000000004a1b34462cb8aeebd5799177f7a29cf28f2d1961716b5b5
	consensus.CSVHeight = 419328;
	consensus.powLimit = uint256S(
	"00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
	// two weeks
	consensus.nPowTargetTimespan = 14 * 24 * 60 * 60;
	consensus.nPowTargetSpacing = 10 * 60;
	consensus.fPowAllowMinDifficultyBlocks = false;
	consensus.fPowNoRetargeting = false;

	// two days
	consensus.nDAAHalfLife = 2 * 24 * 60 * 60;

	// nPowTargetTimespan / nPowTargetSpacing
	consensus.nMinerConfirmationWindow = 2016;
	consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY] = {
	.bit = 28,
	// 95% of 2016
	.nActivationThreshold = 1916,
	// January 1, 2008
	.nStartTime = 1199145601,
	// December 31, 2008
	.nTimeout = 1230767999,
	};

	// The miner fund is enabled by default on mainnet.
	consensus.enableMinerFund = ENABLE_MINER_FUND;

	// The best chain should have at least this much work.
	consensus.nMinimumChainWork =
	ChainParamsConstants::MAINNET_MINIMUM_CHAIN_WORK;

	// By default assume that the signatures in ancestors of this block are
	// valid.
	consensus.defaultAssumeValid =
	ChainParamsConstants::MAINNET_DEFAULT_ASSUME_VALID;

	// August 1, 2017 hard fork
	consensus.uahfHeight = 478558;

	// November 13, 2017 hard fork
	consensus.daaHeight = 504031;

	// November 15, 2018 hard fork
	consensus.magneticAnomalyHeight = 556766;

	// November 15, 2019 protocol upgrade
	consensus.gravitonHeight = 609135;

	// May 15, 2020 12:00:00 UTC protocol upgrade
	consensus.phononHeight = 635258;

	// Nov 15, 2020 12:00:00 UTC protocol upgrade
	consensus.axionActivationTime = 1605441600;

	// May 15, 2021 12:00:00 UTC protocol upgrade
	consensus.tachyonActivationTime = 1621080000;

	// Nov 15, 2021 12:00:00 UTC protocol upgrade
	consensus.selectronActivationTime = 1636977600;

	/**
	* 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 32-bit integer with any alignment.
	*/
	diskMagic[0] = 0xf9;
	diskMagic[1] = 0xbe;
	diskMagic[2] = 0xb4;
	diskMagic[3] = 0xd9;
	netMagic[0] = 0xe3;
	netMagic[1] = 0xe1;
	netMagic[2] = 0xf3;
	netMagic[3] = 0xe8;
	nDefaultPort = 8333;
	nPruneAfterHeight = 100000;
	m_assumed_blockchain_size =
	ChainParamsConstants::MAINNET_ASSUMED_BLOCKCHAIN_SIZE;
	m_assumed_chain_state_size =
	ChainParamsConstants::MAINNET_ASSUMED_CHAINSTATE_SIZE;

	genesis = CreateGenesisBlock(1231006505, 2083236893, 0x1d00ffff, 1,
	50 * COIN);
	consensus.hashGenesisBlock = genesis.GetHash();
	assert(consensus.hashGenesisBlock ==
	uint256S("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1"
	"b60a8ce26f"));
	assert(genesis.hashMerkleRoot ==
	uint256S("4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b"
	"7afdeda33b"));

	// Note that of those which support the service bits prefix, most only
	// support a subset of possible options. This is fine at runtime as
	// we'll fall back to using them as an addrfetch if they don't support
	// the service bits we want, but we should get them updated to support
	// all service bits wanted by any release ASAP to avoid it where
	// possible.
	// Bitcoin ABC seeder
	vSeeds.emplace_back("seed.bitcoinabc.org");
	// BU backed seeder
	vSeeds.emplace_back("btccash-seeder.bitcoinunlimited.info");
	// Jason B. Cox
	vSeeds.emplace_back("seeder.jasonbcox.com");
	// Amaury SÉCHET
	vSeeds.emplace_back("seed.deadalnix.me");
	// BCHD
	vSeeds.emplace_back("seed.bchd.cash");
	// Fabien
	vSeeds.emplace_back("seeder.fabien.cash");

	base58Prefixes[PUBKEY_ADDRESS] = std::vector<uint8_t>(1, 0);
	base58Prefixes[SCRIPT_ADDRESS] = std::vector<uint8_t>(1, 5);
	base58Prefixes[SECRET_KEY] = std::vector<uint8_t>(1, 128);
	base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x88, 0xB2, 0x1E};
	base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4};
	cashaddrPrefix =
	gArgs.GetBoolArg("-ecash", DEFAULT_ECASH) ? "ecash" : "bitcoincash";

	vFixedSeeds = std::vector<SeedSpec6>(
	pnSeed6_main, pnSeed6_main + ARRAYLEN(pnSeed6_main));

	fDefaultConsistencyChecks = false;
	fRequireStandard = true;
	m_is_test_chain = false;
	m_is_mockable_chain = false;

	checkpointData = CheckpointData(CBaseChainParams::MAIN);

	// Data as of block
	// 000000000000000001d2ce557406b017a928be25ee98906397d339c3f68eec5d
	// (height 523992).
	chainTxData = ChainTxData{
	// UNIX timestamp of last known number of transactions.
	1522608016,
	// Total number of transactions between genesis and that timestamp
	// (the tx=... number in the ChainStateFlushed debug.log lines)
	248589038,
	// Estimated number of transactions per second after that timestamp.
	3.2,
	};
	}
	};

	/**
	* Testnet (v3)
	*/
	class CTestNetParams : public CChainParams {
	public:
	CTestNetParams() {
	strNetworkID = CBaseChainParams::TESTNET;
	consensus.nSubsidyHalvingInterval = 210000;
	// 00000000040b4e986385315e14bee30ad876d8b47f748025b26683116d21aa65
	consensus.BIP16Height = 514;
	consensus.BIP34Height = 21111;
	consensus.BIP34Hash = BlockHash::fromHex(
	"0000000023b3a96d3484e5abb3755c413e7d41500f8e2a5c3f0dd01299cd8ef8");
	// 00000000007f6655f22f98e72ed80d8b06dc761d5da09df0fa1dc4be4f861eb6
	consensus.BIP65Height = 581885;
	// 000000002104c8c45e99a8853285a3b592602a3ccde2b832481da85e9e4ba182
	consensus.BIP66Height = 330776;
	// 00000000025e930139bac5c6c31a403776da130831ab85be56578f3fa75369bb
	consensus.CSVHeight = 770112;
	consensus.powLimit = uint256S(
	"00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
	// two weeks
	consensus.nPowTargetTimespan = 14 * 24 * 60 * 60;
	consensus.nPowTargetSpacing = 10 * 60;
	consensus.fPowAllowMinDifficultyBlocks = true;
	consensus.fPowNoRetargeting = false;

	// two days
	consensus.nDAAHalfLife = 2 * 24 * 60 * 60;

	// nPowTargetTimespan / nPowTargetSpacing
	consensus.nMinerConfirmationWindow = 2016;
	consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY] = {
	.bit = 28,
	// 75% of 2016
	.nActivationThreshold = 1512,
	// January 1, 2008
	.nStartTime = 1199145601,
	// December 31, 2008
	.nTimeout = 1230767999,
	};

	// The miner fund is disabled by default on testnet.
	consensus.enableMinerFund = false;

	// The best chain should have at least this much work.
	consensus.nMinimumChainWork =
	ChainParamsConstants::TESTNET_MINIMUM_CHAIN_WORK;

	// By default assume that the signatures in ancestors of this block are
	// valid.
	consensus.defaultAssumeValid =
	ChainParamsConstants::TESTNET_DEFAULT_ASSUME_VALID;

	// August 1, 2017 hard fork
	consensus.uahfHeight = 1155875;

	// November 13, 2017 hard fork
	consensus.daaHeight = 1188697;

	// November 15, 2018 hard fork
	consensus.magneticAnomalyHeight = 1267996;

	// November 15, 2019 protocol upgrade
	consensus.gravitonHeight = 1341711;

	// May 15, 2020 12:00:00 UTC protocol upgrade
	consensus.phononHeight = 1378460;

	// Nov 15, 2020 12:00:00 UTC protocol upgrade
	consensus.axionActivationTime = 1605441600;

	// May 15, 2021 12:00:00 UTC protocol upgrade
	consensus.tachyonActivationTime = 1621080000;

	// Nov 15, 2021 12:00:00 UTC protocol upgrade
	consensus.selectronActivationTime = 1636977600;

	diskMagic[0] = 0x0b;
	diskMagic[1] = 0x11;
	diskMagic[2] = 0x09;
	diskMagic[3] = 0x07;
	netMagic[0] = 0xf4;
	netMagic[1] = 0xe5;
	netMagic[2] = 0xf3;
	netMagic[3] = 0xf4;
	nDefaultPort = 18333;
	nPruneAfterHeight = 1000;
	m_assumed_blockchain_size =
	ChainParamsConstants::TESTNET_ASSUMED_BLOCKCHAIN_SIZE;
	m_assumed_chain_state_size =
	ChainParamsConstants::TESTNET_ASSUMED_CHAINSTATE_SIZE;

	genesis =
	CreateGenesisBlock(1296688602, 414098458, 0x1d00ffff, 1, 50 * COIN);
	consensus.hashGenesisBlock = genesis.GetHash();
	assert(consensus.hashGenesisBlock ==
	uint256S("000000000933ea01ad0ee984209779baaec3ced90fa3f408719526"
	"f8d77f4943"));
	assert(genesis.hashMerkleRoot ==
	uint256S("4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b"
	"7afdeda33b"));

	vFixedSeeds.clear();
	vSeeds.clear();
	// nodes with support for servicebits filtering should be at the top
	// Bitcoin ABC seeder
	vSeeds.emplace_back("testnet-seed.bitcoinabc.org");
	// Amaury SÉCHET
	vSeeds.emplace_back("testnet-seed.deadalnix.me");
	// BCHD
	vSeeds.emplace_back("testnet-seed.bchd.cash");
	// Fabien
	vSeeds.emplace_back("testnet-seeder.fabien.cash");

	base58Prefixes[PUBKEY_ADDRESS] = std::vector<uint8_t>(1, 111);
	base58Prefixes[SCRIPT_ADDRESS] = std::vector<uint8_t>(1, 196);
	base58Prefixes[SECRET_KEY] = std::vector<uint8_t>(1, 239);
	base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
	base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
	cashaddrPrefix =
	gArgs.GetBoolArg("-ecash", DEFAULT_ECASH) ? "ectest" : "bchtest";

	vFixedSeeds = std::vector<SeedSpec6>(
	pnSeed6_test, pnSeed6_test + ARRAYLEN(pnSeed6_test));

	fDefaultConsistencyChecks = false;
	fRequireStandard = false;
	m_is_test_chain = true;
	m_is_mockable_chain = false;

	checkpointData = CheckpointData(CBaseChainParams::TESTNET);

	// Data as of block
	// 000000000005b07ecf85563034d13efd81c1a29e47e22b20f4fc6919d5b09cd6
	// (height 1223263)
	chainTxData = ChainTxData{1522608381, 15052068, 0.15};
	}
	};

	/**
	* Regression test
	*/
	class CRegTestParams : public CChainParams {
	public:
	CRegTestParams() {
	strNetworkID = CBaseChainParams::REGTEST;
	consensus.nSubsidyHalvingInterval = 150;
	// always enforce P2SH BIP16 on regtest
	consensus.BIP16Height = 0;
	// BIP34 activated on regtest (Used in functional tests)
	consensus.BIP34Height = 500;
	consensus.BIP34Hash = BlockHash();
	// BIP65 activated on regtest (Used in functional tests)
	consensus.BIP65Height = 1351;
	// BIP66 activated on regtest (Used in functional tests)
	consensus.BIP66Height = 1251;
	// CSV activated on regtest (Used in functional tests)
	consensus.CSVHeight = 576;
	consensus.powLimit = uint256S(
	"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
	// two weeks
	consensus.nPowTargetTimespan = 14 * 24 * 60 * 60;
	consensus.nPowTargetSpacing = 10 * 60;
	consensus.fPowAllowMinDifficultyBlocks = true;
	consensus.fPowNoRetargeting = true;

	// two days
	consensus.nDAAHalfLife = 2 * 24 * 60 * 60;

	// Faster than normal for regtest (144 instead of 2016)
	consensus.nMinerConfirmationWindow = 144;
	consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY] = {
	.bit = 28,
	// 75% of 144
	.nActivationThreshold = 108,
	};

	// The miner fund is disabled by default on regnet.
	consensus.enableMinerFund = false;

	// The best chain should have at least this much work.
	consensus.nMinimumChainWork = uint256S("0x00");

	// By default assume that the signatures in ancestors of this block are
	// valid.
	consensus.defaultAssumeValid = BlockHash();

	// UAHF is always enabled on regtest.
	consensus.uahfHeight = 0;

	// November 13, 2017 hard fork is always on on regtest.
	consensus.daaHeight = 0;

	// November 15, 2018 hard fork is always on on regtest.
	consensus.magneticAnomalyHeight = 0;

	// November 15, 2019 protocol upgrade
	consensus.gravitonHeight = 0;

	// May 15, 2020 12:00:00 UTC protocol upgrade
	consensus.phononHeight = 0;

	// Nov 15, 2020 12:00:00 UTC protocol upgrade
	consensus.axionActivationTime = 1605441600;

	// May 15, 2021 12:00:00 UTC protocol upgrade
	consensus.tachyonActivationTime = 1621080000;

	// Nov 15, 2021 12:00:00 UTC protocol upgrade
	consensus.selectronActivationTime = 1636977600;

	diskMagic[0] = 0xfa;
	diskMagic[1] = 0xbf;
	diskMagic[2] = 0xb5;
	diskMagic[3] = 0xda;
	netMagic[0] = 0xda;
	netMagic[1] = 0xb5;
	netMagic[2] = 0xbf;
	netMagic[3] = 0xfa;
	nDefaultPort = 18444;
	nPruneAfterHeight = 1000;
	m_assumed_blockchain_size = 0;
	m_assumed_chain_state_size = 0;

	genesis = CreateGenesisBlock(1296688602, 2, 0x207fffff, 1, 50 * COIN);
	consensus.hashGenesisBlock = genesis.GetHash();
	assert(consensus.hashGenesisBlock ==
	uint256S("0x0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b"
	"1a11466e2206"));
	assert(genesis.hashMerkleRoot ==
	uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab212"
	"7b7afdeda33b"));

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

	fDefaultConsistencyChecks = true;
	fRequireStandard = true;
	m_is_test_chain = true;
	m_is_mockable_chain = true;

	checkpointData = CheckpointData(CBaseChainParams::REGTEST);

	chainTxData = ChainTxData{0, 0, 0};

	base58Prefixes[PUBKEY_ADDRESS] = std::vector<uint8_t>(1, 111);
	base58Prefixes[SCRIPT_ADDRESS] = std::vector<uint8_t>(1, 196);
	base58Prefixes[SECRET_KEY] = std::vector<uint8_t>(1, 239);
	base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
	base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
	cashaddrPrefix =
	gArgs.GetBoolArg("-ecash", DEFAULT_ECASH) ? "ecregtest" : "bchreg";
	}
	};

	static std::unique_ptr<CChainParams> globalChainParams;

	const CChainParams &Params() {
	assert(globalChainParams);
	return *globalChainParams;
	}

	std::unique_ptr<CChainParams> CreateChainParams(const std::string &chain) {
	if (chain == CBaseChainParams::MAIN) {
	return std::make_unique<CMainParams>();
	}

	if (chain == CBaseChainParams::TESTNET) {
	return std::make_unique<CTestNetParams>();
	}

	if (chain == CBaseChainParams::REGTEST) {
	return std::make_unique<CRegTestParams>();
	}

	throw std::runtime_error(
	strprintf("%s: Unknown chain %s.", __func__, chain));
	}

	void SelectParams(const std::string &network) {
	SelectBaseParams(network);
	globalChainParams = CreateChainParams(network);
	}

File Metadata

Mime Type: text/x-c++
Expires: Sat, Nov 23, 10:00 (1 d, 16 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 4526148
Default Alt Text: chainparams.cpp (19 KB)

chainparams.cppNo OneTemporaryActions

chainparams.cppView Options

File Metadata

Event Timeline

chainparams.cpp
No OneTemporary
Actions

chainparams.cpp
View Options