#include "checkpoints.h"
-#include "db.h"
+#include "txdb.h"
#include "main.h"
#include "uint256.h"
namespace Checkpoints
{
- struct Checkpoint
- {
- uint256 hashCheckPoint;
- unsigned int nTime;
- };
-
- typedef std::map<int, Checkpoint> MapCheckpoints;
-
- Checkpoint initCheckpoint(uint256 hashCheckPoint, unsigned int nTime)
- {
- return {hashCheckPoint, nTime};
- }
+ typedef std::map<int, std::pair<uint256, unsigned int> > MapCheckpoints;
//
// What makes a good checkpoint block?
//
static MapCheckpoints mapCheckpoints =
boost::assign::map_list_of
- ( 0, initCheckpoint(hashGenesisBlock, 1360105017) )
- ( 6000, initCheckpoint(uint256("0x000000000945e3c9d8e15df834e802521eb79f9ceb4191a27bdfadad4b777f4a"), 1360814368) )
- ( 9690, initCheckpoint(uint256("0x00000000026561450859c46868099e0df6068a538f038cb18988fd8d47dcdaf5"), 1362791423) )
- ( 13560, initCheckpoint(uint256("0xa1591a0fcbf11f282d671581edb9f0aadcd06fee69761081e0a3245914c13729"), 1364674052) )
- ( 14189, initCheckpoint(uint256("0x00000000020f76474d2522b19c7bfafc43ba6ecbabae54293bcd9546159c8c1d"), 1365215020) )
- ( 19600, initCheckpoint(uint256("0x252ae08d6df4bc7220c1dcdaed7b8a6e78bab05a60173511e8f565a3a38ce3c3"), 1367840555) )
- ( 21800, initCheckpoint(uint256("0x64bdeb35023f240ed01beaa082f840f2d4cc6defccbbcda1260de87e58296b37"), 1368888542) )
- ( 26174, initCheckpoint(uint256("0x00000000006cf1bfaa0d73caea92f6d2afa465651a76415b8d53b0bb0e01a8be"), 1371039324) )
- ( 27451, initCheckpoint(uint256("0xd65424c24041b9f2e531f8f275f1a3c8bb105f0b29005b0bd577ae1a73341080"), 1371687462) )
- ( 37092, initCheckpoint(uint256("0x0000000000a38c2f98556f46793b453e92d8fab2d31c0b93fd08bcf78e56099d"), 1376677203) )
- ;
+ ( 0, std::make_pair(hashGenesisBlock, 1360105017) )
+ ( 13560, std::make_pair(uint256("0xa1591a0fcbf11f282d671581edb9f0aadcd06fee69761081e0a3245914c13729"), 1364674052) )
+ ( 143990, std::make_pair(uint256("0x00000000001ff5c3940a9f73ad4a990f64955179bde0f743c76dbf0031429efc"), 1418953493) )
+ ( 149000, std::make_pair(uint256("0x7a24acfcadcf43054e7f7d9f273522c0dfc5791ba4006e0273e7521a8d36c525"), 1420872125) )
+ ( 160000, std::make_pair(uint256("0x000000000001cb1133043d38d077c0e93f66c8b2566779f10f182137d1e34a68"), 1425150237) )
+ ( 200000, std::make_pair(uint256("0x0000000000029f8bbf66e6ea6f3e5db55009404aae0fe395a53dd33142b2bff2"), 1441127233) )
+ ( 221047, std::make_pair(uint256("0xa28aef712e7aa0c285bfe29351ca21ed416689139e3063ef770fc826a8b9e9da"), 1449431646) )
+ ;
// TestNet has no checkpoints
static MapCheckpoints mapCheckpointsTestnet =
boost::assign::map_list_of
- ( 0, initCheckpoint(hashGenesisBlock, 1360105017) )
+ ( 0, std::make_pair(hashGenesisBlockTestNet, 1360105017) )
;
bool CheckHardened(int nHeight, const uint256& hash)
MapCheckpoints::const_iterator i = checkpoints.find(nHeight);
if (i == checkpoints.end()) return true;
- return hash == i->second.hashCheckPoint;
+ return hash == i->second.first;
}
int GetTotalBlocksEstimate()
return checkpoints.rbegin()->first;
}
- int GetLastCheckpointTime()
+ unsigned int GetLastCheckpointTime()
{
MapCheckpoints& checkpoints = (fTestNet ? mapCheckpointsTestnet : mapCheckpoints);
- return checkpoints.rbegin()->second.nTime;
+ return checkpoints.rbegin()->second.second;
}
CBlockIndex* GetLastCheckpoint(const std::map<uint256, CBlockIndex*>& mapBlockIndex)
BOOST_REVERSE_FOREACH(const MapCheckpoints::value_type& i, checkpoints)
{
- const uint256& hash = i.second.hashCheckPoint;
+ const uint256& hash = i.second.first;
std::map<uint256, CBlockIndex*>::const_iterator t = mapBlockIndex.find(hash);
if (t != mapBlockIndex.end())
return t->second;
CBlockIndex* pindex = pindexSyncCheckpoint;
while (pindex->nHeight > pindexCheckpointRecv->nHeight)
if (!(pindex = pindex->pprev))
- return error("ValidateSyncCheckpoint: pprev1 null - block index structure failure");
+ return error("ValidateSyncCheckpoint: pprev null - block index structure failure");
if (pindex->GetBlockHash() != hashCheckpoint)
{
hashInvalidCheckpoint = hashCheckpoint;
}
if (!txdb.TxnCommit())
return error("WriteSyncCheckpoint(): failed to commit to db sync checkpoint %s", hashCheckpoint.ToString().c_str());
+
+#ifndef USE_LEVELDB
txdb.Close();
+#endif
Checkpoints::hashSyncCheckpoint = hashCheckpoint;
return true;
return error("AcceptPendingSyncCheckpoint: SetBestChain failed for sync checkpoint %s", hashPendingCheckpoint.ToString().c_str());
}
}
- txdb.Close();
+#ifndef USE_LEVELDB
+ txdb.Close();
+#endif
if (!WriteSyncCheckpoint(hashPendingCheckpoint))
return error("AcceptPendingSyncCheckpoint(): failed to write sync checkpoint %s", hashPendingCheckpoint.ToString().c_str());
hashPendingCheckpoint = 0;
// Automatically select a suitable sync-checkpoint
uint256 AutoSelectSyncCheckpoint()
{
- // Proof-of-work blocks are immediately checkpointed
- // to defend against 51% attack which rejects other miners block
-
- // Select the last proof-of-work block
- const CBlockIndex *pindex = GetLastBlockIndex(pindexBest, false);
- // Search forward for a block within max span and maturity window
- while (pindex->pnext && (pindex->GetBlockTime() + CHECKPOINT_MAX_SPAN <= pindexBest->GetBlockTime() || pindex->nHeight + std::min(6, nCoinbaseMaturity - 20) <= pindexBest->nHeight))
- pindex = pindex->pnext;
+ const CBlockIndex *pindex = pindexBest;
+ // Search backward for a block within max span and maturity window
+ while (pindex->pprev && (pindex->GetBlockTime() + CHECKPOINT_MAX_SPAN > pindexBest->GetBlockTime() || pindex->nHeight + 8 > pindexBest->nHeight))
+ pindex = pindex->pprev;
return pindex->GetBlockHash();
}
bool ResetSyncCheckpoint()
{
LOCK(cs_hashSyncCheckpoint);
- const uint256& hash = mapCheckpoints.rbegin()->second.hashCheckPoint;
+ const uint256& hash = mapCheckpoints.rbegin()->second.first;
if (mapBlockIndex.count(hash) && !mapBlockIndex[hash]->IsInMainChain())
{
// checkpoint block accepted but not yet in main chain
{
return error("ResetSyncCheckpoint: SetBestChain failed for hardened checkpoint %s", hash.ToString().c_str());
}
+
+#ifndef USE_LEVELDB
txdb.Close();
+#endif
+
}
else if(!mapBlockIndex.count(hash))
{
BOOST_REVERSE_FOREACH(const MapCheckpoints::value_type& i, mapCheckpoints)
{
- const uint256& hash = i.second.hashCheckPoint;
+ const uint256& hash = i.second.first;
if (mapBlockIndex.count(hash) && mapBlockIndex[hash]->IsInMainChain())
{
if (!WriteSyncCheckpoint(hash))
return (nBestHeight >= pindexSync->nHeight + nCoinbaseMaturity ||
pindexSync->GetBlockTime() + nStakeMinAge < GetAdjustedTime());
}
-
- // Is the sync-checkpoint too old?
- bool IsSyncCheckpointTooOld(unsigned int nSeconds)
- {
- LOCK(cs_hashSyncCheckpoint);
- // sync-checkpoint should always be accepted block
- assert(mapBlockIndex.count(hashSyncCheckpoint));
- const CBlockIndex* pindexSync = mapBlockIndex[hashSyncCheckpoint];
- return (pindexSync->GetBlockTime() + nSeconds < GetAdjustedTime());
- }
}
// ppcoin: sync-checkpoint master key
return true;
}
-// ppcoin: process synchronized checkpoint
+// process synchronized checkpoint
bool CSyncCheckpoint::ProcessSyncCheckpoint(CNode* pfrom)
{
if (!CheckSignature())
return error("ProcessSyncCheckpoint: SetBestChain failed for sync checkpoint %s", hashCheckpoint.ToString().c_str());
}
}
+
+#ifndef USE_LEVELDB
txdb.Close();
+#endif
if (!Checkpoints::WriteSyncCheckpoint(hashCheckpoint))
return error("ProcessSyncCheckpoint(): failed to write sync checkpoint %s", hashCheckpoint.ToString().c_str());