/root/bitcoin/src/kernel/chainparams.cpp
| Line | Count | Source | 
| 1 |  | // Copyright (c) 2010 Satoshi Nakamoto | 
| 2 |  | // Copyright (c) 2009-present 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 |  | using namespace util::hex_literals; | 
| 30 |  |  | 
| 31 |  | // Workaround MSVC bug triggering C7595 when calling consteval constructors in | 
| 32 |  | // initializer lists. | 
| 33 |  | // https://developercommunity.visualstudio.com/t/Bogus-C7595-error-on-valid-C20-code/10906093 | 
| 34 |  | #if defined(_MSC_VER) | 
| 35 |  | auto consteval_ctor(auto&& input) { return input; } | 
| 36 |  | #else | 
| 37 | 0 | #define consteval_ctor(input) (input) | 
| 38 |  | #endif | 
| 39 |  |  | 
| 40 |  | static CBlock CreateGenesisBlock(const char* pszTimestamp, const CScript& genesisOutputScript, uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward) | 
| 41 | 0 | { | 
| 42 | 0 |     CMutableTransaction txNew; | 
| 43 | 0 |     txNew.version = 1; | 
| 44 | 0 |     txNew.vin.resize(1); | 
| 45 | 0 |     txNew.vout.resize(1); | 
| 46 | 0 |     txNew.vin[0].scriptSig = CScript() << 486604799 << CScriptNum(4) << std::vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp)); | 
| 47 | 0 |     txNew.vout[0].nValue = genesisReward; | 
| 48 | 0 |     txNew.vout[0].scriptPubKey = genesisOutputScript; | 
| 49 |  | 
 | 
| 50 | 0 |     CBlock genesis; | 
| 51 | 0 |     genesis.nTime    = nTime; | 
| 52 | 0 |     genesis.nBits    = nBits; | 
| 53 | 0 |     genesis.nNonce   = nNonce; | 
| 54 | 0 |     genesis.nVersion = nVersion; | 
| 55 | 0 |     genesis.vtx.push_back(MakeTransactionRef(std::move(txNew))); | 
| 56 | 0 |     genesis.hashPrevBlock.SetNull(); | 
| 57 | 0 |     genesis.hashMerkleRoot = BlockMerkleRoot(genesis); | 
| 58 | 0 |     return genesis; | 
| 59 | 0 | } | 
| 60 |  |  | 
| 61 |  | /** | 
| 62 |  |  * Build the genesis block. Note that the output of its generation | 
| 63 |  |  * transaction cannot be spent since it did not originally exist in the | 
| 64 |  |  * database. | 
| 65 |  |  * | 
| 66 |  |  * CBlock(hash=000000000019d6, ver=1, hashPrevBlock=00000000000000, hashMerkleRoot=4a5e1e, nTime=1231006505, nBits=1d00ffff, nNonce=2083236893, vtx=1) | 
| 67 |  |  *   CTransaction(hash=4a5e1e, ver=1, vin.size=1, vout.size=1, nLockTime=0) | 
| 68 |  |  *     CTxIn(COutPoint(000000, -1), coinbase 04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73) | 
| 69 |  |  *     CTxOut(nValue=50.00000000, scriptPubKey=0x5F1DF16B2B704C8A578D0B) | 
| 70 |  |  *   vMerkleTree: 4a5e1e | 
| 71 |  |  */ | 
| 72 |  | static CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward) | 
| 73 | 0 | { | 
| 74 | 0 |     const char* pszTimestamp = "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks"; | 
| 75 | 0 |     const CScript genesisOutputScript = CScript() << "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f"_hex << OP_CHECKSIG; | 
| 76 | 0 |     return CreateGenesisBlock(pszTimestamp, genesisOutputScript, nTime, nNonce, nBits, nVersion, genesisReward); | 
| 77 | 0 | } | 
| 78 |  |  | 
| 79 |  | /** | 
| 80 |  |  * Main network on which people trade goods and services. | 
| 81 |  |  */ | 
| 82 |  | class CMainParams : public CChainParams { | 
| 83 |  | public: | 
| 84 | 0 |     CMainParams() { | 
| 85 | 0 |         m_chain_type = ChainType::MAIN; | 
| 86 | 0 |         consensus.signet_blocks = false; | 
| 87 | 0 |         consensus.signet_challenge.clear(); | 
| 88 | 0 |         consensus.nSubsidyHalvingInterval = 210000; | 
| 89 | 0 |         consensus.script_flag_exceptions.emplace( // BIP16 exception | 
| 90 | 0 |             uint256{"00000000000002dc756eebf4f49723ed8d30cc28a5f108eb94b1ba88ac4f9c22"}, SCRIPT_VERIFY_NONE); | 
| 91 | 0 |         consensus.script_flag_exceptions.emplace( // Taproot exception | 
| 92 | 0 |             uint256{"0000000000000000000f14c35b2d841e986ab5441de8c585d5ffe55ea1e395ad"}, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS); | 
| 93 | 0 |         consensus.BIP34Height = 227931; | 
| 94 | 0 |         consensus.BIP34Hash = uint256{"000000000000024b89b42a942fe0d9fea3bb44ab7bd1b19115dd6a759c0808b8"}; | 
| 95 | 0 |         consensus.BIP65Height = 388381; // 000000000000000004c2b624ed5d7756c508d90fd0da2c7c679febfa6c4735f0 | 
| 96 | 0 |         consensus.BIP66Height = 363725; // 00000000000000000379eaa19dce8c9b722d46ae6a57c2f1a988119488b50931 | 
| 97 | 0 |         consensus.CSVHeight = 419328; // 000000000000000004a1b34462cb8aeebd5799177f7a29cf28f2d1961716b5b5 | 
| 98 | 0 |         consensus.SegwitHeight = 481824; // 0000000000000000001c8018d9cb3b742ef25114f27563e3fc4a1902167f9893 | 
| 99 | 0 |         consensus.MinBIP9WarningHeight = 483840; // segwit activation height + miner confirmation window | 
| 100 | 0 |         consensus.powLimit = uint256{"00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"}; | 
| 101 | 0 |         consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks | 
| 102 | 0 |         consensus.nPowTargetSpacing = 10 * 60; | 
| 103 | 0 |         consensus.fPowAllowMinDifficultyBlocks = false; | 
| 104 | 0 |         consensus.enforce_BIP94 = false; | 
| 105 | 0 |         consensus.fPowNoRetargeting = false; | 
| 106 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28; | 
| 107 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE; | 
| 108 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT; | 
| 109 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].min_activation_height = 0; // No activation delay | 
| 110 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].threshold = 1815; // 90% | 
| 111 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].period = 2016; | 
| 112 |  |  | 
| 113 |  |         // Deployment of Taproot (BIPs 340-342) | 
| 114 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].bit = 2; | 
| 115 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartTime = 1619222400; // April 24th, 2021 | 
| 116 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeout = 1628640000; // August 11th, 2021 | 
| 117 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 709632; // Approximately November 12th, 2021 | 
| 118 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].threshold = 1815; // 90% | 
| 119 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].period = 2016; | 
| 120 |  | 
 | 
| 121 | 0 |         consensus.nMinimumChainWork = uint256{"0000000000000000000000000000000000000000dee8e2a309ad8a9820433c68"}; | 
| 122 | 0 |         consensus.defaultAssumeValid = uint256{"00000000000000000000611fd22f2df7c8fbd0688745c3a6c3bb5109cc2a12cb"}; // 912683 | 
| 123 |  |  | 
| 124 |  |         /** | 
| 125 |  |          * The message start string is designed to be unlikely to occur in normal data. | 
| 126 |  |          * The characters are rarely used upper ASCII, not valid as UTF-8, and produce | 
| 127 |  |          * a large 32-bit integer with any alignment. | 
| 128 |  |          */ | 
| 129 | 0 |         pchMessageStart[0] = 0xf9; | 
| 130 | 0 |         pchMessageStart[1] = 0xbe; | 
| 131 | 0 |         pchMessageStart[2] = 0xb4; | 
| 132 | 0 |         pchMessageStart[3] = 0xd9; | 
| 133 | 0 |         nDefaultPort = 8333; | 
| 134 | 0 |         nPruneAfterHeight = 100000; | 
| 135 | 0 |         m_assumed_blockchain_size = 810; | 
| 136 | 0 |         m_assumed_chain_state_size = 14; | 
| 137 |  | 
 | 
| 138 | 0 |         genesis = CreateGenesisBlock(1231006505, 2083236893, 0x1d00ffff, 1, 50 * COIN); | 
| 139 | 0 |         consensus.hashGenesisBlock = genesis.GetHash(); | 
| 140 | 0 |         assert(consensus.hashGenesisBlock == uint256{"000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"}); | 
| 141 | 0 |         assert(genesis.hashMerkleRoot == uint256{"4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"}); | 
| 142 |  |  | 
| 143 |  |         // Note that of those which support the service bits prefix, most only support a subset of | 
| 144 |  |         // possible options. | 
| 145 |  |         // This is fine at runtime as we'll fall back to using them as an addrfetch if they don't support the | 
| 146 |  |         // service bits we want, but we should get them updated to support all service bits wanted by any | 
| 147 |  |         // release ASAP to avoid it where possible. | 
| 148 | 0 |         vSeeds.emplace_back("seed.bitcoin.sipa.be."); // Pieter Wuille, only supports x1, x5, x9, and xd | 
| 149 | 0 |         vSeeds.emplace_back("dnsseed.bluematt.me."); // Matt Corallo, only supports x9 | 
| 150 | 0 |         vSeeds.emplace_back("dnsseed.bitcoin.dashjr-list-of-p2p-nodes.us."); // Luke Dashjr | 
| 151 | 0 |         vSeeds.emplace_back("seed.bitcoin.jonasschnelli.ch."); // Jonas Schnelli, only supports x1, x5, x9, and xd | 
| 152 | 0 |         vSeeds.emplace_back("seed.btc.petertodd.net."); // Peter Todd, only supports x1, x5, x9, and xd | 
| 153 | 0 |         vSeeds.emplace_back("seed.bitcoin.sprovoost.nl."); // Sjors Provoost | 
| 154 | 0 |         vSeeds.emplace_back("dnsseed.emzy.de."); // Stephan Oeste | 
| 155 | 0 |         vSeeds.emplace_back("seed.bitcoin.wiz.biz."); // Jason Maurice | 
| 156 | 0 |         vSeeds.emplace_back("seed.mainnet.achownodes.xyz."); // Ava Chow, only supports x1, x5, x9, x49, x809, x849, xd, x400, x404, x408, x448, xc08, xc48, x40c | 
| 157 |  | 
 | 
| 158 | 0 |         base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,0); | 
| 159 | 0 |         base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,5); | 
| 160 | 0 |         base58Prefixes[SECRET_KEY] =     std::vector<unsigned char>(1,128); | 
| 161 | 0 |         base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x88, 0xB2, 0x1E}; | 
| 162 | 0 |         base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4}; | 
| 163 |  | 
 | 
| 164 | 0 |         bech32_hrp = "bc"; | 
| 165 |  | 
 | 
| 166 | 0 |         vFixedSeeds = std::vector<uint8_t>(std::begin(chainparams_seed_main), std::end(chainparams_seed_main)); | 
| 167 |  | 
 | 
| 168 | 0 |         fDefaultConsistencyChecks = false; | 
| 169 | 0 |         m_is_mockable_chain = false; | 
| 170 |  | 
 | 
| 171 | 0 |         m_assumeutxo_data = { | 
| 172 | 0 |             { | 
| 173 | 0 |                 .height = 840'000, | 
| 174 | 0 |                 .hash_serialized = AssumeutxoHash{uint256{"a2a5521b1b5ab65f67818e5e8eccabb7171a517f9e2382208f77687310768f96"}}, | 
| 175 | 0 |                 .m_chain_tx_count = 991032194, | 
| 176 | 0 |                 .blockhash = consteval_ctor(uint256{"0000000000000000000320283a032748cef8227873ff4872689bf23f1cda83a5"}), | 
| 177 | 0 |             }, | 
| 178 | 0 |             { | 
| 179 | 0 |                 .height = 880'000, | 
| 180 | 0 |                 .hash_serialized = AssumeutxoHash{uint256{"dbd190983eaf433ef7c15f78a278ae42c00ef52e0fd2a54953782175fbadcea9"}}, | 
| 181 | 0 |                 .m_chain_tx_count = 1145604538, | 
| 182 | 0 |                 .blockhash = consteval_ctor(uint256{"000000000000000000010b17283c3c400507969a9c2afd1dcf2082ec5cca2880"}), | 
| 183 | 0 |             }, | 
| 184 | 0 |             { | 
| 185 | 0 |                 .height = 910'000, | 
| 186 | 0 |                 .hash_serialized = AssumeutxoHash{uint256{"4daf8a17b4902498c5787966a2b51c613acdab5df5db73f196fa59a4da2f1568"}}, | 
| 187 | 0 |                 .m_chain_tx_count = 1226586151, | 
| 188 | 0 |                 .blockhash = consteval_ctor(uint256{"0000000000000000000108970acb9522ffd516eae17acddcb1bd16469194a821"}), | 
| 189 | 0 |             } | 
| 190 | 0 |         }; | 
| 191 |  | 
 | 
| 192 | 0 |         chainTxData = ChainTxData{ | 
| 193 |  |             // Data from RPC: getchaintxstats 4096 00000000000000000000611fd22f2df7c8fbd0688745c3a6c3bb5109cc2a12cb | 
| 194 | 0 |             .nTime    = 1756722903, | 
| 195 | 0 |             .tx_count = 1235299397, | 
| 196 | 0 |             .dTxRate  = 5.456290459519495, | 
| 197 | 0 |         }; | 
| 198 | 0 |     } | 
| 199 |  | }; | 
| 200 |  |  | 
| 201 |  | /** | 
| 202 |  |  * Testnet (v3): public test network which is reset from time to time. | 
| 203 |  |  */ | 
| 204 |  | class CTestNetParams : public CChainParams { | 
| 205 |  | public: | 
| 206 | 0 |     CTestNetParams() { | 
| 207 | 0 |         m_chain_type = ChainType::TESTNET; | 
| 208 | 0 |         consensus.signet_blocks = false; | 
| 209 | 0 |         consensus.signet_challenge.clear(); | 
| 210 | 0 |         consensus.nSubsidyHalvingInterval = 210000; | 
| 211 | 0 |         consensus.script_flag_exceptions.emplace( // BIP16 exception | 
| 212 | 0 |             uint256{"00000000dd30457c001f4095d208cc1296b0eed002427aa599874af7a432b105"}, SCRIPT_VERIFY_NONE); | 
| 213 | 0 |         consensus.BIP34Height = 21111; | 
| 214 | 0 |         consensus.BIP34Hash = uint256{"0000000023b3a96d3484e5abb3755c413e7d41500f8e2a5c3f0dd01299cd8ef8"}; | 
| 215 | 0 |         consensus.BIP65Height = 581885; // 00000000007f6655f22f98e72ed80d8b06dc761d5da09df0fa1dc4be4f861eb6 | 
| 216 | 0 |         consensus.BIP66Height = 330776; // 000000002104c8c45e99a8853285a3b592602a3ccde2b832481da85e9e4ba182 | 
| 217 | 0 |         consensus.CSVHeight = 770112; // 00000000025e930139bac5c6c31a403776da130831ab85be56578f3fa75369bb | 
| 218 | 0 |         consensus.SegwitHeight = 834624; // 00000000002b980fcd729daaa248fd9316a5200e9b367f4ff2c42453e84201ca | 
| 219 | 0 |         consensus.MinBIP9WarningHeight = 836640; // segwit activation height + miner confirmation window | 
| 220 | 0 |         consensus.powLimit = uint256{"00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"}; | 
| 221 | 0 |         consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks | 
| 222 | 0 |         consensus.nPowTargetSpacing = 10 * 60; | 
| 223 | 0 |         consensus.fPowAllowMinDifficultyBlocks = true; | 
| 224 | 0 |         consensus.enforce_BIP94 = false; | 
| 225 | 0 |         consensus.fPowNoRetargeting = false; | 
| 226 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28; | 
| 227 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE; | 
| 228 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT; | 
| 229 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].min_activation_height = 0; // No activation delay | 
| 230 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].threshold = 1512; // 75% | 
| 231 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].period = 2016; | 
| 232 |  |  | 
| 233 |  |         // Deployment of Taproot (BIPs 340-342) | 
| 234 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].bit = 2; | 
| 235 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartTime = 1619222400; // April 24th, 2021 | 
| 236 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeout = 1628640000; // August 11th, 2021 | 
| 237 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 0; // No activation delay | 
| 238 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].threshold = 1512; // 75% | 
| 239 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].period = 2016; | 
| 240 |  | 
 | 
| 241 | 0 |         consensus.nMinimumChainWork = uint256{"0000000000000000000000000000000000000000000016dd270dd94fac1d7632"}; | 
| 242 | 0 |         consensus.defaultAssumeValid = uint256{"0000000000000065c6c38258e201971a3fdfcc2ceee0dd6e85a6c022d45dee34"}; // 4550000 | 
| 243 |  | 
 | 
| 244 | 0 |         pchMessageStart[0] = 0x0b; | 
| 245 | 0 |         pchMessageStart[1] = 0x11; | 
| 246 | 0 |         pchMessageStart[2] = 0x09; | 
| 247 | 0 |         pchMessageStart[3] = 0x07; | 
| 248 | 0 |         nDefaultPort = 18333; | 
| 249 | 0 |         nPruneAfterHeight = 1000; | 
| 250 | 0 |         m_assumed_blockchain_size = 240; | 
| 251 | 0 |         m_assumed_chain_state_size = 19; | 
| 252 |  | 
 | 
| 253 | 0 |         genesis = CreateGenesisBlock(1296688602, 414098458, 0x1d00ffff, 1, 50 * COIN); | 
| 254 | 0 |         consensus.hashGenesisBlock = genesis.GetHash(); | 
| 255 | 0 |         assert(consensus.hashGenesisBlock == uint256{"000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"}); | 
| 256 | 0 |         assert(genesis.hashMerkleRoot == uint256{"4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"}); | 
| 257 |  |  | 
| 258 | 0 |         vFixedSeeds.clear(); | 
| 259 | 0 |         vSeeds.clear(); | 
| 260 |  |         // nodes with support for servicebits filtering should be at the top | 
| 261 | 0 |         vSeeds.emplace_back("testnet-seed.bitcoin.jonasschnelli.ch."); | 
| 262 | 0 |         vSeeds.emplace_back("seed.tbtc.petertodd.net."); | 
| 263 | 0 |         vSeeds.emplace_back("seed.testnet.bitcoin.sprovoost.nl."); | 
| 264 | 0 |         vSeeds.emplace_back("testnet-seed.bluematt.me."); // Just a static list of stable node(s), only supports x9 | 
| 265 | 0 |         vSeeds.emplace_back("seed.testnet.achownodes.xyz."); // Ava Chow, only supports x1, x5, x9, x49, x809, x849, xd, x400, x404, x408, x448, xc08, xc48, x40c | 
| 266 |  | 
 | 
| 267 | 0 |         base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111); | 
| 268 | 0 |         base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196); | 
| 269 | 0 |         base58Prefixes[SECRET_KEY] =     std::vector<unsigned char>(1,239); | 
| 270 | 0 |         base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF}; | 
| 271 | 0 |         base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94}; | 
| 272 |  | 
 | 
| 273 | 0 |         bech32_hrp = "tb"; | 
| 274 |  | 
 | 
| 275 | 0 |         vFixedSeeds = std::vector<uint8_t>(std::begin(chainparams_seed_test), std::end(chainparams_seed_test)); | 
| 276 |  | 
 | 
| 277 | 0 |         fDefaultConsistencyChecks = false; | 
| 278 | 0 |         m_is_mockable_chain = false; | 
| 279 |  | 
 | 
| 280 | 0 |         m_assumeutxo_data = { | 
| 281 | 0 |             { | 
| 282 | 0 |                 .height = 2'500'000, | 
| 283 | 0 |                 .hash_serialized = AssumeutxoHash{uint256{"f841584909f68e47897952345234e37fcd9128cd818f41ee6c3ca68db8071be7"}}, | 
| 284 | 0 |                 .m_chain_tx_count = 66484552, | 
| 285 | 0 |                 .blockhash = consteval_ctor(uint256{"0000000000000093bcb68c03a9a168ae252572d348a2eaeba2cdf9231d73206f"}), | 
| 286 | 0 |             } | 
| 287 | 0 |         }; | 
| 288 |  | 
 | 
| 289 | 0 |         chainTxData = ChainTxData{ | 
| 290 |  |             // Data from RPC: getchaintxstats 4096 0000000000000065c6c38258e201971a3fdfcc2ceee0dd6e85a6c022d45dee34 | 
| 291 | 0 |             .nTime    = 1751816758, | 
| 292 | 0 |             .tx_count = 508468699, | 
| 293 | 0 |             .dTxRate  = 7.172978845985714, | 
| 294 | 0 |         }; | 
| 295 | 0 |     } | 
| 296 |  | }; | 
| 297 |  |  | 
| 298 |  | /** | 
| 299 |  |  * Testnet (v4): public test network which is reset from time to time. | 
| 300 |  |  */ | 
| 301 |  | class CTestNet4Params : public CChainParams { | 
| 302 |  | public: | 
| 303 | 0 |     CTestNet4Params() { | 
| 304 | 0 |         m_chain_type = ChainType::TESTNET4; | 
| 305 | 0 |         consensus.signet_blocks = false; | 
| 306 | 0 |         consensus.signet_challenge.clear(); | 
| 307 | 0 |         consensus.nSubsidyHalvingInterval = 210000; | 
| 308 | 0 |         consensus.BIP34Height = 1; | 
| 309 | 0 |         consensus.BIP34Hash = uint256{}; | 
| 310 | 0 |         consensus.BIP65Height = 1; | 
| 311 | 0 |         consensus.BIP66Height = 1; | 
| 312 | 0 |         consensus.CSVHeight = 1; | 
| 313 | 0 |         consensus.SegwitHeight = 1; | 
| 314 | 0 |         consensus.MinBIP9WarningHeight = 0; | 
| 315 | 0 |         consensus.powLimit = uint256{"00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"}; | 
| 316 | 0 |         consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks | 
| 317 | 0 |         consensus.nPowTargetSpacing = 10 * 60; | 
| 318 | 0 |         consensus.fPowAllowMinDifficultyBlocks = true; | 
| 319 | 0 |         consensus.enforce_BIP94 = true; | 
| 320 | 0 |         consensus.fPowNoRetargeting = false; | 
| 321 |  | 
 | 
| 322 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28; | 
| 323 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE; | 
| 324 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT; | 
| 325 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].min_activation_height = 0; // No activation delay | 
| 326 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].threshold = 1512; // 75% | 
| 327 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].period = 2016; | 
| 328 |  |  | 
| 329 |  |         // Deployment of Taproot (BIPs 340-342) | 
| 330 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].bit = 2; | 
| 331 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartTime = Consensus::BIP9Deployment::ALWAYS_ACTIVE; | 
| 332 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT; | 
| 333 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 0; // No activation delay | 
| 334 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].threshold = 1512; // 75% | 
| 335 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].period = 2016; | 
| 336 |  | 
 | 
| 337 | 0 |         consensus.nMinimumChainWork = uint256{"00000000000000000000000000000000000000000000034a4690fe592dc49c7c"}; | 
| 338 | 0 |         consensus.defaultAssumeValid = uint256{"000000000000000180a58e7fa3b0db84b5ea76377524894f53660d93ac839d9b"}; // 91000 | 
| 339 |  | 
 | 
| 340 | 0 |         pchMessageStart[0] = 0x1c; | 
| 341 | 0 |         pchMessageStart[1] = 0x16; | 
| 342 | 0 |         pchMessageStart[2] = 0x3f; | 
| 343 | 0 |         pchMessageStart[3] = 0x28; | 
| 344 | 0 |         nDefaultPort = 48333; | 
| 345 | 0 |         nPruneAfterHeight = 1000; | 
| 346 | 0 |         m_assumed_blockchain_size = 22; | 
| 347 | 0 |         m_assumed_chain_state_size = 2; | 
| 348 |  | 
 | 
| 349 | 0 |         const char* testnet4_genesis_msg = "03/May/2024 000000000000000000001ebd58c244970b3aa9d783bb001011fbe8ea8e98e00e"; | 
| 350 | 0 |         const CScript testnet4_genesis_script = CScript() << "000000000000000000000000000000000000000000000000000000000000000000"_hex << OP_CHECKSIG; | 
| 351 | 0 |         genesis = CreateGenesisBlock(testnet4_genesis_msg, | 
| 352 | 0 |                 testnet4_genesis_script, | 
| 353 | 0 |                 1714777860, | 
| 354 | 0 |                 393743547, | 
| 355 | 0 |                 0x1d00ffff, | 
| 356 | 0 |                 1, | 
| 357 | 0 |                 50 * COIN); | 
| 358 | 0 |         consensus.hashGenesisBlock = genesis.GetHash(); | 
| 359 | 0 |         assert(consensus.hashGenesisBlock == uint256{"00000000da84f2bafbbc53dee25a72ae507ff4914b867c565be350b0da8bf043"}); | 
| 360 | 0 |         assert(genesis.hashMerkleRoot == uint256{"7aa0a7ae1e223414cb807e40cd57e667b718e42aaf9306db9102fe28912b7b4e"}); | 
| 361 |  |  | 
| 362 | 0 |         vFixedSeeds.clear(); | 
| 363 | 0 |         vSeeds.clear(); | 
| 364 |  |         // nodes with support for servicebits filtering should be at the top | 
| 365 | 0 |         vSeeds.emplace_back("seed.testnet4.bitcoin.sprovoost.nl."); // Sjors Provoost | 
| 366 | 0 |         vSeeds.emplace_back("seed.testnet4.wiz.biz."); // Jason Maurice | 
| 367 |  | 
 | 
| 368 | 0 |         base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111); | 
| 369 | 0 |         base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196); | 
| 370 | 0 |         base58Prefixes[SECRET_KEY] =     std::vector<unsigned char>(1,239); | 
| 371 | 0 |         base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF}; | 
| 372 | 0 |         base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94}; | 
| 373 |  | 
 | 
| 374 | 0 |         bech32_hrp = "tb"; | 
| 375 |  | 
 | 
| 376 | 0 |         vFixedSeeds = std::vector<uint8_t>(std::begin(chainparams_seed_testnet4), std::end(chainparams_seed_testnet4)); | 
| 377 |  | 
 | 
| 378 | 0 |         fDefaultConsistencyChecks = false; | 
| 379 | 0 |         m_is_mockable_chain = false; | 
| 380 |  | 
 | 
| 381 | 0 |         m_assumeutxo_data = { | 
| 382 | 0 |             { | 
| 383 | 0 |                 .height = 90'000, | 
| 384 | 0 |                 .hash_serialized = AssumeutxoHash{uint256{"784fb5e98241de66fdd429f4392155c9e7db5c017148e66e8fdbc95746f8b9b5"}}, | 
| 385 | 0 |                 .m_chain_tx_count = 11347043, | 
| 386 | 0 |                 .blockhash = consteval_ctor(uint256{"0000000002ebe8bcda020e0dd6ccfbdfac531d2f6a81457191b99fc2df2dbe3b"}), | 
| 387 | 0 |             } | 
| 388 | 0 |         }; | 
| 389 |  | 
 | 
| 390 | 0 |         chainTxData = ChainTxData{ | 
| 391 |  |             // Data from RPC: getchaintxstats 4096 000000000000000180a58e7fa3b0db84b5ea76377524894f53660d93ac839d9b | 
| 392 | 0 |             .nTime    = 1752470331, | 
| 393 | 0 |             .tx_count = 11414302, | 
| 394 | 0 |             .dTxRate  = 0.2842619757327476, | 
| 395 | 0 |         }; | 
| 396 | 0 |     } | 
| 397 |  | }; | 
| 398 |  |  | 
| 399 |  | /** | 
| 400 |  |  * Signet: test network with an additional consensus parameter (see BIP325). | 
| 401 |  |  */ | 
| 402 |  | class SigNetParams : public CChainParams { | 
| 403 |  | public: | 
| 404 |  |     explicit SigNetParams(const SigNetOptions& options) | 
| 405 | 0 |     { | 
| 406 | 0 |         std::vector<uint8_t> bin; | 
| 407 | 0 |         vFixedSeeds.clear(); | 
| 408 | 0 |         vSeeds.clear(); | 
| 409 |  | 
 | 
| 410 | 0 |         if (!options.challenge) { | 
| 411 | 0 |             bin = "512103ad5e0edad18cb1f0fc0d28a3d4f1f3e445640337489abb10404f2d1e086be430210359ef5021964fe22d6f8e05b2463c9540ce96883fe3b278760f048f5189f2e6c452ae"_hex_v_u8; | 
| 412 | 0 |             vFixedSeeds = std::vector<uint8_t>(std::begin(chainparams_seed_signet), std::end(chainparams_seed_signet)); | 
| 413 | 0 |             vSeeds.emplace_back("seed.signet.bitcoin.sprovoost.nl."); | 
| 414 | 0 |             vSeeds.emplace_back("seed.signet.achownodes.xyz."); // Ava Chow, only supports x1, x5, x9, x49, x809, x849, xd, x400, x404, x408, x448, xc08, xc48, x40c | 
| 415 |  | 
 | 
| 416 | 0 |             consensus.nMinimumChainWork = uint256{"0000000000000000000000000000000000000000000000000000067d328e681a"}; | 
| 417 | 0 |             consensus.defaultAssumeValid = uint256{"000000128586e26813922680309f04e1de713c7542fee86ed908f56368aefe2e"}; // 267665 | 
| 418 | 0 |             m_assumed_blockchain_size = 20; | 
| 419 | 0 |             m_assumed_chain_state_size = 4; | 
| 420 | 0 |             chainTxData = ChainTxData{ | 
| 421 |  |                 // Data from RPC: getchaintxstats 4096 000000128586e26813922680309f04e1de713c7542fee86ed908f56368aefe2e | 
| 422 | 0 |                 .nTime    = 1756723017, | 
| 423 | 0 |                 .tx_count = 26185472, | 
| 424 | 0 |                 .dTxRate  = 0.7452721495389969, | 
| 425 | 0 |             }; | 
| 426 | 0 |         } else { | 
| 427 | 0 |             bin = *options.challenge; | 
| 428 | 0 |             consensus.nMinimumChainWork = uint256{}; | 
| 429 | 0 |             consensus.defaultAssumeValid = uint256{}; | 
| 430 | 0 |             m_assumed_blockchain_size = 0; | 
| 431 | 0 |             m_assumed_chain_state_size = 0; | 
| 432 | 0 |             chainTxData = ChainTxData{ | 
| 433 | 0 |                 0, | 
| 434 | 0 |                 0, | 
| 435 | 0 |                 0, | 
| 436 | 0 |             }; | 
| 437 | 0 |             LogInfo("Signet with challenge %s", HexStr(bin)); | 
| 438 | 0 |         } | 
| 439 |  | 
 | 
| 440 | 0 |         if (options.seeds) { | 
| 441 | 0 |             vSeeds = *options.seeds; | 
| 442 | 0 |         } | 
| 443 |  | 
 | 
| 444 | 0 |         m_chain_type = ChainType::SIGNET; | 
| 445 | 0 |         consensus.signet_blocks = true; | 
| 446 | 0 |         consensus.signet_challenge.assign(bin.begin(), bin.end()); | 
| 447 | 0 |         consensus.nSubsidyHalvingInterval = 210000; | 
| 448 | 0 |         consensus.BIP34Height = 1; | 
| 449 | 0 |         consensus.BIP34Hash = uint256{}; | 
| 450 | 0 |         consensus.BIP65Height = 1; | 
| 451 | 0 |         consensus.BIP66Height = 1; | 
| 452 | 0 |         consensus.CSVHeight = 1; | 
| 453 | 0 |         consensus.SegwitHeight = 1; | 
| 454 | 0 |         consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks | 
| 455 | 0 |         consensus.nPowTargetSpacing = 10 * 60; | 
| 456 | 0 |         consensus.fPowAllowMinDifficultyBlocks = false; | 
| 457 | 0 |         consensus.enforce_BIP94 = false; | 
| 458 | 0 |         consensus.fPowNoRetargeting = false; | 
| 459 | 0 |         consensus.MinBIP9WarningHeight = 0; | 
| 460 | 0 |         consensus.powLimit = uint256{"00000377ae000000000000000000000000000000000000000000000000000000"}; | 
| 461 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28; | 
| 462 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = Consensus::BIP9Deployment::NEVER_ACTIVE; | 
| 463 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT; | 
| 464 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].min_activation_height = 0; // No activation delay | 
| 465 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].threshold = 1815; // 90% | 
| 466 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].period = 2016; | 
| 467 |  |  | 
| 468 |  |         // Activation of Taproot (BIPs 340-342) | 
| 469 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].bit = 2; | 
| 470 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartTime = Consensus::BIP9Deployment::ALWAYS_ACTIVE; | 
| 471 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT; | 
| 472 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 0; // No activation delay | 
| 473 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].threshold = 1815; // 90% | 
| 474 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].period = 2016; | 
| 475 |  |  | 
| 476 |  |         // message start is defined as the first 4 bytes of the sha256d of the block script | 
| 477 | 0 |         HashWriter h{}; | 
| 478 | 0 |         h << consensus.signet_challenge; | 
| 479 | 0 |         uint256 hash = h.GetHash(); | 
| 480 | 0 |         std::copy_n(hash.begin(), 4, pchMessageStart.begin()); | 
| 481 |  | 
 | 
| 482 | 0 |         nDefaultPort = 38333; | 
| 483 | 0 |         nPruneAfterHeight = 1000; | 
| 484 |  | 
 | 
| 485 | 0 |         genesis = CreateGenesisBlock(1598918400, 52613770, 0x1e0377ae, 1, 50 * COIN); | 
| 486 | 0 |         consensus.hashGenesisBlock = genesis.GetHash(); | 
| 487 | 0 |         assert(consensus.hashGenesisBlock == uint256{"00000008819873e925422c1ff0f99f7cc9bbb232af63a077a480a3633bee1ef6"}); | 
| 488 | 0 |         assert(genesis.hashMerkleRoot == uint256{"4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"}); | 
| 489 |  |  | 
| 490 | 0 |         m_assumeutxo_data = { | 
| 491 | 0 |             { | 
| 492 | 0 |                 .height = 160'000, | 
| 493 | 0 |                 .hash_serialized = AssumeutxoHash{uint256{"fe0a44309b74d6b5883d246cb419c6221bcccf0b308c9b59b7d70783dbdf928a"}}, | 
| 494 | 0 |                 .m_chain_tx_count = 2289496, | 
| 495 | 0 |                 .blockhash = consteval_ctor(uint256{"0000003ca3c99aff040f2563c2ad8f8ec88bd0fd6b8f0895cfaf1ef90353a62c"}), | 
| 496 | 0 |             } | 
| 497 | 0 |         }; | 
| 498 |  | 
 | 
| 499 | 0 |         base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111); | 
| 500 | 0 |         base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196); | 
| 501 | 0 |         base58Prefixes[SECRET_KEY] =     std::vector<unsigned char>(1,239); | 
| 502 | 0 |         base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF}; | 
| 503 | 0 |         base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94}; | 
| 504 |  | 
 | 
| 505 | 0 |         bech32_hrp = "tb"; | 
| 506 |  | 
 | 
| 507 | 0 |         fDefaultConsistencyChecks = false; | 
| 508 | 0 |         m_is_mockable_chain = false; | 
| 509 | 0 |     } | 
| 510 |  | }; | 
| 511 |  |  | 
| 512 |  | /** | 
| 513 |  |  * Regression test: intended for private networks only. Has minimal difficulty to ensure that | 
| 514 |  |  * blocks can be found instantly. | 
| 515 |  |  */ | 
| 516 |  | class CRegTestParams : public CChainParams | 
| 517 |  | { | 
| 518 |  | public: | 
| 519 |  |     explicit CRegTestParams(const RegTestOptions& opts) | 
| 520 | 0 |     { | 
| 521 | 0 |         m_chain_type = ChainType::REGTEST; | 
| 522 | 0 |         consensus.signet_blocks = false; | 
| 523 | 0 |         consensus.signet_challenge.clear(); | 
| 524 | 0 |         consensus.nSubsidyHalvingInterval = 150; | 
| 525 | 0 |         consensus.BIP34Height = 1; // Always active unless overridden | 
| 526 | 0 |         consensus.BIP34Hash = uint256(); | 
| 527 | 0 |         consensus.BIP65Height = 1;  // Always active unless overridden | 
| 528 | 0 |         consensus.BIP66Height = 1;  // Always active unless overridden | 
| 529 | 0 |         consensus.CSVHeight = 1;    // Always active unless overridden | 
| 530 | 0 |         consensus.SegwitHeight = 0; // Always active unless overridden | 
| 531 | 0 |         consensus.MinBIP9WarningHeight = 0; | 
| 532 | 0 |         consensus.powLimit = uint256{"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"}; | 
| 533 | 0 |         consensus.nPowTargetTimespan = 24 * 60 * 60; // one day | 
| 534 | 0 |         consensus.nPowTargetSpacing = 10 * 60; | 
| 535 | 0 |         consensus.fPowAllowMinDifficultyBlocks = true; | 
| 536 | 0 |         consensus.enforce_BIP94 = opts.enforce_bip94; | 
| 537 | 0 |         consensus.fPowNoRetargeting = true; | 
| 538 |  | 
 | 
| 539 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28; | 
| 540 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = 0; | 
| 541 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT; | 
| 542 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].min_activation_height = 0; // No activation delay | 
| 543 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].threshold = 108; // 75% | 
| 544 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].period = 144; // Faster than normal for regtest (144 instead of 2016) | 
| 545 |  | 
 | 
| 546 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].bit = 2; | 
| 547 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nStartTime = Consensus::BIP9Deployment::ALWAYS_ACTIVE; | 
| 548 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT; | 
| 549 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].min_activation_height = 0; // No activation delay | 
| 550 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].threshold = 108; // 75% | 
| 551 | 0 |         consensus.vDeployments[Consensus::DEPLOYMENT_TAPROOT].period = 144; | 
| 552 |  | 
 | 
| 553 | 0 |         consensus.nMinimumChainWork = uint256{}; | 
| 554 | 0 |         consensus.defaultAssumeValid = uint256{}; | 
| 555 |  | 
 | 
| 556 | 0 |         pchMessageStart[0] = 0xfa; | 
| 557 | 0 |         pchMessageStart[1] = 0xbf; | 
| 558 | 0 |         pchMessageStart[2] = 0xb5; | 
| 559 | 0 |         pchMessageStart[3] = 0xda; | 
| 560 | 0 |         nDefaultPort = 18444; | 
| 561 | 0 |         nPruneAfterHeight = opts.fastprune ? 100 : 1000; | 
| 562 | 0 |         m_assumed_blockchain_size = 0; | 
| 563 | 0 |         m_assumed_chain_state_size = 0; | 
| 564 |  | 
 | 
| 565 | 0 |         for (const auto& [dep, height] : opts.activation_heights) { | 
| 566 | 0 |             switch (dep) { | 
| 567 | 0 |             case Consensus::BuriedDeployment::DEPLOYMENT_SEGWIT: | 
| 568 | 0 |                 consensus.SegwitHeight = int{height}; | 
| 569 | 0 |                 break; | 
| 570 | 0 |             case Consensus::BuriedDeployment::DEPLOYMENT_HEIGHTINCB: | 
| 571 | 0 |                 consensus.BIP34Height = int{height}; | 
| 572 | 0 |                 break; | 
| 573 | 0 |             case Consensus::BuriedDeployment::DEPLOYMENT_DERSIG: | 
| 574 | 0 |                 consensus.BIP66Height = int{height}; | 
| 575 | 0 |                 break; | 
| 576 | 0 |             case Consensus::BuriedDeployment::DEPLOYMENT_CLTV: | 
| 577 | 0 |                 consensus.BIP65Height = int{height}; | 
| 578 | 0 |                 break; | 
| 579 | 0 |             case Consensus::BuriedDeployment::DEPLOYMENT_CSV: | 
| 580 | 0 |                 consensus.CSVHeight = int{height}; | 
| 581 | 0 |                 break; | 
| 582 | 0 |             } | 
| 583 | 0 |         } | 
| 584 |  |  | 
| 585 | 0 |         for (const auto& [deployment_pos, version_bits_params] : opts.version_bits_parameters) { | 
| 586 | 0 |             consensus.vDeployments[deployment_pos].nStartTime = version_bits_params.start_time; | 
| 587 | 0 |             consensus.vDeployments[deployment_pos].nTimeout = version_bits_params.timeout; | 
| 588 | 0 |             consensus.vDeployments[deployment_pos].min_activation_height = version_bits_params.min_activation_height; | 
| 589 | 0 |         } | 
| 590 |  | 
 | 
| 591 | 0 |         genesis = CreateGenesisBlock(1296688602, 2, 0x207fffff, 1, 50 * COIN); | 
| 592 | 0 |         consensus.hashGenesisBlock = genesis.GetHash(); | 
| 593 | 0 |         assert(consensus.hashGenesisBlock == uint256{"0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"}); | 
| 594 | 0 |         assert(genesis.hashMerkleRoot == uint256{"4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"}); | 
| 595 |  |  | 
| 596 | 0 |         vFixedSeeds.clear(); //!< Regtest mode doesn't have any fixed seeds. | 
| 597 | 0 |         vSeeds.clear(); | 
| 598 | 0 |         vSeeds.emplace_back("dummySeed.invalid."); | 
| 599 |  | 
 | 
| 600 | 0 |         fDefaultConsistencyChecks = true; | 
| 601 | 0 |         m_is_mockable_chain = true; | 
| 602 |  | 
 | 
| 603 | 0 |         m_assumeutxo_data = { | 
| 604 | 0 |             {   // For use by unit tests | 
| 605 | 0 |                 .height = 110, | 
| 606 | 0 |                 .hash_serialized = AssumeutxoHash{uint256{"b952555c8ab81fec46f3d4253b7af256d766ceb39fb7752b9d18cdf4a0141327"}}, | 
| 607 | 0 |                 .m_chain_tx_count = 111, | 
| 608 | 0 |                 .blockhash = consteval_ctor(uint256{"6affe030b7965ab538f820a56ef56c8149b7dc1d1c144af57113be080db7c397"}), | 
| 609 | 0 |             }, | 
| 610 | 0 |             { | 
| 611 |  |                 // For use by fuzz target src/test/fuzz/utxo_snapshot.cpp | 
| 612 | 0 |                 .height = 200, | 
| 613 | 0 |                 .hash_serialized = AssumeutxoHash{uint256{"17dcc016d188d16068907cdeb38b75691a118d43053b8cd6a25969419381d13a"}}, | 
| 614 | 0 |                 .m_chain_tx_count = 201, | 
| 615 | 0 |                 .blockhash = consteval_ctor(uint256{"385901ccbd69dff6bbd00065d01fb8a9e464dede7cfe0372443884f9b1dcf6b9"}), | 
| 616 | 0 |             }, | 
| 617 | 0 |             { | 
| 618 |  |                 // For use by test/functional/feature_assumeutxo.py | 
| 619 | 0 |                 .height = 299, | 
| 620 | 0 |                 .hash_serialized = AssumeutxoHash{uint256{"d2b051ff5e8eef46520350776f4100dd710a63447a8e01d917e92e79751a63e2"}}, | 
| 621 | 0 |                 .m_chain_tx_count = 334, | 
| 622 | 0 |                 .blockhash = consteval_ctor(uint256{"7cc695046fec709f8c9394b6f928f81e81fd3ac20977bb68760fa1faa7916ea2"}), | 
| 623 | 0 |             }, | 
| 624 | 0 |         }; | 
| 625 |  | 
 | 
| 626 | 0 |         chainTxData = ChainTxData{ | 
| 627 | 0 |             .nTime = 0, | 
| 628 | 0 |             .tx_count = 0, | 
| 629 | 0 |             .dTxRate = 0.001, // Set a non-zero rate to make it testable | 
| 630 | 0 |         }; | 
| 631 |  | 
 | 
| 632 | 0 |         base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111); | 
| 633 | 0 |         base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196); | 
| 634 | 0 |         base58Prefixes[SECRET_KEY] =     std::vector<unsigned char>(1,239); | 
| 635 | 0 |         base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF}; | 
| 636 | 0 |         base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94}; | 
| 637 |  | 
 | 
| 638 | 0 |         bech32_hrp = "bcrt"; | 
| 639 | 0 |     } | 
| 640 |  | }; | 
| 641 |  |  | 
| 642 |  | std::unique_ptr<const CChainParams> CChainParams::SigNet(const SigNetOptions& options) | 
| 643 | 0 | { | 
| 644 | 0 |     return std::make_unique<const SigNetParams>(options); | 
| 645 | 0 | } | 
| 646 |  |  | 
| 647 |  | std::unique_ptr<const CChainParams> CChainParams::RegTest(const RegTestOptions& options) | 
| 648 | 0 | { | 
| 649 | 0 |     return std::make_unique<const CRegTestParams>(options); | 
| 650 | 0 | } | 
| 651 |  |  | 
| 652 |  | std::unique_ptr<const CChainParams> CChainParams::Main() | 
| 653 | 0 | { | 
| 654 | 0 |     return std::make_unique<const CMainParams>(); | 
| 655 | 0 | } | 
| 656 |  |  | 
| 657 |  | std::unique_ptr<const CChainParams> CChainParams::TestNet() | 
| 658 | 0 | { | 
| 659 | 0 |     return std::make_unique<const CTestNetParams>(); | 
| 660 | 0 | } | 
| 661 |  |  | 
| 662 |  | std::unique_ptr<const CChainParams> CChainParams::TestNet4() | 
| 663 | 0 | { | 
| 664 | 0 |     return std::make_unique<const CTestNet4Params>(); | 
| 665 | 0 | } | 
| 666 |  |  | 
| 667 |  | std::vector<int> CChainParams::GetAvailableSnapshotHeights() const | 
| 668 | 0 | { | 
| 669 | 0 |     std::vector<int> heights; | 
| 670 | 0 |     heights.reserve(m_assumeutxo_data.size()); | 
| 671 |  | 
 | 
| 672 | 0 |     for (const auto& data : m_assumeutxo_data) { | 
| 673 | 0 |         heights.emplace_back(data.height); | 
| 674 | 0 |     } | 
| 675 | 0 |     return heights; | 
| 676 | 0 | } | 
| 677 |  |  | 
| 678 |  | std::optional<ChainType> GetNetworkForMagic(const MessageStartChars& message) | 
| 679 | 0 | { | 
| 680 | 0 |     const auto mainnet_msg = CChainParams::Main()->MessageStart(); | 
| 681 | 0 |     const auto testnet_msg = CChainParams::TestNet()->MessageStart(); | 
| 682 | 0 |     const auto testnet4_msg = CChainParams::TestNet4()->MessageStart(); | 
| 683 | 0 |     const auto regtest_msg = CChainParams::RegTest({})->MessageStart(); | 
| 684 | 0 |     const auto signet_msg = CChainParams::SigNet({})->MessageStart(); | 
| 685 |  | 
 | 
| 686 | 0 |     if (std::ranges::equal(message, mainnet_msg)) { | 
| 687 | 0 |         return ChainType::MAIN; | 
| 688 | 0 |     } else if (std::ranges::equal(message, testnet_msg)) { | 
| 689 | 0 |         return ChainType::TESTNET; | 
| 690 | 0 |     } else if (std::ranges::equal(message, testnet4_msg)) { | 
| 691 | 0 |         return ChainType::TESTNET4; | 
| 692 | 0 |     } else if (std::ranges::equal(message, regtest_msg)) { | 
| 693 | 0 |         return ChainType::REGTEST; | 
| 694 | 0 |     } else if (std::ranges::equal(message, signet_msg)) { | 
| 695 | 0 |         return ChainType::SIGNET; | 
| 696 | 0 |     } | 
| 697 | 0 |     return std::nullopt; | 
| 698 | 0 | } |