Bitcoin Core  25.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>
13 #include <logging.h>
14 #include <primitives/block.h>
15 #include <primitives/transaction.h>
16 #include <script/interpreter.h>
17 #include <script/script.h>
18 #include <uint256.h>
19 #include <util/chaintype.h>
20 #include <util/strencodings.h>
21 
22 #include <algorithm>
23 #include <cassert>
24 #include <cstdint>
25 #include <cstring>
26 #include <type_traits>
27 
28 static CBlock CreateGenesisBlock(const char* pszTimestamp, const CScript& genesisOutputScript, uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
29 {
30  CMutableTransaction txNew;
31  txNew.nVersion = 1;
32  txNew.vin.resize(1);
33  txNew.vout.resize(1);
34  txNew.vin[0].scriptSig = CScript() << 486604799 << CScriptNum(4) << std::vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
35  txNew.vout[0].nValue = genesisReward;
36  txNew.vout[0].scriptPubKey = genesisOutputScript;
37 
38  CBlock genesis;
39  genesis.nTime = nTime;
40  genesis.nBits = nBits;
41  genesis.nNonce = nNonce;
42  genesis.nVersion = nVersion;
43  genesis.vtx.push_back(MakeTransactionRef(std::move(txNew)));
44  genesis.hashPrevBlock.SetNull();
45  genesis.hashMerkleRoot = BlockMerkleRoot(genesis);
46  return genesis;
47 }
48 
60 static CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
61 {
62  const char* pszTimestamp = "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks";
63  const CScript genesisOutputScript = CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") << OP_CHECKSIG;
64  return CreateGenesisBlock(pszTimestamp, genesisOutputScript, nTime, nNonce, nBits, nVersion, genesisReward);
65 }
66 
70 class CMainParams : public CChainParams {
71 public:
72  CMainParams() {
73  m_chain_type = ChainType::MAIN;
74  consensus.signet_blocks = false;
75  consensus.signet_challenge.clear();
76  consensus.nSubsidyHalvingInterval = 210000;
77  consensus.script_flag_exceptions.emplace( // BIP16 exception
78  uint256S("0x00000000000002dc756eebf4f49723ed8d30cc28a5f108eb94b1ba88ac4f9c22"), SCRIPT_VERIFY_NONE);
79  consensus.script_flag_exceptions.emplace( // Taproot exception
80  uint256S("0x0000000000000000000f14c35b2d841e986ab5441de8c585d5ffe55ea1e395ad"), SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS);
81  consensus.BIP34Height = 227931;
82  consensus.BIP34Hash = uint256S("0x000000000000024b89b42a942fe0d9fea3bb44ab7bd1b19115dd6a759c0808b8");
83  consensus.BIP65Height = 388381; // 000000000000000004c2b624ed5d7756c508d90fd0da2c7c679febfa6c4735f0
84  consensus.BIP66Height = 363725; // 00000000000000000379eaa19dce8c9b722d46ae6a57c2f1a988119488b50931
85  consensus.CSVHeight = 419328; // 000000000000000004a1b34462cb8aeebd5799177f7a29cf28f2d1961716b5b5
86  consensus.SegwitHeight = 481824; // 0000000000000000001c8018d9cb3b742ef25114f27563e3fc4a1902167f9893
87  consensus.MinBIP9WarningHeight = 483840; // segwit activation height + miner confirmation window
88  consensus.powLimit = uint256S("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
89  consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
90  consensus.nPowTargetSpacing = 10 * 60;
91  consensus.fPowAllowMinDifficultyBlocks = false;
92  consensus.fPowNoRetargeting = false;
93  consensus.nRuleChangeActivationThreshold = 1815; // 90% of 2016
94  consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
95  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
96  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE;
97  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
98  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].min_activation_height = 0; // No activation delay
99 
100  // Deployment of Taproot (BIPs 340-342)
101  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].bit = 2;
102  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartTime = 1619222400; // April 24th, 2021
103  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeout = 1628640000; // August 11th, 2021
104  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 709632; // Approximately November 12th, 2021
105 
106  consensus.nMinimumChainWork = uint256S("0x000000000000000000000000000000000000000044a50fe819c39ad624021859");
107  consensus.defaultAssumeValid = uint256S("0x000000000000000000035c3f0d31e71a5ee24c5aaf3354689f65bd7b07dee632"); // 784000
108 
114  pchMessageStart[0] = 0xf9;
115  pchMessageStart[1] = 0xbe;
116  pchMessageStart[2] = 0xb4;
117  pchMessageStart[3] = 0xd9;
118  nDefaultPort = 8333;
119  nPruneAfterHeight = 100000;
120  m_assumed_blockchain_size = 540;
121  m_assumed_chain_state_size = 7;
122 
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"));
127 
128  // Note that of those which support the service bits prefix, most only support a subset of
129  // possible options.
130  // This is fine at runtime as we'll fall back to using them as an addrfetch if they don't support the
131  // service bits we want, but we should get them updated to support all service bits wanted by any
132  // release ASAP to avoid it where possible.
133  vSeeds.emplace_back("seed.bitcoin.sipa.be."); // Pieter Wuille, only supports x1, x5, x9, and xd
134  vSeeds.emplace_back("dnsseed.bluematt.me."); // Matt Corallo, only supports x9
135  vSeeds.emplace_back("dnsseed.bitcoin.dashjr.org."); // Luke Dashjr
136  vSeeds.emplace_back("seed.bitcoinstats.com."); // Christian Decker, supports x1 - xf
137  vSeeds.emplace_back("seed.bitcoin.jonasschnelli.ch."); // Jonas Schnelli, only supports x1, x5, x9, and xd
138  vSeeds.emplace_back("seed.btc.petertodd.org."); // Peter Todd, only supports x1, x5, x9, and xd
139  vSeeds.emplace_back("seed.bitcoin.sprovoost.nl."); // Sjors Provoost
140  vSeeds.emplace_back("dnsseed.emzy.de."); // Stephan Oeste
141  vSeeds.emplace_back("seed.bitcoin.wiz.biz."); // Jason Maurice
142 
143  base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,0);
144  base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,5);
145  base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,128);
146  base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x88, 0xB2, 0x1E};
147  base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4};
148 
149  bech32_hrp = "bc";
150 
151  vFixedSeeds = std::vector<uint8_t>(std::begin(chainparams_seed_main), std::end(chainparams_seed_main));
152 
153  fDefaultConsistencyChecks = false;
154  fRequireStandard = true;
155  m_is_test_chain = false;
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 
176  m_assumeutxo_data = MapAssumeutxo{
177  // TODO to be specified in a future patch.
178  };
179 
180  chainTxData = ChainTxData{
181  // Data from RPC: getchaintxstats 4096 000000000000000000035c3f0d31e71a5ee24c5aaf3354689f65bd7b07dee632
182  .nTime = 1680665245,
183  .nTxCount = 820876044,
184  .dTxRate = 3.672283614033389,
185  };
186  }
187 };
188 
192 class CTestNetParams : public CChainParams {
193 public:
194  CTestNetParams() {
195  m_chain_type = ChainType::TESTNET;
196  consensus.signet_blocks = false;
197  consensus.signet_challenge.clear();
198  consensus.nSubsidyHalvingInterval = 210000;
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;
211  consensus.fPowAllowMinDifficultyBlocks = true;
212  consensus.fPowNoRetargeting = false;
213  consensus.nRuleChangeActivationThreshold = 1512; // 75% for testchains
214  consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
215  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
216  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE;
217  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
218  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].min_activation_height = 0; // No activation delay
219 
220  // Deployment of Taproot (BIPs 340-342)
221  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].bit = 2;
222  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartTime = 1619222400; // April 24th, 2021
223  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeout = 1628640000; // August 11th, 2021
224  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 0; // No activation delay
225 
226  consensus.nMinimumChainWork = uint256S("0x000000000000000000000000000000000000000000000977edb0244170858d07");
227  consensus.defaultAssumeValid = uint256S("0x0000000000000021bc50a89cde4870d4a81ffe0153b3c8de77b435a2fd3f6761"); // 2429000
228 
229  pchMessageStart[0] = 0x0b;
230  pchMessageStart[1] = 0x11;
231  pchMessageStart[2] = 0x09;
232  pchMessageStart[3] = 0x07;
233  nDefaultPort = 18333;
234  nPruneAfterHeight = 1000;
235  m_assumed_blockchain_size = 42;
236  m_assumed_chain_state_size = 3;
237 
238  genesis = CreateGenesisBlock(1296688602, 414098458, 0x1d00ffff, 1, 50 * COIN);
239  consensus.hashGenesisBlock = genesis.GetHash();
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.org.");
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 
251  base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
252  base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
253  base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,239);
254  base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
255  base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
256 
257  bech32_hrp = "tb";
258 
259  vFixedSeeds = std::vector<uint8_t>(std::begin(chainparams_seed_test), std::end(chainparams_seed_test));
260 
261  fDefaultConsistencyChecks = false;
262  fRequireStandard = false;
263  m_is_test_chain = true;
264  m_is_mockable_chain = false;
265 
266  checkpointData = {
267  {
268  {546, uint256S("000000002a936ca763904c3c35fce2f3556c559c0214345d31b1bcebf76acb70")},
269  }
270  };
271 
272  m_assumeutxo_data = MapAssumeutxo{
273  // TODO to be specified in a future patch.
274  };
275 
276  chainTxData = ChainTxData{
277  // Data from RPC: getchaintxstats 4096 0000000000000021bc50a89cde4870d4a81ffe0153b3c8de77b435a2fd3f6761
278  .nTime = 1681542696,
279  .nTxCount = 65345929,
280  .dTxRate = 0.09855282814711661,
281  };
282  }
283 };
284 
288 class SigNetParams : public CChainParams {
289 public:
290  explicit SigNetParams(const SigNetOptions& options)
291  {
292  std::vector<uint8_t> bin;
293  vSeeds.clear();
294 
295  if (!options.challenge) {
296  bin = ParseHex("512103ad5e0edad18cb1f0fc0d28a3d4f1f3e445640337489abb10404f2d1e086be430210359ef5021964fe22d6f8e05b2463c9540ce96883fe3b278760f048f5189f2e6c452ae");
297  vSeeds.emplace_back("seed.signet.bitcoin.sprovoost.nl.");
298 
299  // Hardcoded nodes can be removed once there are more DNS seeds
300  vSeeds.emplace_back("178.128.221.177");
301  vSeeds.emplace_back("v7ajjeirttkbnt32wpy3c6w3emwnfr3fkla7hpxcfokr3ysd3kqtzmqd.onion:38333");
302 
303  consensus.nMinimumChainWork = uint256S("0x000000000000000000000000000000000000000000000000000001899d8142b0");
304  consensus.defaultAssumeValid = uint256S("0x0000004429ef154f7e00b4f6b46bfbe2d2678ecd351d95bbfca437ab9a5b84ec"); // 138000
305  m_assumed_blockchain_size = 1;
306  m_assumed_chain_state_size = 0;
307  chainTxData = ChainTxData{
308  // Data from RPC: getchaintxstats 4096 0000004429ef154f7e00b4f6b46bfbe2d2678ecd351d95bbfca437ab9a5b84ec
309  .nTime = 1681127428,
310  .nTxCount = 2226359,
311  .dTxRate = 0.006424463050600656,
312  };
313  } else {
314  bin = *options.challenge;
315  consensus.nMinimumChainWork = uint256{};
316  consensus.defaultAssumeValid = uint256{};
317  m_assumed_blockchain_size = 0;
318  m_assumed_chain_state_size = 0;
319  chainTxData = ChainTxData{
320  0,
321  0,
322  0,
323  };
324  LogPrintf("Signet with challenge %s\n", HexStr(bin));
325  }
326 
327  if (options.seeds) {
328  vSeeds = *options.seeds;
329  }
330 
331  m_chain_type = ChainType::SIGNET;
332  consensus.signet_blocks = true;
333  consensus.signet_challenge.assign(bin.begin(), bin.end());
334  consensus.nSubsidyHalvingInterval = 210000;
335  consensus.BIP34Height = 1;
336  consensus.BIP34Hash = uint256{};
337  consensus.BIP65Height = 1;
338  consensus.BIP66Height = 1;
339  consensus.CSVHeight = 1;
340  consensus.SegwitHeight = 1;
341  consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
342  consensus.nPowTargetSpacing = 10 * 60;
343  consensus.fPowAllowMinDifficultyBlocks = false;
344  consensus.fPowNoRetargeting = false;
345  consensus.nRuleChangeActivationThreshold = 1815; // 90% of 2016
346  consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
347  consensus.MinBIP9WarningHeight = 0;
348  consensus.powLimit = uint256S("00000377ae000000000000000000000000000000000000000000000000000000");
349  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
350  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE;
351  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
352  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].min_activation_height = 0; // No activation delay
353 
354  // Activation of Taproot (BIPs 340-342)
355  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].bit = 2;
356  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartTime = Consensus::BIP9Deployment::ALWAYS_ACTIVE;
357  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
358  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 0; // No activation delay
359 
360  // message start is defined as the first 4 bytes of the sha256d of the block script
361  HashWriter h{};
362  h << consensus.signet_challenge;
363  uint256 hash = h.GetHash();
364  memcpy(pchMessageStart, hash.begin(), 4);
365 
366  nDefaultPort = 38333;
367  nPruneAfterHeight = 1000;
368 
369  genesis = CreateGenesisBlock(1598918400, 52613770, 0x1e0377ae, 1, 50 * COIN);
370  consensus.hashGenesisBlock = genesis.GetHash();
371  assert(consensus.hashGenesisBlock == uint256S("0x00000008819873e925422c1ff0f99f7cc9bbb232af63a077a480a3633bee1ef6"));
372  assert(genesis.hashMerkleRoot == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
373 
374  vFixedSeeds.clear();
375 
376  base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
377  base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
378  base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,239);
379  base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
380  base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
381 
382  bech32_hrp = "tb";
383 
384  fDefaultConsistencyChecks = false;
385  fRequireStandard = true;
386  m_is_test_chain = true;
387  m_is_mockable_chain = false;
388  }
389 };
390 
395 class CRegTestParams : public CChainParams
396 {
397 public:
398  explicit CRegTestParams(const RegTestOptions& opts)
399  {
400  m_chain_type = ChainType::REGTEST;
401  consensus.signet_blocks = false;
402  consensus.signet_challenge.clear();
403  consensus.nSubsidyHalvingInterval = 150;
404  consensus.BIP34Height = 1; // Always active unless overridden
405  consensus.BIP34Hash = uint256();
406  consensus.BIP65Height = 1; // Always active unless overridden
407  consensus.BIP66Height = 1; // Always active unless overridden
408  consensus.CSVHeight = 1; // Always active unless overridden
409  consensus.SegwitHeight = 0; // Always active unless overridden
410  consensus.MinBIP9WarningHeight = 0;
411  consensus.powLimit = uint256S("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
412  consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
413  consensus.nPowTargetSpacing = 10 * 60;
414  consensus.fPowAllowMinDifficultyBlocks = true;
415  consensus.fPowNoRetargeting = true;
416  consensus.nRuleChangeActivationThreshold = 108; // 75% for testchains
417  consensus.nMinerConfirmationWindow = 144; // Faster than normal for regtest (144 instead of 2016)
418 
419  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
420  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = 0;
421  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
422  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].min_activation_height = 0; // No activation delay
423 
424  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].bit = 2;
425  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartTime = Consensus::BIP9Deployment::ALWAYS_ACTIVE;
426  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
427  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 0; // No activation delay
428 
429  consensus.nMinimumChainWork = uint256{};
430  consensus.defaultAssumeValid = uint256{};
431 
432  pchMessageStart[0] = 0xfa;
433  pchMessageStart[1] = 0xbf;
434  pchMessageStart[2] = 0xb5;
435  pchMessageStart[3] = 0xda;
436  nDefaultPort = 18444;
437  nPruneAfterHeight = opts.fastprune ? 100 : 1000;
438  m_assumed_blockchain_size = 0;
439  m_assumed_chain_state_size = 0;
440 
441  for (const auto& [dep, height] : opts.activation_heights) {
442  switch (dep) {
443  case Consensus::BuriedDeployment::DEPLOYMENT_SEGWIT:
444  consensus.SegwitHeight = int{height};
445  break;
446  case Consensus::BuriedDeployment::DEPLOYMENT_HEIGHTINCB:
447  consensus.BIP34Height = int{height};
448  break;
449  case Consensus::BuriedDeployment::DEPLOYMENT_DERSIG:
450  consensus.BIP66Height = int{height};
451  break;
452  case Consensus::BuriedDeployment::DEPLOYMENT_CLTV:
453  consensus.BIP65Height = int{height};
454  break;
455  case Consensus::BuriedDeployment::DEPLOYMENT_CSV:
456  consensus.CSVHeight = int{height};
457  break;
458  }
459  }
460 
461  for (const auto& [deployment_pos, version_bits_params] : opts.version_bits_parameters) {
462  consensus.vDeployments[deployment_pos].nStartTime = version_bits_params.start_time;
463  consensus.vDeployments[deployment_pos].nTimeout = version_bits_params.timeout;
464  consensus.vDeployments[deployment_pos].min_activation_height = version_bits_params.min_activation_height;
465  }
466 
467  genesis = CreateGenesisBlock(1296688602, 2, 0x207fffff, 1, 50 * COIN);
468  consensus.hashGenesisBlock = genesis.GetHash();
469  assert(consensus.hashGenesisBlock == uint256S("0x0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"));
470  assert(genesis.hashMerkleRoot == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
471 
472  vFixedSeeds.clear();
473  vSeeds.clear();
474  vSeeds.emplace_back("dummySeed.invalid.");
475 
476  fDefaultConsistencyChecks = true;
477  fRequireStandard = true;
478  m_is_test_chain = true;
479  m_is_mockable_chain = true;
480 
481  checkpointData = {
482  {
483  {0, uint256S("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206")},
484  }
485  };
486 
487  m_assumeutxo_data = MapAssumeutxo{
488  {
489  110,
490  {AssumeutxoHash{uint256S("0x1ebbf5850204c0bdb15bf030f47c7fe91d45c44c712697e4509ba67adb01c618")}, 110},
491  },
492  {
493  200,
494  {AssumeutxoHash{uint256S("0x51c8d11d8b5c1de51543c579736e786aa2736206d1e11e627568029ce092cf62")}, 200},
495  },
496  };
497 
498  chainTxData = ChainTxData{
499  0,
500  0,
501  0
502  };
503 
504  base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
505  base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
506  base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,239);
507  base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
508  base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
509 
510  bech32_hrp = "bcrt";
511  }
512 };
513 
514 std::unique_ptr<const CChainParams> CChainParams::SigNet(const SigNetOptions& options)
515 {
516  return std::make_unique<const SigNetParams>(options);
517 }
518 
519 std::unique_ptr<const CChainParams> CChainParams::RegTest(const RegTestOptions& options)
520 {
521  return std::make_unique<const CRegTestParams>(options);
522 }
523 
524 std::unique_ptr<const CChainParams> CChainParams::Main()
525 {
526  return std::make_unique<const CMainParams>();
527 }
528 
529 std::unique_ptr<const CChainParams> CChainParams::TestNet()
530 {
531  return std::make_unique<const CTestNetParams>();
532 }
CAmount
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:12
COIN
static constexpr CAmount COIN
The amount of satoshis in one BTC.
Definition: amount.h:15
chainparams_seed_test
static const uint8_t chainparams_seed_test[]
Definition: chainparamsseeds.h:901
chainparams_seed_main
static const uint8_t chainparams_seed_main[]
List of fixed seed nodes for the bitcoin network AUTOGENERATED by contrib/seeds/generate-seeds....
Definition: chainparamsseeds.h:9
CBlockHeader::nNonce
uint32_t nNonce
Definition: block.h:30
CBlockHeader::nBits
uint32_t nBits
Definition: block.h:29
CBlockHeader::nTime
uint32_t nTime
Definition: block.h:28
CBlockHeader::nVersion
int32_t nVersion
Definition: block.h:25
CBlockHeader::hashPrevBlock
uint256 hashPrevBlock
Definition: block.h:26
CBlockHeader::hashMerkleRoot
uint256 hashMerkleRoot
Definition: block.h:27
CBlockHeader::GetHash
uint256 GetHash() const
Definition: block.cpp:11
CBlock
Definition: block.h:69
CBlock::vtx
std::vector< CTransactionRef > vtx
Definition: block.h:72
CChainParams
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system.
Definition: chainparams.h:77
CChainParams::m_assumed_chain_state_size
uint64_t m_assumed_chain_state_size
Definition: chainparams.h:174
CChainParams::Main
static std::unique_ptr< const CChainParams > Main()
Definition: chainparams.cpp:524
CChainParams::bech32_hrp
std::string bech32_hrp
Definition: chainparams.h:177
CChainParams::m_is_test_chain
bool m_is_test_chain
Definition: chainparams.h:183
CChainParams::RegTest
static std::unique_ptr< const CChainParams > RegTest(const RegTestOptions &options)
Definition: chainparams.cpp:519
CChainParams::genesis
CBlock genesis
Definition: chainparams.h:179
CChainParams::m_assumeutxo_data
MapAssumeutxo m_assumeutxo_data
Definition: chainparams.h:186
CChainParams::m_assumed_blockchain_size
uint64_t m_assumed_blockchain_size
Definition: chainparams.h:173
CChainParams::vFixedSeeds
std::vector< uint8_t > vFixedSeeds
Definition: chainparams.h:180
CChainParams::fDefaultConsistencyChecks
bool fDefaultConsistencyChecks
Definition: chainparams.h:181
CChainParams::TestNet
static std::unique_ptr< const CChainParams > TestNet()
Definition: chainparams.cpp:529
CChainParams::base58Prefixes
std::vector< unsigned char > base58Prefixes[MAX_BASE58_TYPES]
Definition: chainparams.h:176
CChainParams::consensus
Consensus::Params consensus
Definition: chainparams.h:169
CChainParams::fRequireStandard
bool fRequireStandard
Definition: chainparams.h:182
CChainParams::vSeeds
std::vector< std::string > vSeeds
Definition: chainparams.h:175
CChainParams::m_is_mockable_chain
bool m_is_mockable_chain
Definition: chainparams.h:184
CChainParams::m_chain_type
ChainType m_chain_type
Definition: chainparams.h:178
CChainParams::checkpointData
CCheckpointData checkpointData
Definition: chainparams.h:185
CChainParams::nDefaultPort
uint16_t nDefaultPort
Definition: chainparams.h:171
CChainParams::pchMessageStart
CMessageHeader::MessageStartChars pchMessageStart
Definition: chainparams.h:170
CChainParams::SigNet
static std::unique_ptr< const CChainParams > SigNet(const SigNetOptions &options)
Definition: chainparams.cpp:514
CChainParams::nPruneAfterHeight
uint64_t nPruneAfterHeight
Definition: chainparams.h:172
CChainParams::chainTxData
ChainTxData chainTxData
Definition: chainparams.h:187
CMainParams
Main network on which people trade goods and services.
Definition: chainparams.cpp:70
CRegTestParams
Regression test: intended for private networks only.
Definition: chainparams.cpp:396
CRegTestParams::CRegTestParams
CRegTestParams(const RegTestOptions &opts)
Definition: chainparams.cpp:398
CScript
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:411
CTestNetParams
Testnet (v3): public test network which is reset from time to time.
Definition: chainparams.cpp:192
HashWriter
A writer stream (for serialization) that computes a 256-bit hash.
Definition: hash.h:102
SigNetParams
Signet: test network with an additional consensus parameter (see BIP325).
Definition: chainparams.cpp:288
SigNetParams::SigNetParams
SigNetParams(const SigNetOptions &options)
Definition: chainparams.cpp:290
base_blob::begin
constexpr unsigned char * begin()
Definition: uint256.h:67
base_blob::SetNull
constexpr void SetNull()
Definition: uint256.h:48
uint256
256-bit opaque blob.
Definition: uint256.h:105
SCRIPT_VERIFY_P2SH
@ SCRIPT_VERIFY_P2SH
Definition: interpreter.h:47
SCRIPT_VERIFY_WITNESS
@ SCRIPT_VERIFY_WITNESS
Definition: interpreter.h:106
SCRIPT_VERIFY_NONE
@ SCRIPT_VERIFY_NONE
Definition: interpreter.h:44
CreateGenesisBlock
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:28
MapAssumeutxo
std::map< int, const AssumeutxoData > MapAssumeutxo
Definition: chainparams.h:58
LogPrintf
#define LogPrintf(...)
Definition: logging.h:236
BlockMerkleRoot
uint256 BlockMerkleRoot(const CBlock &block, bool *mutated)
Definition: merkle.cpp:65
Consensus::DEPLOYMENT_TAPROOT
@ DEPLOYMENT_TAPROOT
Definition: params.h:34
Consensus::DEPLOYMENT_TESTDUMMY
@ DEPLOYMENT_TESTDUMMY
Definition: params.h:33
Consensus::DEPLOYMENT_DERSIG
@ DEPLOYMENT_DERSIG
Definition: params.h:26
Consensus::DEPLOYMENT_CSV
@ DEPLOYMENT_CSV
Definition: params.h:27
Consensus::DEPLOYMENT_SEGWIT
@ DEPLOYMENT_SEGWIT
Definition: params.h:28
Consensus::DEPLOYMENT_HEIGHTINCB
@ DEPLOYMENT_HEIGHTINCB
Definition: params.h:24
Consensus::DEPLOYMENT_CLTV
@ DEPLOYMENT_CLTV
Definition: params.h:25
MakeTransactionRef
static CTransactionRef MakeTransactionRef(Tx &&txIn)
Definition: transaction.h:422
OP_CHECKSIG
@ OP_CHECKSIG
Definition: script.h:186
ParseHex
std::vector< Byte > ParseHex(std::string_view hex_str)
Like TryParseHex, but returns an empty vector on invalid input.
Definition: strencodings.h:65
CChainParams::RegTestOptions
RegTestOptions holds configurations for creating a regtest CChainParams.
Definition: chainparams.h:155
CChainParams::RegTestOptions::version_bits_parameters
std::unordered_map< Consensus::DeploymentPos, VersionBitsParameters > version_bits_parameters
Definition: chainparams.h:156
CChainParams::RegTestOptions::activation_heights
std::unordered_map< Consensus::BuriedDeployment, int > activation_heights
Definition: chainparams.h:157
CChainParams::SigNetOptions
SigNetOptions holds configurations for creating a signet CChainParams.
Definition: chainparams.h:138
CChainParams::SigNetOptions::challenge
std::optional< std::vector< uint8_t > > challenge
Definition: chainparams.h:139
CChainParams::SigNetOptions::seeds
std::optional< std::vector< std::string > > seeds
Definition: chainparams.h:140
CMutableTransaction
A mutable version of CTransaction.
Definition: transaction.h:380
CMutableTransaction::vout
std::vector< CTxOut > vout
Definition: transaction.h:382
CMutableTransaction::vin
std::vector< CTxIn > vin
Definition: transaction.h:381
ChainTxData
Holds various statistics on transactions within a chain.
Definition: chainparams.h:66
ChainTxData::nTime
int64_t nTime
UNIX timestamp of last known number of transactions.
Definition: chainparams.h:67
Consensus::BIP9Deployment::min_activation_height
int min_activation_height
If lock in occurs, delay activation until at least this block height.
Definition: params.h:54
Consensus::BIP9Deployment::bit
int bit
Bit position to select the particular bit in nVersion.
Definition: params.h:45
Consensus::BIP9Deployment::ALWAYS_ACTIVE
static constexpr int64_t ALWAYS_ACTIVE
Special value for nStartTime indicating that the deployment is always active.
Definition: params.h:63
Consensus::BIP9Deployment::NEVER_ACTIVE
static constexpr int64_t NEVER_ACTIVE
Special value for nStartTime indicating that the deployment is never active.
Definition: params.h:68
Consensus::BIP9Deployment::nTimeout
int64_t nTimeout
Timeout/expiry MedianTime for the deployment attempt.
Definition: params.h:49
Consensus::BIP9Deployment::NO_TIMEOUT
static constexpr int64_t NO_TIMEOUT
Constant for nTimeout very far in the future.
Definition: params.h:57
Consensus::BIP9Deployment::nStartTime
int64_t nStartTime
Start MedianTime for version bits miner confirmation.
Definition: params.h:47
Consensus::Params::BIP65Height
int BIP65Height
Block height at which BIP65 becomes active.
Definition: params.h:88
Consensus::Params::CSVHeight
int CSVHeight
Block height at which CSV (BIP68, BIP112 and BIP113) becomes active.
Definition: params.h:92
Consensus::Params::BIP34Hash
uint256 BIP34Hash
Definition: params.h:86
Consensus::Params::nMinerConfirmationWindow
uint32_t nMinerConfirmationWindow
Definition: params.h:106
Consensus::Params::defaultAssumeValid
uint256 defaultAssumeValid
By default assume that the signatures in ancestors of this block are valid.
Definition: params.h:122
Consensus::Params::script_flag_exceptions
std::map< uint256, uint32_t > script_flag_exceptions
Hashes of blocks that.
Definition: params.h:83
Consensus::Params::signet_challenge
std::vector< uint8_t > signet_challenge
Definition: params.h:129
Consensus::Params::signet_blocks
bool signet_blocks
If true, witness commitments contain a payload equal to a Bitcoin Script solution to the signet chall...
Definition: params.h:128
Consensus::Params::SegwitHeight
int SegwitHeight
Block height at which Segwit (BIP141, BIP143 and BIP147) becomes active.
Definition: params.h:96
Consensus::Params::BIP34Height
int BIP34Height
Block height and hash at which BIP34 becomes active.
Definition: params.h:85
Consensus::Params::nSubsidyHalvingInterval
int nSubsidyHalvingInterval
Definition: params.h:76
Consensus::Params::vDeployments
BIP9Deployment vDeployments[MAX_VERSION_BITS_DEPLOYMENTS]
Definition: params.h:107
Consensus::Params::hashGenesisBlock
uint256 hashGenesisBlock
Definition: params.h:75
Consensus::Params::MinBIP9WarningHeight
int MinBIP9WarningHeight
Don't warn about unknown BIP 9 activations below this height.
Definition: params.h:99
Consensus::Params::fPowNoRetargeting
bool fPowNoRetargeting
Definition: params.h:111
Consensus::Params::nMinimumChainWork
uint256 nMinimumChainWork
The best chain should have at least this much work.
Definition: params.h:120
Consensus::Params::nRuleChangeActivationThreshold
uint32_t nRuleChangeActivationThreshold
Minimum blocks including miner confirmation of the total of 2016 blocks in a retargeting period,...
Definition: params.h:105
Consensus::Params::nPowTargetTimespan
int64_t nPowTargetTimespan
Definition: params.h:113
Consensus::Params::BIP66Height
int BIP66Height
Block height at which BIP66 becomes active.
Definition: params.h:90
Consensus::Params::powLimit
uint256 powLimit
Proof of work parameters.
Definition: params.h:109
Consensus::Params::nPowTargetSpacing
int64_t nPowTargetSpacing
Definition: params.h:112
Consensus::Params::fPowAllowMinDifficultyBlocks
bool fPowAllowMinDifficultyBlocks
Definition: params.h:110
uint256S
uint256 uint256S(const char *str)
Definition: uint256.h:118
HexStr
std::string HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
Definition: strencodings.cpp:483
assert
assert(!tx.IsCoinBase())
Generated on Fri Jun 2 2023 02:43:45 for Bitcoin Core by doxygen 1.9.1