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