2014-12-16 17:47:57 -08:00
|
|
|
// Copyright (c) 2009-2014 The Bitcoin Core developers
|
2014-10-30 17:43:19 -07:00
|
|
|
// Distributed under the MIT software license, see the accompanying
|
2019-07-18 07:16:09 -07:00
|
|
|
// file COPYING or https://www.opensource.org/licenses/mit-license.php .
|
2011-09-08 13:50:58 -07:00
|
|
|
|
2011-09-08 09:51:43 -07:00
|
|
|
#include "checkpoints.h"
|
2011-09-08 13:50:58 -07:00
|
|
|
|
2014-08-31 12:32:23 -07:00
|
|
|
#include "chainparams.h"
|
2012-04-15 13:10:54 -07:00
|
|
|
#include "main.h"
|
|
|
|
#include "uint256.h"
|
|
|
|
|
2013-04-12 22:13:08 -07:00
|
|
|
#include <stdint.h>
|
|
|
|
|
|
|
|
#include <boost/foreach.hpp>
|
|
|
|
|
2014-06-24 05:17:43 -07:00
|
|
|
namespace Checkpoints {
|
|
|
|
|
2014-10-30 17:43:19 -07:00
|
|
|
/**
|
2015-04-28 07:47:17 -07:00
|
|
|
* How many times slower we expect checking transactions after the last
|
|
|
|
* checkpoint to be (from checking signatures, which is skipped up to the
|
|
|
|
* last checkpoint). 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
|
2014-10-30 17:43:19 -07:00
|
|
|
* 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.
|
|
|
|
*/
|
2014-03-18 16:26:14 -07:00
|
|
|
static const double SIGCHECK_VERIFICATION_FACTOR = 5.0;
|
2013-02-10 10:46:42 -08:00
|
|
|
|
2014-10-30 17:43:19 -07:00
|
|
|
//! Guess how far we are in the verification process at the given block index
|
2015-04-22 15:19:11 -07:00
|
|
|
double GuessVerificationProgress(const CCheckpointData& data, CBlockIndex *pindex, bool fSigchecks) {
|
2013-02-10 10:46:42 -08:00
|
|
|
if (pindex==NULL)
|
|
|
|
return 0.0;
|
|
|
|
|
2013-04-12 22:13:08 -07:00
|
|
|
int64_t nNow = time(NULL);
|
2013-02-10 10:46:42 -08:00
|
|
|
|
2014-03-18 16:26:14 -07:00
|
|
|
double fSigcheckVerificationFactor = fSigchecks ? SIGCHECK_VERIFICATION_FACTOR : 1.0;
|
2013-02-10 10:46:42 -08:00
|
|
|
double fWorkBefore = 0.0; // Amount of work done before pindex
|
|
|
|
double fWorkAfter = 0.0; // Amount of work left after pindex (estimated)
|
2014-01-17 04:20:43 -08:00
|
|
|
// Work is defined as: 1.0 per transaction before the last checkpoint, and
|
2013-02-10 10:46:42 -08:00
|
|
|
// fSigcheckVerificationFactor per transaction after.
|
|
|
|
|
|
|
|
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;
|
2014-06-28 14:36:06 -07:00
|
|
|
double nExpensiveAfter = (nNow - pindex->GetBlockTime())/86400.0*data.fTransactionsPerDay;
|
2013-02-10 10:46:42 -08:00
|
|
|
fWorkBefore = nCheapBefore + nExpensiveBefore*fSigcheckVerificationFactor;
|
|
|
|
fWorkAfter = nExpensiveAfter*fSigcheckVerificationFactor;
|
|
|
|
}
|
|
|
|
|
2019-10-24 11:51:00 -07:00
|
|
|
return std::min(fWorkBefore / (fWorkBefore + fWorkAfter), 1.0);
|
2013-02-10 10:46:42 -08:00
|
|
|
}
|
|
|
|
|
2015-04-22 15:19:11 -07:00
|
|
|
int GetTotalBlocksEstimate(const CCheckpointData& data)
|
2011-09-08 13:50:58 -07:00
|
|
|
{
|
2015-04-22 15:19:11 -07:00
|
|
|
const MapCheckpoints& checkpoints = data.mapCheckpoints;
|
2012-11-28 09:07:42 -08:00
|
|
|
|
2015-04-22 20:22:36 -07:00
|
|
|
if (checkpoints.empty())
|
|
|
|
return 0;
|
2011-09-08 13:50:58 -07:00
|
|
|
|
2012-04-13 11:53:31 -07:00
|
|
|
return checkpoints.rbegin()->first;
|
2011-09-08 13:50:58 -07:00
|
|
|
}
|
2011-09-08 09:51:43 -07:00
|
|
|
|
2015-04-22 15:19:11 -07:00
|
|
|
CBlockIndex* GetLastCheckpoint(const CCheckpointData& data)
|
2011-09-08 09:51:43 -07:00
|
|
|
{
|
2015-04-22 15:19:11 -07:00
|
|
|
const MapCheckpoints& checkpoints = data.mapCheckpoints;
|
2011-09-08 09:51:43 -07:00
|
|
|
|
2012-04-13 11:53:31 -07:00
|
|
|
BOOST_REVERSE_FOREACH(const MapCheckpoints::value_type& i, checkpoints)
|
2011-09-08 09:51:43 -07:00
|
|
|
{
|
|
|
|
const uint256& hash = i.second;
|
2014-09-03 17:02:44 -07:00
|
|
|
BlockMap::const_iterator t = mapBlockIndex.find(hash);
|
2011-09-08 09:51:43 -07:00
|
|
|
if (t != mapBlockIndex.end())
|
|
|
|
return t->second;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
2014-06-24 05:17:43 -07:00
|
|
|
|
2020-10-06 16:23:20 -07:00
|
|
|
bool IsAncestorOfLastCheckpoint(const CCheckpointData& data, const CBlockIndex* pindex)
|
|
|
|
{
|
|
|
|
CBlockIndex *pindexLastCheckpoint = GetLastCheckpoint(data);
|
|
|
|
return pindexLastCheckpoint && pindexLastCheckpoint->GetAncestor(pindex->nHeight) == pindex;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-06-24 05:17:43 -07:00
|
|
|
} // namespace Checkpoints
|