// Copyright (c) 2009-2012 The Bitcoin developers
-// Copyright (c) 2011-2013 The PPCoin developers
-// Copyright (c) 2013 NovaCoin 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 "db.h"
+#include "txdb.h"
#include "main.h"
#include "uint256.h"
namespace Checkpoints
{
- typedef std::map<int, uint256> MapCheckpoints; // hardened checkpoints
+ 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, hashGenesisBlockOfficial )
- ( 6000, uint256("0x000000000945e3c9d8e15df834e802521eb79f9ceb4191a27bdfadad4b777f4a"))
+ ( 0, std::make_pair(hashGenesisBlock, 1360105017) )
+ ( 9690, std::make_pair(uint256("0x00000000026561450859c46868099e0df6068a538f038cb18988fd8d47dcdaf5"), 1362791423) )
+ ( 13560, std::make_pair(uint256("0xa1591a0fcbf11f282d671581edb9f0aadcd06fee69761081e0a3245914c13729"), 1364674052) )
+ ( 37092, std::make_pair(uint256("0x0000000000a38c2f98556f46793b453e92d8fab2d31c0b93fd08bcf78e56099d"), 1376677203) )
+ ( 44200, std::make_pair(uint256("0xc9bda7232a18b9c1f5ff974a9e5566b2d1879ceb8fc0e9e61fba9038a25b8447"), 1380145962) )
+ ( 65000, std::make_pair(uint256("0xfb2b51a2fd65062c98a7a6053cde46aeaefebb95ba2f680e85a29ee25b1dcf05"), 1388526385) )
+ ( 68600, std::make_pair(uint256("0xb646b0562080ab9411f85d4b2a1ca8b197c67ae170c5e328406871b44233cb06"), 1389867276) )
+ ( 92161, std::make_pair(uint256("0x000000000079090eb31e7fa55487e4e666466253e68b213f44b7977ea7a2eeec"), 1398919969) )
+ ( 98661, std::make_pair(uint256("0x48328dfc0eaffc659723739c6202854d1624449340193bdea3e71ece4ccdd43f"), 1401469019) )
+ ;
+
+ // TestNet has no checkpoints
+ static MapCheckpoints mapCheckpointsTestnet =
+ boost::assign::map_list_of
+ ( 0, std::make_pair(hashGenesisBlockTestNet, 1360105017) )
;
bool CheckHardened(int nHeight, const uint256& hash)
{
- if (fTestNet) return true; // Testnet has no checkpoints
+ MapCheckpoints& checkpoints = (fTestNet ? mapCheckpointsTestnet : mapCheckpoints);
- MapCheckpoints::const_iterator i = mapCheckpoints.find(nHeight);
- if (i == mapCheckpoints.end()) return true;
- return hash == i->second;
+ MapCheckpoints::const_iterator i = checkpoints.find(nHeight);
+ if (i == checkpoints.end()) return true;
+ return hash == i->second.first;
}
int GetTotalBlocksEstimate()
{
- if (fTestNet) return 0;
+ MapCheckpoints& checkpoints = (fTestNet ? mapCheckpointsTestnet : mapCheckpoints);
+
+ return checkpoints.rbegin()->first;
+ }
+
+ int GetLastCheckpointTime()
+ {
+ MapCheckpoints& checkpoints = (fTestNet ? mapCheckpointsTestnet : mapCheckpoints);
- return mapCheckpoints.rbegin()->first;
+ return checkpoints.rbegin()->second.second;
}
CBlockIndex* GetLastCheckpoint(const std::map<uint256, CBlockIndex*>& mapBlockIndex)
{
- if (fTestNet) {
- std::map<uint256, CBlockIndex*>::const_iterator t = mapBlockIndex.find(hashGenesisBlock);
- if (t != mapBlockIndex.end())
- return t->second;
- return NULL;
- }
+ MapCheckpoints& checkpoints = (fTestNet ? mapCheckpointsTestnet : mapCheckpoints);
- BOOST_REVERSE_FOREACH(const MapCheckpoints::value_type& i, mapCheckpoints)
+ BOOST_REVERSE_FOREACH(const MapCheckpoints::value_type& i, checkpoints)
{
- const uint256& hash = i.second;
+ 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;
+ 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;
+ const uint256& hash = i.second.first;
if (mapBlockIndex.count(hash) && mapBlockIndex[hash]->IsInMainChain())
{
if (!WriteSyncCheckpoint(hash))
{
// Test signing a sync-checkpoint with genesis block
CSyncCheckpoint checkpoint;
- checkpoint.hashCheckpoint = hashGenesisBlock;
+ checkpoint.hashCheckpoint = !fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet;
CDataStream sMsg(SER_NETWORK, PROTOCOL_VERSION);
sMsg << (CUnsignedSyncCheckpoint)checkpoint;
checkpoint.vchMsg = std::vector<unsigned char>(sMsg.begin(), sMsg.end());
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());
git://git.novaco.in / novacoin.git / blobdiff