Line data Source code
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 368 : 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 368 : CMutableTransaction txNew;
32 368 : txNew.nVersion = 1;
33 368 : txNew.vin.resize(1);
34 368 : txNew.vout.resize(1);
35 368 : txNew.vin[0].scriptSig = CScript() << 486604799 << CScriptNum(4) << std::vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
36 368 : txNew.vout[0].nValue = genesisReward;
37 368 : txNew.vout[0].scriptPubKey = genesisOutputScript;
38 :
39 368 : CBlock genesis;
40 368 : genesis.nTime = nTime;
41 368 : genesis.nBits = nBits;
42 368 : genesis.nNonce = nNonce;
43 368 : genesis.nVersion = nVersion;
44 368 : genesis.vtx.push_back(MakeTransactionRef(std::move(txNew)));
45 368 : genesis.hashPrevBlock.SetNull();
46 368 : genesis.hashMerkleRoot = BlockMerkleRoot(genesis);
47 368 : return genesis;
48 368 : }
49 :
50 : /**
51 : * Build the genesis block. Note that the output of its generation
52 : * transaction cannot be spent since it did not originally exist in the
53 : * database.
54 : *
55 : * CBlock(hash=000000000019d6, ver=1, hashPrevBlock=00000000000000, hashMerkleRoot=4a5e1e, nTime=1231006505, nBits=1d00ffff, nNonce=2083236893, vtx=1)
56 : * CTransaction(hash=4a5e1e, ver=1, vin.size=1, vout.size=1, nLockTime=0)
57 : * CTxIn(COutPoint(000000, -1), coinbase 04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73)
58 : * CTxOut(nValue=50.00000000, scriptPubKey=0x5F1DF16B2B704C8A578D0B)
59 : * vMerkleTree: 4a5e1e
60 : */
61 368 : static CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
62 : {
63 368 : const char* pszTimestamp = "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks";
64 368 : const CScript genesisOutputScript = CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") << OP_CHECKSIG;
65 368 : return CreateGenesisBlock(pszTimestamp, genesisOutputScript, nTime, nNonce, nBits, nVersion, genesisReward);
66 368 : }
67 :
68 : /**
69 : * Main network on which people trade goods and services.
70 : */
71 : class CMainParams : public CChainParams {
72 : public:
73 78 : CMainParams() {
74 251 : m_chain_type = ChainType::MAIN;
75 78 : consensus.signet_blocks = false;
76 78 : consensus.signet_challenge.clear();
77 78 : consensus.nSubsidyHalvingInterval = 210000;
78 78 : consensus.script_flag_exceptions.emplace( // BIP16 exception
79 78 : uint256S("0x00000000000002dc756eebf4f49723ed8d30cc28a5f108eb94b1ba88ac4f9c22"), SCRIPT_VERIFY_NONE);
80 78 : consensus.script_flag_exceptions.emplace( // Taproot exception
81 78 : uint256S("0x0000000000000000000f14c35b2d841e986ab5441de8c585d5ffe55ea1e395ad"), SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS);
82 78 : consensus.BIP34Height = 227931;
83 78 : consensus.BIP34Hash = uint256S("0x000000000000024b89b42a942fe0d9fea3bb44ab7bd1b19115dd6a759c0808b8");
84 78 : consensus.BIP65Height = 388381; // 000000000000000004c2b624ed5d7756c508d90fd0da2c7c679febfa6c4735f0
85 78 : consensus.BIP66Height = 363725; // 00000000000000000379eaa19dce8c9b722d46ae6a57c2f1a988119488b50931
86 78 : consensus.CSVHeight = 419328; // 000000000000000004a1b34462cb8aeebd5799177f7a29cf28f2d1961716b5b5
87 78 : consensus.SegwitHeight = 481824; // 0000000000000000001c8018d9cb3b742ef25114f27563e3fc4a1902167f9893
88 78 : consensus.MinBIP9WarningHeight = 483840; // segwit activation height + miner confirmation window
89 78 : consensus.powLimit = uint256S("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
90 78 : consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
91 78 : consensus.nPowTargetSpacing = 10 * 60;
92 78 : consensus.fPowAllowMinDifficultyBlocks = false;
93 78 : consensus.fPowNoRetargeting = false;
94 78 : consensus.nRuleChangeActivationThreshold = 1815; // 90% of 2016
95 78 : consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
96 78 : consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
97 78 : consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE;
98 78 : consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
99 78 : consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].min_activation_height = 0; // No activation delay
100 :
101 : // Deployment of Taproot (BIPs 340-342)
102 78 : consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].bit = 2;
103 78 : consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartTime = 1619222400; // April 24th, 2021
104 78 : consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeout = 1628640000; // August 11th, 2021
105 78 : consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 709632; // Approximately November 12th, 2021
106 :
107 78 : consensus.nMinimumChainWork = uint256S("0x000000000000000000000000000000000000000044a50fe819c39ad624021859");
108 78 : consensus.defaultAssumeValid = uint256S("0x000000000000000000035c3f0d31e71a5ee24c5aaf3354689f65bd7b07dee632"); // 784000
109 :
110 : /**
111 : * The message start string is designed to be unlikely to occur in normal data.
112 : * The characters are rarely used upper ASCII, not valid as UTF-8, and produce
113 : * a large 32-bit integer with any alignment.
114 : */
115 78 : pchMessageStart[0] = 0xf9;
116 78 : pchMessageStart[1] = 0xbe;
117 78 : pchMessageStart[2] = 0xb4;
118 78 : pchMessageStart[3] = 0xd9;
119 78 : nDefaultPort = 8333;
120 78 : nPruneAfterHeight = 100000;
121 78 : m_assumed_blockchain_size = 540;
122 78 : m_assumed_chain_state_size = 7;
123 :
124 78 : genesis = CreateGenesisBlock(1231006505, 2083236893, 0x1d00ffff, 1, 50 * COIN);
125 78 : consensus.hashGenesisBlock = genesis.GetHash();
126 78 : assert(consensus.hashGenesisBlock == uint256S("0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"));
127 78 : 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 78 : vSeeds.emplace_back("seed.bitcoin.sipa.be."); // Pieter Wuille, only supports x1, x5, x9, and xd
135 78 : vSeeds.emplace_back("dnsseed.bluematt.me."); // Matt Corallo, only supports x9
136 78 : vSeeds.emplace_back("dnsseed.bitcoin.dashjr.org."); // Luke Dashjr
137 78 : vSeeds.emplace_back("seed.bitcoinstats.com."); // Christian Decker, supports x1 - xf
138 78 : vSeeds.emplace_back("seed.bitcoin.jonasschnelli.ch."); // Jonas Schnelli, only supports x1, x5, x9, and xd
139 78 : vSeeds.emplace_back("seed.btc.petertodd.org."); // Peter Todd, only supports x1, x5, x9, and xd
140 78 : vSeeds.emplace_back("seed.bitcoin.sprovoost.nl."); // Sjors Provoost
141 78 : vSeeds.emplace_back("dnsseed.emzy.de."); // Stephan Oeste
142 78 : vSeeds.emplace_back("seed.bitcoin.wiz.biz."); // Jason Maurice
143 :
144 78 : base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,0);
145 78 : base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,5);
146 78 : base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,128);
147 78 : base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x88, 0xB2, 0x1E};
148 78 : base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4};
149 :
150 78 : bech32_hrp = "bc";
151 :
152 78 : vFixedSeeds = std::vector<uint8_t>(std::begin(chainparams_seed_main), std::end(chainparams_seed_main));
153 :
154 78 : fDefaultConsistencyChecks = false;
155 78 : m_is_test_chain = false;
156 78 : m_is_mockable_chain = false;
157 :
158 156 : checkpointData = {
159 1092 : {
160 78 : { 11111, uint256S("0x0000000069e244f73d78e8fd29ba2fd2ed618bd6fa2ee92559f542fdb26e7c1d")},
161 78 : { 33333, uint256S("0x000000002dd5588a74784eaa7ab0507a18ad16a236e7b1ce69f00d7ddfb5d0a6")},
162 78 : { 74000, uint256S("0x0000000000573993a3c9e41ce34471c079dcf5f52a0e824a81e7f953b8661a20")},
163 78 : {105000, uint256S("0x00000000000291ce28027faea320c8d2b054b2e0fe44a773f3eefb151d6bdc97")},
164 78 : {134444, uint256S("0x00000000000005b12ffd4cd315cd34ffd4a594f430ac814c91184a0d42d2b0fe")},
165 78 : {168000, uint256S("0x000000000000099e61ea72015e79632f216fe6cb33d7899acb35b75c8303b763")},
166 78 : {193000, uint256S("0x000000000000059f452a5f7340de6682a977387c17010ff6e6c3bd83ca8b1317")},
167 78 : {210000, uint256S("0x000000000000048b95347e83192f69cf0366076336c639f9b7228e9ba171342e")},
168 78 : {216116, uint256S("0x00000000000001b4f4b433e81ee46494af945cf96014816a4e2370f11b23df4e")},
169 78 : {225430, uint256S("0x00000000000001c108384350f74090433e7fcf79a606b8e797f065b130575932")},
170 78 : {250000, uint256S("0x000000000000003887df1f29024b06fc2200b55f8af8f35453d7be294df2d214")},
171 78 : {279000, uint256S("0x0000000000000001ae8c72a0b0c301f67e3afca10e819efa9041e458e9bd7e40")},
172 78 : {295000, uint256S("0x00000000000000004d9b4ef50f0f9d686fd69db2e03af35a100370c64632a983")},
173 : }
174 : };
175 :
176 78 : m_assumeutxo_data = MapAssumeutxo{
177 : // TODO to be specified in a future patch.
178 : };
179 :
180 78 : chainTxData = ChainTxData{
181 : // Data from RPC: getchaintxstats 4096 000000000000000000035c3f0d31e71a5ee24c5aaf3354689f65bd7b07dee632
182 : .nTime = 1680665245,
183 : .nTxCount = 820876044,
184 : .dTxRate = 3.672283614033389,
185 : };
186 78 : }
187 : };
188 :
189 : /**
190 : * Testnet (v3): public test network which is reset from time to time.
191 : */
192 : class CTestNetParams : public CChainParams {
193 : public:
194 69 : CTestNetParams() {
195 69 : m_chain_type = ChainType::TESTNET;
196 69 : consensus.signet_blocks = false;
197 69 : consensus.signet_challenge.clear();
198 69 : consensus.nSubsidyHalvingInterval = 210000;
199 69 : consensus.script_flag_exceptions.emplace( // BIP16 exception
200 69 : uint256S("0x00000000dd30457c001f4095d208cc1296b0eed002427aa599874af7a432b105"), SCRIPT_VERIFY_NONE);
201 69 : consensus.BIP34Height = 21111;
202 69 : consensus.BIP34Hash = uint256S("0x0000000023b3a96d3484e5abb3755c413e7d41500f8e2a5c3f0dd01299cd8ef8");
203 69 : consensus.BIP65Height = 581885; // 00000000007f6655f22f98e72ed80d8b06dc761d5da09df0fa1dc4be4f861eb6
204 69 : consensus.BIP66Height = 330776; // 000000002104c8c45e99a8853285a3b592602a3ccde2b832481da85e9e4ba182
205 69 : consensus.CSVHeight = 770112; // 00000000025e930139bac5c6c31a403776da130831ab85be56578f3fa75369bb
206 69 : consensus.SegwitHeight = 834624; // 00000000002b980fcd729daaa248fd9316a5200e9b367f4ff2c42453e84201ca
207 69 : consensus.MinBIP9WarningHeight = 836640; // segwit activation height + miner confirmation window
208 69 : consensus.powLimit = uint256S("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
209 69 : consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
210 69 : consensus.nPowTargetSpacing = 10 * 60;
211 69 : consensus.fPowAllowMinDifficultyBlocks = true;
212 69 : consensus.fPowNoRetargeting = false;
213 69 : consensus.nRuleChangeActivationThreshold = 1512; // 75% for testchains
214 69 : consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
215 69 : consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
216 69 : consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE;
217 69 : consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
218 69 : consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].min_activation_height = 0; // No activation delay
219 :
220 : // Deployment of Taproot (BIPs 340-342)
221 69 : consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].bit = 2;
222 69 : consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartTime = 1619222400; // April 24th, 2021
223 69 : consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeout = 1628640000; // August 11th, 2021
224 69 : consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 0; // No activation delay
225 :
226 69 : consensus.nMinimumChainWork = uint256S("0x000000000000000000000000000000000000000000000977edb0244170858d07");
227 69 : consensus.defaultAssumeValid = uint256S("0x0000000000000021bc50a89cde4870d4a81ffe0153b3c8de77b435a2fd3f6761"); // 2429000
228 :
229 69 : pchMessageStart[0] = 0x0b;
230 69 : pchMessageStart[1] = 0x11;
231 69 : pchMessageStart[2] = 0x09;
232 69 : pchMessageStart[3] = 0x07;
233 69 : nDefaultPort = 18333;
234 69 : nPruneAfterHeight = 1000;
235 69 : m_assumed_blockchain_size = 42;
236 69 : m_assumed_chain_state_size = 3;
237 :
238 69 : genesis = CreateGenesisBlock(1296688602, 414098458, 0x1d00ffff, 1, 50 * COIN);
239 69 : consensus.hashGenesisBlock = genesis.GetHash();
240 69 : assert(consensus.hashGenesisBlock == uint256S("0x000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"));
241 69 : assert(genesis.hashMerkleRoot == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
242 :
243 69 : vFixedSeeds.clear();
244 69 : vSeeds.clear();
245 : // nodes with support for servicebits filtering should be at the top
246 69 : vSeeds.emplace_back("testnet-seed.bitcoin.jonasschnelli.ch.");
247 69 : vSeeds.emplace_back("seed.tbtc.petertodd.org.");
248 69 : vSeeds.emplace_back("seed.testnet.bitcoin.sprovoost.nl.");
249 69 : vSeeds.emplace_back("testnet-seed.bluematt.me."); // Just a static list of stable node(s), only supports x9
250 :
251 69 : base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
252 69 : base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
253 69 : base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,239);
254 69 : base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
255 69 : base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
256 :
257 69 : bech32_hrp = "tb";
258 :
259 69 : vFixedSeeds = std::vector<uint8_t>(std::begin(chainparams_seed_test), std::end(chainparams_seed_test));
260 :
261 69 : fDefaultConsistencyChecks = false;
262 69 : m_is_test_chain = true;
263 69 : m_is_mockable_chain = false;
264 :
265 138 : checkpointData = {
266 138 : {
267 69 : {546, uint256S("000000002a936ca763904c3c35fce2f3556c559c0214345d31b1bcebf76acb70")},
268 : }
269 : };
270 :
271 69 : m_assumeutxo_data = MapAssumeutxo{
272 : // TODO to be specified in a future patch.
273 : };
274 :
275 69 : chainTxData = ChainTxData{
276 : // Data from RPC: getchaintxstats 4096 0000000000000021bc50a89cde4870d4a81ffe0153b3c8de77b435a2fd3f6761
277 : .nTime = 1681542696,
278 : .nTxCount = 65345929,
279 : .dTxRate = 0.09855282814711661,
280 : };
281 69 : }
282 : };
283 :
284 : /**
285 : * Signet: test network with an additional consensus parameter (see BIP325).
286 : */
287 : class SigNetParams : public CChainParams {
288 : public:
289 70 : explicit SigNetParams(const SigNetOptions& options)
290 : {
291 70 : std::vector<uint8_t> bin;
292 70 : vSeeds.clear();
293 :
294 70 : if (!options.challenge) {
295 70 : bin = ParseHex("512103ad5e0edad18cb1f0fc0d28a3d4f1f3e445640337489abb10404f2d1e086be430210359ef5021964fe22d6f8e05b2463c9540ce96883fe3b278760f048f5189f2e6c452ae");
296 70 : vSeeds.emplace_back("seed.signet.bitcoin.sprovoost.nl.");
297 :
298 : // Hardcoded nodes can be removed once there are more DNS seeds
299 70 : vSeeds.emplace_back("178.128.221.177");
300 70 : vSeeds.emplace_back("v7ajjeirttkbnt32wpy3c6w3emwnfr3fkla7hpxcfokr3ysd3kqtzmqd.onion:38333");
301 :
302 70 : consensus.nMinimumChainWork = uint256S("0x000000000000000000000000000000000000000000000000000001899d8142b0");
303 70 : consensus.defaultAssumeValid = uint256S("0x0000004429ef154f7e00b4f6b46bfbe2d2678ecd351d95bbfca437ab9a5b84ec"); // 138000
304 70 : m_assumed_blockchain_size = 1;
305 70 : m_assumed_chain_state_size = 0;
306 70 : chainTxData = ChainTxData{
307 : // Data from RPC: getchaintxstats 4096 0000004429ef154f7e00b4f6b46bfbe2d2678ecd351d95bbfca437ab9a5b84ec
308 : .nTime = 1681127428,
309 : .nTxCount = 2226359,
310 : .dTxRate = 0.006424463050600656,
311 : };
312 70 : } else {
313 0 : bin = *options.challenge;
314 0 : consensus.nMinimumChainWork = uint256{};
315 0 : consensus.defaultAssumeValid = uint256{};
316 0 : m_assumed_blockchain_size = 0;
317 0 : m_assumed_chain_state_size = 0;
318 0 : chainTxData = ChainTxData{
319 : 0,
320 : 0,
321 : 0,
322 : };
323 0 : LogPrintf("Signet with challenge %s\n", HexStr(bin));
324 : }
325 :
326 70 : if (options.seeds) {
327 0 : vSeeds = *options.seeds;
328 0 : }
329 :
330 70 : m_chain_type = ChainType::SIGNET;
331 70 : consensus.signet_blocks = true;
332 70 : consensus.signet_challenge.assign(bin.begin(), bin.end());
333 70 : consensus.nSubsidyHalvingInterval = 210000;
334 70 : consensus.BIP34Height = 1;
335 70 : consensus.BIP34Hash = uint256{};
336 70 : consensus.BIP65Height = 1;
337 70 : consensus.BIP66Height = 1;
338 70 : consensus.CSVHeight = 1;
339 70 : consensus.SegwitHeight = 1;
340 70 : consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
341 70 : consensus.nPowTargetSpacing = 10 * 60;
342 70 : consensus.fPowAllowMinDifficultyBlocks = false;
343 70 : consensus.fPowNoRetargeting = false;
344 70 : consensus.nRuleChangeActivationThreshold = 1815; // 90% of 2016
345 70 : consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
346 70 : consensus.MinBIP9WarningHeight = 0;
347 70 : consensus.powLimit = uint256S("00000377ae000000000000000000000000000000000000000000000000000000");
348 70 : consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
349 70 : consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE;
350 70 : consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
351 70 : consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].min_activation_height = 0; // No activation delay
352 :
353 : // Activation of Taproot (BIPs 340-342)
354 70 : consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].bit = 2;
355 70 : consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartTime = Consensus::BIP9Deployment::ALWAYS_ACTIVE;
356 70 : consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
357 70 : consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 0; // No activation delay
358 :
359 : // message start is defined as the first 4 bytes of the sha256d of the block script
360 70 : HashWriter h{};
361 70 : h << consensus.signet_challenge;
362 70 : uint256 hash = h.GetHash();
363 70 : std::copy_n(hash.begin(), 4, pchMessageStart.begin());
364 :
365 70 : nDefaultPort = 38333;
366 70 : nPruneAfterHeight = 1000;
367 :
368 70 : genesis = CreateGenesisBlock(1598918400, 52613770, 0x1e0377ae, 1, 50 * COIN);
369 70 : consensus.hashGenesisBlock = genesis.GetHash();
370 70 : assert(consensus.hashGenesisBlock == uint256S("0x00000008819873e925422c1ff0f99f7cc9bbb232af63a077a480a3633bee1ef6"));
371 70 : assert(genesis.hashMerkleRoot == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
372 :
373 70 : vFixedSeeds.clear();
374 :
375 70 : base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
376 70 : base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
377 70 : base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,239);
378 70 : base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
379 70 : base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
380 :
381 70 : bech32_hrp = "tb";
382 :
383 70 : fDefaultConsistencyChecks = false;
384 70 : m_is_test_chain = true;
385 70 : m_is_mockable_chain = false;
386 70 : }
387 : };
388 :
389 : /**
390 : * Regression test: intended for private networks only. Has minimal difficulty to ensure that
391 : * blocks can be found instantly.
392 : */
393 : class CRegTestParams : public CChainParams
394 : {
395 : public:
396 151 : explicit CRegTestParams(const RegTestOptions& opts)
397 : {
398 151 : m_chain_type = ChainType::REGTEST;
399 151 : consensus.signet_blocks = false;
400 151 : consensus.signet_challenge.clear();
401 151 : consensus.nSubsidyHalvingInterval = 150;
402 151 : consensus.BIP34Height = 1; // Always active unless overridden
403 151 : consensus.BIP34Hash = uint256();
404 151 : consensus.BIP65Height = 1; // Always active unless overridden
405 151 : consensus.BIP66Height = 1; // Always active unless overridden
406 151 : consensus.CSVHeight = 1; // Always active unless overridden
407 151 : consensus.SegwitHeight = 0; // Always active unless overridden
408 151 : consensus.MinBIP9WarningHeight = 0;
409 151 : consensus.powLimit = uint256S("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
410 151 : consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
411 151 : consensus.nPowTargetSpacing = 10 * 60;
412 151 : consensus.fPowAllowMinDifficultyBlocks = true;
413 151 : consensus.fPowNoRetargeting = true;
414 151 : consensus.nRuleChangeActivationThreshold = 108; // 75% for testchains
415 151 : consensus.nMinerConfirmationWindow = 144; // Faster than normal for regtest (144 instead of 2016)
416 :
417 151 : consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
418 151 : consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = 0;
419 151 : consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
420 151 : consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].min_activation_height = 0; // No activation delay
421 :
422 151 : consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].bit = 2;
423 151 : consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartTime = Consensus::BIP9Deployment::ALWAYS_ACTIVE;
424 151 : consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
425 151 : consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 0; // No activation delay
426 :
427 151 : consensus.nMinimumChainWork = uint256{};
428 151 : consensus.defaultAssumeValid = uint256{};
429 :
430 151 : pchMessageStart[0] = 0xfa;
431 151 : pchMessageStart[1] = 0xbf;
432 151 : pchMessageStart[2] = 0xb5;
433 151 : pchMessageStart[3] = 0xda;
434 151 : nDefaultPort = 18444;
435 151 : nPruneAfterHeight = opts.fastprune ? 100 : 1000;
436 151 : m_assumed_blockchain_size = 0;
437 151 : m_assumed_chain_state_size = 0;
438 :
439 151 : for (const auto& [dep, height] : opts.activation_heights) {
440 0 : switch (dep) {
441 : case Consensus::BuriedDeployment::DEPLOYMENT_SEGWIT:
442 0 : consensus.SegwitHeight = int{height};
443 0 : break;
444 : case Consensus::BuriedDeployment::DEPLOYMENT_HEIGHTINCB:
445 0 : consensus.BIP34Height = int{height};
446 0 : break;
447 : case Consensus::BuriedDeployment::DEPLOYMENT_DERSIG:
448 0 : consensus.BIP66Height = int{height};
449 0 : break;
450 : case Consensus::BuriedDeployment::DEPLOYMENT_CLTV:
451 0 : consensus.BIP65Height = int{height};
452 0 : break;
453 : case Consensus::BuriedDeployment::DEPLOYMENT_CSV:
454 0 : consensus.CSVHeight = int{height};
455 0 : break;
456 : }
457 : }
458 :
459 151 : for (const auto& [deployment_pos, version_bits_params] : opts.version_bits_parameters) {
460 0 : consensus.vDeployments[deployment_pos].nStartTime = version_bits_params.start_time;
461 0 : consensus.vDeployments[deployment_pos].nTimeout = version_bits_params.timeout;
462 0 : consensus.vDeployments[deployment_pos].min_activation_height = version_bits_params.min_activation_height;
463 : }
464 :
465 151 : genesis = CreateGenesisBlock(1296688602, 2, 0x207fffff, 1, 50 * COIN);
466 151 : consensus.hashGenesisBlock = genesis.GetHash();
467 151 : assert(consensus.hashGenesisBlock == uint256S("0x0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"));
468 151 : assert(genesis.hashMerkleRoot == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
469 :
470 151 : vFixedSeeds.clear(); //!< Regtest mode doesn't have any fixed seeds.
471 151 : vSeeds.clear();
472 151 : vSeeds.emplace_back("dummySeed.invalid.");
473 :
474 151 : fDefaultConsistencyChecks = true;
475 151 : m_is_test_chain = true;
476 151 : m_is_mockable_chain = true;
477 :
478 302 : checkpointData = {
479 302 : {
480 151 : {0, uint256S("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206")},
481 : }
482 : };
483 :
484 453 : m_assumeutxo_data = MapAssumeutxo{
485 151 : {
486 151 : 110,
487 151 : {AssumeutxoHash{uint256S("0x1ebbf5850204c0bdb15bf030f47c7fe91d45c44c712697e4509ba67adb01c618")}, 110},
488 : },
489 151 : {
490 151 : 200,
491 151 : {AssumeutxoHash{uint256S("0x51c8d11d8b5c1de51543c579736e786aa2736206d1e11e627568029ce092cf62")}, 200},
492 : },
493 : };
494 :
495 151 : chainTxData = ChainTxData{
496 : 0,
497 : 0,
498 : 0
499 : };
500 :
501 151 : base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
502 151 : base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
503 151 : base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,239);
504 151 : base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
505 151 : base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
506 :
507 151 : bech32_hrp = "bcrt";
508 151 : }
509 : };
510 :
511 70 : std::unique_ptr<const CChainParams> CChainParams::SigNet(const SigNetOptions& options)
512 : {
513 70 : return std::make_unique<const SigNetParams>(options);
514 : }
515 :
516 151 : std::unique_ptr<const CChainParams> CChainParams::RegTest(const RegTestOptions& options)
517 : {
518 151 : return std::make_unique<const CRegTestParams>(options);
519 : }
520 :
521 78 : std::unique_ptr<const CChainParams> CChainParams::Main()
522 : {
523 78 : return std::make_unique<const CMainParams>();
524 : }
525 :
526 69 : std::unique_ptr<const CChainParams> CChainParams::TestNet()
527 : {
528 69 : return std::make_unique<const CTestNetParams>();
529 : }
|
