Bitcoin Core  27.99.0
P2P Digital Currency
chainparams.cpp
Go to the documentation of this file.
1 // Copyright (c) 2010 Satoshi Nakamoto
2 // Copyright (c) 2009-2021 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.
5 
6 #include <kernel/chainparams.h>
7 
8 #include <chainparamsseeds.h>
9 #include <consensus/amount.h>
10 #include <consensus/merkle.h>
11 #include <consensus/params.h>
12 #include <hash.h>
14 #include <logging.h>
15 #include <primitives/block.h>
16 #include <primitives/transaction.h>
17 #include <script/interpreter.h>
18 #include <script/script.h>
19 #include <uint256.h>
20 #include <util/chaintype.h>
21 #include <util/strencodings.h>
22 
23 #include <algorithm>
24 #include <cassert>
25 #include <cstdint>
26 #include <cstring>
27 #include <type_traits>
28 
29 static CBlock CreateGenesisBlock(const char* pszTimestamp, const CScript& genesisOutputScript, uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
30 {
31  CMutableTransaction txNew;
32  txNew.nVersion = 1;
33  txNew.vin.resize(1);
34  txNew.vout.resize(1);
35  txNew.vin[0].scriptSig = CScript() << 486604799 << CScriptNum(4) << std::vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
36  txNew.vout[0].nValue = genesisReward;
37  txNew.vout[0].scriptPubKey = genesisOutputScript;
38 
39  CBlock genesis;
40  genesis.nTime = nTime;
41  genesis.nBits = nBits;
42  genesis.nNonce = nNonce;
43  genesis.nVersion = nVersion;
44  genesis.vtx.push_back(MakeTransactionRef(std::move(txNew)));
45  genesis.hashPrevBlock.SetNull();
46  genesis.hashMerkleRoot = BlockMerkleRoot(genesis);
47  return genesis;
48 }
49 
61 static CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
62 {
63  const char* pszTimestamp = "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks";
64  const CScript genesisOutputScript = CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") << OP_CHECKSIG;
65  return CreateGenesisBlock(pszTimestamp, genesisOutputScript, nTime, nNonce, nBits, nVersion, genesisReward);
66 }
67 
71 class CMainParams : public CChainParams {
72 public:
75  consensus.signet_blocks = false;
78  consensus.script_flag_exceptions.emplace( // BIP16 exception
79  uint256S("0x00000000000002dc756eebf4f49723ed8d30cc28a5f108eb94b1ba88ac4f9c22"), SCRIPT_VERIFY_NONE);
80  consensus.script_flag_exceptions.emplace( // Taproot exception
81  uint256S("0x0000000000000000000f14c35b2d841e986ab5441de8c585d5ffe55ea1e395ad"), SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS);
82  consensus.BIP34Height = 227931;
83  consensus.BIP34Hash = uint256S("0x000000000000024b89b42a942fe0d9fea3bb44ab7bd1b19115dd6a759c0808b8");
84  consensus.BIP65Height = 388381; // 000000000000000004c2b624ed5d7756c508d90fd0da2c7c679febfa6c4735f0
85  consensus.BIP66Height = 363725; // 00000000000000000379eaa19dce8c9b722d46ae6a57c2f1a988119488b50931
86  consensus.CSVHeight = 419328; // 000000000000000004a1b34462cb8aeebd5799177f7a29cf28f2d1961716b5b5
87  consensus.SegwitHeight = 481824; // 0000000000000000001c8018d9cb3b742ef25114f27563e3fc4a1902167f9893
88  consensus.MinBIP9WarningHeight = 483840; // segwit activation height + miner confirmation window
89  consensus.powLimit = uint256S("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
90  consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
91  consensus.nPowTargetSpacing = 10 * 60;
94  consensus.nRuleChangeActivationThreshold = 1815; // 90% of 2016
95  consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
100 
101  // Deployment of Taproot (BIPs 340-342)
103  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartTime = 1619222400; // April 24th, 2021
104  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeout = 1628640000; // August 11th, 2021
105  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 709632; // Approximately November 12th, 2021
106 
107  consensus.nMinimumChainWork = uint256S("0x000000000000000000000000000000000000000063c4ebd298db40af57541800");
108  consensus.defaultAssumeValid = uint256S("0x000000000000000000026811d149d4d261995ec5b3f64f439a0a10e1a464af9a"); // 824000
109 
115  pchMessageStart[0] = 0xf9;
116  pchMessageStart[1] = 0xbe;
117  pchMessageStart[2] = 0xb4;
118  pchMessageStart[3] = 0xd9;
119  nDefaultPort = 8333;
120  nPruneAfterHeight = 100000;
123 
124  genesis = CreateGenesisBlock(1231006505, 2083236893, 0x1d00ffff, 1, 50 * COIN);
126  assert(consensus.hashGenesisBlock == uint256S("0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"));
127  assert(genesis.hashMerkleRoot == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
128 
129  // Note that of those which support the service bits prefix, most only support a subset of
130  // possible options.
131  // This is fine at runtime as we'll fall back to using them as an addrfetch if they don't support the
132  // service bits we want, but we should get them updated to support all service bits wanted by any
133  // release ASAP to avoid it where possible.
134  vSeeds.emplace_back("seed.bitcoin.sipa.be."); // Pieter Wuille, only supports x1, x5, x9, and xd
135  vSeeds.emplace_back("dnsseed.bluematt.me."); // Matt Corallo, only supports x9
136  vSeeds.emplace_back("dnsseed.bitcoin.dashjr.org."); // Luke Dashjr
137  vSeeds.emplace_back("seed.bitcoinstats.com."); // Christian Decker, supports x1 - xf
138  vSeeds.emplace_back("seed.bitcoin.jonasschnelli.ch."); // Jonas Schnelli, only supports x1, x5, x9, and xd
139  vSeeds.emplace_back("seed.btc.petertodd.net."); // Peter Todd, only supports x1, x5, x9, and xd
140  vSeeds.emplace_back("seed.bitcoin.sprovoost.nl."); // Sjors Provoost
141  vSeeds.emplace_back("dnsseed.emzy.de."); // Stephan Oeste
142  vSeeds.emplace_back("seed.bitcoin.wiz.biz."); // Jason Maurice
143 
144  base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,0);
145  base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,5);
146  base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,128);
147  base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x88, 0xB2, 0x1E};
148  base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4};
149 
150  bech32_hrp = "bc";
151 
152  vFixedSeeds = std::vector<uint8_t>(std::begin(chainparams_seed_main), std::end(chainparams_seed_main));
153 
155  m_is_mockable_chain = false;
156 
157  checkpointData = {
158  {
159  { 11111, uint256S("0x0000000069e244f73d78e8fd29ba2fd2ed618bd6fa2ee92559f542fdb26e7c1d")},
160  { 33333, uint256S("0x000000002dd5588a74784eaa7ab0507a18ad16a236e7b1ce69f00d7ddfb5d0a6")},
161  { 74000, uint256S("0x0000000000573993a3c9e41ce34471c079dcf5f52a0e824a81e7f953b8661a20")},
162  {105000, uint256S("0x00000000000291ce28027faea320c8d2b054b2e0fe44a773f3eefb151d6bdc97")},
163  {134444, uint256S("0x00000000000005b12ffd4cd315cd34ffd4a594f430ac814c91184a0d42d2b0fe")},
164  {168000, uint256S("0x000000000000099e61ea72015e79632f216fe6cb33d7899acb35b75c8303b763")},
165  {193000, uint256S("0x000000000000059f452a5f7340de6682a977387c17010ff6e6c3bd83ca8b1317")},
166  {210000, uint256S("0x000000000000048b95347e83192f69cf0366076336c639f9b7228e9ba171342e")},
167  {216116, uint256S("0x00000000000001b4f4b433e81ee46494af945cf96014816a4e2370f11b23df4e")},
168  {225430, uint256S("0x00000000000001c108384350f74090433e7fcf79a606b8e797f065b130575932")},
169  {250000, uint256S("0x000000000000003887df1f29024b06fc2200b55f8af8f35453d7be294df2d214")},
170  {279000, uint256S("0x0000000000000001ae8c72a0b0c301f67e3afca10e819efa9041e458e9bd7e40")},
171  {295000, uint256S("0x00000000000000004d9b4ef50f0f9d686fd69db2e03af35a100370c64632a983")},
172  }
173  };
174 
176  // TODO to be specified in a future patch.
177  };
178 
180  // Data from RPC: getchaintxstats 4096 000000000000000000026811d149d4d261995ec5b3f64f439a0a10e1a464af9a
181  .nTime = 1704194835,
182  .nTxCount = 946728933,
183  .dTxRate = 6.569290261471664,
184  };
185  }
186 };
187 
191 class CTestNetParams : public CChainParams {
192 public:
195  consensus.signet_blocks = false;
196  consensus.signet_challenge.clear();
198  consensus.script_flag_exceptions.emplace( // BIP16 exception
199  uint256S("0x00000000dd30457c001f4095d208cc1296b0eed002427aa599874af7a432b105"), SCRIPT_VERIFY_NONE);
200  consensus.BIP34Height = 21111;
201  consensus.BIP34Hash = uint256S("0x0000000023b3a96d3484e5abb3755c413e7d41500f8e2a5c3f0dd01299cd8ef8");
202  consensus.BIP65Height = 581885; // 00000000007f6655f22f98e72ed80d8b06dc761d5da09df0fa1dc4be4f861eb6
203  consensus.BIP66Height = 330776; // 000000002104c8c45e99a8853285a3b592602a3ccde2b832481da85e9e4ba182
204  consensus.CSVHeight = 770112; // 00000000025e930139bac5c6c31a403776da130831ab85be56578f3fa75369bb
205  consensus.SegwitHeight = 834624; // 00000000002b980fcd729daaa248fd9316a5200e9b367f4ff2c42453e84201ca
206  consensus.MinBIP9WarningHeight = 836640; // segwit activation height + miner confirmation window
207  consensus.powLimit = uint256S("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
208  consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
209  consensus.nPowTargetSpacing = 10 * 60;
212  consensus.nRuleChangeActivationThreshold = 1512; // 75% for testchains
213  consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
218 
219  // Deployment of Taproot (BIPs 340-342)
221  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartTime = 1619222400; // April 24th, 2021
222  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeout = 1628640000; // August 11th, 2021
224 
225  consensus.nMinimumChainWork = uint256S("0x000000000000000000000000000000000000000000000c59b14e264ba6c15db9");
226  consensus.defaultAssumeValid = uint256S("0x000000000001323071f38f21ea5aae529ece491eadaccce506a59bcc2d968917"); // 2550000
227 
228  pchMessageStart[0] = 0x0b;
229  pchMessageStart[1] = 0x11;
230  pchMessageStart[2] = 0x09;
231  pchMessageStart[3] = 0x07;
232  nDefaultPort = 18333;
233  nPruneAfterHeight = 1000;
236 
237  genesis = CreateGenesisBlock(1296688602, 414098458, 0x1d00ffff, 1, 50 * COIN);
239  assert(consensus.hashGenesisBlock == uint256S("0x000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"));
240  assert(genesis.hashMerkleRoot == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
241 
242  vFixedSeeds.clear();
243  vSeeds.clear();
244  // nodes with support for servicebits filtering should be at the top
245  vSeeds.emplace_back("testnet-seed.bitcoin.jonasschnelli.ch.");
246  vSeeds.emplace_back("seed.tbtc.petertodd.net.");
247  vSeeds.emplace_back("seed.testnet.bitcoin.sprovoost.nl.");
248  vSeeds.emplace_back("testnet-seed.bluematt.me."); // Just a static list of stable node(s), only supports x9
249 
250  base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
251  base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
252  base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,239);
253  base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
254  base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
255 
256  bech32_hrp = "tb";
257 
258  vFixedSeeds = std::vector<uint8_t>(std::begin(chainparams_seed_test), std::end(chainparams_seed_test));
259 
261  m_is_mockable_chain = false;
262 
263  checkpointData = {
264  {
265  {546, uint256S("000000002a936ca763904c3c35fce2f3556c559c0214345d31b1bcebf76acb70")},
266  }
267  };
268 
270  {
271  .height = 2'500'000,
272  .hash_serialized = AssumeutxoHash{uint256S("0xf841584909f68e47897952345234e37fcd9128cd818f41ee6c3ca68db8071be7")},
273  .nChainTx = 66484552,
274  .blockhash = uint256S("0x0000000000000093bcb68c03a9a168ae252572d348a2eaeba2cdf9231d73206f")
275  }
276  };
277 
279  // Data from RPC: getchaintxstats 4096 000000000001323071f38f21ea5aae529ece491eadaccce506a59bcc2d968917
280  .nTime = 1703579240,
281  .nTxCount = 67845391,
282  .dTxRate = 1.464436832560951,
283  };
284  }
285 };
286 
290 class SigNetParams : public CChainParams {
291 public:
292  explicit SigNetParams(const SigNetOptions& options)
293  {
294  std::vector<uint8_t> bin;
295  vSeeds.clear();
296 
297  if (!options.challenge) {
298  bin = ParseHex("512103ad5e0edad18cb1f0fc0d28a3d4f1f3e445640337489abb10404f2d1e086be430210359ef5021964fe22d6f8e05b2463c9540ce96883fe3b278760f048f5189f2e6c452ae");
299  vSeeds.emplace_back("seed.signet.bitcoin.sprovoost.nl.");
300 
301  // Hardcoded nodes can be removed once there are more DNS seeds
302  vSeeds.emplace_back("178.128.221.177");
303  vSeeds.emplace_back("v7ajjeirttkbnt32wpy3c6w3emwnfr3fkla7hpxcfokr3ysd3kqtzmqd.onion:38333");
304 
305  consensus.nMinimumChainWork = uint256S("0x00000000000000000000000000000000000000000000000000000206e86f08e8");
306  consensus.defaultAssumeValid = uint256S("0x0000000870f15246ba23c16e370a7ffb1fc8a3dcf8cb4492882ed4b0e3d4cd26"); // 180000
310  // Data from RPC: getchaintxstats 4096 0000000870f15246ba23c16e370a7ffb1fc8a3dcf8cb4492882ed4b0e3d4cd26
311  .nTime = 1706331472,
312  .nTxCount = 2425380,
313  .dTxRate = 0.008277759863833788,
314  };
315  } else {
316  bin = *options.challenge;
322  0,
323  0,
324  0,
325  };
326  LogPrintf("Signet with challenge %s\n", HexStr(bin));
327  }
328 
329  if (options.seeds) {
330  vSeeds = *options.seeds;
331  }
332 
334  consensus.signet_blocks = true;
335  consensus.signet_challenge.assign(bin.begin(), bin.end());
341  consensus.CSVHeight = 1;
343  consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
344  consensus.nPowTargetSpacing = 10 * 60;
347  consensus.nRuleChangeActivationThreshold = 1815; // 90% of 2016
348  consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
350  consensus.powLimit = uint256S("00000377ae000000000000000000000000000000000000000000000000000000");
355 
356  // Activation of Taproot (BIPs 340-342)
361 
362  // message start is defined as the first 4 bytes of the sha256d of the block script
363  HashWriter h{};
365  uint256 hash = h.GetHash();
366  std::copy_n(hash.begin(), 4, pchMessageStart.begin());
367 
368  nDefaultPort = 38333;
369  nPruneAfterHeight = 1000;
370 
371  genesis = CreateGenesisBlock(1598918400, 52613770, 0x1e0377ae, 1, 50 * COIN);
373  assert(consensus.hashGenesisBlock == uint256S("0x00000008819873e925422c1ff0f99f7cc9bbb232af63a077a480a3633bee1ef6"));
374  assert(genesis.hashMerkleRoot == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
375 
376  vFixedSeeds.clear();
377 
379  {
380  .height = 160'000,
381  .hash_serialized = AssumeutxoHash{uint256S("0xfe0a44309b74d6b5883d246cb419c6221bcccf0b308c9b59b7d70783dbdf928a")},
382  .nChainTx = 2289496,
383  .blockhash = uint256S("0x0000003ca3c99aff040f2563c2ad8f8ec88bd0fd6b8f0895cfaf1ef90353a62c")
384  }
385  };
386 
387  base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
388  base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
389  base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,239);
390  base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
391  base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
392 
393  bech32_hrp = "tb";
394 
396  m_is_mockable_chain = false;
397  }
398 };
399 
405 {
406 public:
407  explicit CRegTestParams(const RegTestOptions& opts)
408  {
410  consensus.signet_blocks = false;
411  consensus.signet_challenge.clear();
413  consensus.BIP34Height = 1; // Always active unless overridden
415  consensus.BIP65Height = 1; // Always active unless overridden
416  consensus.BIP66Height = 1; // Always active unless overridden
417  consensus.CSVHeight = 1; // Always active unless overridden
418  consensus.SegwitHeight = 0; // Always active unless overridden
420  consensus.powLimit = uint256S("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
421  consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
422  consensus.nPowTargetSpacing = 10 * 60;
425  consensus.nRuleChangeActivationThreshold = 108; // 75% for testchains
426  consensus.nMinerConfirmationWindow = 144; // Faster than normal for regtest (144 instead of 2016)
427 
432 
437 
440 
441  pchMessageStart[0] = 0xfa;
442  pchMessageStart[1] = 0xbf;
443  pchMessageStart[2] = 0xb5;
444  pchMessageStart[3] = 0xda;
445  nDefaultPort = 18444;
446  nPruneAfterHeight = opts.fastprune ? 100 : 1000;
449 
450  for (const auto& [dep, height] : opts.activation_heights) {
451  switch (dep) {
453  consensus.SegwitHeight = int{height};
454  break;
456  consensus.BIP34Height = int{height};
457  break;
459  consensus.BIP66Height = int{height};
460  break;
462  consensus.BIP65Height = int{height};
463  break;
465  consensus.CSVHeight = int{height};
466  break;
467  }
468  }
469 
470  for (const auto& [deployment_pos, version_bits_params] : opts.version_bits_parameters) {
471  consensus.vDeployments[deployment_pos].nStartTime = version_bits_params.start_time;
472  consensus.vDeployments[deployment_pos].nTimeout = version_bits_params.timeout;
473  consensus.vDeployments[deployment_pos].min_activation_height = version_bits_params.min_activation_height;
474  }
475 
476  genesis = CreateGenesisBlock(1296688602, 2, 0x207fffff, 1, 50 * COIN);
478  assert(consensus.hashGenesisBlock == uint256S("0x0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"));
479  assert(genesis.hashMerkleRoot == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
480 
481  vFixedSeeds.clear();
482  vSeeds.clear();
483  vSeeds.emplace_back("dummySeed.invalid.");
484 
486  m_is_mockable_chain = true;
487 
488  checkpointData = {
489  {
490  {0, uint256S("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206")},
491  }
492  };
493 
495  {
496  .height = 110,
497  .hash_serialized = AssumeutxoHash{uint256S("0x6657b736d4fe4db0cbc796789e812d5dba7f5c143764b1b6905612f1830609d1")},
498  .nChainTx = 111,
499  .blockhash = uint256S("0x696e92821f65549c7ee134edceeeeaaa4105647a3c4fd9f298c0aec0ab50425c")
500  },
501  {
502  // For use by test/functional/feature_assumeutxo.py
503  .height = 299,
504  .hash_serialized = AssumeutxoHash{uint256S("0xa4bf3407ccb2cc0145c49ebba8fa91199f8a3903daf0883875941497d2493c27")},
505  .nChainTx = 334,
506  .blockhash = uint256S("0x3bb7ce5eba0be48939b7a521ac1ba9316afee2c7bada3a0cca24188e6d7d96c0")
507  },
508  };
509 
511  0,
512  0,
513  0
514  };
515 
516  base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
517  base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
518  base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,239);
519  base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
520  base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
521 
522  bech32_hrp = "bcrt";
523  }
524 };
525 
526 std::unique_ptr<const CChainParams> CChainParams::SigNet(const SigNetOptions& options)
527 {
528  return std::make_unique<const SigNetParams>(options);
529 }
530 
531 std::unique_ptr<const CChainParams> CChainParams::RegTest(const RegTestOptions& options)
532 {
533  return std::make_unique<const CRegTestParams>(options);
534 }
535 
536 std::unique_ptr<const CChainParams> CChainParams::Main()
537 {
538  return std::make_unique<const CMainParams>();
539 }
540 
541 std::unique_ptr<const CChainParams> CChainParams::TestNet()
542 {
543  return std::make_unique<const CTestNetParams>();
544 }
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:12
static constexpr CAmount COIN
The amount of satoshis in one BTC.
Definition: amount.h:15
static const uint8_t chainparams_seed_test[]
static const uint8_t chainparams_seed_main[]
List of fixed seed nodes for the bitcoin network AUTOGENERATED by contrib/seeds/generate-seeds....
uint32_t nNonce
Definition: block.h:30
uint32_t nBits
Definition: block.h:29
uint32_t nTime
Definition: block.h:28
int32_t nVersion
Definition: block.h:25
uint256 hashPrevBlock
Definition: block.h:26
uint256 hashMerkleRoot
Definition: block.h:27
uint256 GetHash() const
Definition: block.cpp:11
Definition: block.h:69
std::vector< CTransactionRef > vtx
Definition: block.h:72
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system.
Definition: chainparams.h:81
uint64_t m_assumed_chain_state_size
Definition: chainparams.h:172
MessageStartChars pchMessageStart
Definition: chainparams.h:168
static std::unique_ptr< const CChainParams > Main()
std::string bech32_hrp
Definition: chainparams.h:175
static std::unique_ptr< const CChainParams > RegTest(const RegTestOptions &options)
CBlock genesis
Definition: chainparams.h:177
uint64_t m_assumed_blockchain_size
Definition: chainparams.h:171
std::vector< uint8_t > vFixedSeeds
Definition: chainparams.h:178
bool fDefaultConsistencyChecks
Definition: chainparams.h:179
static std::unique_ptr< const CChainParams > TestNet()
std::vector< unsigned char > base58Prefixes[MAX_BASE58_TYPES]
Definition: chainparams.h:174
Consensus::Params consensus
Definition: chainparams.h:167
std::vector< AssumeutxoData > m_assumeutxo_data
Definition: chainparams.h:182
std::vector< std::string > vSeeds
Definition: chainparams.h:173
bool m_is_mockable_chain
Definition: chainparams.h:180
ChainType m_chain_type
Definition: chainparams.h:176
CCheckpointData checkpointData
Definition: chainparams.h:181
uint16_t nDefaultPort
Definition: chainparams.h:169
static std::unique_ptr< const CChainParams > SigNet(const SigNetOptions &options)
uint64_t nPruneAfterHeight
Definition: chainparams.h:170
ChainTxData chainTxData
Definition: chainparams.h:183
Main network on which people trade goods and services.
Definition: chainparams.cpp:71
Regression test: intended for private networks only.
CRegTestParams(const RegTestOptions &opts)
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:414
Testnet (v3): public test network which is reset from time to time.
A writer stream (for serialization) that computes a 256-bit hash.
Definition: hash.h:101
Signet: test network with an additional consensus parameter (see BIP325).
SigNetParams(const SigNetOptions &options)
constexpr unsigned char * begin()
Definition: uint256.h:68
constexpr void SetNull()
Definition: uint256.h:49
256-bit opaque blob.
Definition: uint256.h:106
@ SCRIPT_VERIFY_P2SH
Definition: interpreter.h:49
@ SCRIPT_VERIFY_WITNESS
Definition: interpreter.h:108
@ SCRIPT_VERIFY_NONE
Definition: interpreter.h:46
static CBlock CreateGenesisBlock(const char *pszTimestamp, const CScript &genesisOutputScript, uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount &genesisReward)
Definition: chainparams.cpp:29
#define LogPrintf(...)
Definition: logging.h:245
uint256 BlockMerkleRoot(const CBlock &block, bool *mutated)
Definition: merkle.cpp:65
@ DEPLOYMENT_TAPROOT
Definition: params.h:34
@ DEPLOYMENT_TESTDUMMY
Definition: params.h:33
@ DEPLOYMENT_DERSIG
Definition: params.h:26
@ DEPLOYMENT_CSV
Definition: params.h:27
@ DEPLOYMENT_SEGWIT
Definition: params.h:28
@ DEPLOYMENT_HEIGHTINCB
Definition: params.h:24
@ DEPLOYMENT_CLTV
Definition: params.h:25
static CTransactionRef MakeTransactionRef(Tx &&txIn)
Definition: transaction.h:424
@ OP_CHECKSIG
Definition: script.h:189
std::vector< Byte > ParseHex(std::string_view hex_str)
Like TryParseHex, but returns an empty vector on invalid input.
Definition: strencodings.h:65
RegTestOptions holds configurations for creating a regtest CChainParams.
Definition: chainparams.h:153
std::unordered_map< Consensus::DeploymentPos, VersionBitsParameters > version_bits_parameters
Definition: chainparams.h:154
std::unordered_map< Consensus::BuriedDeployment, int > activation_heights
Definition: chainparams.h:155
SigNetOptions holds configurations for creating a signet CChainParams.
Definition: chainparams.h:136
std::optional< std::vector< uint8_t > > challenge
Definition: chainparams.h:137
std::optional< std::vector< std::string > > seeds
Definition: chainparams.h:138
A mutable version of CTransaction.
Definition: transaction.h:378
std::vector< CTxOut > vout
Definition: transaction.h:380
std::vector< CTxIn > vin
Definition: transaction.h:379
Holds various statistics on transactions within a chain.
Definition: chainparams.h:70
int64_t nTime
UNIX timestamp of last known number of transactions.
Definition: chainparams.h:71
int min_activation_height
If lock in occurs, delay activation until at least this block height.
Definition: params.h:54
int bit
Bit position to select the particular bit in nVersion.
Definition: params.h:45
static constexpr int64_t ALWAYS_ACTIVE
Special value for nStartTime indicating that the deployment is always active.
Definition: params.h:63
static constexpr int64_t NEVER_ACTIVE
Special value for nStartTime indicating that the deployment is never active.
Definition: params.h:68
int64_t nTimeout
Timeout/expiry MedianTime for the deployment attempt.
Definition: params.h:49
static constexpr int64_t NO_TIMEOUT
Constant for nTimeout very far in the future.
Definition: params.h:57
int64_t nStartTime
Start MedianTime for version bits miner confirmation.
Definition: params.h:47
int BIP65Height
Block height at which BIP65 becomes active.
Definition: params.h:88
int CSVHeight
Block height at which CSV (BIP68, BIP112 and BIP113) becomes active.
Definition: params.h:92
uint256 BIP34Hash
Definition: params.h:86
uint32_t nMinerConfirmationWindow
Definition: params.h:106
uint256 defaultAssumeValid
By default assume that the signatures in ancestors of this block are valid.
Definition: params.h:122
std::map< uint256, uint32_t > script_flag_exceptions
Hashes of blocks that.
Definition: params.h:83
std::vector< uint8_t > signet_challenge
Definition: params.h:129
bool signet_blocks
If true, witness commitments contain a payload equal to a Bitcoin Script solution to the signet chall...
Definition: params.h:128
int SegwitHeight
Block height at which Segwit (BIP141, BIP143 and BIP147) becomes active.
Definition: params.h:96
int BIP34Height
Block height and hash at which BIP34 becomes active.
Definition: params.h:85
int nSubsidyHalvingInterval
Definition: params.h:76
BIP9Deployment vDeployments[MAX_VERSION_BITS_DEPLOYMENTS]
Definition: params.h:107
uint256 hashGenesisBlock
Definition: params.h:75
int MinBIP9WarningHeight
Don't warn about unknown BIP 9 activations below this height.
Definition: params.h:99
bool fPowNoRetargeting
Definition: params.h:111
uint256 nMinimumChainWork
The best chain should have at least this much work.
Definition: params.h:120
uint32_t nRuleChangeActivationThreshold
Minimum blocks including miner confirmation of the total of 2016 blocks in a retargeting period,...
Definition: params.h:105
int64_t nPowTargetTimespan
Definition: params.h:113
int BIP66Height
Block height at which BIP66 becomes active.
Definition: params.h:90
uint256 powLimit
Proof of work parameters.
Definition: params.h:109
int64_t nPowTargetSpacing
Definition: params.h:112
bool fPowAllowMinDifficultyBlocks
Definition: params.h:110
uint256 uint256S(const char *str)
Definition: uint256.h:119
std::string HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
assert(!tx.IsCoinBase())