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.version = 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-list-of-p2p-nodes.us."); // 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  vSeeds.emplace_back("seed.mainnet.achownodes.xyz."); // Ava Chow, only supports x1, x5, x9, x49, x809, x849, xd, x400, x404, x408, x448, xc08, xc48, x40c
144 
145  base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,0);
146  base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,5);
147  base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,128);
148  base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x88, 0xB2, 0x1E};
149  base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4};
150 
151  bech32_hrp = "bc";
152 
153  vFixedSeeds = std::vector<uint8_t>(std::begin(chainparams_seed_main), std::end(chainparams_seed_main));
154 
156  m_is_mockable_chain = false;
157 
158  checkpointData = {
159  {
160  { 11111, uint256S("0x0000000069e244f73d78e8fd29ba2fd2ed618bd6fa2ee92559f542fdb26e7c1d")},
161  { 33333, uint256S("0x000000002dd5588a74784eaa7ab0507a18ad16a236e7b1ce69f00d7ddfb5d0a6")},
162  { 74000, uint256S("0x0000000000573993a3c9e41ce34471c079dcf5f52a0e824a81e7f953b8661a20")},
163  {105000, uint256S("0x00000000000291ce28027faea320c8d2b054b2e0fe44a773f3eefb151d6bdc97")},
164  {134444, uint256S("0x00000000000005b12ffd4cd315cd34ffd4a594f430ac814c91184a0d42d2b0fe")},
165  {168000, uint256S("0x000000000000099e61ea72015e79632f216fe6cb33d7899acb35b75c8303b763")},
166  {193000, uint256S("0x000000000000059f452a5f7340de6682a977387c17010ff6e6c3bd83ca8b1317")},
167  {210000, uint256S("0x000000000000048b95347e83192f69cf0366076336c639f9b7228e9ba171342e")},
168  {216116, uint256S("0x00000000000001b4f4b433e81ee46494af945cf96014816a4e2370f11b23df4e")},
169  {225430, uint256S("0x00000000000001c108384350f74090433e7fcf79a606b8e797f065b130575932")},
170  {250000, uint256S("0x000000000000003887df1f29024b06fc2200b55f8af8f35453d7be294df2d214")},
171  {279000, uint256S("0x0000000000000001ae8c72a0b0c301f67e3afca10e819efa9041e458e9bd7e40")},
172  {295000, uint256S("0x00000000000000004d9b4ef50f0f9d686fd69db2e03af35a100370c64632a983")},
173  }
174  };
175 
177  // TODO to be specified in a future patch.
178  };
179 
181  // Data from RPC: getchaintxstats 4096 000000000000000000026811d149d4d261995ec5b3f64f439a0a10e1a464af9a
182  .nTime = 1704194835,
183  .nTxCount = 946728933,
184  .dTxRate = 6.569290261471664,
185  };
186  }
187 };
188 
192 class CTestNetParams : public CChainParams {
193 public:
196  consensus.signet_blocks = false;
197  consensus.signet_challenge.clear();
199  consensus.script_flag_exceptions.emplace( // BIP16 exception
200  uint256S("0x00000000dd30457c001f4095d208cc1296b0eed002427aa599874af7a432b105"), SCRIPT_VERIFY_NONE);
201  consensus.BIP34Height = 21111;
202  consensus.BIP34Hash = uint256S("0x0000000023b3a96d3484e5abb3755c413e7d41500f8e2a5c3f0dd01299cd8ef8");
203  consensus.BIP65Height = 581885; // 00000000007f6655f22f98e72ed80d8b06dc761d5da09df0fa1dc4be4f861eb6
204  consensus.BIP66Height = 330776; // 000000002104c8c45e99a8853285a3b592602a3ccde2b832481da85e9e4ba182
205  consensus.CSVHeight = 770112; // 00000000025e930139bac5c6c31a403776da130831ab85be56578f3fa75369bb
206  consensus.SegwitHeight = 834624; // 00000000002b980fcd729daaa248fd9316a5200e9b367f4ff2c42453e84201ca
207  consensus.MinBIP9WarningHeight = 836640; // segwit activation height + miner confirmation window
208  consensus.powLimit = uint256S("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
209  consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
210  consensus.nPowTargetSpacing = 10 * 60;
213  consensus.nRuleChangeActivationThreshold = 1512; // 75% for testchains
214  consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
219 
220  // Deployment of Taproot (BIPs 340-342)
222  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartTime = 1619222400; // April 24th, 2021
223  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeout = 1628640000; // August 11th, 2021
225 
226  consensus.nMinimumChainWork = uint256S("0x000000000000000000000000000000000000000000000c59b14e264ba6c15db9");
227  consensus.defaultAssumeValid = uint256S("0x000000000001323071f38f21ea5aae529ece491eadaccce506a59bcc2d968917"); // 2550000
228 
229  pchMessageStart[0] = 0x0b;
230  pchMessageStart[1] = 0x11;
231  pchMessageStart[2] = 0x09;
232  pchMessageStart[3] = 0x07;
233  nDefaultPort = 18333;
234  nPruneAfterHeight = 1000;
237 
238  genesis = CreateGenesisBlock(1296688602, 414098458, 0x1d00ffff, 1, 50 * COIN);
240  assert(consensus.hashGenesisBlock == uint256S("0x000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"));
241  assert(genesis.hashMerkleRoot == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
242 
243  vFixedSeeds.clear();
244  vSeeds.clear();
245  // nodes with support for servicebits filtering should be at the top
246  vSeeds.emplace_back("testnet-seed.bitcoin.jonasschnelli.ch.");
247  vSeeds.emplace_back("seed.tbtc.petertodd.net.");
248  vSeeds.emplace_back("seed.testnet.bitcoin.sprovoost.nl.");
249  vSeeds.emplace_back("testnet-seed.bluematt.me."); // Just a static list of stable node(s), only supports x9
250  vSeeds.emplace_back("seed.testnet.achownodes.xyz."); // Ava Chow, only supports x1, x5, x9, x49, x809, x849, xd, x400, x404, x408, x448, xc08, xc48, x40c
251 
252  base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
253  base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
254  base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,239);
255  base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
256  base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
257 
258  bech32_hrp = "tb";
259 
260  vFixedSeeds = std::vector<uint8_t>(std::begin(chainparams_seed_test), std::end(chainparams_seed_test));
261 
263  m_is_mockable_chain = false;
264 
265  checkpointData = {
266  {
267  {546, uint256S("000000002a936ca763904c3c35fce2f3556c559c0214345d31b1bcebf76acb70")},
268  }
269  };
270 
272  {
273  .height = 2'500'000,
274  .hash_serialized = AssumeutxoHash{uint256S("0xf841584909f68e47897952345234e37fcd9128cd818f41ee6c3ca68db8071be7")},
275  .nChainTx = 66484552,
276  .blockhash = uint256S("0x0000000000000093bcb68c03a9a168ae252572d348a2eaeba2cdf9231d73206f")
277  }
278  };
279 
281  // Data from RPC: getchaintxstats 4096 000000000001323071f38f21ea5aae529ece491eadaccce506a59bcc2d968917
282  .nTime = 1703579240,
283  .nTxCount = 67845391,
284  .dTxRate = 1.464436832560951,
285  };
286  }
287 };
288 
292 class SigNetParams : public CChainParams {
293 public:
294  explicit SigNetParams(const SigNetOptions& options)
295  {
296  std::vector<uint8_t> bin;
297  vSeeds.clear();
298 
299  if (!options.challenge) {
300  bin = ParseHex("512103ad5e0edad18cb1f0fc0d28a3d4f1f3e445640337489abb10404f2d1e086be430210359ef5021964fe22d6f8e05b2463c9540ce96883fe3b278760f048f5189f2e6c452ae");
301  vSeeds.emplace_back("seed.signet.bitcoin.sprovoost.nl.");
302  vSeeds.emplace_back("seed.signet.achownodes.xyz."); // Ava Chow, only supports x1, x5, x9, x49, x809, x849, xd, x400, x404, x408, x448, xc08, xc48, x40c
303 
304  // Hardcoded nodes can be removed once there are more DNS seeds
305  vSeeds.emplace_back("178.128.221.177");
306  vSeeds.emplace_back("v7ajjeirttkbnt32wpy3c6w3emwnfr3fkla7hpxcfokr3ysd3kqtzmqd.onion:38333");
307 
308  consensus.nMinimumChainWork = uint256S("0x00000000000000000000000000000000000000000000000000000206e86f08e8");
309  consensus.defaultAssumeValid = uint256S("0x0000000870f15246ba23c16e370a7ffb1fc8a3dcf8cb4492882ed4b0e3d4cd26"); // 180000
313  // Data from RPC: getchaintxstats 4096 0000000870f15246ba23c16e370a7ffb1fc8a3dcf8cb4492882ed4b0e3d4cd26
314  .nTime = 1706331472,
315  .nTxCount = 2425380,
316  .dTxRate = 0.008277759863833788,
317  };
318  } else {
319  bin = *options.challenge;
325  0,
326  0,
327  0,
328  };
329  LogPrintf("Signet with challenge %s\n", HexStr(bin));
330  }
331 
332  if (options.seeds) {
333  vSeeds = *options.seeds;
334  }
335 
337  consensus.signet_blocks = true;
338  consensus.signet_challenge.assign(bin.begin(), bin.end());
344  consensus.CSVHeight = 1;
346  consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
347  consensus.nPowTargetSpacing = 10 * 60;
350  consensus.nRuleChangeActivationThreshold = 1815; // 90% of 2016
351  consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
353  consensus.powLimit = uint256S("00000377ae000000000000000000000000000000000000000000000000000000");
358 
359  // Activation of Taproot (BIPs 340-342)
364 
365  // message start is defined as the first 4 bytes of the sha256d of the block script
366  HashWriter h{};
368  uint256 hash = h.GetHash();
369  std::copy_n(hash.begin(), 4, pchMessageStart.begin());
370 
371  nDefaultPort = 38333;
372  nPruneAfterHeight = 1000;
373 
374  genesis = CreateGenesisBlock(1598918400, 52613770, 0x1e0377ae, 1, 50 * COIN);
376  assert(consensus.hashGenesisBlock == uint256S("0x00000008819873e925422c1ff0f99f7cc9bbb232af63a077a480a3633bee1ef6"));
377  assert(genesis.hashMerkleRoot == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
378 
379  vFixedSeeds.clear();
380 
382  {
383  .height = 160'000,
384  .hash_serialized = AssumeutxoHash{uint256S("0xfe0a44309b74d6b5883d246cb419c6221bcccf0b308c9b59b7d70783dbdf928a")},
385  .nChainTx = 2289496,
386  .blockhash = uint256S("0x0000003ca3c99aff040f2563c2ad8f8ec88bd0fd6b8f0895cfaf1ef90353a62c")
387  }
388  };
389 
390  base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
391  base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
392  base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,239);
393  base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
394  base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
395 
396  bech32_hrp = "tb";
397 
399  m_is_mockable_chain = false;
400  }
401 };
402 
408 {
409 public:
410  explicit CRegTestParams(const RegTestOptions& opts)
411  {
413  consensus.signet_blocks = false;
414  consensus.signet_challenge.clear();
416  consensus.BIP34Height = 1; // Always active unless overridden
418  consensus.BIP65Height = 1; // Always active unless overridden
419  consensus.BIP66Height = 1; // Always active unless overridden
420  consensus.CSVHeight = 1; // Always active unless overridden
421  consensus.SegwitHeight = 0; // Always active unless overridden
423  consensus.powLimit = uint256S("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
424  consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
425  consensus.nPowTargetSpacing = 10 * 60;
428  consensus.nRuleChangeActivationThreshold = 108; // 75% for testchains
429  consensus.nMinerConfirmationWindow = 144; // Faster than normal for regtest (144 instead of 2016)
430 
435 
440 
443 
444  pchMessageStart[0] = 0xfa;
445  pchMessageStart[1] = 0xbf;
446  pchMessageStart[2] = 0xb5;
447  pchMessageStart[3] = 0xda;
448  nDefaultPort = 18444;
449  nPruneAfterHeight = opts.fastprune ? 100 : 1000;
452 
453  for (const auto& [dep, height] : opts.activation_heights) {
454  switch (dep) {
456  consensus.SegwitHeight = int{height};
457  break;
459  consensus.BIP34Height = int{height};
460  break;
462  consensus.BIP66Height = int{height};
463  break;
465  consensus.BIP65Height = int{height};
466  break;
468  consensus.CSVHeight = int{height};
469  break;
470  }
471  }
472 
473  for (const auto& [deployment_pos, version_bits_params] : opts.version_bits_parameters) {
474  consensus.vDeployments[deployment_pos].nStartTime = version_bits_params.start_time;
475  consensus.vDeployments[deployment_pos].nTimeout = version_bits_params.timeout;
476  consensus.vDeployments[deployment_pos].min_activation_height = version_bits_params.min_activation_height;
477  }
478 
479  genesis = CreateGenesisBlock(1296688602, 2, 0x207fffff, 1, 50 * COIN);
481  assert(consensus.hashGenesisBlock == uint256S("0x0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"));
482  assert(genesis.hashMerkleRoot == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
483 
484  vFixedSeeds.clear();
485  vSeeds.clear();
486  vSeeds.emplace_back("dummySeed.invalid.");
487 
489  m_is_mockable_chain = true;
490 
491  checkpointData = {
492  {
493  {0, uint256S("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206")},
494  }
495  };
496 
498  { // For use by unit tests
499  .height = 110,
500  .hash_serialized = AssumeutxoHash{uint256S("0x6657b736d4fe4db0cbc796789e812d5dba7f5c143764b1b6905612f1830609d1")},
501  .nChainTx = 111,
502  .blockhash = uint256S("0x696e92821f65549c7ee134edceeeeaaa4105647a3c4fd9f298c0aec0ab50425c")
503  },
504  {
505  // For use by fuzz target src/test/fuzz/utxo_snapshot.cpp
506  .height = 200,
507  .hash_serialized = AssumeutxoHash{uint256S("0x4f34d431c3e482f6b0d67b64609ece3964dc8d7976d02ac68dd7c9c1421738f2")},
508  .nChainTx = 201,
509  .blockhash = uint256S("0x5e93653318f294fb5aa339d00bbf8cf1c3515488ad99412c37608b139ea63b27"),
510  },
511  {
512  // For use by test/functional/feature_assumeutxo.py
513  .height = 299,
514  .hash_serialized = AssumeutxoHash{uint256S("0xa4bf3407ccb2cc0145c49ebba8fa91199f8a3903daf0883875941497d2493c27")},
515  .nChainTx = 334,
516  .blockhash = uint256S("0x3bb7ce5eba0be48939b7a521ac1ba9316afee2c7bada3a0cca24188e6d7d96c0")
517  },
518  };
519 
521  0,
522  0,
523  0
524  };
525 
526  base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
527  base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
528  base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,239);
529  base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
530  base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
531 
532  bech32_hrp = "bcrt";
533  }
534 };
535 
536 std::unique_ptr<const CChainParams> CChainParams::SigNet(const SigNetOptions& options)
537 {
538  return std::make_unique<const SigNetParams>(options);
539 }
540 
541 std::unique_ptr<const CChainParams> CChainParams::RegTest(const RegTestOptions& options)
542 {
543  return std::make_unique<const CRegTestParams>(options);
544 }
545 
546 std::unique_ptr<const CChainParams> CChainParams::Main()
547 {
548  return std::make_unique<const CMainParams>();
549 }
550 
551 std::unique_ptr<const CChainParams> CChainParams::TestNet()
552 {
553  return std::make_unique<const CTestNetParams>();
554 }
555 
557 {
558  std::vector<int> heights;
559  heights.reserve(m_assumeutxo_data.size());
560 
561  for (const auto& data : m_assumeutxo_data) {
562  heights.emplace_back(data.height);
563  }
564  return heights;
565 }
566 
567 std::optional<ChainType> GetNetworkForMagic(const MessageStartChars& message)
568 {
569  const auto mainnet_msg = CChainParams::Main()->MessageStart();
570  const auto testnet_msg = CChainParams::TestNet()->MessageStart();
571  const auto regtest_msg = CChainParams::RegTest({})->MessageStart();
572  const auto signet_msg = CChainParams::SigNet({})->MessageStart();
573 
574  if (std::equal(message.begin(), message.end(), mainnet_msg.data())) {
575  return ChainType::MAIN;
576  } else if (std::equal(message.begin(), message.end(), testnet_msg.data())) {
577  return ChainType::TESTNET;
578  } else if (std::equal(message.begin(), message.end(), regtest_msg.data())) {
579  return ChainType::REGTEST;
580  } else if (std::equal(message.begin(), message.end(), signet_msg.data())) {
581  return ChainType::SIGNET;
582  }
583  return std::nullopt;
584 }
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:173
MessageStartChars pchMessageStart
Definition: chainparams.h:169
static std::unique_ptr< const CChainParams > Main()
std::string bech32_hrp
Definition: chainparams.h:176
std::vector< int > GetAvailableSnapshotHeights() const
static std::unique_ptr< const CChainParams > RegTest(const RegTestOptions &options)
CBlock genesis
Definition: chainparams.h:178
uint64_t m_assumed_blockchain_size
Definition: chainparams.h:172
std::vector< uint8_t > vFixedSeeds
Definition: chainparams.h:179
bool fDefaultConsistencyChecks
Definition: chainparams.h:180
static std::unique_ptr< const CChainParams > TestNet()
std::vector< unsigned char > base58Prefixes[MAX_BASE58_TYPES]
Definition: chainparams.h:175
Consensus::Params consensus
Definition: chainparams.h:168
std::vector< AssumeutxoData > m_assumeutxo_data
Definition: chainparams.h:183
std::vector< std::string > vSeeds
Definition: chainparams.h:174
bool m_is_mockable_chain
Definition: chainparams.h:181
ChainType m_chain_type
Definition: chainparams.h:177
CCheckpointData checkpointData
Definition: chainparams.h:182
uint16_t nDefaultPort
Definition: chainparams.h:170
static std::unique_ptr< const CChainParams > SigNet(const SigNetOptions &options)
uint64_t nPruneAfterHeight
Definition: chainparams.h:171
ChainTxData chainTxData
Definition: chainparams.h:184
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
std::string HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
Definition: hex_base.cpp:29
@ SCRIPT_VERIFY_P2SH
Definition: interpreter.h:49
@ SCRIPT_VERIFY_WITNESS
Definition: interpreter.h:108
@ SCRIPT_VERIFY_NONE
Definition: interpreter.h:46
std::optional< ChainType > GetNetworkForMagic(const MessageStartChars &message)
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:244
uint256 BlockMerkleRoot(const CBlock &block, bool *mutated)
Definition: merkle.cpp:65
std::array< uint8_t, 4 > MessageStartChars
@ 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:66
RegTestOptions holds configurations for creating a regtest CChainParams.
Definition: chainparams.h:154
std::unordered_map< Consensus::DeploymentPos, VersionBitsParameters > version_bits_parameters
Definition: chainparams.h:155
std::unordered_map< Consensus::BuriedDeployment, int > activation_heights
Definition: chainparams.h:156
SigNetOptions holds configurations for creating a signet CChainParams.
Definition: chainparams.h:137
std::optional< std::vector< uint8_t > > challenge
Definition: chainparams.h:138
std::optional< std::vector< std::string > > seeds
Definition: chainparams.h:139
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
assert(!tx.IsCoinBase())