chainparams.cpp

Go to the documentation of this file.

// Copyright (c) 2010 Satoshi Nakamoto
// Copyright (c) 2009-2016 The Bitcoin Core developers
// Copyright (c) 2017-2020 The Bitcoin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#include <chainparams.h>
 
#include <chainparamsconstants.h>
#include <chainparamsseeds.h>
#include <consensus/merkle.h>
#include <currencyunit.h>
#include <tinyformat.h>
#include <util/system.h>
 
#include <cassert>
 
static CBlock CreateGenesisBlock(const char *pszTimestamp,
                                 const CScript &genesisOutputScript,
                                 uint32_t nTime, uint32_t nNonce,
                                 uint32_t nBits, int32_t nVersion,
                                 const Amount genesisReward) {
    CMutableTransaction txNew;
    txNew.nVersion = 1;
    txNew.vin.resize(1);
    txNew.vout.resize(1);
    txNew.vin[0].scriptSig =
        CScript() << 486604799 << CScriptNum(4)
                  << std::vector<uint8_t>((const uint8_t *)pszTimestamp,
                                          (const uint8_t *)pszTimestamp +
                                              strlen(pszTimestamp));
    txNew.vout[0].nValue = genesisReward;
    txNew.vout[0].scriptPubKey = genesisOutputScript;
 
    CBlock genesis;
    genesis.nTime = nTime;
    genesis.nBits = nBits;
    genesis.nNonce = nNonce;
    genesis.nVersion = nVersion;
    genesis.vtx.push_back(MakeTransactionRef(std::move(txNew)));
    genesis.hashPrevBlock.SetNull();
    genesis.hashMerkleRoot = BlockMerkleRoot(genesis);
    return genesis;
}
 
CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits,
                          int32_t nVersion, const Amount genesisReward) {
    const char *pszTimestamp =
        "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks";
    const CScript genesisOutputScript =
        CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909"
                              "a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112"
                              "de5c384df7ba0b8d578a4c702b6bf11d5f")
                  << OP_CHECKSIG;
    return CreateGenesisBlock(pszTimestamp, genesisOutputScript, nTime, nNonce,
                              nBits, nVersion, genesisReward);
}
 
class CMainParams : public CChainParams {
public:
    CMainParams() {
        strNetworkID = CBaseChainParams::MAIN;
        consensus.nSubsidyHalvingInterval = 210000;
        // 00000000000000ce80a7e057163a4db1d5ad7b20fb6f598c9597b9665c8fb0d4 -
        // April 1, 2012
        consensus.BIP16Height = 173805;
        consensus.BIP34Height = 227931;
        consensus.BIP34Hash = BlockHash::fromHex(
            "000000000000024b89b42a942fe0d9fea3bb44ab7bd1b19115dd6a759c0808b8");
        // 000000000000000004c2b624ed5d7756c508d90fd0da2c7c679febfa6c4735f0
        consensus.BIP65Height = 388381;
        // 00000000000000000379eaa19dce8c9b722d46ae6a57c2f1a988119488b50931
        consensus.BIP66Height = 363725;
        // 000000000000000004a1b34462cb8aeebd5799177f7a29cf28f2d1961716b5b5
        consensus.CSVHeight = 419328;
        consensus.powLimit = uint256S(
            "00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
        // two weeks
        consensus.nPowTargetTimespan = 14 * 24 * 60 * 60;
        consensus.nPowTargetSpacing = 10 * 60;
        consensus.fPowAllowMinDifficultyBlocks = false;
        consensus.fPowNoRetargeting = false;
 
        // two days
        consensus.nDAAHalfLife = 2 * 24 * 60 * 60;
 
        // nPowTargetTimespan / nPowTargetSpacing
        consensus.nMinerConfirmationWindow = 2016;
        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY] = {
            .bit = 28,
            // 95% of 2016
            .nActivationThreshold = 1916,
            // January 1, 2008
            .nStartTime = 1199145601,
            // December 31, 2008
            .nTimeout = 1230767999,
        };
 
        // The miner fund is enabled by default on mainnet.
        consensus.enableMinerFund = true;
 
        // The best chain should have at least this much work.
        consensus.nMinimumChainWork =
            ChainParamsConstants::MAINNET_MINIMUM_CHAIN_WORK;
 
        // By default assume that the signatures in ancestors of this block are
        // valid.
        consensus.defaultAssumeValid =
            ChainParamsConstants::MAINNET_DEFAULT_ASSUME_VALID;
 
        // August 1, 2017 hard fork
        consensus.uahfHeight = 478558;
 
        // November 13, 2017 hard fork
        consensus.daaHeight = 504031;
 
        // November 15, 2018 hard fork
        consensus.magneticAnomalyHeight = 556766;
 
        // November 15, 2019 protocol upgrade
        consensus.gravitonHeight = 609135;
 
        // May 15, 2020 12:00:00 UTC protocol upgrade
        consensus.phononHeight = 635258;
 
        // Nov 15, 2020 12:00:00 UTC protocol upgrade
        consensus.axionHeight = 661647;
 
        // May 15, 2022 12:00:00 UTC protocol upgrade
        consensus.gluonHeight = 739535;
 
        // Nov 15, 2022 12:00:00 UTC protocol upgrade
        consensus.jeffersonActivationTime = 1668513600;
 
        // May 15, 2023 12:00:00 UTC protocol upgrade
        consensus.wellingtonActivationTime = 1684152000;
 
        diskMagic[0] = 0xf9;
        diskMagic[1] = 0xbe;
        diskMagic[2] = 0xb4;
        diskMagic[3] = 0xd9;
        netMagic[0] = 0xe3;
        netMagic[1] = 0xe1;
        netMagic[2] = 0xf3;
        netMagic[3] = 0xe8;
        nDefaultPort = 8333;
        nPruneAfterHeight = 100000;
        m_assumed_blockchain_size =
            ChainParamsConstants::MAINNET_ASSUMED_BLOCKCHAIN_SIZE;
        m_assumed_chain_state_size =
            ChainParamsConstants::MAINNET_ASSUMED_CHAINSTATE_SIZE;
 
        genesis = CreateGenesisBlock(1231006505, 2083236893, 0x1d00ffff, 1,
                                     50 * COIN);
        consensus.hashGenesisBlock = genesis.GetHash();
        assert(consensus.hashGenesisBlock ==
               uint256S("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1"
                        "b60a8ce26f"));
        assert(genesis.hashMerkleRoot ==
               uint256S("4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b"
                        "7afdeda33b"));
 
        // Note that of those which support the service bits prefix, most only
        // support a subset of possible options. This is fine at runtime as
        // we'll fall back to using them as an addrfetch if they don't support
        // the service bits we want, but we should get them updated to support
        // all service bits wanted by any release ASAP to avoid it where
        // possible.
        // Bitcoin ABC seeder
        vSeeds.emplace_back("seed.bitcoinabc.org");
        // Amaury SÉCHET
        vSeeds.emplace_back("seed.deadalnix.me");
        // Fabien
        vSeeds.emplace_back("seeder.fabien.cash");
        vSeeds.emplace_back("seeder2.fabien.cash");
        // status.cash
        vSeeds.emplace_back("seeder.status.cash");
 
        base58Prefixes[PUBKEY_ADDRESS] = std::vector<uint8_t>(1, 0);
        base58Prefixes[SCRIPT_ADDRESS] = std::vector<uint8_t>(1, 5);
        base58Prefixes[SECRET_KEY] = std::vector<uint8_t>(1, 128);
        base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x88, 0xB2, 0x1E};
        base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4};
        cashaddrPrefix =
            gArgs.GetBoolArg("-ecash", DEFAULT_ECASH) ? "ecash" : "bitcoincash";
 
        vFixedSeeds = std::vector<SeedSpec6>(std::begin(pnSeed6_main),
                                             std::end(pnSeed6_main));
 
        fDefaultConsistencyChecks = false;
        fRequireStandard = true;
        m_is_test_chain = false;
        m_is_mockable_chain = false;
 
        checkpointData = CheckpointData(CBaseChainParams::MAIN);
 
        m_assumeutxo_data = MapAssumeutxo{
            // TODO to be specified in a future patch.
        };
 
        // Data as of block
        // 000000000000000001d2ce557406b017a928be25ee98906397d339c3f68eec5d
        // (height 523992).
        chainTxData = ChainTxData{
            // UNIX timestamp of last known number of transactions.
            1522608016,
            // Total number of transactions between genesis and that timestamp
            // (the tx=... number in the ChainStateFlushed debug.log lines)
            248589038,
            // Estimated number of transactions per second after that timestamp.
            3.2,
        };
    }
};
 
class CTestNetParams : public CChainParams {
public:
    CTestNetParams() {
        strNetworkID = CBaseChainParams::TESTNET;
        consensus.nSubsidyHalvingInterval = 210000;
        // 00000000040b4e986385315e14bee30ad876d8b47f748025b26683116d21aa65
        consensus.BIP16Height = 514;
        consensus.BIP34Height = 21111;
        consensus.BIP34Hash = BlockHash::fromHex(
            "0000000023b3a96d3484e5abb3755c413e7d41500f8e2a5c3f0dd01299cd8ef8");
        // 00000000007f6655f22f98e72ed80d8b06dc761d5da09df0fa1dc4be4f861eb6
        consensus.BIP65Height = 581885;
        // 000000002104c8c45e99a8853285a3b592602a3ccde2b832481da85e9e4ba182
        consensus.BIP66Height = 330776;
        // 00000000025e930139bac5c6c31a403776da130831ab85be56578f3fa75369bb
        consensus.CSVHeight = 770112;
        consensus.powLimit = uint256S(
            "00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
        // two weeks
        consensus.nPowTargetTimespan = 14 * 24 * 60 * 60;
        consensus.nPowTargetSpacing = 10 * 60;
        consensus.fPowAllowMinDifficultyBlocks = true;
        consensus.fPowNoRetargeting = false;
 
        // two days
        consensus.nDAAHalfLife = 2 * 24 * 60 * 60;
 
        // nPowTargetTimespan / nPowTargetSpacing
        consensus.nMinerConfirmationWindow = 2016;
        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY] = {
            .bit = 28,
            // 75% of 2016
            .nActivationThreshold = 1512,
            // January 1, 2008
            .nStartTime = 1199145601,
            // December 31, 2008
            .nTimeout = 1230767999,
        };
 
        // The miner fund is disabled by default on testnet.
        consensus.enableMinerFund = false;
 
        // The best chain should have at least this much work.
        consensus.nMinimumChainWork =
            ChainParamsConstants::TESTNET_MINIMUM_CHAIN_WORK;
 
        // By default assume that the signatures in ancestors of this block are
        // valid.
        consensus.defaultAssumeValid =
            ChainParamsConstants::TESTNET_DEFAULT_ASSUME_VALID;
 
        // August 1, 2017 hard fork
        consensus.uahfHeight = 1155875;
 
        // November 13, 2017 hard fork
        consensus.daaHeight = 1188697;
 
        // November 15, 2018 hard fork
        consensus.magneticAnomalyHeight = 1267996;
 
        // November 15, 2019 protocol upgrade
        consensus.gravitonHeight = 1341711;
 
        // May 15, 2020 12:00:00 UTC protocol upgrade
        consensus.phononHeight = 1378460;
 
        // Nov 15, 2020 12:00:00 UTC protocol upgrade
        consensus.axionHeight = 1421481;
 
        // May 15, 2022 12:00:00 UTC protocol upgrade
        consensus.gluonHeight = 1503556;
 
        // Nov 15, 2022 12:00:00 UTC protocol upgrade
        consensus.jeffersonActivationTime = 1668513600;
 
        // May 15, 2023 12:00:00 UTC protocol upgrade
        consensus.wellingtonActivationTime = 1684152000;
 
        diskMagic[0] = 0x0b;
        diskMagic[1] = 0x11;
        diskMagic[2] = 0x09;
        diskMagic[3] = 0x07;
        netMagic[0] = 0xf4;
        netMagic[1] = 0xe5;
        netMagic[2] = 0xf3;
        netMagic[3] = 0xf4;
        nDefaultPort = 18333;
        nPruneAfterHeight = 1000;
        m_assumed_blockchain_size =
            ChainParamsConstants::TESTNET_ASSUMED_BLOCKCHAIN_SIZE;
        m_assumed_chain_state_size =
            ChainParamsConstants::TESTNET_ASSUMED_CHAINSTATE_SIZE;
 
        genesis =
            CreateGenesisBlock(1296688602, 414098458, 0x1d00ffff, 1, 50 * COIN);
        consensus.hashGenesisBlock = genesis.GetHash();
        assert(consensus.hashGenesisBlock ==
               uint256S("000000000933ea01ad0ee984209779baaec3ced90fa3f408719526"
                        "f8d77f4943"));
        assert(genesis.hashMerkleRoot ==
               uint256S("4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b"
                        "7afdeda33b"));
 
        vFixedSeeds.clear();
        vSeeds.clear();
        // nodes with support for servicebits filtering should be at the top
        // Bitcoin ABC seeder
        vSeeds.emplace_back("testnet-seed.bitcoinabc.org");
        // Amaury SÉCHET
        vSeeds.emplace_back("testnet-seed.deadalnix.me");
        // Fabien
        vSeeds.emplace_back("testnet-seeder.fabien.cash");
        // status.cash
        vSeeds.emplace_back("testnet-seeder.status.cash");
 
        base58Prefixes[PUBKEY_ADDRESS] = std::vector<uint8_t>(1, 111);
        base58Prefixes[SCRIPT_ADDRESS] = std::vector<uint8_t>(1, 196);
        base58Prefixes[SECRET_KEY] = std::vector<uint8_t>(1, 239);
        base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
        base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
        cashaddrPrefix =
            gArgs.GetBoolArg("-ecash", DEFAULT_ECASH) ? "ectest" : "bchtest";
 
        vFixedSeeds = std::vector<SeedSpec6>(std::begin(pnSeed6_test),
                                             std::end(pnSeed6_test));
 
        fDefaultConsistencyChecks = false;
        fRequireStandard = false;
        m_is_test_chain = true;
        m_is_mockable_chain = false;
 
        checkpointData = CheckpointData(CBaseChainParams::TESTNET);
 
        m_assumeutxo_data = MapAssumeutxo{
            // TODO to be specified in a future patch.
        };
 
        // Data as of block
        // 000000000005b07ecf85563034d13efd81c1a29e47e22b20f4fc6919d5b09cd6
        // (height 1223263)
        chainTxData = ChainTxData{1522608381, 15052068, 0.15};
    }
};
 
class CRegTestParams : public CChainParams {
public:
    CRegTestParams() {
        strNetworkID = CBaseChainParams::REGTEST;
        consensus.nSubsidyHalvingInterval = 150;
        // always enforce P2SH BIP16 on regtest
        consensus.BIP16Height = 0;
        // BIP34 activated on regtest (Used in functional tests)
        consensus.BIP34Height = 500;
        consensus.BIP34Hash = BlockHash();
        // BIP65 activated on regtest (Used in functional tests)
        consensus.BIP65Height = 1351;
        // BIP66 activated on regtest (Used in functional tests)
        consensus.BIP66Height = 1251;
        // CSV activated on regtest (Used in functional tests)
        consensus.CSVHeight = 576;
        consensus.powLimit = uint256S(
            "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
        // two weeks
        consensus.nPowTargetTimespan = 14 * 24 * 60 * 60;
        consensus.nPowTargetSpacing = 10 * 60;
        consensus.fPowAllowMinDifficultyBlocks = true;
        consensus.fPowNoRetargeting = true;
 
        // two days
        consensus.nDAAHalfLife = 2 * 24 * 60 * 60;
 
        // Faster than normal for regtest (144 instead of 2016)
        consensus.nMinerConfirmationWindow = 144;
        consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY] = {
            .bit = 28,
            // 75% of 144
            .nActivationThreshold = 108,
        };
 
        // The miner fund is disabled by default on regnet.
        consensus.enableMinerFund = false;
 
        // The best chain should have at least this much work.
        consensus.nMinimumChainWork = uint256S("0x00");
 
        // By default assume that the signatures in ancestors of this block are
        // valid.
        consensus.defaultAssumeValid = BlockHash();
 
        // UAHF is always enabled on regtest.
        consensus.uahfHeight = 0;
 
        // November 13, 2017 hard fork is always on on regtest.
        consensus.daaHeight = 0;
 
        // November 15, 2018 hard fork is always on on regtest.
        consensus.magneticAnomalyHeight = 0;
 
        // November 15, 2019 protocol upgrade
        consensus.gravitonHeight = 0;
 
        // May 15, 2020 12:00:00 UTC protocol upgrade
        consensus.phononHeight = 0;
 
        // Nov 15, 2020 12:00:00 UTC protocol upgrade
        consensus.axionHeight = 0;
 
        // May 15, 2022 12:00:00 UTC protocol upgrade
        consensus.gluonHeight = 0;
 
        // Nov 15, 2022 12:00:00 UTC protocol upgrade
        consensus.jeffersonActivationTime = 1668513600;
 
        // May 15, 2023 12:00:00 UTC protocol upgrade
        consensus.wellingtonActivationTime = 1684152000;
 
        diskMagic[0] = 0xfa;
        diskMagic[1] = 0xbf;
        diskMagic[2] = 0xb5;
        diskMagic[3] = 0xda;
        netMagic[0] = 0xda;
        netMagic[1] = 0xb5;
        netMagic[2] = 0xbf;
        netMagic[3] = 0xfa;
        nDefaultPort = 18444;
        nPruneAfterHeight = gArgs.GetBoolArg("-fastprune", false) ? 100 : 1000;
        m_assumed_blockchain_size = 0;
        m_assumed_chain_state_size = 0;
 
        genesis = CreateGenesisBlock(1296688602, 2, 0x207fffff, 1, 50 * COIN);
        consensus.hashGenesisBlock = genesis.GetHash();
        assert(consensus.hashGenesisBlock ==
               uint256S("0x0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b"
                        "1a11466e2206"));
        assert(genesis.hashMerkleRoot ==
               uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab212"
                        "7b7afdeda33b"));
 
        vFixedSeeds.clear();
        vSeeds.clear();
 
        fDefaultConsistencyChecks = true;
        fRequireStandard = true;
        m_is_test_chain = true;
        m_is_mockable_chain = true;
 
        checkpointData = CheckpointData(CBaseChainParams::REGTEST);
 
        m_assumeutxo_data = MapAssumeutxo{
            {
                110,
                {AssumeutxoHash{uint256S("0xff755939f6fd81bf966e2f347f5d3660d62"
                                         "39334050eb557a6f005d7d8184ea9")},
                 110},
            },
            {
                210,
                {AssumeutxoHash{uint256S("0xd6089fa8d2100926326cacdd452231e30bb"
                                         "4e64f07aa5bfec96e055ac2a9a87a")},
                 210},
            },
        };
 
        chainTxData = ChainTxData{0, 0, 0};
 
        base58Prefixes[PUBKEY_ADDRESS] = std::vector<uint8_t>(1, 111);
        base58Prefixes[SCRIPT_ADDRESS] = std::vector<uint8_t>(1, 196);
        base58Prefixes[SECRET_KEY] = std::vector<uint8_t>(1, 239);
        base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
        base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
        cashaddrPrefix =
            gArgs.GetBoolArg("-ecash", DEFAULT_ECASH) ? "ecregtest" : "bchreg";
    }
};
 
static std::unique_ptr<CChainParams> globalChainParams;
 
const CChainParams &Params() {
    assert(globalChainParams);
    return *globalChainParams;
}
 
std::unique_ptr<CChainParams> CreateChainParams(const std::string &chain) {
    if (chain == CBaseChainParams::MAIN) {
        return std::make_unique<CMainParams>();
    }
 
    if (chain == CBaseChainParams::TESTNET) {
        return std::make_unique<CTestNetParams>();
    }
 
    if (chain == CBaseChainParams::REGTEST) {
        return std::make_unique<CRegTestParams>();
    }
 
    throw std::runtime_error(
        strprintf("%s: Unknown chain %s.", __func__, chain));
}
 
void SelectParams(const std::string &network) {
    SelectBaseParams(network);
    globalChainParams = CreateChainParams(network);
}