src/chainparams.cpp

   1 // Copyright (c) 2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2014 The Bitcoin developers
   3 // Distributed under the MIT/X11 software license, see the accompanying
   4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   5
   6 #include "chainparams.h"
   7
   8 #include "random.h"
   9 #include "util.h"
  10
  11 #include <assert.h>
  12
  13 #include <boost/assign/list_of.hpp>
  14
  15 using namespace std;
  16 using namespace boost::assign;
  17
  18 struct SeedSpec6 {
  19     uint8_t addr[16];
  20     uint16_t port;
  21 };
  22
  23 #include "chainparamsseeds.h"
  24
  25 //
  26 // Main network
  27 //
  28
  29 // Convert the pnSeeds6 array into usable address objects.
  30 static void convertSeed6(std::vector<CAddress> &vSeedsOut, const SeedSpec6 *data, unsigned int count)
  31 {
  32     // It'll only connect to one or two seed nodes because once it connects,
  33     // it'll get a pile of addresses with newer timestamps.
  34     // Seed nodes are given a random 'last seen time' of between one and two
  35     // weeks ago.
  36     const int64_t nOneWeek = 7*24*60*60;
  37     for (unsigned int i = 0; i < count; i++)
  38     {
  39         struct in6_addr ip;
  40         memcpy(&ip, data[i].addr, sizeof(ip));
  41         CAddress addr(CService(ip, data[i].port));
  42         addr.nTime = GetTime() - GetRand(nOneWeek) - nOneWeek;
  43         vSeedsOut.push_back(addr);
  44     }
  45 }
  46
  47 class CMainParams : public CChainParams {
  48 public:
  49     CMainParams() {
  50         networkID = CBaseChainParams::MAIN;
  51         strNetworkID = "main";
  52         // The message start string is designed to be unlikely to occur in normal data.
  53         // The characters are rarely used upper ASCII, not valid as UTF-8, and produce
  54         // a large 4-byte int at any alignment.
  55         pchMessageStart[0] = 0xf9;
  56         pchMessageStart[1] = 0xbe;
  57         pchMessageStart[2] = 0xb4;
  58         pchMessageStart[3] = 0xd9;
  59         vAlertPubKey = ParseHex("04fc9702847840aaf195de8442ebecedf5b095cdbb9bc716bda9110971b28a49e0ead8564ff0db22209e0374782c093bb899692d524e9d6a6956e7c5ecbcd68284");
  60         nDefaultPort = 8333;
  61         bnProofOfWorkLimit = ~uint256(0) >> 32;
  62         nSubsidyHalvingInterval = 210000;
  63         nEnforceBlockUpgradeMajority = 750;
  64         nRejectBlockOutdatedMajority = 950;
  65         nToCheckBlockUpgradeMajority = 1000;
  66         nMinerThreads = 0;
  67         nTargetTimespan = 14 * 24 * 60 * 60; // two weeks
  68         nTargetSpacing = 10 * 60;
  69
  70         // Build the genesis block. Note that the output of the genesis coinbase cannot
  71         // be spent as it did not originally exist in the database.
  72         //
  73         // CBlock(hash=000000000019d6, ver=1, hashPrevBlock=00000000000000, hashMerkleRoot=4a5e1e, nTime=1231006505, nBits=1d00ffff, nNonce=2083236893, vtx=1)
  74         //   CTransaction(hash=4a5e1e, ver=1, vin.size=1, vout.size=1, nLockTime=0)
  75         //     CTxIn(COutPoint(000000, -1), coinbase 04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73)
  76         //     CTxOut(nValue=50.00000000, scriptPubKey=0x5F1DF16B2B704C8A578D0B)
  77         //   vMerkleTree: 4a5e1e
  78         const char* pszTimestamp = "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks";
  79         CMutableTransaction txNew;
  80         txNew.vin.resize(1);
  81         txNew.vout.resize(1);
  82         txNew.vin[0].scriptSig = CScript() << 486604799 << CScriptNum(4) << vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
  83         txNew.vout[0].nValue = 50 * COIN;
  84         txNew.vout[0].scriptPubKey = CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") << OP_CHECKSIG;
  85         genesis.vtx.push_back(txNew);
  86         genesis.hashPrevBlock = 0;
  87         genesis.hashMerkleRoot = genesis.BuildMerkleTree();
  88         genesis.nVersion = 1;
  89         genesis.nTime    = 1231006505;
  90         genesis.nBits    = 0x1d00ffff;
  91         genesis.nNonce   = 2083236893;
  92
  93         hashGenesisBlock = genesis.GetHash();
  94         assert(hashGenesisBlock == uint256("0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"));
  95         assert(genesis.hashMerkleRoot == uint256("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
  96
  97         vSeeds.push_back(CDNSSeedData("bitcoin.sipa.be", "seed.bitcoin.sipa.be"));
  98         vSeeds.push_back(CDNSSeedData("bluematt.me", "dnsseed.bluematt.me"));
  99         vSeeds.push_back(CDNSSeedData("dashjr.org", "dnsseed.bitcoin.dashjr.org"));
 100         vSeeds.push_back(CDNSSeedData("bitcoinstats.com", "seed.bitcoinstats.com"));
 101         vSeeds.push_back(CDNSSeedData("bitnodes.io", "seed.bitnodes.io"));
 102         vSeeds.push_back(CDNSSeedData("open-nodes.org", "seeds.bitcoin.open-nodes.org"));
 103         vSeeds.push_back(CDNSSeedData("xf2.org", "bitseed.xf2.org"));
 104
 105         base58Prefixes[PUBKEY_ADDRESS] = list_of(0);
 106         base58Prefixes[SCRIPT_ADDRESS] = list_of(5);
 107         base58Prefixes[SECRET_KEY] =     list_of(128);
 108         base58Prefixes[EXT_PUBLIC_KEY] = list_of(0x04)(0x88)(0xB2)(0x1E);
 109         base58Prefixes[EXT_SECRET_KEY] = list_of(0x04)(0x88)(0xAD)(0xE4);
 110
 111         convertSeed6(vFixedSeeds, pnSeed6_main, ARRAYLEN(pnSeed6_main));
 112
 113         fRequireRPCPassword = true;
 114         fMiningRequiresPeers = true;
 115         fDefaultCheckMemPool = false;
 116         fAllowMinDifficultyBlocks = false;
 117         fRequireStandard = true;
 118         fMineBlocksOnDemand = false;
 119     }
 120 };
 121 static CMainParams mainParams;
 122
 123 //
 124 // Testnet (v3)
 125 //
 126
 127 class CTestNetParams : public CMainParams {
 128 public:
 129     CTestNetParams() {
 130         networkID = CBaseChainParams::TESTNET;
 131         strNetworkID = "test";
 132         // The message start string is designed to be unlikely to occur in normal data.
 133         // The characters are rarely used upper ASCII, not valid as UTF-8, and produce
 134         // a large 4-byte int at any alignment.
 135         pchMessageStart[0] = 0x0b;
 136         pchMessageStart[1] = 0x11;
 137         pchMessageStart[2] = 0x09;
 138         pchMessageStart[3] = 0x07;
 139         vAlertPubKey = ParseHex("04302390343f91cc401d56d68b123028bf52e5fca1939df127f63c6467cdf9c8e2c14b61104cf817d0b780da337893ecc4aaff1309e536162dabbdb45200ca2b0a");
 140         nDefaultPort = 18333;
 141         nEnforceBlockUpgradeMajority = 51;
 142         nRejectBlockOutdatedMajority = 75;
 143         nToCheckBlockUpgradeMajority = 100;
 144         nMinerThreads = 0;
 145         nTargetTimespan = 14 * 24 * 60 * 60; // two weeks
 146         nTargetSpacing = 10 * 60;
 147
 148         // Modify the testnet genesis block so the timestamp is valid for a later start.
 149         genesis.nTime = 1296688602;
 150         genesis.nNonce = 414098458;
 151         hashGenesisBlock = genesis.GetHash();
 152         assert(hashGenesisBlock == uint256("0x000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"));
 153
 154         vFixedSeeds.clear();
 155         vSeeds.clear();
 156         vSeeds.push_back(CDNSSeedData("alexykot.me", "testnet-seed.alexykot.me"));
 157         vSeeds.push_back(CDNSSeedData("bitcoin.petertodd.org", "testnet-seed.bitcoin.petertodd.org"));
 158         vSeeds.push_back(CDNSSeedData("bluematt.me", "testnet-seed.bluematt.me"));
 159
 160         base58Prefixes[PUBKEY_ADDRESS] = list_of(111);
 161         base58Prefixes[SCRIPT_ADDRESS] = list_of(196);
 162         base58Prefixes[SECRET_KEY]     = list_of(239);
 163         base58Prefixes[EXT_PUBLIC_KEY] = list_of(0x04)(0x35)(0x87)(0xCF);
 164         base58Prefixes[EXT_SECRET_KEY] = list_of(0x04)(0x35)(0x83)(0x94);
 165
 166         convertSeed6(vFixedSeeds, pnSeed6_test, ARRAYLEN(pnSeed6_test));
 167
 168         fRequireRPCPassword = true;
 169         fMiningRequiresPeers = true;
 170         fDefaultCheckMemPool = false;
 171         fAllowMinDifficultyBlocks = true;
 172         fRequireStandard = false;
 173         fMineBlocksOnDemand = false;
 174     }
 175 };
 176 static CTestNetParams testNetParams;
 177
 178 //
 179 // Regression test
 180 //
 181 class CRegTestParams : public CTestNetParams {
 182 public:
 183     CRegTestParams() {
 184         networkID = CBaseChainParams::REGTEST;
 185         strNetworkID = "regtest";
 186         pchMessageStart[0] = 0xfa;
 187         pchMessageStart[1] = 0xbf;
 188         pchMessageStart[2] = 0xb5;
 189         pchMessageStart[3] = 0xda;
 190         nSubsidyHalvingInterval = 150;
 191         nEnforceBlockUpgradeMajority = 750;
 192         nRejectBlockOutdatedMajority = 950;
 193         nToCheckBlockUpgradeMajority = 1000;
 194         nMinerThreads = 1;
 195         nTargetTimespan = 14 * 24 * 60 * 60; // two weeks
 196         nTargetSpacing = 10 * 60;
 197         bnProofOfWorkLimit = ~uint256(0) >> 1;
 198         genesis.nTime = 1296688602;
 199         genesis.nBits = 0x207fffff;
 200         genesis.nNonce = 2;
 201         hashGenesisBlock = genesis.GetHash();
 202         nDefaultPort = 18444;
 203         assert(hashGenesisBlock == uint256("0x0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"));
 204
 205         vSeeds.clear();  // Regtest mode doesn't have any DNS seeds.
 206
 207         fRequireRPCPassword = false;
 208         fMiningRequiresPeers = false;
 209         fDefaultCheckMemPool = true;
 210         fAllowMinDifficultyBlocks = true;
 211         fRequireStandard = false;
 212         fMineBlocksOnDemand = true;
 213     }
 214 };
 215 static CRegTestParams regTestParams;
 216
 217 static CChainParams *pCurrentParams = 0;
 218
 219 const CChainParams &Params() {
 220     assert(pCurrentParams);
 221     return *pCurrentParams;
 222 }
 223
 224 void SelectParams(CBaseChainParams::Network network) {
 225     SelectBaseParams(network);
 226     switch (network) {
 227         case CBaseChainParams::MAIN:
 228             pCurrentParams = &mainParams;
 229             break;
 230         case CBaseChainParams::TESTNET:
 231             pCurrentParams = &testNetParams;
 232             break;
 233         case CBaseChainParams::REGTEST:
 234             pCurrentParams = &regTestParams;
 235             break;
 236         default:
 237             assert(false && "Unimplemented network");
 238             return;
 239     }
 240 }
 241
 242 bool SelectParamsFromCommandLine() {
 243     if (!SelectBaseParamsFromCommandLine())
 244         return false;
 245
 246     SelectParams(BaseParams().NetworkID());
 247     return true;
 248 }