Flowee/thehub
1
Fork 0
Code Issues Pull Requests Releases 4 Wiki Activity
Files
master
thehub/hub/server/chainparams.cpp
T

735 lines
33 KiB
C++
Raw Permalink Blame History

/*
* This file is part of the Flowee project
* Copyright (c) 2010 Satoshi Nakamoto
* Copyright (c) 2009-2015 The Bitcoin Core developers
* Copyright (C) 2016-2021 Tom Zander <tom@flowee.org>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "chainparams.h"
#include <SettingsDefaults.h>
#include <util.h>
#include <merkle.h>
#include <utilstrencodings.h>
#include <boost/assign/list_of.hpp>
#include <boost/algorithm/string/case_conv.hpp> // for to_lower()
#include "chainparamsseeds.h"
static Block CreateGenesisBlock(const char* pszTimestamp, const CScript& genesisOutputScript, uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, int64_t genesisReward)
{
CMutableTransaction txNew;
txNew.nVersion = nVersion;
txNew.vin.resize(1);
txNew.vout.resize(1);
txNew.vin[0].scriptSig = CScript() << 486604799 << CScriptNum(4) << std::vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
txNew.vout[0].nValue = genesisReward;
txNew.vout[0].scriptPubKey = genesisOutputScript;
MutableBlock genesis;
genesis.nTime = nTime;
genesis.nBits = nBits;
genesis.nNonce = nNonce;
genesis.nVersion = nVersion;
genesis.vtx.push_back(txNew);
genesis.hashPrevBlock.SetNull();
genesis.hashMerkleRoot = BlockMerkleRoot(genesis);
return Block::fromOldBlock(genesis);
}
/**
* Build the genesis block. Note that the output of its generation
* transaction cannot be spent since it did not originally exist in the
* database.
*
* CBlock(hash=000000000019d6, ver=1, hashPrevBlock=00000000000000, hashMerkleRoot=4a5e1e, nTime=1231006505, nBits=1d00ffff, nNonce=2083236893, vtx=1)
* CTransaction(hash=4a5e1e, ver=1, vin.size=1, vout.size=1, nLockTime=0)
* CTxIn(COutPoint(000000, -1), coinbase 04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73)
* CTxOut(nValue=50.00000000, scriptPubKey=0x5F1DF16B2B704C8A578D0B)
* vMerkleTree: 4a5e1e
*/
static Block CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, int64_t genesisReward)
{
const char* pszTimestamp = "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks";
const CScript genesisOutputScript = CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") << OP_CHECKSIG;
return CreateGenesisBlock(pszTimestamp, genesisOutputScript, nTime, nNonce, nBits, nVersion, genesisReward);
}
/**
* Main network
*/
/**
* What makes a good checkpoint block?
* + Is surrounded by blocks with reasonable timestamps
* (no blocks before with a timestamp after, none after with
* timestamp before)
* + Contains no strange transactions
*/
class CMainParams : public CChainParams {
public:
CMainParams() {
strNetworkID = "main";
consensus.nSubsidyHalvingInterval = 210000;
consensus.BIP34Height = 227931;
consensus.BIP65Height = 388381; // CHECKLOCKTIMEVERIFY
consensus.BIP66Height = 363725; // DERSIG
consensus.BIP68Height = 419328; // sequence locks & CHECKSEQUENCEVERIFY
consensus.powLimit = uint256S("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
consensus.nPowTargetSpacing = 10 * 60;
consensus.fPowAllowMinDifficultyBlocks = false;
consensus.fPowNoRetargeting = false;
consensus.nRuleChangeActivationThreshold = 1916; // 95% of 2016
consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
// The half life for the ASERT DAA. For every (nASERTHalfLife) seconds behind schedule the blockchain gets,
// difficulty is cut in half. Doubled if blocks are ahead of schedule.
// Two days
consensus.nASERTHalfLife = 2 * 24 * 60 * 60;
/**
* The message start string is designed to be unlikely to occur in normal data.
* The characters are rarely used upper ASCII, not valid as UTF-8, and produce
* a large 32-bit integer with any alignment.
*/
pchMessageStart[0] = 0xf9;
pchMessageStart[1] = 0xbe;
pchMessageStart[2] = 0xb4;
pchMessageStart[3] = 0xd9;
pchMessageStartCash[0] = 0XE3;
pchMessageStartCash[1] = 0XE1;
pchMessageStartCash[2] = 0XF3;
pchMessageStartCash[3] = 0XE8;
nDefaultPort = Settings::DefaultMainnetPort;
nMaxTipAge = 24 * 60 * 60;
nPruneAfterHeight = 100000;
genesis = CreateGenesisBlock(1231006505, 2083236893, 0x1d00ffff, 1, 50 * COIN);
consensus.hashGenesisBlock = genesis.createHash();
// Timestamps for forking consensus rule changes:
assert(consensus.hashGenesisBlock == uint256S("0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"));
assert(genesis.merkleRoot() == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
vSeeds.push_back(CDNSSeedData("flowee", "seed.flowee.cash"));
vSeeds.push_back(CDNSSeedData("bchd", "seed.bchd.cash"));
base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,0);
base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,5);
base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,128);
base58Prefixes[EXT_PUBLIC_KEY] = boost::assign::list_of(0x04)(0x88)(0xB2)(0x1E).convert_to_container<std::vector<unsigned char> >();
base58Prefixes[EXT_SECRET_KEY] = boost::assign::list_of(0x04)(0x88)(0xAD)(0xE4).convert_to_container<std::vector<unsigned char> >();
vFixedSeeds = std::vector<SeedSpec6>(pnSeed6_main, pnSeed6_main + ARRAYLEN(pnSeed6_main));
fMiningRequiresPeers = true;
fDefaultConsistencyChecks = false;
fRequireStandard = true;
fMineBlocksOnDemand = false;
fTestnetToBeDeprecatedFieldRPC = false;
consensus.hf201708Height = 478559;
consensus.hf201711Height = 504031;
consensus.hf201805Height = 530356;
consensus.hf201811Height = 556767;
consensus.hf201905Height = 582680;
consensus.hf201911Height = 609135;
consensus.hf202005Height = 635258;
consensus.hf202011Height = 661648;
consensus.hf202205Height = 740237;
consensus.hf202305Height = 792772;
consensus.hf202405Height = 845890;
consensus.hf202505Height = 898373;
consensus.hf202605ActivationTime = 1778846400;
checkpointData = CCheckpointData {
boost::assign::map_list_of
( 11111, uint256S("0000000069e244f73d78e8fd29ba2fd2ed618bd6fa2ee92559f542fdb26e7c1d"))
( 33333, uint256S("000000002dd5588a74784eaa7ab0507a18ad16a236e7b1ce69f00d7ddfb5d0a6"))
( 74000, uint256S("0000000000573993a3c9e41ce34471c079dcf5f52a0e824a81e7f953b8661a20"))
(105000, uint256S("00000000000291ce28027faea320c8d2b054b2e0fe44a773f3eefb151d6bdc97"))
(134444, uint256S("00000000000005b12ffd4cd315cd34ffd4a594f430ac814c91184a0d42d2b0fe"))
(168000, uint256S("000000000000099e61ea72015e79632f216fe6cb33d7899acb35b75c8303b763"))
(193000, uint256S("000000000000059f452a5f7340de6682a977387c17010ff6e6c3bd83ca8b1317"))
(210000, uint256S("000000000000048b95347e83192f69cf0366076336c639f9b7228e9ba171342e"))
(216116, uint256S("00000000000001b4f4b433e81ee46494af945cf96014816a4e2370f11b23df4e"))
(225430, uint256S("00000000000001c108384350f74090433e7fcf79a606b8e797f065b130575932"))
(250000, uint256S("000000000000003887df1f29024b06fc2200b55f8af8f35453d7be294df2d214"))
(279000, uint256S("0000000000000001ae8c72a0b0c301f67e3afca10e819efa9041e458e9bd7e40"))
(295000, uint256S("00000000000000004d9b4ef50f0f9d686fd69db2e03af35a100370c64632a983"))
(478559, uint256S("000000000000000000651ef99cb9fcbe0dadde1d424bd9f15ff20136191a5eec"))
(556767, uint256S("0000000000000000004626ff6e3b936941d341c5932ece4357eeccac44e6d56c"))
(582680, uint256S("000000000000000001b4b8e36aec7d4f9671a47872cb9a74dc16ca398c7dcc18"))
(609136, uint256S("000000000000000000b48bb207faac5ac655c313e41ac909322eaa694f5bc5b1"))
(635259, uint256S("00000000000000000033dfef1fc2d6a5d5520b078c55193a9bf498c5b27530f7"))
(661648, uint256S("0000000000000000029e471c41818d24b8b74c911071c4ef0b4a0509f9b5a8ce"))
(951500, uint256S("0000000000000000008c8c61caec128d0d02922f1710e512fffafa827455ef37"))
,
1779066920, // * UNIX timestamp of last checkpoint block
415610000, // * total number of transactions between genesis and last checkpoint
// (the tx=... number in the new best hub.log lines)
40000.0 // * estimated number of transactions per day after checkpoint
};
}
};
/**
* Testnet (v3)
*/
class CTestNetParams : public CChainParams {
public:
CTestNetParams() {
strNetworkID = "test";
consensus.nSubsidyHalvingInterval = 210000;
consensus.BIP34Height = 21111;
consensus.BIP65Height = 581885; // CHECKLOCKTIMEVERIFY
consensus.BIP66Height = 330776; // DERSIG
consensus.BIP68Height = 770112; // sequence locks & CHECKSEQUENCEVERIFY
consensus.powLimit = uint256S("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
consensus.nPowTargetSpacing = 10 * 60;
consensus.fPowAllowMinDifficultyBlocks = true;
consensus.fPowNoRetargeting = false;
consensus.nRuleChangeActivationThreshold = 1512; // 75% for testchains
consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
consensus.nASERTHalfLife = 60 * 60;
pchMessageStart[0] = 0x0B;
pchMessageStart[1] = 0x11;
pchMessageStart[2] = 0x09;
pchMessageStart[3] = 0x07;
pchMessageStartCash[0] = 0xF4;
pchMessageStartCash[1] = 0xE5;
pchMessageStartCash[2] = 0xF3;
pchMessageStartCash[3] = 0xF4;
nDefaultPort = Settings::DefaultTestnetPort;
nMaxTipAge = 0x7fffffff;
nPruneAfterHeight = 1000;
genesis = CreateGenesisBlock(1296688602, 414098458, 0x1d00ffff, 1, 50 * COIN);
consensus.hashGenesisBlock = genesis.createHash();
assert(consensus.hashGenesisBlock == uint256S("0x000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"));
assert(genesis.merkleRoot() == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
vFixedSeeds.clear();
vSeeds.clear();
vSeeds.push_back(CDNSSeedData("bchd", "testnet-seed.bchd.cash"));
vSeeds.push_back(CDNSSeedData("bitcoinforks.org", "testnet-seed-bch.bitcoinforks.org"));
base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,239);
base58Prefixes[EXT_PUBLIC_KEY] = boost::assign::list_of(0x04)(0x35)(0x87)(0xCF).convert_to_container<std::vector<unsigned char> >();
base58Prefixes[EXT_SECRET_KEY] = boost::assign::list_of(0x04)(0x35)(0x83)(0x94).convert_to_container<std::vector<unsigned char> >();
vFixedSeeds = std::vector<SeedSpec6>(pnSeed6_test, pnSeed6_test + ARRAYLEN(pnSeed6_test));
fMiningRequiresPeers = true;
fDefaultConsistencyChecks = false;
fRequireStandard = false;
fMineBlocksOnDemand = false;
fTestnetToBeDeprecatedFieldRPC = true;
consensus.hf201708Height = 1155876;
consensus.hf201711Height = 1188697;
consensus.hf201805Height = 1267994;
consensus.hf201811Height = 1267997;
consensus.hf201905Height = 1303885;
consensus.hf201911Height = 1341711;
consensus.hf202005Height = 1378460;
consensus.hf202011Height = 1421482;
consensus.hf202205Height = 1500205;
consensus.hf202305Height = 1552787;
consensus.hf202405Height = 1605520;
consensus.hf202505Height = 1658049;
consensus.hf202605ActivationTime = 1778846400;
checkpointData = CCheckpointData {
boost::assign::map_list_of
(546, uint256S("000000002a936ca763904c3c35fce2f3556c559c0214345d31b1bcebf76acb70"))
(1155875, uint256S("00000000f17c850672894b9a75b63a1e72830bbd5f4" "c8889b5c1a80e7faef138"))
(1188697, uint256S("0000000000170ed0918077bde7b4d36cc4c91be69fa" "09211f748240dabe047fb"))
(1233070, uint256S("0000000000000253c6201a2076663cfe4722e4c75f537552cc4ce989d15f7cd5"))
(1267997, uint256S("00000000000002773f8970352e4a3368a1ce6ef91eb606b64389b36fdbf1bd56"))
(1303885, uint256S("00000000000000479138892ef0e4fa478ccc938fb94df862ef5bde7e8dee23d3"))
(1341712, uint256S("00000000fffc44ea2e202bd905a9fbbb9491ef9e9d5a9eed4039079229afa35b"))
(1421482, uint256S("0000000023e0680a8a062b3cc289a4a341124ce7fcb6340ede207e194d73b60a"))
,
1522608381, // * UNIX timestamp of last checkpoint block
15052068, // * total number of transactions between genesis and last checkpoint
// (the tx=... number in the SetBestChain hub.log lines)
300 // * estimated number of transactions per day after checkpoint
};
}
};
/**
* Testnet (v4)
*/
class CTestNet4Params : public CChainParams {
public:
CTestNet4Params() {
strNetworkID = "test4";
consensus.nSubsidyHalvingInterval = 210000;
consensus.BIP34Height = 2;
consensus.BIP65Height = 3; // CHECKLOCKTIMEVERIFY
consensus.BIP66Height = 4; // DERSIG
consensus.BIP68Height = 5; // sequence locks & CHECKSEQUENCEVERIFY
consensus.powLimit = uint256S("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
consensus.nPowTargetSpacing = 10 * 60;
consensus.fPowAllowMinDifficultyBlocks = true;
consensus.fPowNoRetargeting = false;
consensus.nRuleChangeActivationThreshold = 1512; // 75% for testchains
consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
// The half life for the ASERT DAA. For every (nASERTHalfLife) seconds behind schedule the blockchain gets,
// difficulty is cut in half. Doubled if blocks are ahead of schedule.
// One hour
consensus.nASERTHalfLife = 60 * 60;
pchMessageStart[0] = 0xcd;
pchMessageStart[1] = 0x22;
pchMessageStart[2] = 0xa7;
pchMessageStart[3] = 0x92;
pchMessageStartCash[0] = 0xe2;
pchMessageStartCash[1] = 0xb7;
pchMessageStartCash[2] = 0xda;
pchMessageStartCash[3] = 0xaf;
nDefaultPort = Settings::DefaultTestnet4Port;
nMaxTipAge = 0x7fffffff;
nPruneAfterHeight = 1000;
genesis = CreateGenesisBlock(1597811185, 114152193, 0x1d00ffff, 1, 50 * COIN);
consensus.hashGenesisBlock = genesis.createHash();
assert(consensus.hashGenesisBlock == uint256S("0x000000001dd410c49a788668ce26751718cc797474d3152a5fc073dd44fd9f7b"));
vFixedSeeds.clear();
vSeeds.clear();
vSeeds.push_back(CDNSSeedData("flowee", "testnet4-seed.flowee.cash"));
vSeeds.push_back(CDNSSeedData("toomim", "testnet4-seed-bch.toom.im"));
vSeeds.push_back(CDNSSeedData("loping.net", "seed.tbch4.loping.net"));
base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1, 111);
base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1, 196);
base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1, 239);
base58Prefixes[EXT_PUBLIC_KEY] = boost::assign::list_of(0x04)(0x35)(0x87)(0xCF).convert_to_container<std::vector<unsigned char> >();
base58Prefixes[EXT_SECRET_KEY] = boost::assign::list_of(0x04)(0x35)(0x83)(0x94).convert_to_container<std::vector<unsigned char> >();
vFixedSeeds = std::vector<SeedSpec6>(pnSeed6_test4, pnSeed6_test4 + ARRAYLEN(pnSeed6_test4));
fMiningRequiresPeers = true;
fDefaultConsistencyChecks = false;
fRequireStandard = true;
fMineBlocksOnDemand = false;
fTestnetToBeDeprecatedFieldRPC = true;
consensus.hf201708Height = 6;
consensus.hf201711Height = 3000;
consensus.hf201805Height = 4000;
consensus.hf201811Height = 4000;
consensus.hf201905Height = 0; // we use schnorr from the start.
consensus.hf201911Height = 5000;
consensus.hf202005Height = 0; // sigop counting irrelevant on this chain.
consensus.hf202011Height = 16845;
consensus.hf202205Height = 95464;
consensus.hf202305Height = 148043;
consensus.hf202405Height = 200740;
consensus.hf202505Height = 253318;
consensus.hf202605ActivationTime = 1778846400;
checkpointData = CCheckpointData{
boost::assign::map_list_of
(5677, uint256S("0x0000000019df558b6686b1a1c3e7aee0535c38052651b711f84eebafc0cc4b5e"))
(9999, uint256S("0x00000000016522b7506939b23734bca7681c42a53997f2943ab4c8013936b419"))
,
1602102194, // * UNIX timestamp of last checkpoint block
11789, // * total number of transactions between genesis and last checkpoint
// (the tx=... number in the SetBestChain hub.log lines)
1.3 // * estimated number of transactions per day after checkpoint
};
}
};
/**
* Scaling Network
*/
class CScaleNetParams : public CChainParams {
public:
CScaleNetParams() {
strNetworkID = "scale";
consensus.nSubsidyHalvingInterval = 210000;
consensus.BIP34Height = 2;
consensus.BIP65Height = 3; // CHECKLOCKTIMEVERIFY
consensus.BIP66Height = 4; // DERSIG
consensus.BIP68Height = 5; // sequence locks & CHECKSEQUENCEVERIFY
consensus.powLimit = uint256S("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
consensus.nPowTargetSpacing = 10 * 60;
consensus.fPowAllowMinDifficultyBlocks = true;
consensus.fPowNoRetargeting = false;
consensus.nRuleChangeActivationThreshold = 1512; // 75% for testchains
consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
consensus.nASERTHalfLife = 2 * 24 * 60 * 60;
pchMessageStart[0] = 0xba;
pchMessageStart[1] = 0xc2;
pchMessageStart[2] = 0x2d;
pchMessageStart[3] = 0xc4;
pchMessageStartCash[0] = 0xc3;
pchMessageStartCash[1] = 0xaf;
pchMessageStartCash[2] = 0xe1;
pchMessageStartCash[3] = 0xa2;
nDefaultPort = Settings::DefaultScalenetPort;
nMaxTipAge = 0x7fffffff;
nPruneAfterHeight = 1000;
//! Modify the testnet genesis block so the timestamp is valid for a later start.
genesis = CreateGenesisBlock(1598282438, -1567304284, 0x1d00ffff, 1, 50 * COIN);
consensus.hashGenesisBlock = genesis.createHash();
assert(consensus.hashGenesisBlock == uint256S("00000000e6453dc2dfe1ffa19023f86002eb11dbb8e87d0291a4599f0430be52"));
assert(genesis.merkleRoot() == uint256S("4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
vFixedSeeds.clear();
vSeeds.clear();
vSeeds.push_back(CDNSSeedData("toom.im", "scalenet-seed-bch.toom.im"));
vSeeds.push_back(CDNSSeedData("loping.net", "seed.sbch.loping.net"));
vSeeds.push_back(CDNSSeedData("bitcoinforks.org", "scalenet-seed-bch.bitcoinforks.org"));
base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1, 111);
base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1, 196);
base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1, 239);
base58Prefixes[EXT_PUBLIC_KEY] = boost::assign::list_of(0x04)(0x35)(0x87)(0xCF).convert_to_container<std::vector<unsigned char> >();
base58Prefixes[EXT_SECRET_KEY] = boost::assign::list_of(0x04)(0x35)(0x83)(0x94).convert_to_container<std::vector<unsigned char> >();
vFixedSeeds = std::vector<SeedSpec6>(pnSeed6_scalenet, pnSeed6_scalenet + ARRAYLEN(pnSeed6_scalenet));
fMiningRequiresPeers = true;
fDefaultConsistencyChecks = false;
fRequireStandard = false;
fMineBlocksOnDemand = false;
fTestnetToBeDeprecatedFieldRPC = true;
consensus.hf201708Height = 6;
consensus.hf201711Height = 3000;
consensus.hf201805Height = 4000;
consensus.hf201811Height = 4000;
consensus.hf201905Height = 0; // we use schnorr from the start.
consensus.hf201911Height = 5000;
consensus.hf202005Height = 0; // sigop counting irrelevant on this chain.
consensus.hf202011Height = 16869;
consensus.hf202205Height = 10006;
consensus.hf202305Height = 10006;
consensus.hf202405Height = 10006;
consensus.hf202505Height = 10006;
consensus.hf202605ActivationTime = 1778846400;
checkpointData = CCheckpointData{
boost::assign::map_list_of
(0, uint256S("0x00000000e6453dc2dfe1ffa19023f86002eb11dbb8e87d0291a4599f0430be52"))
(45, uint256S("0x00000000d75a7c9098d02b321e9900b16ecbd552167e65683fe86e5ecf88b320"))
(9999, uint256S("0x000000007fb3362740efd1435aa414f54171993483799782f83c61bc7bf1b1be"))
,
1601685801, // * UNIX timestamp of last checkpoint block
12467, // * total number of transactions between genesis and last checkpoint
// (the tx=... number in the SetBestChain hub.log lines)
90000 // * estimated number of transactions per day after checkpoint
};
}
};
/**
* Chipnet
*/
class CChipNetParams : public CChainParams {
public:
CChipNetParams() {
strNetworkID = CBaseChainParams::CHIPNET;
consensus.nSubsidyHalvingInterval = 210000;
consensus.BIP34Height = 2;
consensus.BIP65Height = 3; // CHECKLOCKTIMEVERIFY
consensus.BIP66Height = 4; // DERSIG
consensus.BIP68Height = 5; // sequence locks & CHECKSEQUENCEVERIFY
consensus.powLimit = uint256S("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
consensus.nPowTargetSpacing = 10 * 60;
consensus.fPowAllowMinDifficultyBlocks = true;
consensus.fPowNoRetargeting = false;
consensus.nRuleChangeActivationThreshold = 1512; // 75% for testchains
consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
consensus.nASERTHalfLife = 60 * 60;
pchMessageStart[0] = 0xcd;
pchMessageStart[1] = 0x22;
pchMessageStart[2] = 0xa7;
pchMessageStart[3] = 0x92;
pchMessageStartCash[0] = 0xe2;
pchMessageStartCash[1] = 0xb7;
pchMessageStartCash[2] = 0xda;
pchMessageStartCash[3] = 0xaf;
nDefaultPort = Settings::DefaultChipnetPort;
nMaxTipAge = 0x7fffffff;
nPruneAfterHeight = 1000;
genesis = CreateGenesisBlock(1597811185, 114152193, 0x1d00ffff, 1, 50 * COIN);
consensus.hashGenesisBlock = genesis.createHash();
assert(consensus.hashGenesisBlock == uint256S("0x000000001dd410c49a788668ce26751718cc797474d3152a5fc073dd44fd9f7b"));
vFixedSeeds.clear();
vSeeds.clear();
vSeeds.push_back(CDNSSeedData("bitjson", "chipnet.bitjson.com"));
base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1, 111);
base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1, 196);
base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1, 239);
base58Prefixes[EXT_PUBLIC_KEY] = boost::assign::list_of(0x04)(0x35)(0x87)(0xCF).convert_to_container<std::vector<unsigned char> >();
base58Prefixes[EXT_SECRET_KEY] = boost::assign::list_of(0x04)(0x35)(0x83)(0x94).convert_to_container<std::vector<unsigned char> >();
vFixedSeeds = std::vector<SeedSpec6>(pnSeed6_chipnet, pnSeed6_chipnet + ARRAYLEN(pnSeed6_chipnet));
fMiningRequiresPeers = true;
fDefaultConsistencyChecks = false;
fRequireStandard = true;
fMineBlocksOnDemand = false;
fTestnetToBeDeprecatedFieldRPC = true;
consensus.hf201708Height = 6;
consensus.hf201711Height = 3000;
consensus.hf201805Height = 4000;
consensus.hf201811Height = 4000;
consensus.hf201905Height = 0; // we use schnorr from the start.
consensus.hf201911Height = 5000;
consensus.hf202005Height = 0; // sigop counting irrelevant on this chain.
consensus.hf202011Height = 16845;
consensus.hf202205Height = 95464;
consensus.hf202305Height = 121956;
consensus.hf202405Height = 174519;
consensus.hf202505Height = 227228;
consensus.hf202605ActivationTime = 1763208000;
checkpointData = CCheckpointData{
boost::assign::map_list_of
(0, uint256S("0x000000001dd410c49a788668ce26751718cc797474d3152a5fc073dd44fd9f7b"))
(5000, uint256S("0x000000009f092d074574a216faec682040a853c4f079c33dfd2c3ef1fd8108c4"))
(16845, uint256S("0x00000000fb325b8f34fe80c96a5f708a08699a68bbab82dba4474d86bd743077"))
(38000, uint256S("0x000000000015197537e59f339e3b1bbf81a66f691bd3d7aa08560fc7bf5113fb"))
(54700, uint256S("0x00000000009af4379d87f17d0f172ee4769b48839a5a3a3e81d69da4322518b8"))
(68117, uint256S("0x0000000000a2c2fc11a3b72adbd10a3f02a1f8745da55a85321523043639829a"))
(95465, uint256S("0x00000000a77206a2265cabc47cc2c34706ba1c5e5a5743ac6681b83d43c91a01"))
(115252, uint256S("0x00000000040ba9641ba98a37b2e5ceead38e4e2930ac8f145c8094f94c708727"))
(115510, uint256S("0x000000006ad16ee5ee579bc3712b6f15cdf0a7f25a694e1979616794b73c5122"))
(121957, uint256S("0x0000000056087dee73fb66178ca70da89dfd0be098b1a63cf6fe93934cd04c78"))
(122396, uint256S("0x000000000363cd56e49a46684cec1d99854c4aae662a6faee0df4c9a49dc8a33"))
(128042, uint256S("0x0000000010e506eeb528dd8238947c6fcdf8d752ece66517eea778650600edae"))
(148000, uint256S("0x000000009788ecce39b046caab3cf0f72e8c5409df23454679dbdcae2bd4dded"))
(178140, uint256S("0x000000003c37cc0372a5b9ccacca921786bbfc699722fc41e9fdbb1de4146ef1"))
(206364, uint256S("0x00000000146a073b9d4e172adbee5252014a8b4d75c56cce36858311565ae251"))
(228000, uint256S("0x00000000144b00db5736b33bd572b3a3a52aa9b4c26ba59fc212aeb68a9b7a20"))
(232000, uint256S("0x0000000017d92f88ed2c81885c57f999184860a042250510be06b3edd12e0dc5"))
(255000, uint256S("0x000000008654e310c090d6846459500c3a6531044fa9339865865575375db624"))
(284827, uint256S("0x000000007af65a6e8853f858b3f2a8e7edabe41e6264410276705b324267d7d8"))
,
1766497373,
971240,
751.68
};
}
};
/**
* Regression test
*/
class CRegTestParams : public CChainParams {
public:
CRegTestParams() {
strNetworkID = "regtest";
consensus.nSubsidyHalvingInterval = 150;
consensus.BIP34Height = -1; // BIP34 has not necessarily activated on regtest
consensus.BIP65Height = 1; // CHECKLOCKTIMEVERIFY
consensus.BIP66Height = 1; // DERSIG
consensus.BIP68Height = 1; // sequence locks & CHECKSEQUENCEVERIFY
consensus.powLimit = uint256S("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
consensus.nPowTargetSpacing = 10 * 60;
consensus.fPowAllowMinDifficultyBlocks = true;
consensus.fPowNoRetargeting = true;
consensus.nRuleChangeActivationThreshold = 108; // 75% for testchains
consensus.nMinerConfirmationWindow = 144; // Faster than normal for regtest (144 instead of 2016)
consensus.nASERTHalfLife = 0; // not used in regtest.
pchMessageStart[0] = 0xfa;
pchMessageStart[1] = 0xbf;
pchMessageStart[2] = 0xb5;
pchMessageStart[3] = 0xda;
pchMessageStartCash[0] = 0xDA;
pchMessageStartCash[1] = 0xB5;
pchMessageStartCash[2] = 0xBF;
pchMessageStartCash[3] = 0xFA;
nMaxTipAge = 24 * 60 * 60;
nDefaultPort = 18444;
nPruneAfterHeight = 1000;
genesis = CreateGenesisBlock(1296688602, 2, 0x207fffff, 1, 50 * COIN);
consensus.hashGenesisBlock = genesis.createHash();
assert(consensus.hashGenesisBlock == uint256S("0x0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"));
assert(genesis.merkleRoot() == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
vFixedSeeds.clear(); //! Regtest mode doesn't have any fixed seeds.
vSeeds.clear(); //! Regtest mode doesn't have any DNS seeds.
fMiningRequiresPeers = false;
fDefaultConsistencyChecks = true;
fRequireStandard = false;
fMineBlocksOnDemand = true;
fTestnetToBeDeprecatedFieldRPC = false;
consensus.hf201708Height = 0;
consensus.hf201711Height = 0;
consensus.hf201805Height = 1;
consensus.hf201811Height = 9999999; // avoid invalidating my unit-test chain
consensus.hf201905Height = 1;
consensus.hf201911Height = 0;
consensus.hf202005Height = 0;
consensus.hf202011Height = 0;
consensus.hf202205Height = 0;
consensus.hf202305Height = 0;
consensus.hf202405Height = 0;
consensus.hf202505Height = 0;
consensus.hf202605ActivationTime = 1778846400;
checkpointData = CCheckpointData {
boost::assign::map_list_of
( 0, uint256S("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206")),
0,
0,
0
};
base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,239);
base58Prefixes[EXT_PUBLIC_KEY] = boost::assign::list_of(0x04)(0x35)(0x87)(0xCF).convert_to_container<std::vector<unsigned char> >();
base58Prefixes[EXT_SECRET_KEY] = boost::assign::list_of(0x04)(0x35)(0x83)(0x94).convert_to_container<std::vector<unsigned char> >();
}
};
namespace Static {
class Chains {
public:
Chains() : m_currentParams(nullptr) {}
CChainParams &main() {
if (m_main.get() == nullptr)
m_main.reset(new CMainParams());
return *m_main.get();
}
CChainParams &regtest() {
if (m_regtest.get() == nullptr)
m_regtest.reset(new CRegTestParams());
return *m_regtest.get();
}
CChainParams &testnet3() {
if (m_testnet.get() == nullptr)
m_testnet.reset(new CTestNetParams());
return *m_testnet.get();
}
CChainParams &testnet4() {
if (m_testnet4.get() == nullptr)
m_testnet4.reset(new CTestNet4Params());
return *m_testnet4.get();
}
CChainParams &scalenet() {
if (m_scalenet.get() == nullptr)
m_scalenet.reset(new CScaleNetParams());
return *m_scalenet.get();
}
CChainParams &chipnet() {
if (m_chipnet.get() == nullptr)
m_chipnet.reset(new CChipNetParams());
return *m_chipnet.get();
}
CChainParams &current() const {
assert(m_currentParams);
return *m_currentParams;
}
bool isSet() const {
return m_currentParams != nullptr;
}
void setCurrent(CChainParams &params) {
m_currentParams = &params;
}
private:
std::unique_ptr<CChainParams> m_main, m_testnet, m_testnet4, m_scalenet, m_chipnet, m_regtest;
CChainParams *m_currentParams;
};
}
static Static::Chains s_chains;
const CChainParams &Params() {
return s_chains.current();
}
CChainParams& Params(const std::string& chain)
{
if (chain == CBaseChainParams::MAIN)
return s_chains.main();
else if (chain == CBaseChainParams::TESTNET)
return s_chains.testnet3();
else if (chain == CBaseChainParams::TESTNET4)
return s_chains.testnet4();
else if (chain == CBaseChainParams::SCALENET)
return s_chains.scalenet();
else if (chain == CBaseChainParams::CHIPNET)
return s_chains.chipnet();
else if (chain == CBaseChainParams::REGTEST)
return s_chains.regtest();
else
throw std::runtime_error(strprintf("%s: Unknown chain %s.", __func__, chain));
}
void SelectParams(const std::string& network)
{
SelectBaseParams(network);
s_chains.setCurrent(Params(network));
}
bool ParamsConfigured() {
return s_chains.isSet();
}
Reference in New Issue View Git Blame Copy Permalink