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("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"),
 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         // Founders reward script expects a vector of 2-of-3 multisig addresses
 358         vFoundersRewardAddress = {
 359             "t2UNzUUx8mWBCRYPRezvA363EYXyEpHokyi", "t2N9PH9Wk9xjqYg9iin1Ua3aekJqfAtE543", "t2NGQjYMQhFndDHguvUw4wZdNdsssA6K7x2", "t2ENg7hHVqqs9JwU5cgjvSbxnT2a9USNfhy",
 360             "t2BkYdVCHzvTJJUTx4yZB8qeegD8QsPx8bo", "t2J8q1xH1EuigJ52MfExyyjYtN3VgvshKDf", "t2Crq9mydTm37kZokC68HzT6yez3t2FBnFj", "t2EaMPUiQ1kthqcP5UEkF42CAFKJqXCkXC9",
 361             "t2F9dtQc63JDDyrhnfpzvVYTJcr57MkqA12", "t2LPirmnfYSZc481GgZBa6xUGcoovfytBnC", "t26xfxoSw2UV9Pe5o3C8V4YybQD4SESfxtp", "t2D3k4fNdErd66YxtvXEdft9xuLoKD7CcVo",
 362             "t2DWYBkxKNivdmsMiivNJzutaQGqmoRjRnL", "t2C3kFF9iQRxfc4B9zgbWo4dQLLqzqjpuGQ", "t2MnT5tzu9HSKcppRyUNwoTp8MUueuSGNaB", "t2AREsWdoW1F8EQYsScsjkgqobmgrkKeUkK",
 363             "t2Vf4wKcJ3ZFtLj4jezUUKkwYR92BLHn5UT", "t2K3fdViH6R5tRuXLphKyoYXyZhyWGghDNY", "t2VEn3KiKyHSGyzd3nDw6ESWtaCQHwuv9WC", "t2F8XouqdNMq6zzEvxQXHV1TjwZRHwRg8gC",
 364             "t2BS7Mrbaef3fA4xrmkvDisFVXVrRBnZ6Qj", "t2FuSwoLCdBVPwdZuYoHrEzxAb9qy4qjbnL", "t2SX3U8NtrT6gz5Db1AtQCSGjrpptr8JC6h", "t2V51gZNSoJ5kRL74bf9YTtbZuv8Fcqx2FH",
 365             "t2FyTsLjjdm4jeVwir4xzj7FAkUidbr1b4R", "t2EYbGLekmpqHyn8UBF6kqpahrYm7D6N1Le", "t2NQTrStZHtJECNFT3dUBLYA9AErxPCmkka", "t2GSWZZJzoesYxfPTWXkFn5UaxjiYxGBU2a",
 366             "t2RpffkzyLRevGM3w9aWdqMX6bd8uuAK3vn", "t2JzjoQqnuXtTGSN7k7yk5keURBGvYofh1d", "t2AEefc72ieTnsXKmgK2bZNckiwvZe3oPNL", "t2NNs3ZGZFsNj2wvmVd8BSwSfvETgiLrD8J",
 367             "t2ECCQPVcxUCSSQopdNquguEPE14HsVfcUn", "t2JabDUkG8TaqVKYfqDJ3rqkVdHKp6hwXvG", "t2FGzW5Zdc8Cy98ZKmRygsVGi6oKcmYir9n", "t2DUD8a21FtEFn42oVLp5NGbogY13uyjy9t",
 368             "t2UjVSd3zheHPgAkuX8WQW2CiC9xHQ8EvWp", "t2TBUAhELyHUn8i6SXYsXz5Lmy7kDzA1uT5", "t2Tz3uCyhP6eizUWDc3bGH7XUC9GQsEyQNc", "t2NysJSZtLwMLWEJ6MH3BsxRh6h27mNcsSy",
 369             "t2KXJVVyyrjVxxSeazbY9ksGyft4qsXUNm9", "t2J9YYtH31cveiLZzjaE4AcuwVho6qjTNzp", "t2QgvW4sP9zaGpPMH1GRzy7cpydmuRfB4AZ", "t2NDTJP9MosKpyFPHJmfjc5pGCvAU58XGa4",
 370             "t29pHDBWq7qN4EjwSEHg8wEqYe9pkmVrtRP", "t2Ez9KM8VJLuArcxuEkNRAkhNvidKkzXcjJ", "t2D5y7J5fpXajLbGrMBQkFg2mFN8fo3n8cX", "t2UV2wr1PTaUiybpkV3FdSdGxUJeZdZztyt",
 371             };
 372         assert(vFoundersRewardAddress.size() <= consensus.GetLastFoundersRewardBlockHeight());
 373     }
 374 };
 375 static CTestNetParams testNetParams;
 376
 377 /**
 378  * Regression test
 379  */
 380 class CRegTestParams : public CChainParams {
 381 public:
 382     CRegTestParams() {
 383         strNetworkID = "regtest";
 384         strCurrencyUnits = "REG";
 385         bip44CoinType = 1;
 386         consensus.fCoinbaseMustBeProtected = false;
 387         consensus.nSubsidySlowStartInterval = 0;
 388         consensus.nSubsidyHalvingInterval = 150;
 389         consensus.nMajorityEnforceBlockUpgrade = 750;
 390         consensus.nMajorityRejectBlockOutdated = 950;
 391         consensus.nMajorityWindow = 1000;
 392         consensus.powLimit = uint256S("0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f");
 393         consensus.nPowAveragingWindow = 17;
 394         assert(maxUint/UintToArith256(consensus.powLimit) >= consensus.nPowAveragingWindow);
 395         consensus.nPowMaxAdjustDown = 0; // Turn off adjustment down
 396         consensus.nPowMaxAdjustUp = 0; // Turn off adjustment up
 397         consensus.nPowTargetSpacing = 2.5 * 60;
 398         consensus.nPowAllowMinDifficultyBlocksAfterHeight = 0;
 399         consensus.vUpgrades[Consensus::BASE_SPROUT].nProtocolVersion = 170002;
 400         consensus.vUpgrades[Consensus::BASE_SPROUT].nActivationHeight =
 401             Consensus::NetworkUpgrade::ALWAYS_ACTIVE;
 402         consensus.vUpgrades[Consensus::UPGRADE_TESTDUMMY].nProtocolVersion = 170002;
 403         consensus.vUpgrades[Consensus::UPGRADE_TESTDUMMY].nActivationHeight =
 404             Consensus::NetworkUpgrade::NO_ACTIVATION_HEIGHT;
 405         consensus.vUpgrades[Consensus::UPGRADE_OVERWINTER].nProtocolVersion = 170003;
 406         consensus.vUpgrades[Consensus::UPGRADE_OVERWINTER].nActivationHeight =
 407             Consensus::NetworkUpgrade::NO_ACTIVATION_HEIGHT;
 408         consensus.vUpgrades[Consensus::UPGRADE_SAPLING].nProtocolVersion = 170006;
 409         consensus.vUpgrades[Consensus::UPGRADE_SAPLING].nActivationHeight =
 410             Consensus::NetworkUpgrade::NO_ACTIVATION_HEIGHT;
 411
 412         // The best chain should have at least this much work.
 413         consensus.nMinimumChainWork = uint256S("0x00");
 414
 415         pchMessageStart[0] = 0xaa;
 416         pchMessageStart[1] = 0xe8;
 417         pchMessageStart[2] = 0x3f;
 418         pchMessageStart[3] = 0x5f;
 419         nDefaultPort = 18344;
 420         nPruneAfterHeight = 1000;
 421         const size_t N = 48, K = 5;
 422         BOOST_STATIC_ASSERT(equihash_parameters_acceptable(N, K));
 423         nEquihashN = N;
 424         nEquihashK = K;
 425
 426         genesis = CreateGenesisBlock(
 427             1296688602,
 428             uint256S("0x0000000000000000000000000000000000000000000000000000000000000009"),
 429             ParseHex("01936b7db1eb4ac39f151b8704642d0a8bda13ec547d54cd5e43ba142fc6d8877cab07b3"),
 430             0x200f0f0f, 4, 0);
 431         consensus.hashGenesisBlock = genesis.GetHash();
 432         assert(consensus.hashGenesisBlock == uint256S("0x029f11d80ef9765602235e1bc9727e3eb6ba20839319f761fee920d63401e327"));
 433         assert(genesis.hashMerkleRoot == uint256S("0xc4eaa58879081de3c24a7b117ed2b28300e7ec4c4c1dff1d3f1268b7857a4ddb"));
 434
 435         vFixedSeeds.clear(); //! Regtest mode doesn't have any fixed seeds.
 436         vSeeds.clear();  //! Regtest mode doesn't have any DNS seeds.
 437
 438         fMiningRequiresPeers = false;
 439         fDefaultConsistencyChecks = true;
 440         fRequireStandard = false;
 441         fMineBlocksOnDemand = true;
 442         fTestnetToBeDeprecatedFieldRPC = false;
 443
 444         checkpointData = (CCheckpointData){
 445             boost::assign::map_list_of
 446             ( 0, uint256S("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206")),
 447             0,
 448             0,
 449             0
 450         };
 451         // These prefixes are the same as the testnet prefixes
 452         base58Prefixes[PUBKEY_ADDRESS]     = {0x1D,0x25};
 453         base58Prefixes[SCRIPT_ADDRESS]     = {0x1C,0xBA};
 454         base58Prefixes[SECRET_KEY]         = {0xEF};
 455         // do not rely on these BIP32 prefixes; they are not specified and may change
 456         base58Prefixes[EXT_PUBLIC_KEY]     = {0x04,0x35,0x87,0xCF};
 457         base58Prefixes[EXT_SECRET_KEY]     = {0x04,0x35,0x83,0x94};
 458         base58Prefixes[ZCPAYMENT_ADDRRESS] = {0x16,0xB6};
 459         base58Prefixes[ZCVIEWING_KEY]      = {0xA8,0xAC,0x0C};
 460         base58Prefixes[ZCSPENDING_KEY]     = {0xAC,0x08};
 461
 462         bech32HRPs[SAPLING_PAYMENT_ADDRESS]      = "zregtestsapling";
 463         bech32HRPs[SAPLING_FULL_VIEWING_KEY]     = "zviewregtestsapling";
 464         bech32HRPs[SAPLING_INCOMING_VIEWING_KEY] = "zivkregtestsapling";
 465         bech32HRPs[SAPLING_EXTENDED_SPEND_KEY]   = "secret-extended-key-regtest";
 466
 467         // Founders reward script expects a vector of 2-of-3 multisig addresses
 468         vFoundersRewardAddress = { "t2FwcEhFdNXuFMv1tcYwaBJtYVtMj8b1uTg" };
 469         assert(vFoundersRewardAddress.size() <= consensus.GetLastFoundersRewardBlockHeight());
 470     }
 471
 472     void UpdateNetworkUpgradeParameters(Consensus::UpgradeIndex idx, int nActivationHeight)
 473     {
 474         assert(idx > Consensus::BASE_SPROUT && idx < Consensus::MAX_NETWORK_UPGRADES);
 475         consensus.vUpgrades[idx].nActivationHeight = nActivationHeight;
 476     }
 477 };
 478 static CRegTestParams regTestParams;
 479
 480 static CChainParams *pCurrentParams = 0;
 481
 482 const CChainParams &Params() {
 483     assert(pCurrentParams);
 484     return *pCurrentParams;
 485 }
 486
 487 CChainParams &Params(CBaseChainParams::Network network) {
 488     switch (network) {
 489         case CBaseChainParams::MAIN:
 490             return mainParams;
 491         case CBaseChainParams::TESTNET:
 492             return testNetParams;
 493         case CBaseChainParams::REGTEST:
 494             return regTestParams;
 495         default:
 496             assert(false && "Unimplemented network");
 497             return mainParams;
 498     }
 499 }
 500
 501 void SelectParams(CBaseChainParams::Network network) {
 502     SelectBaseParams(network);
 503     pCurrentParams = &Params(network);
 504
 505     // Some python qa rpc tests need to enforce the coinbase consensus rule
 506     if (network == CBaseChainParams::REGTEST && mapArgs.count("-regtestprotectcoinbase")) {
 507         regTestParams.SetRegTestCoinbaseMustBeProtected();
 508     }
 509 }
 510
 511 bool SelectParamsFromCommandLine()
 512 {
 513     CBaseChainParams::Network network = NetworkIdFromCommandLine();
 514     if (network == CBaseChainParams::MAX_NETWORK_TYPES)
 515         return false;
 516
 517     SelectParams(network);
 518     return true;
 519 }
 520
 521
 522 // Block height must be >0 and <=last founders reward block height
 523 // Index variable i ranges from 0 - (vFoundersRewardAddress.size()-1)
 524 std::string CChainParams::GetFoundersRewardAddressAtHeight(int nHeight) const {
 525     int maxHeight = consensus.GetLastFoundersRewardBlockHeight();
 526     assert(nHeight > 0 && nHeight <= maxHeight);
 527
 528     size_t addressChangeInterval = (maxHeight + vFoundersRewardAddress.size()) / vFoundersRewardAddress.size();
 529     size_t i = nHeight / addressChangeInterval;
 530     return vFoundersRewardAddress[i];
 531 }
 532
 533 // Block height must be >0 and <=last founders reward block height
 534 // The founders reward address is expected to be a multisig (P2SH) address
 535 CScript CChainParams::GetFoundersRewardScriptAtHeight(int nHeight) const {
 536     assert(nHeight > 0 && nHeight <= consensus.GetLastFoundersRewardBlockHeight());
 537
 538     CTxDestination address = DecodeDestination(GetFoundersRewardAddressAtHeight(nHeight).c_str());
 539     assert(IsValidDestination(address));
 540     assert(boost::get<CScriptID>(&address) != nullptr);
 541     CScriptID scriptID = boost::get<CScriptID>(address); // address is a boost variant
 542     CScript script = CScript() << OP_HASH160 << ToByteVector(scriptID) << OP_EQUAL;
 543     return script;
 544 }
 545
 546 std::string CChainParams::GetFoundersRewardAddressAtIndex(int i) const {
 547     assert(i >= 0 && i < vFoundersRewardAddress.size());
 548     return vFoundersRewardAddress[i];
 549 }
 550
 551 void UpdateNetworkUpgradeParameters(Consensus::UpgradeIndex idx, int nActivationHeight)
 552 {
 553     regTestParams.UpdateNetworkUpgradeParameters(idx, nActivationHeight);
 554 }