LCOV - code coverage report
Current view: top level - src/kernel - chainparams.cpp (source / functions) Coverage Total Hit
Test: fuzz_coverage.info Lines: 93.2 % 427 398
Test Date: 2025-09-10 04:04:06 Functions: 100.0 % 14 14
Branches: 49.4 % 316 156

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

Generated by: LCOV version 2.0-1