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 "main.h"
   7 #include "crypto/equihash.h"
   8
   9 #include "util.h"
  10 #include "utilstrencodings.h"
  11
  12 #include <assert.h>
  13
  14 #include <boost/assign/list_of.hpp>
  15
  16 #include "base58.h"
  17
  18 using namespace std;
  19
  20 #include "chainparamsseeds.h"
  21
  22 /**
  23  * Main network
  24  */
  25 /**
  26  * What makes a good checkpoint block?
  27  * + Is surrounded by blocks with reasonable timestamps
  28  *   (no blocks before with a timestamp after, none after with
  29  *    timestamp before)
  30  * + Contains no strange transactions
  31  */
  32
  33 const arith_uint256 maxUint = UintToArith256(uint256S("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"));
  34
  35 class CMainParams : public CChainParams {
  36 public:
  37     CMainParams() {
  38         strNetworkID = "main";
  39         consensus.fCoinbaseMustBeProtected = false;//true;
  40         consensus.nSubsidySlowStartInterval = 20000;
  41         consensus.nSubsidyHalvingInterval = 840000;
  42         consensus.nMajorityEnforceBlockUpgrade = 750;
  43         consensus.nMajorityRejectBlockOutdated = 950;
  44         consensus.nMajorityWindow = 4000;
  45         consensus.powLimit = uint256S("0007ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
  46         consensus.nPowAveragingWindow = 17;
  47         assert(maxUint/UintToArith256(consensus.powLimit) >= consensus.nPowAveragingWindow);
  48         consensus.nPowMaxAdjustDown = 32; // 32% adjustment down
  49         consensus.nPowMaxAdjustUp = 16; // 16% adjustment up
  50         consensus.nPowTargetSpacing = 1 * 60;
  51         consensus.fPowAllowMinDifficultyBlocks = true; //false;
  52         /**
  53          * The message start string is designed to be unlikely to occur in normal data.
  54          * The characters are rarely used upper ASCII, not valid as UTF-8, and produce
  55          * a large 32-bit integer with any alignment.
  56          */
  57         pchMessageStart[0] = 0xf9;
  58         pchMessageStart[1] = 0xee;
  59         pchMessageStart[2] = 0xe4;
  60         pchMessageStart[3] = 0x8d;
  61         vAlertPubKey = ParseHex("020e46e79a2a8d12b9b5d12c7a91adb4e454edfae43c0a0cb805427d2ac7613fd9");
  62         nDefaultPort = 7770;
  63
  64         nMinerThreads = 0;
  65         nMaxTipAge = 24 * 60 * 60;
  66         nPruneAfterHeight = 100000;
  67         const size_t N = 200, K = 9;
  68         BOOST_STATIC_ASSERT(equihash_parameters_acceptable(N, K));
  69         nEquihashN = N;
  70         nEquihashK = K;
  71
  72         /**
  73          * Build the genesis block. Note that the output of its generation
  74          * transaction cannot be spent since it did not originally exist in the
  75          * database (and is in any case of zero value).
  76          *
  77          * >>> from pyblake2 import blake2s
  78          * >>> '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()
  79          */
  80         const char* pszTimestamp = "Zcash0b9c4eef8b7cc417ee5001e3500984b6fea35683a7cac141a043c42064835d34";
  81         CMutableTransaction txNew;
  82         txNew.vin.resize(1);
  83         txNew.vout.resize(1);
  84         txNew.vin[0].scriptSig = CScript() << 520617983 << CScriptNum(4) << vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
  85         txNew.vout[0].nValue = 0;
  86         txNew.vout[0].scriptPubKey = CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") << OP_CHECKSIG;
  87         genesis.vtx.push_back(txNew);
  88         genesis.hashPrevBlock.SetNull();
  89         genesis.hashMerkleRoot = genesis.BuildMerkleTree();
  90
  91         genesis.nVersion = 1;
  92         genesis.nTime    = 1231006505;
  93         // TODO generate harder genesis block
  94         //genesis.nBits    = 0x1d00ffff;
  95         genesis.nBits    = KOMODO_MINDIFF_NBITS;
  96         genesis.nNonce   = uint256S("0x000000000000000000000000000000000000000000000000000000000000000b");
  97         genesis.nSolution = ParseHex("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");
  98
  99         consensus.hashGenesisBlock = genesis.GetHash();
 100         assert(consensus.hashGenesisBlock == uint256S("0x00040fe8ec8471911baa1db1266ea15dd06b4a8a5c453883c000b031973dce08"));
 101         assert(genesis.hashMerkleRoot == uint256S("0xc4eaa58879081de3c24a7b117ed2b28300e7ec4c4c1dff1d3f1268b7857a4ddb"));
 102
 103         vFixedSeeds.clear();
 104         vSeeds.clear();
 105
 106         // TODO: set up bootstrapping for mainnet
 107         base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,60);
 108         base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,85);
 109         base58Prefixes[SECRET_KEY] =     std::vector<unsigned char>(1,188);
 110         base58Prefixes[EXT_PUBLIC_KEY] = boost::assign::list_of(0x04)(0x88)(0xB2)(0x1E).convert_to_container<std::vector<unsigned char> >();
 111         base58Prefixes[EXT_SECRET_KEY] = boost::assign::list_of(0x04)(0x88)(0xAD)(0xE4).convert_to_container<std::vector<unsigned char> >();
 112         // guarantees the first two characters, when base58 encoded, are "zc"
 113         base58Prefixes[ZCPAYMENT_ADDRRESS] = {22,154};
 114         // guarantees the first two characters, when base58 encoded, are "SK"
 115         base58Prefixes[ZCSPENDING_KEY] = {171,54};
 116
 117         /*
 118         // guarantees the first 2 characters, when base58 encoded, are "t1"
 119         base58Prefixes[PUBKEY_ADDRESS]     = {0x1C,0xB8};
 120         // guarantees the first 2 characters, when base58 encoded, are "t3"
 121         base58Prefixes[SCRIPT_ADDRESS]     = {0x1C,0xBD};
 122         // the first character, when base58 encoded, is "5" or "K" or "L" (as in Bitcoin)
 123         base58Prefixes[SECRET_KEY]         = {0x80};
 124         // do not rely on these BIP32 prefixes; they are not specified and may change
 125         base58Prefixes[EXT_PUBLIC_KEY]     = {0x04,0x88,0xB2,0x1E};
 126         base58Prefixes[EXT_SECRET_KEY]     = {0x04,0x88,0xAD,0xE4};
 127         // guarantees the first 2 characters, when base58 encoded, are "zc"
 128         base58Prefixes[ZCPAYMENT_ADDRRESS] = {0x16,0x9A};
 129         // guarantees the first 2 characters, when base58 encoded, are "SK"
 130         base58Prefixes[ZCSPENDING_KEY]     = {0xAB,0x36};*/
 131
 132         vFixedSeeds = std::vector<SeedSpec6>(pnSeed6_main, pnSeed6_main + ARRAYLEN(pnSeed6_main));
 133
 134         fRequireRPCPassword = true;
 135         fMiningRequiresPeers = true;
 136         fDefaultConsistencyChecks = false;
 137         fRequireStandard = true;
 138         fMineBlocksOnDemand = false;
 139         fTestnetToBeDeprecatedFieldRPC = false;
 140
 141         checkpointData = (Checkpoints::CCheckpointData) {
 142             boost::assign::map_list_of
 143             ( 0, consensus.hashGenesisBlock),
 144             genesis.nTime, // * UNIX timestamp of last checkpoint block
 145             0,   // * total number of transactions between genesis and last checkpoint
 146                  //   (the tx=... number in the SetBestChain debug.log lines)
 147             0    // * estimated number of transactions per day after checkpoint
 148         };
 149     }
 150 };
 151 static CMainParams mainParams;
 152
 153 /**
 154  * Testnet (v3)
 155  */
 156 class CTestNetParams : public CMainParams {
 157 public:
 158     CTestNetParams() {
 159         strNetworkID = "test";
 160         consensus.nMajorityEnforceBlockUpgrade = 51;
 161         consensus.nMajorityRejectBlockOutdated = 75;
 162         consensus.nMajorityWindow = 400;
 163         consensus.powLimit = uint256S("07ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
 164         assert(maxUint/UintToArith256(consensus.powLimit) >= consensus.nPowAveragingWindow);
 165         consensus.fPowAllowMinDifficultyBlocks = true;
 166         pchMessageStart[0] = 0x5A;
 167         pchMessageStart[1] = 0x1F;
 168         pchMessageStart[2] = 0x7E;
 169         pchMessageStart[3] = 0x62;
 170         vAlertPubKey = ParseHex("00");
 171         nDefaultPort = 17770;
 172         nMinerThreads = 0;
 173         nPruneAfterHeight = 1000;
 174
 175         //! Modify the testnet genesis block so the timestamp is valid for a later start.
 176         genesis.nTime = 1296688602;
 177         genesis.nBits = KOMODO_MINDIFF_NBITS;
 178         genesis.nNonce = uint256S("0x0000000000000000000000000000000000000000000000000000000000000009");
 179         genesis.nSolution = ParseHex("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");
 180         consensus.hashGenesisBlock = genesis.GetHash();
 181         assert(consensus.hashGenesisBlock == uint256S("0x05a60a92d99d85997cce3b87616c089f6124d7342af37106edc76126334a2c38"));
 182
 183         vFixedSeeds.clear();
 184         vSeeds.clear();
 185         //vSeeds.push_back(CDNSSeedData("z.cash", "dns.testnet.z.cash")); // Komodo
 186
 187         base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,0);
 188         base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,5);
 189         base58Prefixes[SECRET_KEY] =     std::vector<unsigned char>(1,128);
 190         base58Prefixes[EXT_PUBLIC_KEY] = boost::assign::list_of(0x04)(0x35)(0x87)(0xCF).convert_to_container<std::vector<unsigned char> >();
 191         base58Prefixes[EXT_SECRET_KEY] = boost::assign::list_of(0x04)(0x35)(0x83)(0x94).convert_to_container<std::vector<unsigned char> >();
 192         base58Prefixes[ZCPAYMENT_ADDRRESS] = {20,81};
 193         base58Prefixes[ZCSPENDING_KEY] = {177,235};
 194
 195         vFixedSeeds = std::vector<SeedSpec6>(pnSeed6_test, pnSeed6_test + ARRAYLEN(pnSeed6_test));
 196
 197         fRequireRPCPassword = true;
 198         fMiningRequiresPeers = false;//true;
 199         fDefaultConsistencyChecks = false;
 200         fRequireStandard = true;
 201         fMineBlocksOnDemand = false;
 202         fTestnetToBeDeprecatedFieldRPC = true;
 203
 204         checkpointData = (Checkpoints::CCheckpointData) {
 205             boost::assign::map_list_of
 206             ( 0, consensus.hashGenesisBlock),
 207             genesis.nTime,
 208             0,
 209             0
 210         };
 211
 212         // Founders reward script expects a vector of 2-of-3 multisig addresses
 213         vFoundersRewardAddress = {
 214             "t2UNzUUx8mWBCRYPRezvA363EYXyEpHokyi", "t2N9PH9Wk9xjqYg9iin1Ua3aekJqfAtE543", "t2NGQjYMQhFndDHguvUw4wZdNdsssA6K7x2", "t27ktmq1kbeCWiQ5TZ7w5npSzcdbBmTB7v6",
 215             "t2GcBttAKD2WTHka8HyGc2dfvVTKYZUfHmJ", "t2Q3vxWaD9LrdqUE8Xd9Ddjpr9pUQ2aGotK", "t2TTfWDsYu998fHWzVP9Gns4fgxXXRi1Wzu", "t2KS6R4MMWdSBMjLCiw2iMyhWGRQPmyRqDn",
 216             "t2Q2ELrgotWv3Eec6LEtMMiiQ8dtW38u8Tj", "t2AEgJA88vTWAKqxJDFUEJWyHUtQAZi5G1D", "t2HCSdmpq1TQKksuwPQevwAzPTgfJ2rkMbG", "t2HQCPFAUQaUdJWHPhg5pPBxit7inaJzubE",
 217             "t2Fzqvq8Y9e6Mn3JNPb982aYsLmq4b5HmhH", "t2HEz7YZQqDUgC5h4y2WSD3mWneqJNVRjjJ", "t2GCR1SCk687Eeo5NEZ23MLsms7JjVWBgfG", "t2KyiPR9Lztq2w1w747X6W4nkUMAGL8M9KN",
 218             "t2UxymadyxSyVihmbq7S1yxw5dCBqJ1S4jT", "t2AVeMy7fdmTcJhckqiKRG8B7F1vccEhSqU", "t26m7LwihQzD2sH7ZVhYpPJM5j7kzwbfKW9", "t2DgwUNTe7NxuyPU6fxsB5xJXap3E4yWXrN",
 219             "t2U6funcXA11fC9SZehyvUL3rk3Vhuh7fzS", "t284JhyS8LGM72Tx1porSqwrcq3CejthP1p", "t29egu8QcpzKeLoPLqWS6QVMnUUPQdF6eNm", "t29LqD9p9D3B26euBwFi6mfcWu8HPA38VNs",
 220             "t28GsAMCxAyLy85XaasddDzaYFTtfewr86y", "t2GV44QyaikQPLUfm6oTfZnw71LLjnR7gDG", "t2U2QzNLQ1jtAu4L6xxVnRXLBsQpQvGRR2g", "t2QKGr5PNan7nrwDgseyHMN9NFeeuUjCh8b",
 221             "t2AfS8u6HwBeJpKpbuxztvRjupKQDXqnrwa", "t2CTRQUViQd3CWMhnKhFnUHqDLUyTxmWhJs", "t2CbM9EqszNURqh1UXZBXYhwp1R4GwEhWRE", "t2LM7uYiAsKDU42GNSnMwDxbZ8s1DowQzYH",
 222             "t2AgvT35LHR378AE3ouz6xKMhkTLHLJC6nD", "t285EAQXUVyi4NMddJv2QqTrnv45GRMbP8e", "t2EpMRCD5b8f2DCQ37npNULcpZhkjC8muqA", "t2BCmWXrRPiCeQTpizSWKKRPM5X6PS7umDY",
 223             "t2DN7X6wDFn5hYKBiBmn3Z98st419yaTVTH", "t2QJj8HeCwQ6mHwqekxxDLZntYpZTHNU62t", "t2QdHBR1Yciqn4j8gpS8DcQZZtYetKvfNj3", "t2E5cpLA1ey5VNxFNcuopeQMq2rH2NHiPdu",
 224             "t2EVRGtzjFAyz8CF8ndvLuiJu7qZUfDa93H", "t2KoQDk3BSFadBkuaWdLwchFuQamzw9RE4L", "t2FnR3yhTmuiejEJeu6qpidWTghRd1HpjLt", "t2BAuBAAospDc9d1u5nNGEi6x4NRJBD2PQ2",
 225             "t2RtKrLCGcyPkm4a4APg1YY9Wu2m4R2PgrB", "t28aUbSteZzBq2pFgj1K1XNZRZP5mMMyakV", "t2Urdy1ERfkvsFuy6Z4BkhvYGzWdmivfAFR", "t2ADinR4JrvCMd4Q1XGALPajzFrirqvhED6",
 226         };
 227         assert(vFoundersRewardAddress.size() <= consensus.GetLastFoundersRewardBlockHeight());
 228     }
 229 };
 230 static CTestNetParams testNetParams;
 231
 232 /**
 233  * Regression test
 234  */
 235 class CRegTestParams : public CTestNetParams {
 236 public:
 237     CRegTestParams() {
 238         strNetworkID = "regtest";
 239         consensus.fCoinbaseMustBeProtected = false;
 240         consensus.nSubsidySlowStartInterval = 0;
 241         consensus.nSubsidyHalvingInterval = 150;
 242         consensus.nMajorityEnforceBlockUpgrade = 750;
 243         consensus.nMajorityRejectBlockOutdated = 950;
 244         consensus.nMajorityWindow = 1000;
 245         consensus.powLimit = uint256S("0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f");
 246         assert(maxUint/UintToArith256(consensus.powLimit) >= consensus.nPowAveragingWindow);
 247         consensus.nPowMaxAdjustDown = 0; // Turn off adjustment down
 248         consensus.nPowMaxAdjustUp = 0; // Turn off adjustment up
 249         pchMessageStart[0] = 0xaa;
 250         pchMessageStart[1] = 0x8e;
 251         pchMessageStart[2] = 0xf3;
 252         pchMessageStart[3] = 0xf5;
 253         nMinerThreads = 1;
 254         nMaxTipAge = 24 * 60 * 60;
 255         const size_t N = 48, K = 5;
 256         BOOST_STATIC_ASSERT(equihash_parameters_acceptable(N, K));
 257         nEquihashN = N;
 258         nEquihashK = K;
 259         genesis.nTime = 1296688602;
 260         genesis.nBits = KOMODO_MINDIFF_NBITS;
 261         genesis.nNonce = uint256S("0x0000000000000000000000000000000000000000000000000000000000000021");
 262         genesis.nSolution = ParseHex("0f2a976db4c4263da10fd5d38eb1790469cf19bdb4bf93450e09a72fdff17a3454326399");
 263         consensus.hashGenesisBlock = genesis.GetHash();
 264         nDefaultPort = 17779;
 265         assert(consensus.hashGenesisBlock == uint256S("0x00a215b4fe36f5d2f829d43e587bf10e89e64f9f48a5b6ce18559089e8fd643d"));
 266         nPruneAfterHeight = 1000;
 267
 268         vFixedSeeds.clear(); //! Regtest mode doesn't have any fixed seeds.
 269         vSeeds.clear();  //! Regtest mode doesn't have any DNS seeds.
 270
 271         fRequireRPCPassword = false;
 272         fMiningRequiresPeers = false;
 273         fDefaultConsistencyChecks = true;
 274         fRequireStandard = false;
 275         fMineBlocksOnDemand = true;
 276         fTestnetToBeDeprecatedFieldRPC = false;
 277
 278         checkpointData = (Checkpoints::CCheckpointData){
 279             boost::assign::map_list_of
 280             ( 0, uint256S("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206")),
 281             0,
 282             0,
 283             0
 284         };
 285
 286         // Founders reward script expects a vector of 2-of-3 multisig addresses
 287         vFoundersRewardAddress = { "t2FwcEhFdNXuFMv1tcYwaBJtYVtMj8b1uTg" };
 288         assert(vFoundersRewardAddress.size() <= consensus.GetLastFoundersRewardBlockHeight());
 289     }
 290 };
 291 static CRegTestParams regTestParams;
 292
 293 static CChainParams *pCurrentParams = 0;
 294
 295 const CChainParams &Params() {
 296     assert(pCurrentParams);
 297     return *pCurrentParams;
 298 }
 299
 300 CChainParams &Params(CBaseChainParams::Network network) {
 301     switch (network) {
 302         case CBaseChainParams::MAIN:
 303             return mainParams;
 304         case CBaseChainParams::TESTNET:
 305             return testNetParams;
 306         case CBaseChainParams::REGTEST:
 307             return regTestParams;
 308         default:
 309             assert(false && "Unimplemented network");
 310             return mainParams;
 311     }
 312 }
 313
 314 void SelectParams(CBaseChainParams::Network network) {
 315     SelectBaseParams(network);
 316     pCurrentParams = &Params(network);
 317
 318     // Some python qa rpc tests need to enforce the coinbase consensus rule
 319     if (network == CBaseChainParams::REGTEST && mapArgs.count("-regtestprotectcoinbase")) {
 320         regTestParams.SetRegTestCoinbaseMustBeProtected();
 321     }
 322 }
 323
 324 bool SelectParamsFromCommandLine()
 325 {
 326     CBaseChainParams::Network network = NetworkIdFromCommandLine();
 327     if (network == CBaseChainParams::MAX_NETWORK_TYPES)
 328         return false;
 329
 330     SelectParams(network);
 331     return true;
 332 }
 333
 334
 335 // Block height must be >0 and <=last founders reward block height
 336 // Index variable i ranges from 0 - (vFoundersRewardAddress.size()-1)
 337 std::string CChainParams::GetFoundersRewardAddressAtHeight(int nHeight) const {
 338     int maxHeight = consensus.GetLastFoundersRewardBlockHeight();
 339     assert(nHeight > 0 && nHeight <= maxHeight);
 340
 341     size_t addressChangeInterval = (maxHeight + vFoundersRewardAddress.size()) / vFoundersRewardAddress.size();
 342     size_t i = nHeight / addressChangeInterval;
 343     return vFoundersRewardAddress[i];
 344 }
 345
 346 // Block height must be >0 and <=last founders reward block height
 347 // The founders reward address is expected to be a multisig (P2SH) address
 348 CScript CChainParams::GetFoundersRewardScriptAtHeight(int nHeight) const {
 349     assert(nHeight > 0 && nHeight <= consensus.GetLastFoundersRewardBlockHeight());
 350
 351     CBitcoinAddress address(GetFoundersRewardAddressAtHeight(nHeight).c_str());
 352     assert(address.IsValid());
 353     assert(address.IsScript());
 354     CScriptID scriptID = get<CScriptID>(address.Get()); // Get() returns a boost variant
 355     CScript script = CScript() << OP_HASH160 << ToByteVector(scriptID) << OP_EQUAL;
 356     return script;
 357 }
 358
 359 std::string CChainParams::GetFoundersRewardAddressAtIndex(int i) const {
 360     assert(i >= 0 && i < vFoundersRewardAddress.size());
 361     return vFoundersRewardAddress[i];
 362 }