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