src/chainparams.cpp

   1 // Copyright (c) 2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2014 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 "main.h"
   7 #include "crypto/equihash.h"
   8
   9 #include "util.h"
  10 #include "utilstrencodings.h"
  11
  12 #include <assert.h>
  13
  14 #include <boost/assign/list_of.hpp>
  15
  16 #include "base58.h"
  17
  18 #include "chainparamsseeds.h"
  19
  20 static CBlock CreateGenesisBlock(const char* pszTimestamp, const CScript& genesisOutputScript, uint32_t nTime, const uint256& nNonce, const std::vector<unsigned char>& nSolution, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
  21 {
  22     CMutableTransaction txNew;
  23     txNew.nVersion = 1;
  24     txNew.vin.resize(1);
  25     txNew.vout.resize(1);
  26     txNew.vin[0].scriptSig = CScript() << 520617983 << CScriptNum(4) << std::vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
  27     txNew.vout[0].nValue = genesisReward;
  28     txNew.vout[0].scriptPubKey = genesisOutputScript;
  29
  30     CBlock genesis;
  31     genesis.nTime    = nTime;
  32     genesis.nBits    = nBits;
  33     genesis.nNonce   = nNonce;
  34     genesis.nSolution = nSolution;
  35     genesis.nVersion = nVersion;
  36     genesis.vtx.push_back(txNew);
  37     genesis.hashPrevBlock.SetNull();
  38     genesis.hashMerkleRoot = genesis.BuildMerkleTree();
  39     return genesis;
  40 }
  41
  42 /**
  43  * Build the genesis block. Note that the output of its generation
  44  * transaction cannot be spent since it did not originally exist in the
  45  * database (and is in any case of zero value).
  46  *
  47  * >>> from pyblake2 import blake2s
  48  * >>> 'Zcash' + blake2s(b'The Economist 2016-10-29 Known unknown: Another crypto-currency is born. BTC#436254 0000000000000000044f321997f336d2908cf8c8d6893e88dbf067e2d949487d ETH#2521903 483039a6b6bd8bd05f0584f9a078d075e454925eb71c1f13eaff59b405a721bb DJIA close on 27 Oct 2016: 18,169.68').hexdigest()
  49  *
  50  * CBlock(hash=00040fe8, ver=4, hashPrevBlock=00000000000000, hashMerkleRoot=c4eaa5, nTime=1477641360, nBits=1f07ffff, nNonce=4695, vtx=1)
  51  *   CTransaction(hash=c4eaa5, ver=1, vin.size=1, vout.size=1, nLockTime=0)
  52  *     CTxIn(COutPoint(000000, -1), coinbase 04ffff071f0104455a6361736830623963346565663862376363343137656535303031653335303039383462366665613335363833613763616331343161303433633432303634383335643334)
  53  *     CTxOut(nValue=0.00000000, scriptPubKey=0x5F1DF16B2B704C8A578D0B)
  54  *   vMerkleTree: c4eaa5
  55  */
  56 static CBlock CreateGenesisBlock(uint32_t nTime, const uint256& nNonce, const std::vector<unsigned char>& nSolution, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
  57 {
  58     const char* pszTimestamp = "Zcash0b9c4eef8b7cc417ee5001e3500984b6fea35683a7cac141a043c42064835d34";
  59     const CScript genesisOutputScript = CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") << OP_CHECKSIG;
  60     return CreateGenesisBlock(pszTimestamp, genesisOutputScript, nTime, nNonce, nSolution, nBits, nVersion, genesisReward);
  61 }
  62
  63 /**
  64  * Main network
  65  */
  66 /**
  67  * What makes a good checkpoint block?
  68  * + Is surrounded by blocks with reasonable timestamps
  69  *   (no blocks before with a timestamp after, none after with
  70  *    timestamp before)
  71  * + Contains no strange transactions
  72  */
  73
  74 const arith_uint256 maxUint = UintToArith256(uint256S("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"));
  75
  76 class CMainParams : public CChainParams {
  77 public:
  78     CMainParams() {
  79         strNetworkID = "main";
  80         strCurrencyUnits = "ZEC";
  81         consensus.fCoinbaseMustBeProtected = true;
  82         consensus.nSubsidySlowStartInterval = 20000;
  83         consensus.nSubsidyHalvingInterval = 840000;
  84         consensus.nMajorityEnforceBlockUpgrade = 750;
  85         consensus.nMajorityRejectBlockOutdated = 950;
  86         consensus.nMajorityWindow = 4000;
  87         consensus.powLimit = uint256S("0007ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
  88         consensus.nPowAveragingWindow = 17;
  89         assert(maxUint/UintToArith256(consensus.powLimit) >= consensus.nPowAveragingWindow);
  90         consensus.nPowMaxAdjustDown = 32; // 32% adjustment down
  91         consensus.nPowMaxAdjustUp = 16; // 16% adjustment up
  92         consensus.nPowTargetSpacing = 2.5 * 60;
  93         consensus.vUpgrades[Consensus::BASE_SPROUT].nActivationHeight =
  94             Consensus::NetworkUpgrade::ALWAYS_ACTIVE;
  95         consensus.vUpgrades[Consensus::UPGRADE_TESTDUMMY].nActivationHeight =
  96             Consensus::NetworkUpgrade::NO_ACTIVATION_HEIGHT;
  97
  98         /**
  99          * The message start string should be awesome! ⓩ❤
 100          */
 101         pchMessageStart[0] = 0x24;
 102         pchMessageStart[1] = 0xe9;
 103         pchMessageStart[2] = 0x27;
 104         pchMessageStart[3] = 0x64;
 105         vAlertPubKey = ParseHex("04b7ecf0baa90495ceb4e4090f6b2fd37eec1e9c85fac68a487f3ce11589692e4a317479316ee814e066638e1db54e37a10689b70286e6315b1087b6615d179264");
 106         nDefaultPort = 8233;
 107         nMaxTipAge = 24 * 60 * 60;
 108         nPruneAfterHeight = 100000;
 109         const size_t N = 200, K = 9;
 110         BOOST_STATIC_ASSERT(equihash_parameters_acceptable(N, K));
 111         nEquihashN = N;
 112         nEquihashK = K;
 113
 114         genesis = CreateGenesisBlock(
 115             1477641360,
 116             uint256S("0x0000000000000000000000000000000000000000000000000000000000001257"),
 117             ParseHex("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"),
 118             0x1f07ffff, 4, 0);
 119         consensus.hashGenesisBlock = genesis.GetHash();
 120         assert(consensus.hashGenesisBlock == uint256S("0x00040fe8ec8471911baa1db1266ea15dd06b4a8a5c453883c000b031973dce08"));
 121         assert(genesis.hashMerkleRoot == uint256S("0xc4eaa58879081de3c24a7b117ed2b28300e7ec4c4c1dff1d3f1268b7857a4ddb"));
 122
 123         vFixedSeeds.clear();
 124         vSeeds.clear();
 125         vSeeds.push_back(CDNSSeedData("z.cash", "dnsseed.z.cash")); // Zcash
 126         vSeeds.push_back(CDNSSeedData("str4d.xyz", "dnsseed.str4d.xyz")); // @str4d
 127         vSeeds.push_back(CDNSSeedData("znodes.org", "dnsseed.znodes.org")); // @bitcartel
 128
 129         // guarantees the first 2 characters, when base58 encoded, are "t1"
 130         base58Prefixes[PUBKEY_ADDRESS]     = {0x1C,0xB8};
 131         // guarantees the first 2 characters, when base58 encoded, are "t3"
 132         base58Prefixes[SCRIPT_ADDRESS]     = {0x1C,0xBD};
 133         // the first character, when base58 encoded, is "5" or "K" or "L" (as in Bitcoin)
 134         base58Prefixes[SECRET_KEY]         = {0x80};
 135         // do not rely on these BIP32 prefixes; they are not specified and may change
 136         base58Prefixes[EXT_PUBLIC_KEY]     = {0x04,0x88,0xB2,0x1E};
 137         base58Prefixes[EXT_SECRET_KEY]     = {0x04,0x88,0xAD,0xE4};
 138         // guarantees the first 2 characters, when base58 encoded, are "zc"
 139         base58Prefixes[ZCPAYMENT_ADDRRESS] = {0x16,0x9A};
 140         // guarantees the first 4 characters, when base58 encoded, are "ZiVK"
 141         base58Prefixes[ZCVIEWING_KEY]      = {0xA8,0xAB,0xD3};
 142         // guarantees the first 2 characters, when base58 encoded, are "SK"
 143         base58Prefixes[ZCSPENDING_KEY]     = {0xAB,0x36};
 144
 145         vFixedSeeds = std::vector<SeedSpec6>(pnSeed6_main, pnSeed6_main + ARRAYLEN(pnSeed6_main));
 146
 147         fMiningRequiresPeers = true;
 148         fDefaultConsistencyChecks = false;
 149         fRequireStandard = true;
 150         fMineBlocksOnDemand = false;
 151         fTestnetToBeDeprecatedFieldRPC = false;
 152
 153         checkpointData = (CCheckpointData) {
 154             boost::assign::map_list_of
 155             (0, consensus.hashGenesisBlock)
 156             (2500, uint256S("0x00000006dc968f600be11a86cbfbf7feb61c7577f45caced2e82b6d261d19744"))
 157             (15000, uint256S("0x00000000b6bc56656812a5b8dcad69d6ad4446dec23b5ec456c18641fb5381ba"))
 158             (67500, uint256S("0x000000006b366d2c1649a6ebb4787ac2b39c422f451880bc922e3a6fbd723616")),
 159             1487767578,     // * UNIX timestamp of last checkpoint block
 160             325430,         // * total number of transactions between genesis and last checkpoint
 161                             //   (the tx=... number in the SetBestChain debug.log lines)
 162             2777            // * estimated number of transactions per day after checkpoint
 163                             //   total number of tx / (checkpoint block height / (24 * 24))
 164         };
 165
 166         // Founders reward script expects a vector of 2-of-3 multisig addresses
 167         vFoundersRewardAddress = {
 168             "t3Vz22vK5z2LcKEdg16Yv4FFneEL1zg9ojd", /* main-index: 0*/
 169             "t3cL9AucCajm3HXDhb5jBnJK2vapVoXsop3", /* main-index: 1*/
 170             "t3fqvkzrrNaMcamkQMwAyHRjfDdM2xQvDTR", /* main-index: 2*/
 171             "t3TgZ9ZT2CTSK44AnUPi6qeNaHa2eC7pUyF", /* main-index: 3*/
 172             "t3SpkcPQPfuRYHsP5vz3Pv86PgKo5m9KVmx", /* main-index: 4*/
 173             "t3Xt4oQMRPagwbpQqkgAViQgtST4VoSWR6S", /* main-index: 5*/
 174             "t3ayBkZ4w6kKXynwoHZFUSSgXRKtogTXNgb", /* main-index: 6*/
 175             "t3adJBQuaa21u7NxbR8YMzp3km3TbSZ4MGB", /* main-index: 7*/
 176             "t3K4aLYagSSBySdrfAGGeUd5H9z5Qvz88t2", /* main-index: 8*/
 177             "t3RYnsc5nhEvKiva3ZPhfRSk7eyh1CrA6Rk", /* main-index: 9*/
 178             "t3Ut4KUq2ZSMTPNE67pBU5LqYCi2q36KpXQ", /* main-index: 10*/
 179             "t3ZnCNAvgu6CSyHm1vWtrx3aiN98dSAGpnD", /* main-index: 11*/
 180             "t3fB9cB3eSYim64BS9xfwAHQUKLgQQroBDG", /* main-index: 12*/
 181             "t3cwZfKNNj2vXMAHBQeewm6pXhKFdhk18kD", /* main-index: 13*/
 182             "t3YcoujXfspWy7rbNUsGKxFEWZqNstGpeG4", /* main-index: 14*/
 183             "t3bLvCLigc6rbNrUTS5NwkgyVrZcZumTRa4", /* main-index: 15*/
 184             "t3VvHWa7r3oy67YtU4LZKGCWa2J6eGHvShi", /* main-index: 16*/
 185             "t3eF9X6X2dSo7MCvTjfZEzwWrVzquxRLNeY", /* main-index: 17*/
 186             "t3esCNwwmcyc8i9qQfyTbYhTqmYXZ9AwK3X", /* main-index: 18*/
 187             "t3M4jN7hYE2e27yLsuQPPjuVek81WV3VbBj", /* main-index: 19*/
 188             "t3gGWxdC67CYNoBbPjNvrrWLAWxPqZLxrVY", /* main-index: 20*/
 189             "t3LTWeoxeWPbmdkUD3NWBquk4WkazhFBmvU", /* main-index: 21*/
 190             "t3P5KKX97gXYFSaSjJPiruQEX84yF5z3Tjq", /* main-index: 22*/
 191             "t3f3T3nCWsEpzmD35VK62JgQfFig74dV8C9", /* main-index: 23*/
 192             "t3Rqonuzz7afkF7156ZA4vi4iimRSEn41hj", /* main-index: 24*/
 193             "t3fJZ5jYsyxDtvNrWBeoMbvJaQCj4JJgbgX", /* main-index: 25*/
 194             "t3Pnbg7XjP7FGPBUuz75H65aczphHgkpoJW", /* main-index: 26*/
 195             "t3WeKQDxCijL5X7rwFem1MTL9ZwVJkUFhpF", /* main-index: 27*/
 196             "t3Y9FNi26J7UtAUC4moaETLbMo8KS1Be6ME", /* main-index: 28*/
 197             "t3aNRLLsL2y8xcjPheZZwFy3Pcv7CsTwBec", /* main-index: 29*/
 198             "t3gQDEavk5VzAAHK8TrQu2BWDLxEiF1unBm", /* main-index: 30*/
 199             "t3Rbykhx1TUFrgXrmBYrAJe2STxRKFL7G9r", /* main-index: 31*/
 200             "t3aaW4aTdP7a8d1VTE1Bod2yhbeggHgMajR", /* main-index: 32*/
 201             "t3YEiAa6uEjXwFL2v5ztU1fn3yKgzMQqNyo", /* main-index: 33*/
 202             "t3g1yUUwt2PbmDvMDevTCPWUcbDatL2iQGP", /* main-index: 34*/
 203             "t3dPWnep6YqGPuY1CecgbeZrY9iUwH8Yd4z", /* main-index: 35*/
 204             "t3QRZXHDPh2hwU46iQs2776kRuuWfwFp4dV", /* main-index: 36*/
 205             "t3enhACRxi1ZD7e8ePomVGKn7wp7N9fFJ3r", /* main-index: 37*/
 206             "t3PkLgT71TnF112nSwBToXsD77yNbx2gJJY", /* main-index: 38*/
 207             "t3LQtHUDoe7ZhhvddRv4vnaoNAhCr2f4oFN", /* main-index: 39*/
 208             "t3fNcdBUbycvbCtsD2n9q3LuxG7jVPvFB8L", /* main-index: 40*/
 209             "t3dKojUU2EMjs28nHV84TvkVEUDu1M1FaEx", /* main-index: 41*/
 210             "t3aKH6NiWN1ofGd8c19rZiqgYpkJ3n679ME", /* main-index: 42*/
 211             "t3MEXDF9Wsi63KwpPuQdD6by32Mw2bNTbEa", /* main-index: 43*/
 212             "t3WDhPfik343yNmPTqtkZAoQZeqA83K7Y3f", /* main-index: 44*/
 213             "t3PSn5TbMMAEw7Eu36DYctFezRzpX1hzf3M", /* main-index: 45*/
 214             "t3R3Y5vnBLrEn8L6wFjPjBLnxSUQsKnmFpv", /* main-index: 46*/
 215             "t3Pcm737EsVkGTbhsu2NekKtJeG92mvYyoN", /* main-index: 47*/
 216 //            "t3PZ9PPcLzgL57XRSG5ND4WNBC9UTFb8DXv", /* main-index: 48*/
 217 //            "t3L1WgcyQ95vtpSgjHfgANHyVYvffJZ9iGb", /* main-index: 49*/
 218 //            "t3JtoXqsv3FuS7SznYCd5pZJGU9di15mdd7", /* main-index: 50*/
 219 //            "t3hLJHrHs3ytDgExxr1mD8DYSrk1TowGV25", /* main-index: 51*/
 220 //            "t3fmYHU2DnVaQgPhDs6TMFVmyC3qbWEWgXN", /* main-index: 52*/
 221 //            "t3T4WmAp6nrLkJ24iPpGeCe1fSWTPv47ASG", /* main-index: 53*/
 222 //            "t3fP6GrDM4QVwdjFhmCxGNbe7jXXXSDQ5dv", /* main-index: 54*/
 223 };
 224         assert(vFoundersRewardAddress.size() <= consensus.GetLastFoundersRewardBlockHeight());
 225     }
 226 };
 227 static CMainParams mainParams;
 228
 229 /**
 230  * Testnet (v3)
 231  */
 232 class CTestNetParams : public CChainParams {
 233 public:
 234     CTestNetParams() {
 235         strNetworkID = "test";
 236         strCurrencyUnits = "TAZ";
 237         consensus.fCoinbaseMustBeProtected = true;
 238         consensus.nSubsidySlowStartInterval = 20000;
 239         consensus.nSubsidyHalvingInterval = 840000;
 240         consensus.nMajorityEnforceBlockUpgrade = 51;
 241         consensus.nMajorityRejectBlockOutdated = 75;
 242         consensus.nMajorityWindow = 400;
 243         consensus.powLimit = uint256S("07ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
 244         consensus.nPowAveragingWindow = 17;
 245         assert(maxUint/UintToArith256(consensus.powLimit) >= consensus.nPowAveragingWindow);
 246         consensus.nPowMaxAdjustDown = 32; // 32% adjustment down
 247         consensus.nPowMaxAdjustUp = 16; // 16% adjustment up
 248         consensus.nPowTargetSpacing = 2.5 * 60;
 249         consensus.vUpgrades[Consensus::BASE_SPROUT].nActivationHeight =
 250             Consensus::NetworkUpgrade::ALWAYS_ACTIVE;
 251         consensus.vUpgrades[Consensus::UPGRADE_TESTDUMMY].nActivationHeight =
 252             Consensus::NetworkUpgrade::NO_ACTIVATION_HEIGHT;
 253
 254         pchMessageStart[0] = 0xfa;
 255         pchMessageStart[1] = 0x1a;
 256         pchMessageStart[2] = 0xf9;
 257         pchMessageStart[3] = 0xbf;
 258         vAlertPubKey = ParseHex("044e7a1553392325c871c5ace5d6ad73501c66f4c185d6b0453cf45dec5a1322e705c672ac1a27ef7cdaf588c10effdf50ed5f95f85f2f54a5f6159fca394ed0c6");
 259         nDefaultPort = 18233;
 260         nMaxTipAge = 24 * 60 * 60;
 261         nPruneAfterHeight = 1000;
 262         const size_t N = 200, K = 9;
 263         BOOST_STATIC_ASSERT(equihash_parameters_acceptable(N, K));
 264         nEquihashN = N;
 265         nEquihashK = K;
 266
 267         genesis = CreateGenesisBlock(
 268             1477648033,
 269             uint256S("0x0000000000000000000000000000000000000000000000000000000000000006"),
 270             ParseHex("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"),
 271             0x2007ffff, 4, 0);
 272         consensus.hashGenesisBlock = genesis.GetHash();
 273         assert(consensus.hashGenesisBlock == uint256S("0x05a60a92d99d85997cce3b87616c089f6124d7342af37106edc76126334a2c38"));
 274         assert(genesis.hashMerkleRoot == uint256S("0xc4eaa58879081de3c24a7b117ed2b28300e7ec4c4c1dff1d3f1268b7857a4ddb"));
 275
 276         vFixedSeeds.clear();
 277         vSeeds.clear();
 278         vSeeds.push_back(CDNSSeedData("z.cash", "dnsseed.testnet.z.cash")); // Zcash
 279
 280         // guarantees the first 2 characters, when base58 encoded, are "tm"
 281         base58Prefixes[PUBKEY_ADDRESS]     = {0x1D,0x25};
 282         // guarantees the first 2 characters, when base58 encoded, are "t2"
 283         base58Prefixes[SCRIPT_ADDRESS]     = {0x1C,0xBA};
 284         // the first character, when base58 encoded, is "9" or "c" (as in Bitcoin)
 285         base58Prefixes[SECRET_KEY]         = {0xEF};
 286         // do not rely on these BIP32 prefixes; they are not specified and may change
 287         base58Prefixes[EXT_PUBLIC_KEY]     = {0x04,0x35,0x87,0xCF};
 288         base58Prefixes[EXT_SECRET_KEY]     = {0x04,0x35,0x83,0x94};
 289         // guarantees the first 2 characters, when base58 encoded, are "zt"
 290         base58Prefixes[ZCPAYMENT_ADDRRESS] = {0x16,0xB6};
 291         // guarantees the first 4 characters, when base58 encoded, are "ZiVt"
 292         base58Prefixes[ZCVIEWING_KEY]      = {0xA8,0xAC,0x0C};
 293         // guarantees the first 2 characters, when base58 encoded, are "ST"
 294         base58Prefixes[ZCSPENDING_KEY]     = {0xAC,0x08};
 295
 296         vFixedSeeds = std::vector<SeedSpec6>(pnSeed6_test, pnSeed6_test + ARRAYLEN(pnSeed6_test));
 297
 298         fMiningRequiresPeers = true;
 299         fDefaultConsistencyChecks = false;
 300         fRequireStandard = true;
 301         fMineBlocksOnDemand = false;
 302         fTestnetToBeDeprecatedFieldRPC = true;
 303
 304         checkpointData = (CCheckpointData) {
 305             boost::assign::map_list_of
 306             (0, consensus.hashGenesisBlock)
 307             (38000, uint256S("0x001e9a2d2e2892b88e9998cf7b079b41d59dd085423a921fe8386cecc42287b8")),
 308             1486897419,  // * UNIX timestamp of last checkpoint block
 309             47163,       // * total number of transactions between genesis and last checkpoint
 310                          //   (the tx=... number in the SetBestChain debug.log lines)
 311             715          //   total number of tx / (checkpoint block height / (24 * 24))
 312         };
 313
 314         // Founders reward script expects a vector of 2-of-3 multisig addresses
 315         vFoundersRewardAddress = {
 316             "t2UNzUUx8mWBCRYPRezvA363EYXyEpHokyi", "t2N9PH9Wk9xjqYg9iin1Ua3aekJqfAtE543", "t2NGQjYMQhFndDHguvUw4wZdNdsssA6K7x2", "t2ENg7hHVqqs9JwU5cgjvSbxnT2a9USNfhy",
 317             "t2BkYdVCHzvTJJUTx4yZB8qeegD8QsPx8bo", "t2J8q1xH1EuigJ52MfExyyjYtN3VgvshKDf", "t2Crq9mydTm37kZokC68HzT6yez3t2FBnFj", "t2EaMPUiQ1kthqcP5UEkF42CAFKJqXCkXC9",
 318             "t2F9dtQc63JDDyrhnfpzvVYTJcr57MkqA12", "t2LPirmnfYSZc481GgZBa6xUGcoovfytBnC", "t26xfxoSw2UV9Pe5o3C8V4YybQD4SESfxtp", "t2D3k4fNdErd66YxtvXEdft9xuLoKD7CcVo",
 319             "t2DWYBkxKNivdmsMiivNJzutaQGqmoRjRnL", "t2C3kFF9iQRxfc4B9zgbWo4dQLLqzqjpuGQ", "t2MnT5tzu9HSKcppRyUNwoTp8MUueuSGNaB", "t2AREsWdoW1F8EQYsScsjkgqobmgrkKeUkK",
 320             "t2Vf4wKcJ3ZFtLj4jezUUKkwYR92BLHn5UT", "t2K3fdViH6R5tRuXLphKyoYXyZhyWGghDNY", "t2VEn3KiKyHSGyzd3nDw6ESWtaCQHwuv9WC", "t2F8XouqdNMq6zzEvxQXHV1TjwZRHwRg8gC",
 321             "t2BS7Mrbaef3fA4xrmkvDisFVXVrRBnZ6Qj", "t2FuSwoLCdBVPwdZuYoHrEzxAb9qy4qjbnL", "t2SX3U8NtrT6gz5Db1AtQCSGjrpptr8JC6h", "t2V51gZNSoJ5kRL74bf9YTtbZuv8Fcqx2FH",
 322             "t2FyTsLjjdm4jeVwir4xzj7FAkUidbr1b4R", "t2EYbGLekmpqHyn8UBF6kqpahrYm7D6N1Le", "t2NQTrStZHtJECNFT3dUBLYA9AErxPCmkka", "t2GSWZZJzoesYxfPTWXkFn5UaxjiYxGBU2a",
 323             "t2RpffkzyLRevGM3w9aWdqMX6bd8uuAK3vn", "t2JzjoQqnuXtTGSN7k7yk5keURBGvYofh1d", "t2AEefc72ieTnsXKmgK2bZNckiwvZe3oPNL", "t2NNs3ZGZFsNj2wvmVd8BSwSfvETgiLrD8J",
 324             "t2ECCQPVcxUCSSQopdNquguEPE14HsVfcUn", "t2JabDUkG8TaqVKYfqDJ3rqkVdHKp6hwXvG", "t2FGzW5Zdc8Cy98ZKmRygsVGi6oKcmYir9n", "t2DUD8a21FtEFn42oVLp5NGbogY13uyjy9t",
 325             "t2UjVSd3zheHPgAkuX8WQW2CiC9xHQ8EvWp", "t2TBUAhELyHUn8i6SXYsXz5Lmy7kDzA1uT5", "t2Tz3uCyhP6eizUWDc3bGH7XUC9GQsEyQNc", "t2NysJSZtLwMLWEJ6MH3BsxRh6h27mNcsSy",
 326             "t2KXJVVyyrjVxxSeazbY9ksGyft4qsXUNm9", "t2J9YYtH31cveiLZzjaE4AcuwVho6qjTNzp", "t2QgvW4sP9zaGpPMH1GRzy7cpydmuRfB4AZ", "t2NDTJP9MosKpyFPHJmfjc5pGCvAU58XGa4",
 327             "t29pHDBWq7qN4EjwSEHg8wEqYe9pkmVrtRP", "t2Ez9KM8VJLuArcxuEkNRAkhNvidKkzXcjJ", "t2D5y7J5fpXajLbGrMBQkFg2mFN8fo3n8cX", "t2UV2wr1PTaUiybpkV3FdSdGxUJeZdZztyt",
 328             };
 329         assert(vFoundersRewardAddress.size() <= consensus.GetLastFoundersRewardBlockHeight());
 330     }
 331 };
 332 static CTestNetParams testNetParams;
 333
 334 /**
 335  * Regression test
 336  */
 337 class CRegTestParams : public CChainParams {
 338 public:
 339     CRegTestParams() {
 340         strNetworkID = "regtest";
 341         strCurrencyUnits = "REG";
 342         consensus.fCoinbaseMustBeProtected = false;
 343         consensus.nSubsidySlowStartInterval = 0;
 344         consensus.nSubsidyHalvingInterval = 150;
 345         consensus.nMajorityEnforceBlockUpgrade = 750;
 346         consensus.nMajorityRejectBlockOutdated = 950;
 347         consensus.nMajorityWindow = 1000;
 348         consensus.powLimit = uint256S("0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f");
 349         consensus.nPowAveragingWindow = 17;
 350         assert(maxUint/UintToArith256(consensus.powLimit) >= consensus.nPowAveragingWindow);
 351         consensus.nPowMaxAdjustDown = 0; // Turn off adjustment down
 352         consensus.nPowMaxAdjustUp = 0; // Turn off adjustment up
 353         consensus.nPowTargetSpacing = 2.5 * 60;
 354         consensus.vUpgrades[Consensus::BASE_SPROUT].nActivationHeight =
 355             Consensus::NetworkUpgrade::ALWAYS_ACTIVE;
 356         consensus.vUpgrades[Consensus::UPGRADE_TESTDUMMY].nActivationHeight =
 357             Consensus::NetworkUpgrade::NO_ACTIVATION_HEIGHT;
 358
 359         pchMessageStart[0] = 0xaa;
 360         pchMessageStart[1] = 0xe8;
 361         pchMessageStart[2] = 0x3f;
 362         pchMessageStart[3] = 0x5f;
 363         nDefaultPort = 18344;
 364         nMaxTipAge = 24 * 60 * 60;
 365         nPruneAfterHeight = 1000;
 366         const size_t N = 48, K = 5;
 367         BOOST_STATIC_ASSERT(equihash_parameters_acceptable(N, K));
 368         nEquihashN = N;
 369         nEquihashK = K;
 370
 371         genesis = CreateGenesisBlock(
 372             1296688602,
 373             uint256S("0x0000000000000000000000000000000000000000000000000000000000000009"),
 374             ParseHex("01936b7db1eb4ac39f151b8704642d0a8bda13ec547d54cd5e43ba142fc6d8877cab07b3"),
 375             0x200f0f0f, 4, 0);
 376         consensus.hashGenesisBlock = genesis.GetHash();
 377         assert(consensus.hashGenesisBlock == uint256S("0x029f11d80ef9765602235e1bc9727e3eb6ba20839319f761fee920d63401e327"));
 378         assert(genesis.hashMerkleRoot == uint256S("0xc4eaa58879081de3c24a7b117ed2b28300e7ec4c4c1dff1d3f1268b7857a4ddb"));
 379
 380         vFixedSeeds.clear(); //! Regtest mode doesn't have any fixed seeds.
 381         vSeeds.clear();  //! Regtest mode doesn't have any DNS seeds.
 382
 383         fMiningRequiresPeers = false;
 384         fDefaultConsistencyChecks = true;
 385         fRequireStandard = false;
 386         fMineBlocksOnDemand = true;
 387         fTestnetToBeDeprecatedFieldRPC = false;
 388
 389         checkpointData = (CCheckpointData){
 390             boost::assign::map_list_of
 391             ( 0, uint256S("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206")),
 392             0,
 393             0,
 394             0
 395         };
 396         // These prefixes are the same as the testnet prefixes
 397         base58Prefixes[PUBKEY_ADDRESS]     = {0x1D,0x25};
 398         base58Prefixes[SCRIPT_ADDRESS]     = {0x1C,0xBA};
 399         base58Prefixes[SECRET_KEY]         = {0xEF};
 400         // do not rely on these BIP32 prefixes; they are not specified and may change
 401         base58Prefixes[EXT_PUBLIC_KEY]     = {0x04,0x35,0x87,0xCF};
 402         base58Prefixes[EXT_SECRET_KEY]     = {0x04,0x35,0x83,0x94};
 403         base58Prefixes[ZCPAYMENT_ADDRRESS] = {0x16,0xB6};
 404         base58Prefixes[ZCVIEWING_KEY]      = {0xA8,0xAC,0x0C};
 405         base58Prefixes[ZCSPENDING_KEY]     = {0xAC,0x08};
 406
 407         // Founders reward script expects a vector of 2-of-3 multisig addresses
 408         vFoundersRewardAddress = { "t2FwcEhFdNXuFMv1tcYwaBJtYVtMj8b1uTg" };
 409         assert(vFoundersRewardAddress.size() <= consensus.GetLastFoundersRewardBlockHeight());
 410     }
 411
 412     void UpdateNetworkUpgradeParameters(Consensus::UpgradeIndex idx, int nActivationHeight)
 413     {
 414         assert(idx > Consensus::BASE_SPROUT && idx < Consensus::MAX_NETWORK_UPGRADES);
 415         consensus.vUpgrades[idx].nActivationHeight = nActivationHeight;
 416     }
 417 };
 418 static CRegTestParams regTestParams;
 419
 420 static CChainParams *pCurrentParams = 0;
 421
 422 const CChainParams &Params() {
 423     assert(pCurrentParams);
 424     return *pCurrentParams;
 425 }
 426
 427 CChainParams &Params(CBaseChainParams::Network network) {
 428     switch (network) {
 429         case CBaseChainParams::MAIN:
 430             return mainParams;
 431         case CBaseChainParams::TESTNET:
 432             return testNetParams;
 433         case CBaseChainParams::REGTEST:
 434             return regTestParams;
 435         default:
 436             assert(false && "Unimplemented network");
 437             return mainParams;
 438     }
 439 }
 440
 441 void SelectParams(CBaseChainParams::Network network) {
 442     SelectBaseParams(network);
 443     pCurrentParams = &Params(network);
 444
 445     // Some python qa rpc tests need to enforce the coinbase consensus rule
 446     if (network == CBaseChainParams::REGTEST && mapArgs.count("-regtestprotectcoinbase")) {
 447         regTestParams.SetRegTestCoinbaseMustBeProtected();
 448     }
 449 }
 450
 451 bool SelectParamsFromCommandLine()
 452 {
 453     CBaseChainParams::Network network = NetworkIdFromCommandLine();
 454     if (network == CBaseChainParams::MAX_NETWORK_TYPES)
 455         return false;
 456
 457     SelectParams(network);
 458     return true;
 459 }
 460
 461
 462 // Block height must be >0 and <=last founders reward block height
 463 // Index variable i ranges from 0 - (vFoundersRewardAddress.size()-1)
 464 std::string CChainParams::GetFoundersRewardAddressAtHeight(int nHeight) const {
 465     int maxHeight = consensus.GetLastFoundersRewardBlockHeight();
 466     assert(nHeight > 0 && nHeight <= maxHeight);
 467
 468     size_t addressChangeInterval = (maxHeight + vFoundersRewardAddress.size()) / vFoundersRewardAddress.size();
 469     size_t i = nHeight / addressChangeInterval;
 470     return vFoundersRewardAddress[i];
 471 }
 472
 473 // Block height must be >0 and <=last founders reward block height
 474 // The founders reward address is expected to be a multisig (P2SH) address
 475 CScript CChainParams::GetFoundersRewardScriptAtHeight(int nHeight) const {
 476     assert(nHeight > 0 && nHeight <= consensus.GetLastFoundersRewardBlockHeight());
 477
 478     CBitcoinAddress address(GetFoundersRewardAddressAtHeight(nHeight).c_str());
 479     assert(address.IsValid());
 480     assert(address.IsScript());
 481     CScriptID scriptID = boost::get<CScriptID>(address.Get()); // Get() returns a boost variant
 482     CScript script = CScript() << OP_HASH160 << ToByteVector(scriptID) << OP_EQUAL;
 483     return script;
 484 }
 485
 486 std::string CChainParams::GetFoundersRewardAddressAtIndex(int i) const {
 487     assert(i >= 0 && i < vFoundersRewardAddress.size());
 488     return vFoundersRewardAddress[i];
 489 }
 490
 491 void UpdateNetworkUpgradeParameters(Consensus::UpgradeIndex idx, int nActivationHeight)
 492 {
 493     regTestParams.UpdateNetworkUpgradeParameters(idx, nActivationHeight);
 494 }