1 // Copyright (c) 2010 Satoshi Nakamoto
2 // Copyright (c) 2009-2016 The Bitcoin Core developers
3 // Distributed under the MIT software license, see the accompanying
4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
6 #include "chainparams.h"
7 #include "consensus/merkle.h"
9 #include "tinyformat.h"
11 #include "utilstrencodings.h"
15 #include <boost/assign/list_of.hpp>
17 #include "chainparamsseeds.h"
19 static CBlock
CreateGenesisBlock(const char* pszTimestamp
, const CScript
& genesisOutputScript
, uint32_t nTime
, uint32_t nNonce
, uint32_t nBits
, int32_t nVersion
, const CAmount
& genesisReward
)
21 CMutableTransaction txNew
;
25 txNew
.vin
[0].scriptSig
= CScript() << 486604799 << CScriptNum(4) << std::vector
<unsigned char>((const unsigned char*)pszTimestamp
, (const unsigned char*)pszTimestamp
+ strlen(pszTimestamp
));
26 txNew
.vout
[0].nValue
= genesisReward
;
27 txNew
.vout
[0].scriptPubKey
= genesisOutputScript
;
30 genesis
.nTime
= nTime
;
31 genesis
.nBits
= nBits
;
32 genesis
.nNonce
= nNonce
;
33 genesis
.nVersion
= nVersion
;
34 genesis
.vtx
.push_back(MakeTransactionRef(std::move(txNew
)));
35 genesis
.hashPrevBlock
.SetNull();
36 genesis
.hashMerkleRoot
= BlockMerkleRoot(genesis
);
41 * Build the genesis block. Note that the output of its generation
42 * transaction cannot be spent since it did not originally exist in the
45 * CBlock(hash=000000000019d6, ver=1, hashPrevBlock=00000000000000, hashMerkleRoot=4a5e1e, nTime=1231006505, nBits=1d00ffff, nNonce=2083236893, vtx=1)
46 * CTransaction(hash=4a5e1e, ver=1, vin.size=1, vout.size=1, nLockTime=0)
47 * CTxIn(COutPoint(000000, -1), coinbase 04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73)
48 * CTxOut(nValue=50.00000000, scriptPubKey=0x5F1DF16B2B704C8A578D0B)
51 static CBlock
CreateGenesisBlock(uint32_t nTime
, uint32_t nNonce
, uint32_t nBits
, int32_t nVersion
, const CAmount
& genesisReward
)
53 const char* pszTimestamp
= "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks";
54 const CScript genesisOutputScript
= CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") << OP_CHECKSIG
;
55 return CreateGenesisBlock(pszTimestamp
, genesisOutputScript
, nTime
, nNonce
, nBits
, nVersion
, genesisReward
);
58 void CChainParams::UpdateBIP9Parameters(Consensus::DeploymentPos d
, int64_t nStartTime
, int64_t nTimeout
)
60 consensus
.vDeployments
[d
].nStartTime
= nStartTime
;
61 consensus
.vDeployments
[d
].nTimeout
= nTimeout
;
68 * What makes a good checkpoint block?
69 * + Is surrounded by blocks with reasonable timestamps
70 * (no blocks before with a timestamp after, none after with
72 * + Contains no strange transactions
75 class CMainParams
: public CChainParams
{
78 strNetworkID
= "main";
79 consensus
.nSubsidyHalvingInterval
= 210000;
80 consensus
.BIP34Height
= 227931;
81 consensus
.BIP34Hash
= uint256S("0x000000000000024b89b42a942fe0d9fea3bb44ab7bd1b19115dd6a759c0808b8");
82 consensus
.BIP65Height
= 388381; // 000000000000000004c2b624ed5d7756c508d90fd0da2c7c679febfa6c4735f0
83 consensus
.BIP66Height
= 363725; // 00000000000000000379eaa19dce8c9b722d46ae6a57c2f1a988119488b50931
84 consensus
.powLimit
= uint256S("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
85 consensus
.nPowTargetTimespan
= 14 * 24 * 60 * 60; // two weeks
86 consensus
.nPowTargetSpacing
= 10 * 60;
87 consensus
.fPowAllowMinDifficultyBlocks
= false;
88 consensus
.fPowNoRetargeting
= false;
89 consensus
.nRuleChangeActivationThreshold
= 1916; // 95% of 2016
90 consensus
.nMinerConfirmationWindow
= 2016; // nPowTargetTimespan / nPowTargetSpacing
91 consensus
.vDeployments
[Consensus::DEPLOYMENT_TESTDUMMY
].bit
= 28;
92 consensus
.vDeployments
[Consensus::DEPLOYMENT_TESTDUMMY
].nStartTime
= 1199145601; // January 1, 2008
93 consensus
.vDeployments
[Consensus::DEPLOYMENT_TESTDUMMY
].nTimeout
= 1230767999; // December 31, 2008
95 // Deployment of BIP68, BIP112, and BIP113.
96 consensus
.vDeployments
[Consensus::DEPLOYMENT_CSV
].bit
= 0;
97 consensus
.vDeployments
[Consensus::DEPLOYMENT_CSV
].nStartTime
= 1462060800; // May 1st, 2016
98 consensus
.vDeployments
[Consensus::DEPLOYMENT_CSV
].nTimeout
= 1493596800; // May 1st, 2017
100 // Deployment of SegWit (BIP141, BIP143, and BIP147)
101 consensus
.vDeployments
[Consensus::DEPLOYMENT_SEGWIT
].bit
= 1;
102 consensus
.vDeployments
[Consensus::DEPLOYMENT_SEGWIT
].nStartTime
= 1479168000; // November 15th, 2016.
103 consensus
.vDeployments
[Consensus::DEPLOYMENT_SEGWIT
].nTimeout
= 1510704000; // November 15th, 2017.
105 // The best chain should have at least this much work.
106 consensus
.nMinimumChainWork
= uint256S("0x0000000000000000000000000000000000000000003f94d1ad391682fe038bf5");
108 // By default assume that the signatures in ancestors of this block are valid.
109 consensus
.defaultAssumeValid
= uint256S("0x00000000000000000013176bf8d7dfeab4e1db31dc93bc311b436e82ab226b90"); //453354
112 * The message start string is designed to be unlikely to occur in normal data.
113 * The characters are rarely used upper ASCII, not valid as UTF-8, and produce
114 * a large 32-bit integer with any alignment.
116 pchMessageStart
[0] = 0xf9;
117 pchMessageStart
[1] = 0xbe;
118 pchMessageStart
[2] = 0xb4;
119 pchMessageStart
[3] = 0xd9;
121 nPruneAfterHeight
= 100000;
123 genesis
= CreateGenesisBlock(1231006505, 2083236893, 0x1d00ffff, 1, 50 * COIN
);
124 consensus
.hashGenesisBlock
= genesis
.GetHash();
125 assert(consensus
.hashGenesisBlock
== uint256S("0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"));
126 assert(genesis
.hashMerkleRoot
== uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
128 // Note that of those with the service bits flag, most only support a subset of possible options
129 vSeeds
.push_back(CDNSSeedData("bitcoin.sipa.be", "seed.bitcoin.sipa.be", true)); // Pieter Wuille, only supports x1, x5, x9, and xd
130 vSeeds
.push_back(CDNSSeedData("bluematt.me", "dnsseed.bluematt.me", true)); // Matt Corallo, only supports x9
131 vSeeds
.push_back(CDNSSeedData("dashjr.org", "dnsseed.bitcoin.dashjr.org")); // Luke Dashjr
132 vSeeds
.push_back(CDNSSeedData("bitcoinstats.com", "seed.bitcoinstats.com", true)); // Christian Decker, supports x1 - xf
133 vSeeds
.push_back(CDNSSeedData("bitcoin.jonasschnelli.ch", "seed.bitcoin.jonasschnelli.ch", true)); // Jonas Schnelli, only supports x1, x5, x9, and xd
134 vSeeds
.push_back(CDNSSeedData("petertodd.org", "seed.btc.petertodd.org", true)); // Peter Todd, only supports x1, x5, x9, and xd
136 base58Prefixes
[PUBKEY_ADDRESS
] = std::vector
<unsigned char>(1,0);
137 base58Prefixes
[SCRIPT_ADDRESS
] = std::vector
<unsigned char>(1,5);
138 base58Prefixes
[SECRET_KEY
] = std::vector
<unsigned char>(1,128);
139 base58Prefixes
[EXT_PUBLIC_KEY
] = boost::assign::list_of(0x04)(0x88)(0xB2)(0x1E).convert_to_container
<std::vector
<unsigned char> >();
140 base58Prefixes
[EXT_SECRET_KEY
] = boost::assign::list_of(0x04)(0x88)(0xAD)(0xE4).convert_to_container
<std::vector
<unsigned char> >();
142 vFixedSeeds
= std::vector
<SeedSpec6
>(pnSeed6_main
, pnSeed6_main
+ ARRAYLEN(pnSeed6_main
));
144 fDefaultConsistencyChecks
= false;
145 fRequireStandard
= true;
146 fMineBlocksOnDemand
= false;
148 checkpointData
= (CCheckpointData
) {
149 boost::assign::map_list_of
150 ( 11111, uint256S("0x0000000069e244f73d78e8fd29ba2fd2ed618bd6fa2ee92559f542fdb26e7c1d"))
151 ( 33333, uint256S("0x000000002dd5588a74784eaa7ab0507a18ad16a236e7b1ce69f00d7ddfb5d0a6"))
152 ( 74000, uint256S("0x0000000000573993a3c9e41ce34471c079dcf5f52a0e824a81e7f953b8661a20"))
153 (105000, uint256S("0x00000000000291ce28027faea320c8d2b054b2e0fe44a773f3eefb151d6bdc97"))
154 (134444, uint256S("0x00000000000005b12ffd4cd315cd34ffd4a594f430ac814c91184a0d42d2b0fe"))
155 (168000, uint256S("0x000000000000099e61ea72015e79632f216fe6cb33d7899acb35b75c8303b763"))
156 (193000, uint256S("0x000000000000059f452a5f7340de6682a977387c17010ff6e6c3bd83ca8b1317"))
157 (210000, uint256S("0x000000000000048b95347e83192f69cf0366076336c639f9b7228e9ba171342e"))
158 (216116, uint256S("0x00000000000001b4f4b433e81ee46494af945cf96014816a4e2370f11b23df4e"))
159 (225430, uint256S("0x00000000000001c108384350f74090433e7fcf79a606b8e797f065b130575932"))
160 (250000, uint256S("0x000000000000003887df1f29024b06fc2200b55f8af8f35453d7be294df2d214"))
161 (279000, uint256S("0x0000000000000001ae8c72a0b0c301f67e3afca10e819efa9041e458e9bd7e40"))
162 (295000, uint256S("0x00000000000000004d9b4ef50f0f9d686fd69db2e03af35a100370c64632a983"))
165 chainTxData
= ChainTxData
{
166 // Data as of block 00000000000000000166d612d5595e2b1cd88d71d695fc580af64d8da8658c23 (height 446482).
167 1483472411, // * UNIX timestamp of last known number of transactions
168 184495391, // * total number of transactions between genesis and that timestamp
169 // (the tx=... number in the SetBestChain debug.log lines)
170 3.2 // * estimated number of transactions per second after that timestamp
178 class CTestNetParams
: public CChainParams
{
181 strNetworkID
= "test";
182 consensus
.nSubsidyHalvingInterval
= 210000;
183 consensus
.BIP34Height
= 21111;
184 consensus
.BIP34Hash
= uint256S("0x0000000023b3a96d3484e5abb3755c413e7d41500f8e2a5c3f0dd01299cd8ef8");
185 consensus
.BIP65Height
= 581885; // 00000000007f6655f22f98e72ed80d8b06dc761d5da09df0fa1dc4be4f861eb6
186 consensus
.BIP66Height
= 330776; // 000000002104c8c45e99a8853285a3b592602a3ccde2b832481da85e9e4ba182
187 consensus
.powLimit
= uint256S("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
188 consensus
.nPowTargetTimespan
= 14 * 24 * 60 * 60; // two weeks
189 consensus
.nPowTargetSpacing
= 10 * 60;
190 consensus
.fPowAllowMinDifficultyBlocks
= true;
191 consensus
.fPowNoRetargeting
= false;
192 consensus
.nRuleChangeActivationThreshold
= 1512; // 75% for testchains
193 consensus
.nMinerConfirmationWindow
= 2016; // nPowTargetTimespan / nPowTargetSpacing
194 consensus
.vDeployments
[Consensus::DEPLOYMENT_TESTDUMMY
].bit
= 28;
195 consensus
.vDeployments
[Consensus::DEPLOYMENT_TESTDUMMY
].nStartTime
= 1199145601; // January 1, 2008
196 consensus
.vDeployments
[Consensus::DEPLOYMENT_TESTDUMMY
].nTimeout
= 1230767999; // December 31, 2008
198 // Deployment of BIP68, BIP112, and BIP113.
199 consensus
.vDeployments
[Consensus::DEPLOYMENT_CSV
].bit
= 0;
200 consensus
.vDeployments
[Consensus::DEPLOYMENT_CSV
].nStartTime
= 1456790400; // March 1st, 2016
201 consensus
.vDeployments
[Consensus::DEPLOYMENT_CSV
].nTimeout
= 1493596800; // May 1st, 2017
203 // Deployment of SegWit (BIP141, BIP143, and BIP147)
204 consensus
.vDeployments
[Consensus::DEPLOYMENT_SEGWIT
].bit
= 1;
205 consensus
.vDeployments
[Consensus::DEPLOYMENT_SEGWIT
].nStartTime
= 1462060800; // May 1st 2016
206 consensus
.vDeployments
[Consensus::DEPLOYMENT_SEGWIT
].nTimeout
= 1493596800; // May 1st 2017
208 // The best chain should have at least this much work.
209 consensus
.nMinimumChainWork
= uint256S("0x00000000000000000000000000000000000000000000001f057509eba81aed91");
211 // By default assume that the signatures in ancestors of this block are valid.
212 consensus
.defaultAssumeValid
= uint256S("0x00000000000128796ee387cf110ccb9d2f36cffaf7f73079c995377c65ac0dcc"); //1079274
214 pchMessageStart
[0] = 0x0b;
215 pchMessageStart
[1] = 0x11;
216 pchMessageStart
[2] = 0x09;
217 pchMessageStart
[3] = 0x07;
218 nDefaultPort
= 18333;
219 nPruneAfterHeight
= 1000;
221 genesis
= CreateGenesisBlock(1296688602, 414098458, 0x1d00ffff, 1, 50 * COIN
);
222 consensus
.hashGenesisBlock
= genesis
.GetHash();
223 assert(consensus
.hashGenesisBlock
== uint256S("0x000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"));
224 assert(genesis
.hashMerkleRoot
== uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
228 // nodes with support for servicebits filtering should be at the top
229 vSeeds
.push_back(CDNSSeedData("testnetbitcoin.jonasschnelli.ch", "testnet-seed.bitcoin.jonasschnelli.ch", true));
230 vSeeds
.push_back(CDNSSeedData("petertodd.org", "seed.tbtc.petertodd.org", true));
231 vSeeds
.push_back(CDNSSeedData("bluematt.me", "testnet-seed.bluematt.me"));
232 vSeeds
.push_back(CDNSSeedData("bitcoin.schildbach.de", "testnet-seed.bitcoin.schildbach.de"));
234 base58Prefixes
[PUBKEY_ADDRESS
] = std::vector
<unsigned char>(1,111);
235 base58Prefixes
[SCRIPT_ADDRESS
] = std::vector
<unsigned char>(1,196);
236 base58Prefixes
[SECRET_KEY
] = std::vector
<unsigned char>(1,239);
237 base58Prefixes
[EXT_PUBLIC_KEY
] = boost::assign::list_of(0x04)(0x35)(0x87)(0xCF).convert_to_container
<std::vector
<unsigned char> >();
238 base58Prefixes
[EXT_SECRET_KEY
] = boost::assign::list_of(0x04)(0x35)(0x83)(0x94).convert_to_container
<std::vector
<unsigned char> >();
240 vFixedSeeds
= std::vector
<SeedSpec6
>(pnSeed6_test
, pnSeed6_test
+ ARRAYLEN(pnSeed6_test
));
242 fDefaultConsistencyChecks
= false;
243 fRequireStandard
= false;
244 fMineBlocksOnDemand
= false;
247 checkpointData
= (CCheckpointData
) {
248 boost::assign::map_list_of
249 ( 546, uint256S("000000002a936ca763904c3c35fce2f3556c559c0214345d31b1bcebf76acb70")),
252 chainTxData
= ChainTxData
{
253 // Data as of block 00000000c2872f8f8a8935c8e3c5862be9038c97d4de2cf37ed496991166928a (height 1063660)
265 class CRegTestParams
: public CChainParams
{
268 strNetworkID
= "regtest";
269 consensus
.nSubsidyHalvingInterval
= 150;
270 consensus
.BIP34Height
= 100000000; // BIP34 has not activated on regtest (far in the future so block v1 are not rejected in tests)
271 consensus
.BIP34Hash
= uint256();
272 consensus
.BIP65Height
= 1351; // BIP65 activated on regtest (Used in rpc activation tests)
273 consensus
.BIP66Height
= 1251; // BIP66 activated on regtest (Used in rpc activation tests)
274 consensus
.powLimit
= uint256S("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
275 consensus
.nPowTargetTimespan
= 14 * 24 * 60 * 60; // two weeks
276 consensus
.nPowTargetSpacing
= 10 * 60;
277 consensus
.fPowAllowMinDifficultyBlocks
= true;
278 consensus
.fPowNoRetargeting
= true;
279 consensus
.nRuleChangeActivationThreshold
= 108; // 75% for testchains
280 consensus
.nMinerConfirmationWindow
= 144; // Faster than normal for regtest (144 instead of 2016)
281 consensus
.vDeployments
[Consensus::DEPLOYMENT_TESTDUMMY
].bit
= 28;
282 consensus
.vDeployments
[Consensus::DEPLOYMENT_TESTDUMMY
].nStartTime
= 0;
283 consensus
.vDeployments
[Consensus::DEPLOYMENT_TESTDUMMY
].nTimeout
= 999999999999ULL;
284 consensus
.vDeployments
[Consensus::DEPLOYMENT_CSV
].bit
= 0;
285 consensus
.vDeployments
[Consensus::DEPLOYMENT_CSV
].nStartTime
= 0;
286 consensus
.vDeployments
[Consensus::DEPLOYMENT_CSV
].nTimeout
= 999999999999ULL;
287 consensus
.vDeployments
[Consensus::DEPLOYMENT_SEGWIT
].bit
= 1;
288 consensus
.vDeployments
[Consensus::DEPLOYMENT_SEGWIT
].nStartTime
= 0;
289 consensus
.vDeployments
[Consensus::DEPLOYMENT_SEGWIT
].nTimeout
= 999999999999ULL;
291 // The best chain should have at least this much work.
292 consensus
.nMinimumChainWork
= uint256S("0x00");
294 // By default assume that the signatures in ancestors of this block are valid.
295 consensus
.defaultAssumeValid
= uint256S("0x00");
297 pchMessageStart
[0] = 0xfa;
298 pchMessageStart
[1] = 0xbf;
299 pchMessageStart
[2] = 0xb5;
300 pchMessageStart
[3] = 0xda;
301 nDefaultPort
= 18444;
302 nPruneAfterHeight
= 1000;
304 genesis
= CreateGenesisBlock(1296688602, 2, 0x207fffff, 1, 50 * COIN
);
305 consensus
.hashGenesisBlock
= genesis
.GetHash();
306 assert(consensus
.hashGenesisBlock
== uint256S("0x0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"));
307 assert(genesis
.hashMerkleRoot
== uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
309 vFixedSeeds
.clear(); //!< Regtest mode doesn't have any fixed seeds.
310 vSeeds
.clear(); //!< Regtest mode doesn't have any DNS seeds.
312 fDefaultConsistencyChecks
= true;
313 fRequireStandard
= false;
314 fMineBlocksOnDemand
= true;
316 checkpointData
= (CCheckpointData
){
317 boost::assign::map_list_of
318 ( 0, uint256S("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"))
321 chainTxData
= ChainTxData
{
327 base58Prefixes
[PUBKEY_ADDRESS
] = std::vector
<unsigned char>(1,111);
328 base58Prefixes
[SCRIPT_ADDRESS
] = std::vector
<unsigned char>(1,196);
329 base58Prefixes
[SECRET_KEY
] = std::vector
<unsigned char>(1,239);
330 base58Prefixes
[EXT_PUBLIC_KEY
] = boost::assign::list_of(0x04)(0x35)(0x87)(0xCF).convert_to_container
<std::vector
<unsigned char> >();
331 base58Prefixes
[EXT_SECRET_KEY
] = boost::assign::list_of(0x04)(0x35)(0x83)(0x94).convert_to_container
<std::vector
<unsigned char> >();
335 static std::unique_ptr
<CChainParams
> globalChainParams
;
337 const CChainParams
&Params() {
338 assert(globalChainParams
);
339 return *globalChainParams
;
342 std::unique_ptr
<CChainParams
> CreateChainParams(const std::string
& chain
)
344 if (chain
== CBaseChainParams::MAIN
)
345 return std::unique_ptr
<CChainParams
>(new CMainParams());
346 else if (chain
== CBaseChainParams::TESTNET
)
347 return std::unique_ptr
<CChainParams
>(new CTestNetParams());
348 else if (chain
== CBaseChainParams::REGTEST
)
349 return std::unique_ptr
<CChainParams
>(new CRegTestParams());
350 throw std::runtime_error(strprintf("%s: Unknown chain %s.", __func__
, chain
));
353 void SelectParams(const std::string
& network
)
355 SelectBaseParams(network
);
356 globalChainParams
= CreateChainParams(network
);
359 void UpdateBIP9Parameters(Consensus::DeploymentPos d
, int64_t nStartTime
, int64_t nTimeout
)
361 globalChainParams
->UpdateBIP9Parameters(d
, nStartTime
, nTimeout
);