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