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