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 <kernel/messagestartchars.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:
73  CMainParams() {
74  m_chain_type = ChainType::MAIN;
75  consensus.signet_blocks = false;
76  consensus.signet_challenge.clear();
77  consensus.nSubsidyHalvingInterval = 210000;
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;
92  consensus.fPowAllowMinDifficultyBlocks = false;
93  consensus.fPowNoRetargeting = false;
94  consensus.nRuleChangeActivationThreshold = 1815; // 90% of 2016
95  consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
96  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
97  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE;
98  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
99  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].min_activation_height = 0; // No activation delay
100 
101  // Deployment of Taproot (BIPs 340-342)
102  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].bit = 2;
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("0x000000000000000000000000000000000000000044a50fe819c39ad624021859");
108  consensus.defaultAssumeValid = uint256S("0x000000000000000000035c3f0d31e71a5ee24c5aaf3354689f65bd7b07dee632"); // 784000
109 
115  pchMessageStart[0] = 0xf9;
116  pchMessageStart[1] = 0xbe;
117  pchMessageStart[2] = 0xb4;
118  pchMessageStart[3] = 0xd9;
119  nDefaultPort = 8333;
120  nPruneAfterHeight = 100000;
121  m_assumed_blockchain_size = 540;
122  m_assumed_chain_state_size = 7;
123 
124  genesis = CreateGenesisBlock(1231006505, 2083236893, 0x1d00ffff, 1, 50 * COIN);
125  consensus.hashGenesisBlock = genesis.GetHash();
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.org."); // 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 
154  fDefaultConsistencyChecks = false;
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 
175  m_assumeutxo_data = MapAssumeutxo{
176  // TODO to be specified in a future patch.
177  };
178 
179  chainTxData = ChainTxData{
180  // Data from RPC: getchaintxstats 4096 000000000000000000035c3f0d31e71a5ee24c5aaf3354689f65bd7b07dee632
181  .nTime = 1680665245,
182  .nTxCount = 820876044,
183  .dTxRate = 3.672283614033389,
184  };
185  }
186 };
187 
191 class CTestNetParams : public CChainParams {
192 public:
193  CTestNetParams() {
194  m_chain_type = ChainType::TESTNET;
195  consensus.signet_blocks = false;
196  consensus.signet_challenge.clear();
197  consensus.nSubsidyHalvingInterval = 210000;
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;
210  consensus.fPowAllowMinDifficultyBlocks = true;
211  consensus.fPowNoRetargeting = false;
212  consensus.nRuleChangeActivationThreshold = 1512; // 75% for testchains
213  consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
214  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
215  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE;
216  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
217  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].min_activation_height = 0; // No activation delay
218 
219  // Deployment of Taproot (BIPs 340-342)
220  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].bit = 2;
221  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartTime = 1619222400; // April 24th, 2021
222  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeout = 1628640000; // August 11th, 2021
223  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 0; // No activation delay
224 
225  consensus.nMinimumChainWork = uint256S("0x000000000000000000000000000000000000000000000977edb0244170858d07");
226  consensus.defaultAssumeValid = uint256S("0x0000000000000021bc50a89cde4870d4a81ffe0153b3c8de77b435a2fd3f6761"); // 2429000
227 
228  pchMessageStart[0] = 0x0b;
229  pchMessageStart[1] = 0x11;
230  pchMessageStart[2] = 0x09;
231  pchMessageStart[3] = 0x07;
232  nDefaultPort = 18333;
233  nPruneAfterHeight = 1000;
234  m_assumed_blockchain_size = 42;
235  m_assumed_chain_state_size = 3;
236 
237  genesis = CreateGenesisBlock(1296688602, 414098458, 0x1d00ffff, 1, 50 * COIN);
238  consensus.hashGenesisBlock = genesis.GetHash();
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.org.");
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 
260  fDefaultConsistencyChecks = false;
261  m_is_mockable_chain = false;
262 
263  checkpointData = {
264  {
265  {546, uint256S("000000002a936ca763904c3c35fce2f3556c559c0214345d31b1bcebf76acb70")},
266  }
267  };
268 
269  m_assumeutxo_data = MapAssumeutxo{
270  // TODO to be specified in a future patch.
271  };
272 
273  chainTxData = ChainTxData{
274  // Data from RPC: getchaintxstats 4096 0000000000000021bc50a89cde4870d4a81ffe0153b3c8de77b435a2fd3f6761
275  .nTime = 1681542696,
276  .nTxCount = 65345929,
277  .dTxRate = 0.09855282814711661,
278  };
279  }
280 };
281 
285 class SigNetParams : public CChainParams {
286 public:
287  explicit SigNetParams(const SigNetOptions& options)
288  {
289  std::vector<uint8_t> bin;
290  vSeeds.clear();
291 
292  if (!options.challenge) {
293  bin = ParseHex("512103ad5e0edad18cb1f0fc0d28a3d4f1f3e445640337489abb10404f2d1e086be430210359ef5021964fe22d6f8e05b2463c9540ce96883fe3b278760f048f5189f2e6c452ae");
294  vSeeds.emplace_back("seed.signet.bitcoin.sprovoost.nl.");
295 
296  // Hardcoded nodes can be removed once there are more DNS seeds
297  vSeeds.emplace_back("178.128.221.177");
298  vSeeds.emplace_back("v7ajjeirttkbnt32wpy3c6w3emwnfr3fkla7hpxcfokr3ysd3kqtzmqd.onion:38333");
299 
300  consensus.nMinimumChainWork = uint256S("0x000000000000000000000000000000000000000000000000000001899d8142b0");
301  consensus.defaultAssumeValid = uint256S("0x0000004429ef154f7e00b4f6b46bfbe2d2678ecd351d95bbfca437ab9a5b84ec"); // 138000
302  m_assumed_blockchain_size = 1;
303  m_assumed_chain_state_size = 0;
304  chainTxData = ChainTxData{
305  // Data from RPC: getchaintxstats 4096 0000004429ef154f7e00b4f6b46bfbe2d2678ecd351d95bbfca437ab9a5b84ec
306  .nTime = 1681127428,
307  .nTxCount = 2226359,
308  .dTxRate = 0.006424463050600656,
309  };
310  } else {
311  bin = *options.challenge;
312  consensus.nMinimumChainWork = uint256{};
313  consensus.defaultAssumeValid = uint256{};
314  m_assumed_blockchain_size = 0;
315  m_assumed_chain_state_size = 0;
316  chainTxData = ChainTxData{
317  0,
318  0,
319  0,
320  };
321  LogPrintf("Signet with challenge %s\n", HexStr(bin));
322  }
323 
324  if (options.seeds) {
325  vSeeds = *options.seeds;
326  }
327 
328  m_chain_type = ChainType::SIGNET;
329  consensus.signet_blocks = true;
330  consensus.signet_challenge.assign(bin.begin(), bin.end());
331  consensus.nSubsidyHalvingInterval = 210000;
332  consensus.BIP34Height = 1;
333  consensus.BIP34Hash = uint256{};
334  consensus.BIP65Height = 1;
335  consensus.BIP66Height = 1;
336  consensus.CSVHeight = 1;
337  consensus.SegwitHeight = 1;
338  consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
339  consensus.nPowTargetSpacing = 10 * 60;
340  consensus.fPowAllowMinDifficultyBlocks = false;
341  consensus.fPowNoRetargeting = false;
342  consensus.nRuleChangeActivationThreshold = 1815; // 90% of 2016
343  consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
344  consensus.MinBIP9WarningHeight = 0;
345  consensus.powLimit = uint256S("00000377ae000000000000000000000000000000000000000000000000000000");
346  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
347  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE;
348  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
349  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].min_activation_height = 0; // No activation delay
350 
351  // Activation of Taproot (BIPs 340-342)
352  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].bit = 2;
353  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartTime = Consensus::BIP9Deployment::ALWAYS_ACTIVE;
354  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
355  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 0; // No activation delay
356 
357  // message start is defined as the first 4 bytes of the sha256d of the block script
358  HashWriter h{};
359  h << consensus.signet_challenge;
360  uint256 hash = h.GetHash();
361  std::copy_n(hash.begin(), 4, pchMessageStart.begin());
362 
363  nDefaultPort = 38333;
364  nPruneAfterHeight = 1000;
365 
366  genesis = CreateGenesisBlock(1598918400, 52613770, 0x1e0377ae, 1, 50 * COIN);
367  consensus.hashGenesisBlock = genesis.GetHash();
368  assert(consensus.hashGenesisBlock == uint256S("0x00000008819873e925422c1ff0f99f7cc9bbb232af63a077a480a3633bee1ef6"));
369  assert(genesis.hashMerkleRoot == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
370 
371  vFixedSeeds.clear();
372 
373  base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
374  base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
375  base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,239);
376  base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
377  base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
378 
379  bech32_hrp = "tb";
380 
381  fDefaultConsistencyChecks = false;
382  m_is_mockable_chain = false;
383  }
384 };
385 
390 class CRegTestParams : public CChainParams
391 {
392 public:
393  explicit CRegTestParams(const RegTestOptions& opts)
394  {
395  m_chain_type = ChainType::REGTEST;
396  consensus.signet_blocks = false;
397  consensus.signet_challenge.clear();
398  consensus.nSubsidyHalvingInterval = 150;
399  consensus.BIP34Height = 1; // Always active unless overridden
400  consensus.BIP34Hash = uint256();
401  consensus.BIP65Height = 1; // Always active unless overridden
402  consensus.BIP66Height = 1; // Always active unless overridden
403  consensus.CSVHeight = 1; // Always active unless overridden
404  consensus.SegwitHeight = 0; // Always active unless overridden
405  consensus.MinBIP9WarningHeight = 0;
406  consensus.powLimit = uint256S("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
407  consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
408  consensus.nPowTargetSpacing = 10 * 60;
409  consensus.fPowAllowMinDifficultyBlocks = true;
410  consensus.fPowNoRetargeting = true;
411  consensus.nRuleChangeActivationThreshold = 108; // 75% for testchains
412  consensus.nMinerConfirmationWindow = 144; // Faster than normal for regtest (144 instead of 2016)
413 
414  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
415  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = 0;
416  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
417  consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].min_activation_height = 0; // No activation delay
418 
419  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].bit = 2;
420  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartTime = Consensus::BIP9Deployment::ALWAYS_ACTIVE;
421  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
422  consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 0; // No activation delay
423 
424  consensus.nMinimumChainWork = uint256{};
425  consensus.defaultAssumeValid = uint256{};
426 
427  pchMessageStart[0] = 0xfa;
428  pchMessageStart[1] = 0xbf;
429  pchMessageStart[2] = 0xb5;
430  pchMessageStart[3] = 0xda;
431  nDefaultPort = 18444;
432  nPruneAfterHeight = opts.fastprune ? 100 : 1000;
433  m_assumed_blockchain_size = 0;
434  m_assumed_chain_state_size = 0;
435 
436  for (const auto& [dep, height] : opts.activation_heights) {
437  switch (dep) {
438  case Consensus::BuriedDeployment::DEPLOYMENT_SEGWIT:
439  consensus.SegwitHeight = int{height};
440  break;
441  case Consensus::BuriedDeployment::DEPLOYMENT_HEIGHTINCB:
442  consensus.BIP34Height = int{height};
443  break;
444  case Consensus::BuriedDeployment::DEPLOYMENT_DERSIG:
445  consensus.BIP66Height = int{height};
446  break;
447  case Consensus::BuriedDeployment::DEPLOYMENT_CLTV:
448  consensus.BIP65Height = int{height};
449  break;
450  case Consensus::BuriedDeployment::DEPLOYMENT_CSV:
451  consensus.CSVHeight = int{height};
452  break;
453  }
454  }
455 
456  for (const auto& [deployment_pos, version_bits_params] : opts.version_bits_parameters) {
457  consensus.vDeployments[deployment_pos].nStartTime = version_bits_params.start_time;
458  consensus.vDeployments[deployment_pos].nTimeout = version_bits_params.timeout;
459  consensus.vDeployments[deployment_pos].min_activation_height = version_bits_params.min_activation_height;
460  }
461 
462  genesis = CreateGenesisBlock(1296688602, 2, 0x207fffff, 1, 50 * COIN);
463  consensus.hashGenesisBlock = genesis.GetHash();
464  assert(consensus.hashGenesisBlock == uint256S("0x0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"));
465  assert(genesis.hashMerkleRoot == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
466 
467  vFixedSeeds.clear();
468  vSeeds.clear();
469  vSeeds.emplace_back("dummySeed.invalid.");
470 
471  fDefaultConsistencyChecks = true;
472  m_is_mockable_chain = true;
473 
474  checkpointData = {
475  {
476  {0, uint256S("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206")},
477  }
478  };
479 
480  m_assumeutxo_data = MapAssumeutxo{
481  {
482  110,
483  {AssumeutxoHash{uint256S("0x1ebbf5850204c0bdb15bf030f47c7fe91d45c44c712697e4509ba67adb01c618")}, 110},
484  },
485  {
486  200,
487  {AssumeutxoHash{uint256S("0x51c8d11d8b5c1de51543c579736e786aa2736206d1e11e627568029ce092cf62")}, 200},
488  },
489  };
490 
491  chainTxData = ChainTxData{
492  0,
493  0,
494  0
495  };
496 
497  base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
498  base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
499  base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,239);
500  base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
501  base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
502 
503  bech32_hrp = "bcrt";
504  }
505 };
506 
507 std::unique_ptr<const CChainParams> CChainParams::SigNet(const SigNetOptions& options)
508 {
509  return std::make_unique<const SigNetParams>(options);
510 }
511 
512 std::unique_ptr<const CChainParams> CChainParams::RegTest(const RegTestOptions& options)
513 {
514  return std::make_unique<const CRegTestParams>(options);
515 }
516 
517 std::unique_ptr<const CChainParams> CChainParams::Main()
518 {
519  return std::make_unique<const CMainParams>();
520 }
521 
522 std::unique_ptr<const CChainParams> CChainParams::TestNet()
523 {
524  return std::make_unique<const CTestNetParams>();
525 }
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:76
CChainParams::m_assumed_chain_state_size
uint64_t m_assumed_chain_state_size
Definition: chainparams.h:162
CChainParams::pchMessageStart
MessageStartChars pchMessageStart
Definition: chainparams.h:158
CChainParams::Main
static std::unique_ptr< const CChainParams > Main()
Definition: chainparams.cpp:517
CChainParams::bech32_hrp
std::string bech32_hrp
Definition: chainparams.h:165
CChainParams::RegTest
static std::unique_ptr< const CChainParams > RegTest(const RegTestOptions &options)
Definition: chainparams.cpp:512
CChainParams::genesis
CBlock genesis
Definition: chainparams.h:167
CChainParams::m_assumeutxo_data
MapAssumeutxo m_assumeutxo_data
Definition: chainparams.h:172
CChainParams::m_assumed_blockchain_size
uint64_t m_assumed_blockchain_size
Definition: chainparams.h:161
CChainParams::vFixedSeeds
std::vector< uint8_t > vFixedSeeds
Definition: chainparams.h:168
CChainParams::fDefaultConsistencyChecks
bool fDefaultConsistencyChecks
Definition: chainparams.h:169
CChainParams::TestNet
static std::unique_ptr< const CChainParams > TestNet()
Definition: chainparams.cpp:522
CChainParams::base58Prefixes
std::vector< unsigned char > base58Prefixes[MAX_BASE58_TYPES]
Definition: chainparams.h:164
CChainParams::consensus
Consensus::Params consensus
Definition: chainparams.h:157
CChainParams::vSeeds
std::vector< std::string > vSeeds
Definition: chainparams.h:163
CChainParams::m_is_mockable_chain
bool m_is_mockable_chain
Definition: chainparams.h:170
CChainParams::m_chain_type
ChainType m_chain_type
Definition: chainparams.h:166
CChainParams::checkpointData
CCheckpointData checkpointData
Definition: chainparams.h:171
CChainParams::nDefaultPort
uint16_t nDefaultPort
Definition: chainparams.h:159
CChainParams::SigNet
static std::unique_ptr< const CChainParams > SigNet(const SigNetOptions &options)
Definition: chainparams.cpp:507
CChainParams::nPruneAfterHeight
uint64_t nPruneAfterHeight
Definition: chainparams.h:160
CChainParams::chainTxData
ChainTxData chainTxData
Definition: chainparams.h:173
CMainParams
Main network on which people trade goods and services.
Definition: chainparams.cpp:71
CRegTestParams
Regression test: intended for private networks only.
Definition: chainparams.cpp:391
CRegTestParams::CRegTestParams
CRegTestParams(const RegTestOptions &opts)
Definition: chainparams.cpp:393
CScript
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:413
CTestNetParams
Testnet (v3): public test network which is reset from time to time.
Definition: chainparams.cpp:191
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:285
SigNetParams::SigNetParams
SigNetParams(const SigNetOptions &options)
Definition: chainparams.cpp:287
base_blob::begin
constexpr unsigned char * begin()
Definition: uint256.h:68
base_blob::SetNull
constexpr void SetNull()
Definition: uint256.h:49
uint256
256-bit opaque blob.
Definition: uint256.h:106
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:29
MapAssumeutxo
std::map< int, const AssumeutxoData > MapAssumeutxo
Definition: chainparams.h:57
LogPrintf
#define LogPrintf(...)
Definition: logging.h:237
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:188
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:143
CChainParams::RegTestOptions::version_bits_parameters
std::unordered_map< Consensus::DeploymentPos, VersionBitsParameters > version_bits_parameters
Definition: chainparams.h:144
CChainParams::RegTestOptions::activation_heights
std::unordered_map< Consensus::BuriedDeployment, int > activation_heights
Definition: chainparams.h:145
CChainParams::SigNetOptions
SigNetOptions holds configurations for creating a signet CChainParams.
Definition: chainparams.h:126
CChainParams::SigNetOptions::challenge
std::optional< std::vector< uint8_t > > challenge
Definition: chainparams.h:127
CChainParams::SigNetOptions::seeds
std::optional< std::vector< std::string > > seeds
Definition: chainparams.h:128
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:65
ChainTxData::nTime
int64_t nTime
UNIX timestamp of last known number of transactions.
Definition: chainparams.h:66
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:119
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 Mon Sep 25 2023 20:02:20 for Bitcoin Core by doxygen 1.9.1