bitcoin/src/chainparams.cpp at master · Dash-OS/bitcoin · GitHub

History

372 lines (317 loc) · 18.5 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

// Distributed under the MIT software license, see the accompanying

// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <chainparams.h>

#include <consensus/merkle.h>

#include <tinyformat.h>

#include <util.h>

#include <utilstrencodings.h>

#include <assert.h>

#include <chainparamsseeds.h>

static CBlock CreateGenesisBlock(const char* pszTimestamp, const CScript& genesisOutputScript, uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)

{

CMutableTransaction txNew;

txNew.nVersion = 1;

txNew.vin.resize(1);

txNew.vout.resize(1);

txNew.vin[0].scriptSig = CScript() << 486604799 << CScriptNum(4) << std::vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));

txNew.vout[0].nValue = genesisReward;

txNew.vout[0].scriptPubKey = genesisOutputScript;

CBlock genesis;

genesis.nTime = nTime;

genesis.nBits = nBits;

genesis.nNonce = nNonce;

genesis.nVersion = nVersion;

genesis.vtx.push_back(MakeTransactionRef(std::move(txNew)));

genesis.hashPrevBlock.SetNull();

genesis.hashMerkleRoot = BlockMerkleRoot(genesis);

return genesis;

}

/**

* Build the genesis block. Note that the output of its generation

* transaction cannot be spent since it did not originally exist in the

* database.

* CBlock(hash=000000000019d6, ver=1, hashPrevBlock=00000000000000, hashMerkleRoot=4a5e1e, nTime=1231006505, nBits=1d00ffff, nNonce=2083236893, vtx=1)

* CTransaction(hash=4a5e1e, ver=1, vin.size=1, vout.size=1, nLockTime=0)

* CTxIn(COutPoint(000000, -1), coinbase 04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73)

* CTxOut(nValue=50.00000000, scriptPubKey=0x5F1DF16B2B704C8A578D0B)

* vMerkleTree: 4a5e1e

static CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)

{

const char* pszTimestamp = "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks";

const CScript genesisOutputScript = CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") << OP_CHECKSIG;

return CreateGenesisBlock(pszTimestamp, genesisOutputScript, nTime, nNonce, nBits, nVersion, genesisReward);

}

void CChainParams::UpdateVersionBitsParameters(Consensus::DeploymentPos d, int64_t nStartTime, int64_t nTimeout)

{

consensus.vDeployments[d].nStartTime = nStartTime;

consensus.vDeployments[d].nTimeout = nTimeout;

}

/**

* Main network

/**

* What makes a good checkpoint block?

* + Is surrounded by blocks with reasonable timestamps

* (no blocks before with a timestamp after, none after with

* timestamp before)

* + Contains no strange transactions

class CMainParams : public CChainParams {

public:

CMainParams() {

strNetworkID = "main";

consensus.nSubsidyHalvingInterval = 210000;

consensus.BIP16Height = 173805; // 00000000000000ce80a7e057163a4db1d5ad7b20fb6f598c9597b9665c8fb0d4 - April 1, 2012

consensus.BIP34Height = 227931;

consensus.BIP34Hash = uint256S("0x000000000000024b89b42a942fe0d9fea3bb44ab7bd1b19115dd6a759c0808b8");

consensus.BIP65Height = 388381; // 000000000000000004c2b624ed5d7756c508d90fd0da2c7c679febfa6c4735f0

consensus.BIP66Height = 363725; // 00000000000000000379eaa19dce8c9b722d46ae6a57c2f1a988119488b50931

consensus.powLimit = uint256S("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");

consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks

consensus.nPowTargetSpacing = 10 * 60;

consensus.fPowAllowMinDifficultyBlocks = false;

consensus.fPowNoRetargeting = false;

consensus.nRuleChangeActivationThreshold = 1916; // 95% of 2016

consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing

consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;

consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = 1199145601; // January 1, 2008

consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = 1230767999; // December 31, 2008

// Deployment of BIP68, BIP112, and BIP113.

consensus.vDeployments[Consensus::DEPLOYMENT_CSV].bit = 0;

consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nStartTime = 1462060800; // May 1st, 2016

consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nTimeout = 1493596800; // May 1st, 2017

// Deployment of SegWit (BIP141, BIP143, and BIP147)

consensus.vDeployments[Consensus::DEPLOYMENT_SEGWIT].bit = 1;

consensus.vDeployments[Consensus::DEPLOYMENT_SEGWIT].nStartTime = 1479168000; // November 15th, 2016.

consensus.vDeployments[Consensus::DEPLOYMENT_SEGWIT].nTimeout = 1510704000; // November 15th, 2017.

// The best chain should have at least this much work.

consensus.nMinimumChainWork = uint256S("0x000000000000000000000000000000000000000000723d3581fe1bd55373540a");

// By default assume that the signatures in ancestors of this block are valid.

consensus.defaultAssumeValid = uint256S("0x0000000000000000003b9ce759c2a087d52abc4266f8f4ebd6d768b89defa50a"); //477890

/**

* The message start string is designed to be unlikely to occur in normal data.

* The characters are rarely used upper ASCII, not valid as UTF-8, and produce

* a large 32-bit integer with any alignment.

pchMessageStart[0] = 0xf9;

pchMessageStart[1] = 0xbe;

pchMessageStart[2] = 0xb4;

pchMessageStart[3] = 0xd9;

nDefaultPort = 8333;

nPruneAfterHeight = 100000;

genesis = CreateGenesisBlock(1231006505, 2083236893, 0x1d00ffff, 1, 50 * COIN);

consensus.hashGenesisBlock = genesis.GetHash();

assert(consensus.hashGenesisBlock == uint256S("0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"));

assert(genesis.hashMerkleRoot == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));

// Note that of those with the service bits flag, most only support a subset of possible options

vSeeds.emplace_back("seed.bitcoin.sipa.be", true); // Pieter Wuille, only supports x1, x5, x9, and xd

vSeeds.emplace_back("dnsseed.bluematt.me", true); // Matt Corallo, only supports x9

vSeeds.emplace_back("dnsseed.bitcoin.dashjr.org", false); // Luke Dashjr

vSeeds.emplace_back("seed.bitcoinstats.com", true); // Christian Decker, supports x1 - xf

vSeeds.emplace_back("seed.bitcoin.jonasschnelli.ch", true); // Jonas Schnelli, only supports x1, x5, x9, and xd

vSeeds.emplace_back("seed.btc.petertodd.org", true); // Peter Todd, only supports x1, x5, x9, and xd

base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,0);

base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,5);

base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,128);

base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x88, 0xB2, 0x1E};

base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4};

bech32_hrp = "bc";

vFixedSeeds = std::vector<SeedSpec6>(pnSeed6_main, pnSeed6_main + ARRAYLEN(pnSeed6_main));

fDefaultConsistencyChecks = false;

fRequireStandard = true;

fMineBlocksOnDemand = false;

checkpointData = {

{

{ 11111, uint256S("0x0000000069e244f73d78e8fd29ba2fd2ed618bd6fa2ee92559f542fdb26e7c1d")},

{ 33333, uint256S("0x000000002dd5588a74784eaa7ab0507a18ad16a236e7b1ce69f00d7ddfb5d0a6")},

{ 74000, uint256S("0x0000000000573993a3c9e41ce34471c079dcf5f52a0e824a81e7f953b8661a20")},

{105000, uint256S("0x00000000000291ce28027faea320c8d2b054b2e0fe44a773f3eefb151d6bdc97")},

{134444, uint256S("0x00000000000005b12ffd4cd315cd34ffd4a594f430ac814c91184a0d42d2b0fe")},

{168000, uint256S("0x000000000000099e61ea72015e79632f216fe6cb33d7899acb35b75c8303b763")},

{193000, uint256S("0x000000000000059f452a5f7340de6682a977387c17010ff6e6c3bd83ca8b1317")},

{210000, uint256S("0x000000000000048b95347e83192f69cf0366076336c639f9b7228e9ba171342e")},

{216116, uint256S("0x00000000000001b4f4b433e81ee46494af945cf96014816a4e2370f11b23df4e")},

{225430, uint256S("0x00000000000001c108384350f74090433e7fcf79a606b8e797f065b130575932")},

{250000, uint256S("0x000000000000003887df1f29024b06fc2200b55f8af8f35453d7be294df2d214")},

{279000, uint256S("0x0000000000000001ae8c72a0b0c301f67e3afca10e819efa9041e458e9bd7e40")},

{295000, uint256S("0x00000000000000004d9b4ef50f0f9d686fd69db2e03af35a100370c64632a983")},

}

};

chainTxData = ChainTxData{

// Data as of block 000000000000000000d97e53664d17967bd4ee50b23abb92e54a34eb222d15ae (height 478913).

1501801925, // * UNIX timestamp of last known number of transactions

243756039, // * total number of transactions between genesis and that timestamp

// (the tx=... number in the SetBestChain debug.log lines)

3.1 // * estimated number of transactions per second after that timestamp

};

}

};

/**

* Testnet (v3)

class CTestNetParams : public CChainParams {

public:

CTestNetParams() {

strNetworkID = "test";

consensus.nSubsidyHalvingInterval = 210000;

consensus.BIP16Height = 514; // 00000000040b4e986385315e14bee30ad876d8b47f748025b26683116d21aa65

consensus.BIP34Height = 21111;

consensus.BIP34Hash = uint256S("0x0000000023b3a96d3484e5abb3755c413e7d41500f8e2a5c3f0dd01299cd8ef8");

consensus.BIP65Height = 581885; // 00000000007f6655f22f98e72ed80d8b06dc761d5da09df0fa1dc4be4f861eb6

consensus.BIP66Height = 330776; // 000000002104c8c45e99a8853285a3b592602a3ccde2b832481da85e9e4ba182

consensus.powLimit = uint256S("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");

consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks

consensus.nPowTargetSpacing = 10 * 60;

consensus.fPowAllowMinDifficultyBlocks = true;

consensus.fPowNoRetargeting = false;

consensus.nRuleChangeActivationThreshold = 1512; // 75% for testchains

consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing

consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;

consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = 1199145601; // January 1, 2008

consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = 1230767999; // December 31, 2008

// Deployment of BIP68, BIP112, and BIP113.

consensus.vDeployments[Consensus::DEPLOYMENT_CSV].bit = 0;

consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nStartTime = 1456790400; // March 1st, 2016

consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nTimeout = 1493596800; // May 1st, 2017

// Deployment of SegWit (BIP141, BIP143, and BIP147)

consensus.vDeployments[Consensus::DEPLOYMENT_SEGWIT].bit = 1;

consensus.vDeployments[Consensus::DEPLOYMENT_SEGWIT].nStartTime = 1462060800; // May 1st 2016

consensus.vDeployments[Consensus::DEPLOYMENT_SEGWIT].nTimeout = 1493596800; // May 1st 2017

// The best chain should have at least this much work.

consensus.nMinimumChainWork = uint256S("0x00000000000000000000000000000000000000000000002830dab7f76dbb7d63");

// By default assume that the signatures in ancestors of this block are valid.

consensus.defaultAssumeValid = uint256S("0x0000000002e9e7b00e1f6dc5123a04aad68dd0f0968d8c7aa45f6640795c37b1"); //1135275

pchMessageStart[0] = 0x0b;

pchMessageStart[1] = 0x11;

pchMessageStart[2] = 0x09;

pchMessageStart[3] = 0x07;

nDefaultPort = 18333;

nPruneAfterHeight = 1000;

genesis = CreateGenesisBlock(1296688602, 414098458, 0x1d00ffff, 1, 50 * COIN);

consensus.hashGenesisBlock = genesis.GetHash();

assert(consensus.hashGenesisBlock == uint256S("0x000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"));

assert(genesis.hashMerkleRoot == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));

vFixedSeeds.clear();

vSeeds.clear();

// nodes with support for servicebits filtering should be at the top

vSeeds.emplace_back("testnet-seed.bitcoin.jonasschnelli.ch", true);

vSeeds.emplace_back("seed.tbtc.petertodd.org", true);

vSeeds.emplace_back("seed.testnet.bitcoin.sprovoost.nl", true);

vSeeds.emplace_back("testnet-seed.bluematt.me", false);

base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);

base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);

base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,239);

base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};

base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};

bech32_hrp = "tb";

vFixedSeeds = std::vector<SeedSpec6>(pnSeed6_test, pnSeed6_test + ARRAYLEN(pnSeed6_test));

fDefaultConsistencyChecks = false;

fRequireStandard = false;

fMineBlocksOnDemand = false;

checkpointData = {

{

{546, uint256S("000000002a936ca763904c3c35fce2f3556c559c0214345d31b1bcebf76acb70")},

}

};

chainTxData = ChainTxData{

// Data as of block 00000000000001c200b9790dc637d3bb141fe77d155b966ed775b17e109f7c6c (height 1156179)

1501802953,

14706531,

0.15

};

}

};

/**

* Regression test

class CRegTestParams : public CChainParams {

public:

CRegTestParams() {

strNetworkID = "regtest";

consensus.nSubsidyHalvingInterval = 150;

consensus.BIP16Height = 0; // always enforce P2SH BIP16 on regtest

consensus.BIP34Height = 100000000; // BIP34 has not activated on regtest (far in the future so block v1 are not rejected in tests)

consensus.BIP34Hash = uint256();

consensus.BIP65Height = 1351; // BIP65 activated on regtest (Used in rpc activation tests)

consensus.BIP66Height = 1251; // BIP66 activated on regtest (Used in rpc activation tests)

consensus.powLimit = uint256S("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");

consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks

consensus.nPowTargetSpacing = 10 * 60;

consensus.fPowAllowMinDifficultyBlocks = true;

consensus.fPowNoRetargeting = true;

consensus.nRuleChangeActivationThreshold = 108; // 75% for testchains

consensus.nMinerConfirmationWindow = 144; // Faster than normal for regtest (144 instead of 2016)

consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;

consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = 0;

consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;

consensus.vDeployments[Consensus::DEPLOYMENT_CSV].bit = 0;

consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nStartTime = 0;

consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;

consensus.vDeployments[Consensus::DEPLOYMENT_SEGWIT].bit = 1;

consensus.vDeployments[Consensus::DEPLOYMENT_SEGWIT].nStartTime = Consensus::BIP9Deployment::ALWAYS_ACTIVE;

consensus.vDeployments[Consensus::DEPLOYMENT_SEGWIT].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;

// The best chain should have at least this much work.

consensus.nMinimumChainWork = uint256S("0x00");

// By default assume that the signatures in ancestors of this block are valid.

consensus.defaultAssumeValid = uint256S("0x00");

pchMessageStart[0] = 0xfa;

pchMessageStart[1] = 0xbf;

pchMessageStart[2] = 0xb5;

pchMessageStart[3] = 0xda;

nDefaultPort = 18444;

nPruneAfterHeight = 1000;

genesis = CreateGenesisBlock(1296688602, 2, 0x207fffff, 1, 50 * COIN);

consensus.hashGenesisBlock = genesis.GetHash();

assert(consensus.hashGenesisBlock == uint256S("0x0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"));

assert(genesis.hashMerkleRoot == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));

vFixedSeeds.clear(); //!< Regtest mode doesn't have any fixed seeds.

vSeeds.clear(); //!< Regtest mode doesn't have any DNS seeds.

fDefaultConsistencyChecks = true;

fRequireStandard = false;

fMineBlocksOnDemand = true;

checkpointData = {

{

{0, uint256S("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206")},

}

};

chainTxData = ChainTxData{

};

base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);

base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);

base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,239);

base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};

base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};

bech32_hrp = "bcrt";

}

};

static std::unique_ptr<CChainParams> globalChainParams;

const CChainParams &Params() {

assert(globalChainParams);

return *globalChainParams;

}

std::unique_ptr<CChainParams> CreateChainParams(const std::string& chain)

{

if (chain == CBaseChainParams::MAIN)

return std::unique_ptr<CChainParams>(new CMainParams());

else if (chain == CBaseChainParams::TESTNET)

return std::unique_ptr<CChainParams>(new CTestNetParams());

else if (chain == CBaseChainParams::REGTEST)

return std::unique_ptr<CChainParams>(new CRegTestParams());

throw std::runtime_error(strprintf("%s: Unknown chain %s.", __func__, chain));

}

void SelectParams(const std::string& network)

{

SelectBaseParams(network);

globalChainParams = CreateChainParams(network);

}

void UpdateVersionBitsParameters(Consensus::DeploymentPos d, int64_t nStartTime, int64_t nTimeout)

{

globalChainParams->UpdateVersionBitsParameters(d, nStartTime, nTimeout);

}

bitcoin/src/chainparams.cpp at master · Dash-OS/bitcoin · GitHub

Uh oh!

Expand file tree

Breadcrumbs

chainparams.cpp

Latest commit

History

Breadcrumbs

chainparams.cpp

File metadata and controls