146 lines
5.3 KiB
C++
146 lines
5.3 KiB
C++
// Copyright (c) 2009-2012 The Bitcoin developers
|
|
// Copyright (c) 2013 Primecoin developers
|
|
// Distributed under conditional MIT/X11 software license,
|
|
// see the accompanying file COPYING
|
|
|
|
#include <boost/assign/list_of.hpp> // for 'map_list_of()'
|
|
#include <boost/foreach.hpp>
|
|
|
|
#include "checkpoints.h"
|
|
|
|
#include "main.h"
|
|
#include "uint256.h"
|
|
|
|
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 fSigcheckVerificationFactor = 5.0;
|
|
|
|
struct CCheckpointData {
|
|
const MapCheckpoints *mapCheckpoints;
|
|
int64 nTimeLastCheckpoint;
|
|
int64 nTransactionsLastCheckpoint;
|
|
double fTransactionsPerDay;
|
|
};
|
|
|
|
// 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
|
|
( 0, hashGenesisBlockOfficial )
|
|
( 74722, uint256("0x74778cd8a5f2fbacca95dc4de02771e24e365c3f28412189f349355096826afe"))
|
|
( 84106, uint256("0xbb081d595e948203a67a7501c30d6a8c413db97deb1234185c4929f66be945ef"))
|
|
( 85429, uint256("0xa2bd26fbebcfa02f4e291806f0214e17c2dfb250c3443bbb1778c0cd532776f4"))
|
|
;
|
|
static const CCheckpointData data = {
|
|
&mapCheckpoints,
|
|
1374921070, // * UNIX timestamp of last checkpoint block
|
|
14264869, // * total number of transactions between genesis and last checkpoint
|
|
// (the tx=... number in the SetBestChain debug.log lines)
|
|
60000.0 // * estimated number of transactions per day after checkpoint
|
|
};
|
|
|
|
static MapCheckpoints mapCheckpointsTestnet =
|
|
boost::assign::map_list_of
|
|
( 0, hashGenesisBlockTestNet )
|
|
;
|
|
static const CCheckpointData dataTestnet = {
|
|
&mapCheckpointsTestnet,
|
|
1338180505,
|
|
16341,
|
|
300
|
|
};
|
|
|
|
const CCheckpointData &Checkpoints() {
|
|
if (fTestNet)
|
|
return dataTestnet;
|
|
else
|
|
return data;
|
|
}
|
|
|
|
bool CheckBlock(int nHeight, const uint256& hash)
|
|
{
|
|
if (!GetBoolArg("-checkpoints", true))
|
|
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) {
|
|
if (pindex==NULL)
|
|
return 0.0;
|
|
|
|
int64 nNow = time(NULL);
|
|
|
|
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 checkoint, 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 (!GetBoolArg("-checkpoints", true))
|
|
return 0;
|
|
|
|
const MapCheckpoints& checkpoints = *Checkpoints().mapCheckpoints;
|
|
|
|
return checkpoints.rbegin()->first;
|
|
}
|
|
|
|
CBlockIndex* GetLastCheckpoint(const std::map<uint256, CBlockIndex*>& mapBlockIndex)
|
|
{
|
|
if (!GetBoolArg("-checkpoints", true))
|
|
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;
|
|
}
|
|
|
|
uint256 GetLatestHardenedCheckpoint()
|
|
{
|
|
const MapCheckpoints& checkpoints = *Checkpoints().mapCheckpoints;
|
|
return (checkpoints.rbegin()->second);
|
|
}
|
|
}
|