mirror of
https://github.com/dashpay/dash.git
synced 2024-12-30 14:25:53 +01:00
171 lines
7.0 KiB
C++
171 lines
7.0 KiB
C++
// Copyright (c) 2009-2014 The Bitcoin developers
|
|
// Copyright (c) 2014-2015 The Darkcoin developers
|
|
// Distributed under the MIT/X11 software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#include "checkpoints.h"
|
|
|
|
#include "main.h"
|
|
#include "uint256.h"
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <boost/assign/list_of.hpp> // for 'map_list_of()'
|
|
#include <boost/foreach.hpp>
|
|
|
|
namespace Checkpoints
|
|
{
|
|
typedef std::map<int, uint256> MapCheckpoints;
|
|
|
|
// How many times we expect transactions after the last checkpoint to
|
|
// be slower. This number is a compromise, as it can't be accurate for
|
|
// every system. When reindexing from a fast disk with a slow CPU, it
|
|
// can be up to 20, while when downloading from a slow network with a
|
|
// fast multicore CPU, it won't be much higher than 1.
|
|
static const double SIGCHECK_VERIFICATION_FACTOR = 5.0;
|
|
|
|
struct CCheckpointData {
|
|
const MapCheckpoints *mapCheckpoints;
|
|
int64_t nTimeLastCheckpoint;
|
|
int64_t nTransactionsLastCheckpoint;
|
|
double fTransactionsPerDay;
|
|
};
|
|
|
|
bool fEnabled = true;
|
|
|
|
// 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
|
|
static MapCheckpoints mapCheckpoints =
|
|
boost::assign::map_list_of
|
|
( 1500, uint256("0x000000aaf0300f59f49bc3e970bad15c11f961fe2347accffff19d96ec9778e3"))
|
|
( 4991, uint256("0x000000003b01809551952460744d5dbb8fcbd6cbae3c220267bf7fa43f837367"))
|
|
( 9918, uint256("0x00000000213e229f332c0ffbe34defdaa9e74de87f2d8d1f01af8d121c3c170b"))
|
|
( 16912, uint256("0x00000000075c0d10371d55a60634da70f197548dbbfa4123e12abfcbc5738af9"))
|
|
( 23912, uint256("0x0000000000335eac6703f3b1732ec8b2f89c3ba3a7889e5767b090556bb9a276"))
|
|
( 35457, uint256("0x0000000000b0ae211be59b048df14820475ad0dd53b9ff83b010f71a77342d9f"))
|
|
( 45479, uint256("0x000000000063d411655d590590e16960f15ceea4257122ac430c6fbe39fbf02d"))
|
|
( 55895, uint256("0x0000000000ae4c53a43639a4ca027282f69da9c67ba951768a20415b6439a2d7"))
|
|
( 68899, uint256("0x0000000000194ab4d3d9eeb1f2f792f21bb39ff767cb547fe977640f969d77b7"))
|
|
( 74619, uint256("0x000000000011d28f38f05d01650a502cc3f4d0e793fbc26e2a2ca71f07dc3842"))
|
|
( 75095, uint256("0x0000000000193d12f6ad352a9996ee58ef8bdc4946818a5fec5ce99c11b87f0d"))
|
|
( 88805, uint256("0x00000000001392f1652e9bf45cd8bc79dc60fe935277cd11538565b4a94fa85f"))
|
|
( 107996, uint256("0x00000000000a23840ac16115407488267aa3da2b9bc843e301185b7d17e4dc40"))
|
|
( 137993, uint256("0x00000000000cf69ce152b1bffdeddc59188d7a80879210d6e5c9503011929c3c"))
|
|
( 167996, uint256("0x000000000009486020a80f7f2cc065342b0c2fb59af5e090cd813dba68ab0fed"))
|
|
( 207992, uint256("0x00000000000d85c22be098f74576ef00b7aa00c05777e966aff68a270f1e01a5"))
|
|
( 217752, uint256("0x00000000000a7baeb2148272a7e14edf5af99a64af456c0afc23d15a0918b704"))
|
|
;
|
|
static const CCheckpointData data = {
|
|
&mapCheckpoints,
|
|
1403283082, // * UNIX timestamp of last checkpoint block
|
|
511516, // * total number of transactions between genesis and last checkpoint
|
|
// (the tx=... number in the SetBestChain debug.log lines)
|
|
7701 // * estimated number of transactions per day after checkpoint
|
|
};
|
|
|
|
static MapCheckpoints mapCheckpointsTestnet =
|
|
boost::assign::map_list_of
|
|
( 261, uint256("00000c26026d0815a7e2ce4fa270775f61403c040647ff2c3091f99e894a4618"))
|
|
;
|
|
static const CCheckpointData dataTestnet = {
|
|
&mapCheckpointsTestnet,
|
|
1405699509,
|
|
201,
|
|
500
|
|
};
|
|
|
|
static MapCheckpoints mapCheckpointsRegtest =
|
|
boost::assign::map_list_of
|
|
( 0, uint256("0x000008ca1832a4baf228eb1553c03d3a2c8e02399550dd6ea8d65cec3ef23d2e"))
|
|
;
|
|
static const CCheckpointData dataRegtest = {
|
|
&mapCheckpointsRegtest,
|
|
0,
|
|
0,
|
|
0
|
|
};
|
|
|
|
const CCheckpointData &Checkpoints() {
|
|
if (Params().NetworkID() == CChainParams::TESTNET)
|
|
return dataTestnet;
|
|
else if (Params().NetworkID() == CChainParams::MAIN)
|
|
return data;
|
|
else
|
|
return dataRegtest;
|
|
}
|
|
|
|
bool CheckBlock(int nHeight, const uint256& hash)
|
|
{
|
|
if (!fEnabled)
|
|
return true;
|
|
|
|
const MapCheckpoints& checkpoints = *Checkpoints().mapCheckpoints;
|
|
|
|
MapCheckpoints::const_iterator i = checkpoints.find(nHeight);
|
|
if (i == checkpoints.end()) return true;
|
|
return hash == i->second;
|
|
}
|
|
|
|
// Guess how far we are in the verification process at the given block index
|
|
double GuessVerificationProgress(CBlockIndex *pindex, bool fSigchecks) {
|
|
if (pindex==NULL)
|
|
return 0.0;
|
|
|
|
int64_t nNow = time(NULL);
|
|
|
|
double fSigcheckVerificationFactor = fSigchecks ? SIGCHECK_VERIFICATION_FACTOR : 1.0;
|
|
double fWorkBefore = 0.0; // Amount of work done before pindex
|
|
double fWorkAfter = 0.0; // Amount of work left after pindex (estimated)
|
|
// Work is defined as: 1.0 per transaction before the last checkpoint, and
|
|
// fSigcheckVerificationFactor per transaction after.
|
|
|
|
const CCheckpointData &data = Checkpoints();
|
|
|
|
if (pindex->nChainTx <= data.nTransactionsLastCheckpoint) {
|
|
double nCheapBefore = pindex->nChainTx;
|
|
double nCheapAfter = data.nTransactionsLastCheckpoint - pindex->nChainTx;
|
|
double nExpensiveAfter = (nNow - data.nTimeLastCheckpoint)/86400.0*data.fTransactionsPerDay;
|
|
fWorkBefore = nCheapBefore;
|
|
fWorkAfter = nCheapAfter + nExpensiveAfter*fSigcheckVerificationFactor;
|
|
} else {
|
|
double nCheapBefore = data.nTransactionsLastCheckpoint;
|
|
double nExpensiveBefore = pindex->nChainTx - data.nTransactionsLastCheckpoint;
|
|
double nExpensiveAfter = (nNow - pindex->nTime)/86400.0*data.fTransactionsPerDay;
|
|
fWorkBefore = nCheapBefore + nExpensiveBefore*fSigcheckVerificationFactor;
|
|
fWorkAfter = nExpensiveAfter*fSigcheckVerificationFactor;
|
|
}
|
|
|
|
return fWorkBefore / (fWorkBefore + fWorkAfter);
|
|
}
|
|
|
|
int GetTotalBlocksEstimate()
|
|
{
|
|
if (!fEnabled)
|
|
return 0;
|
|
|
|
const MapCheckpoints& checkpoints = *Checkpoints().mapCheckpoints;
|
|
|
|
return checkpoints.rbegin()->first;
|
|
}
|
|
|
|
CBlockIndex* GetLastCheckpoint(const std::map<uint256, CBlockIndex*>& mapBlockIndex)
|
|
{
|
|
if (!fEnabled)
|
|
return NULL;
|
|
|
|
const MapCheckpoints& checkpoints = *Checkpoints().mapCheckpoints;
|
|
|
|
BOOST_REVERSE_FOREACH(const MapCheckpoints::value_type& i, checkpoints)
|
|
{
|
|
const uint256& hash = i.second;
|
|
std::map<uint256, CBlockIndex*>::const_iterator t = mapBlockIndex.find(hash);
|
|
if (t != mapBlockIndex.end())
|
|
return t->second;
|
|
}
|
|
return NULL;
|
|
}
|
|
}
|