X-Git-Url: https://git.novaco.in/?p=novacoin.git;a=blobdiff_plain;f=src%2Fcheckpoints.cpp;h=a9728ff77ad573abf7775e454f8f64f24006c82e;hp=26cc6985059e3d6dec5a9becbaf7219be4c2930e;hb=6bd80c2d737da9422283de5dd3033e318dcb96b7;hpb=e95e5247384a893ddb54e963f1dcc9a4d35f14e1 diff --git a/src/checkpoints.cpp b/src/checkpoints.cpp index 26cc698..a9728ff 100644 --- a/src/checkpoints.cpp +++ b/src/checkpoints.cpp @@ -1,17 +1,21 @@ -// Copyright (c) 2011 The Bitcoin developers -// Copyright (c) 2011-2012 The PPCoin developers +// Copyright (c) 2009-2012 The Bitcoin developers // Distributed under the MIT/X11 software license, see the accompanying -// file license.txt or http://www.opensource.org/licenses/mit-license.php. +// file COPYING or http://www.opensource.org/licenses/mit-license.php. #include // for 'map_list_of()' #include +#include -#include "headers.h" #include "checkpoints.h" +#include "txdb.h" +#include "main.h" +#include "uint256.h" + namespace Checkpoints { - typedef std::map MapCheckpoints; // hardened checkpoints + typedef std::map > MapCheckpoints; + typedef std::list ListBannedBlocks; // // What makes a good checkpoint block? @@ -22,33 +26,66 @@ namespace Checkpoints // static MapCheckpoints mapCheckpoints = boost::assign::map_list_of - ( 0, hashGenesisBlock ) - ; // ppcoin: no checkpoint yet; to be created in future releases + ( 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) ) + ( 243100, std::make_pair(uint256("0x000000000006522d1ebc0734cb0e6b83f5d4da0c3cbc72bd91b82016f611c4f0"), 1458215793) ) + ; + + static ListBannedBlocks listBanned = + boost::assign::list_of + // Invalid block #221047 with future timestamp of 2016/02/23 09:24:17 UTC + ( uint256("0x46223e5432ceffe650d5729b4bb8479dcdf0ca1e534fa8e69382dc87b42ea94b") ) + ; + + // 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; + } + + bool CheckBanned(const uint256 &nHash) + { + if (fTestNet) // Testnet has no banned blocks + return true; + ListBannedBlocks::const_iterator it = std::find(listBanned.begin(), listBanned.end(), nHash); + return it == listBanned.end(); } int GetTotalBlocksEstimate() { - if (fTestNet) return 0; + MapCheckpoints& checkpoints = (fTestNet ? mapCheckpointsTestnet : mapCheckpoints); + + return checkpoints.rbegin()->first; + } + + unsigned int GetLastCheckpointTime() + { + MapCheckpoints& checkpoints = (fTestNet ? mapCheckpointsTestnet : mapCheckpoints); - return mapCheckpoints.rbegin()->first; + return checkpoints.rbegin()->second.second; } CBlockIndex* GetLastCheckpoint(const std::map& mapBlockIndex) { - if (fTestNet) return NULL; + MapCheckpoints& checkpoints = (fTestNet ? mapCheckpointsTestnet : mapCheckpoints); - int64 nResult; - 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::const_iterator t = mapBlockIndex.find(hash); if (t != mapBlockIndex.end()) return t->second; @@ -57,12 +94,24 @@ namespace Checkpoints } // ppcoin: synchronized checkpoint (centrally broadcasted) - uint256 hashSyncCheckpoint; + uint256 hashSyncCheckpoint = 0; + uint256 hashPendingCheckpoint = 0; CSyncCheckpoint checkpointMessage; CSyncCheckpoint checkpointMessagePending; uint256 hashInvalidCheckpoint = 0; CCriticalSection cs_hashSyncCheckpoint; + // ppcoin: get last synchronized checkpoint + CBlockIndex* GetLastSyncCheckpoint() + { + LOCK(cs_hashSyncCheckpoint); + if (!mapBlockIndex.count(hashSyncCheckpoint)) + error("GetSyncCheckpoint: block index missing for current sync-checkpoint %s", hashSyncCheckpoint.ToString().c_str()); + else + return mapBlockIndex[hashSyncCheckpoint]; + return NULL; + } + // ppcoin: only descendant of current sync-checkpoint is allowed bool ValidateSyncCheckpoint(uint256 hashCheckpoint) { @@ -81,8 +130,8 @@ namespace Checkpoints // that current checkpoint should be a descendant block CBlockIndex* pindex = pindexSyncCheckpoint; while (pindex->nHeight > pindexCheckpointRecv->nHeight) - if (!(pindex = pindex->pprev)) - return error("ValidateSyncCheckpoint: pprev1 null - block index structure failure"); + if ((pindex = pindex->pprev) == NULL) + return error("ValidateSyncCheckpoint: pprev null - block index structure failure"); if (pindex->GetBlockHash() != hashCheckpoint) { hashInvalidCheckpoint = hashCheckpoint; @@ -96,7 +145,7 @@ namespace Checkpoints // to verify. CBlockIndex* pindex = pindexCheckpointRecv; while (pindex->nHeight > pindexSyncCheckpoint->nHeight) - if (!(pindex = pindex->pprev)) + if ((pindex = pindex->pprev) == NULL) return error("ValidateSyncCheckpoint: pprev2 null - block index structure failure"); if (pindex->GetBlockHash() != hashSyncCheckpoint) { @@ -106,62 +155,79 @@ namespace Checkpoints return true; } + bool WriteSyncCheckpoint(const uint256& hashCheckpoint) + { + CTxDB txdb; + txdb.TxnBegin(); + if (!txdb.WriteSyncCheckpoint(hashCheckpoint)) + { + txdb.TxnAbort(); + return error("WriteSyncCheckpoint(): failed to write to db sync checkpoint %s", hashCheckpoint.ToString().c_str()); + } + 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; + } + bool AcceptPendingSyncCheckpoint() { - CRITICAL_BLOCK(cs_hashSyncCheckpoint) + LOCK(cs_hashSyncCheckpoint); + if (hashPendingCheckpoint != 0 && mapBlockIndex.count(hashPendingCheckpoint)) { - if ((!checkpointMessagePending.IsNull()) && mapBlockIndex.count(checkpointMessagePending.hashCheckpoint)) + if (!ValidateSyncCheckpoint(hashPendingCheckpoint)) { - if (!ValidateSyncCheckpoint(checkpointMessagePending.hashCheckpoint)) - { - checkpointMessagePending.SetNull(); - return false; - } - - CTxDB txdb; - CBlockIndex* pindexCheckpoint = mapBlockIndex[checkpointMessagePending.hashCheckpoint]; - if (!pindexCheckpoint->IsInMainChain()) - { - txdb.TxnBegin(); - if (!Reorganize(txdb, pindexCheckpoint)) - { - txdb.TxnAbort(); - hashInvalidCheckpoint = checkpointMessagePending.hashCheckpoint; - return error("ProcessSyncCheckpoint: Reorganize failed for sync checkpoint %s", checkpointMessagePending.hashCheckpoint.ToString().c_str()); - } - } + hashPendingCheckpoint = 0; + checkpointMessagePending.SetNull(); + return false; + } - txdb.TxnBegin(); - if (!txdb.WriteSyncCheckpoint(checkpointMessagePending.hashCheckpoint)) + CTxDB txdb; + CBlockIndex* pindexCheckpoint = mapBlockIndex[hashPendingCheckpoint]; + if (!pindexCheckpoint->IsInMainChain()) + { + CBlock block; + if (!block.ReadFromDisk(pindexCheckpoint)) + return error("AcceptPendingSyncCheckpoint: ReadFromDisk failed for sync checkpoint %s", hashPendingCheckpoint.ToString().c_str()); + if (!block.SetBestChain(txdb, pindexCheckpoint)) { - txdb.TxnAbort(); - return error("AcceptPendingSyncCheckpoint() : failed to write to db sync checkpoint %s\n", checkpointMessagePending.hashCheckpoint.ToString().c_str()); + hashInvalidCheckpoint = hashPendingCheckpoint; + return error("AcceptPendingSyncCheckpoint: SetBestChain failed for sync checkpoint %s", hashPendingCheckpoint.ToString().c_str()); } - if (!txdb.TxnCommit()) - return error("AcceptPendingSyncCheckpoint() : failed to commit to db sync checkpoint %s\n", checkpointMessagePending.hashCheckpoint.ToString().c_str()); - txdb.Close(); + } - hashSyncCheckpoint = checkpointMessagePending.hashCheckpoint; - checkpointMessage = checkpointMessagePending; - checkpointMessagePending.SetNull(); - printf("AcceptPendingSyncCheckpoint : sync-checkpoint at %s\n", hashSyncCheckpoint.ToString().c_str()); - // relay the checkpoint - CRITICAL_BLOCK(cs_hashSyncCheckpoint) - BOOST_FOREACH(CNode* pnode, vNodes) - checkpointMessage.RelayTo(pnode); - return true; +#ifndef USE_LEVELDB + txdb.Close(); +#endif + if (!WriteSyncCheckpoint(hashPendingCheckpoint)) + return error("AcceptPendingSyncCheckpoint(): failed to write sync checkpoint %s", hashPendingCheckpoint.ToString().c_str()); + hashPendingCheckpoint = 0; + checkpointMessage = checkpointMessagePending; + checkpointMessagePending.SetNull(); + printf("AcceptPendingSyncCheckpoint : sync-checkpoint at %s\n", hashSyncCheckpoint.ToString().c_str()); + // relay the checkpoint + if (!checkpointMessage.IsNull()) + { + for (std::vector::iterator it = vNodes.begin(); it != vNodes.end(); ++it) + checkpointMessage.RelayTo(*it); } + return true; } - return false; } + // Automatically select a suitable sync-checkpoint uint256 AutoSelectSyncCheckpoint() { - // select block roughly 8 hours ago - CBlockIndex *pindex = mapBlockIndex[hashSyncCheckpoint]; - while (pindex->pnext && pindex->pnext->GetBlockTime() + AUTO_CHECKPOINT_MIN_SPAN <= GetAdjustedTime()) - 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(); } @@ -171,209 +237,226 @@ namespace Checkpoints if (fTestNet) return true; // Testnet has no checkpoints int nHeight = pindexPrev->nHeight + 1; - CRITICAL_BLOCK(cs_hashSyncCheckpoint) - { - // sync-checkpoint should always be accepted block - assert(mapBlockIndex.count(hashSyncCheckpoint)); - const CBlockIndex* pindexSync = mapBlockIndex[hashSyncCheckpoint]; + LOCK(cs_hashSyncCheckpoint); + // sync-checkpoint should always be accepted block + assert(mapBlockIndex.count(hashSyncCheckpoint)); + const CBlockIndex* pindexSync = mapBlockIndex[hashSyncCheckpoint]; - if (nHeight > pindexSync->nHeight) - { - // trace back to same height as sync-checkpoint - const CBlockIndex* pindex = pindexPrev; - while (pindex->nHeight > pindexSync->nHeight) - if (!(pindex = pindex->pprev)) - return error("CheckSync: pprev null - block index structure failure"); - if (pindex->nHeight < pindexSync->nHeight || pindex->GetBlockHash() != hashSyncCheckpoint) - return false; // only descendant of sync-checkpoint can pass check - } - if (nHeight == pindexSync->nHeight && hashBlock != hashSyncCheckpoint) - return false; // same height with sync-checkpoint - if (nHeight < pindexSync->nHeight && !mapBlockIndex.count(hashBlock)) - return false; // lower height than sync-checkpoint + if (nHeight > pindexSync->nHeight) + { + // trace back to same height as sync-checkpoint + const CBlockIndex* pindex = pindexPrev; + while (pindex->nHeight > pindexSync->nHeight) + if ((pindex = pindex->pprev) == NULL) + return error("CheckSync: pprev null - block index structure failure"); + if (pindex->nHeight < pindexSync->nHeight || pindex->GetBlockHash() != hashSyncCheckpoint) + return false; // only descendant of sync-checkpoint can pass check } + if (nHeight == pindexSync->nHeight && hashBlock != hashSyncCheckpoint) + return false; // same height with sync-checkpoint + if (nHeight < pindexSync->nHeight && !mapBlockIndex.count(hashBlock)) + return false; // lower height than sync-checkpoint return true; } - bool IsPendingSyncCheckpoint(uint256 hashBlock) + bool WantedByPendingSyncCheckpoint(uint256 hashBlock) { - CRITICAL_BLOCK(cs_hashSyncCheckpoint) - return ((!checkpointMessagePending.IsNull()) && hashBlock == checkpointMessagePending.hashCheckpoint); + LOCK(cs_hashSyncCheckpoint); + if (hashPendingCheckpoint == 0) + return false; + if (hashBlock == hashPendingCheckpoint) + return true; + if (mapOrphanBlocks.count(hashPendingCheckpoint) + && hashBlock == WantedByOrphan(mapOrphanBlocks[hashPendingCheckpoint])) + return true; + return false; } - // ppcoin: automatic checkpoint (represented by height of checkpoint) - int nAutoCheckpoint = 0; - int nBranchPoint = 0; // branch point to alternative branch - - // ppcoin: check automatic checkpoint - // To pass the check: - // - All ancestors (including the block itself) have block index already - // - The immediate ancestor in main chain must not have height less than - // checkpoint height - bool CheckAuto(const CBlockIndex *pindex) + // ppcoin: reset synchronized checkpoint to last hardened checkpoint + bool ResetSyncCheckpoint() { - while (pindex) + LOCK(cs_hashSyncCheckpoint); + const uint256& hash = mapCheckpoints.rbegin()->second.first; + if (mapBlockIndex.count(hash) && !mapBlockIndex[hash]->IsInMainChain()) { - if (pindex->IsInMainChain()) + // checkpoint block accepted but not yet in main chain + printf("ResetSyncCheckpoint: SetBestChain to hardened checkpoint %s\n", hash.ToString().c_str()); + CTxDB txdb; + CBlock block; + if (!block.ReadFromDisk(mapBlockIndex[hash])) + return error("ResetSyncCheckpoint: ReadFromDisk failed for hardened checkpoint %s", hash.ToString().c_str()); + if (!block.SetBestChain(txdb, mapBlockIndex[hash])) { - if (pindex->nHeight >= nAutoCheckpoint) - return true; - else - { - nBranchPoint = pindex->nHeight; - return error("Checkpoints: new block on alternative branch at height=%d before auto checkpoint at height=%d", pindex->nHeight, nAutoCheckpoint); - } + return error("ResetSyncCheckpoint: SetBestChain failed for hardened checkpoint %s", hash.ToString().c_str()); } - else - pindex = pindex->pprev; + +#ifndef USE_LEVELDB + txdb.Close(); +#endif + + } + else if(!mapBlockIndex.count(hash)) + { + // checkpoint block not yet accepted + hashPendingCheckpoint = hash; + checkpointMessagePending.SetNull(); + printf("ResetSyncCheckpoint: pending for sync-checkpoint %s\n", hashPendingCheckpoint.ToString().c_str()); } - return error("Checkpoints: failed to find any ancestor on main chain for the new block - internal error"); - } - // ppcoin: get next chain checkpoint - int GetNextChainCheckpoint(const CBlockIndex *pindexLast) - { - CBigNum bnTarget; - CBigNum bnTargetMax = 0; // max target of all blocks since checkpoint - CBigNum bnTargetMin = 0; // min target of all candidate checkpoints - int nMinTargetHeight = 0; // min target height of candidate checkpoints - int nCheckpointMin = 0; // minimum candidate checkpoint - int nCheckpointMax = 0; // maximum candidate checkpoint - int nDepth = pindexLast->nHeight - pindexLast->nCheckpoint; - const CBlockIndex *pindex = pindexLast; - while (nDepth >= 0 && pindex) + BOOST_REVERSE_FOREACH(const MapCheckpoints::value_type& i, mapCheckpoints) { - bnTarget.SetCompact(pindex->nBits); - if (bnTarget > bnTargetMax) - bnTargetMax = bnTarget; - if (nCheckpointMax > 0 && bnTarget < bnTargetMin) - { - bnTargetMin = bnTarget; - nMinTargetHeight = pindex->nHeight; - } - if (nCheckpointMax == 0 && pindexLast->GetBlockTime() - pindex->GetBlockTime() > AUTO_CHECKPOINT_MIN_SPAN) + const uint256& hash = i.second.first; + if (mapBlockIndex.count(hash) && mapBlockIndex[hash]->IsInMainChain()) { - nCheckpointMax = pindex->nHeight; - bnTargetMin.SetCompact(pindex->nBits); - nMinTargetHeight = pindex->nHeight; + if (!WriteSyncCheckpoint(hash)) + return error("ResetSyncCheckpoint: failed to write sync checkpoint %s", hash.ToString().c_str()); + printf("ResetSyncCheckpoint: sync-checkpoint reset to %s\n", hashSyncCheckpoint.ToString().c_str()); + return true; } - if (pindexLast->GetBlockTime() - pindex->GetBlockTime() < AUTO_CHECKPOINT_MAX_SPAN) - nCheckpointMin = pindex->nHeight; - pindex = pindex->pprev; - nDepth--; } - assert (nDepth == -1); // arrive at chain checkpoint now - - printf("Checkpoints: min=%d max=%d tminheight=%d tmin=0x%08x tmax=0x%08x\n", - nCheckpointMin, nCheckpointMax, nMinTargetHeight, - bnTargetMin.GetCompact(), bnTargetMax.GetCompact()); - if (nCheckpointMax == 0) // checkpoint stays if max candidate not found - return pindexLast->nCheckpoint; - - if (bnTargetMin * 100 > bnTargetMax * 90) - return nCheckpointMax; - if (bnTarget * 100 > bnTargetMax * 90) - return nMinTargetHeight; - else - return nCheckpointMin; + return false; } - // ppcoin: get next auto checkpoint from the new chain checkpoint - int GetNextAutoCheckpoint(int nCheckpoint) + void AskForPendingSyncCheckpoint(CNode* pfrom) { - return (std::max(nAutoCheckpoint, nCheckpoint)); + LOCK(cs_hashSyncCheckpoint); + if (pfrom && hashPendingCheckpoint != 0 && (!mapBlockIndex.count(hashPendingCheckpoint)) && (!mapOrphanBlocks.count(hashPendingCheckpoint))) + pfrom->AskFor(CInv(MSG_BLOCK, hashPendingCheckpoint)); } - // ppcoin: advance to next automatic checkpoint - void AdvanceAutoCheckpoint(int nCheckpoint) + bool SetCheckpointPrivKey(std::string strPrivKey) { - nAutoCheckpoint = GetNextAutoCheckpoint(nCheckpoint); - printf("Checkpoints: auto checkpoint now at height=%d\n", nAutoCheckpoint); + // Test signing a sync-checkpoint with genesis block + CSyncCheckpoint checkpoint; + checkpoint.hashCheckpoint = !fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet; + CDataStream sMsg(SER_NETWORK, PROTOCOL_VERSION); + sMsg << (CUnsignedSyncCheckpoint)checkpoint; + checkpoint.vchMsg = std::vector(sMsg.begin(), sMsg.end()); + + std::vector vchPrivKey = ParseHex(strPrivKey); + CKey key; + key.SetPrivKey(CPrivKey(vchPrivKey.begin(), vchPrivKey.end())); // if key is not correct openssl may crash + if (!key.Sign(Hash(checkpoint.vchMsg.begin(), checkpoint.vchMsg.end()), checkpoint.vchSig)) + return false; + + // Test signing successful, proceed + CSyncCheckpoint::strMasterPrivKey = strPrivKey; + return true; } - // ppcoin: reset auto checkpoint - bool ResetAutoCheckpoint(int nCheckpoint) + bool SendSyncCheckpoint(uint256 hashCheckpoint) { - if (nCheckpoint <= 0 || nCheckpoint > nBestHeight) - return error("ResetAutoCheckpoint() : new checkpoint invalid"); - if (nCheckpoint >= nAutoCheckpoint) - return error("ResetAutoCheckpoint() : new checkpoint not earlier than current auto checkpoint"); - CTxDB txdb; - txdb.TxnBegin(); - if (!txdb.WriteAutoCheckpoint(nCheckpoint, true)) - return error("ResetAutoCheckpoint() : database write failed"); - if (!txdb.TxnCommit()) - return error("ResetAutoCheckpoint() : database commit failed"); - nAutoCheckpoint = nCheckpoint; - nBranchPoint = 0; // clear branch point - - // clear ban list to accept alternative branches - CRITICAL_BLOCK(cs_vNodes) + CSyncCheckpoint checkpoint; + checkpoint.hashCheckpoint = hashCheckpoint; + CDataStream sMsg(SER_NETWORK, PROTOCOL_VERSION); + sMsg << (CUnsignedSyncCheckpoint)checkpoint; + checkpoint.vchMsg = std::vector(sMsg.begin(), sMsg.end()); + + if (CSyncCheckpoint::strMasterPrivKey.empty()) + return error("SendSyncCheckpoint: Checkpoint master key unavailable."); + std::vector vchPrivKey = ParseHex(CSyncCheckpoint::strMasterPrivKey); + CKey key; + key.SetPrivKey(CPrivKey(vchPrivKey.begin(), vchPrivKey.end())); // if key is not correct openssl may crash + if (!key.Sign(Hash(checkpoint.vchMsg.begin(), checkpoint.vchMsg.end()), checkpoint.vchSig)) + return error("SendSyncCheckpoint: Unable to sign checkpoint, check private key?"); + + if(!checkpoint.ProcessSyncCheckpoint(NULL)) { - BOOST_FOREACH(CNode* pnode, vNodes) - pnode->ClearBanned(); + printf("WARNING: SendSyncCheckpoint: Failed to process checkpoint.\n"); + return false; } + // Relay checkpoint + { + LOCK(cs_vNodes); + for (std::vector::iterator it = vNodes.begin(); it != vNodes.end(); ++it) + checkpoint.RelayTo(*it); + } return true; } + + // Is the sync-checkpoint outside maturity window? + bool IsMatureSyncCheckpoint() + { + LOCK(cs_hashSyncCheckpoint); + // sync-checkpoint should always be accepted block + assert(mapBlockIndex.count(hashSyncCheckpoint)); + const CBlockIndex* pindexSync = mapBlockIndex[hashSyncCheckpoint]; + return (nBestHeight >= pindexSync->nHeight + nCoinbaseMaturity || + pindexSync->GetBlockTime() + nStakeMinAge < GetAdjustedTime()); + } +} + +// ppcoin: sync-checkpoint master key +const std::string CSyncCheckpoint::strMasterPubKey = "04a51b735f816de4ec3f891d5b38bbc91e1f7245c7c08d17990760b86b4d8fc3910a850ffecf73bfa8886f01739a0c4c4322201282d07b6e48ce931cc92af94850"; + +std::string CSyncCheckpoint::strMasterPrivKey = ""; + +// ppcoin: verify signature of sync-checkpoint message +bool CSyncCheckpoint::CheckSignature() +{ + CPubKey key(ParseHex(CSyncCheckpoint::strMasterPubKey)); + if (!key.Verify(Hash(vchMsg.begin(), vchMsg.end()), vchSig)) + return error("CSyncCheckpoint::CheckSignature() : verify signature failed"); + + // Now unserialize the data + CDataStream sMsg(vchMsg, SER_NETWORK, PROTOCOL_VERSION); + sMsg >> *(CUnsignedSyncCheckpoint*)this; + return true; } -// ppcoin: process synchronized checkpoint +// process synchronized checkpoint bool CSyncCheckpoint::ProcessSyncCheckpoint(CNode* pfrom) { if (!CheckSignature()) return false; - CRITICAL_BLOCK(Checkpoints::cs_hashSyncCheckpoint) + LOCK(Checkpoints::cs_hashSyncCheckpoint); + if (!mapBlockIndex.count(hashCheckpoint)) { - if (!mapBlockIndex.count(hashCheckpoint)) + // We haven't received the checkpoint chain, keep the checkpoint as pending + Checkpoints::hashPendingCheckpoint = hashCheckpoint; + Checkpoints::checkpointMessagePending = *this; + printf("ProcessSyncCheckpoint: pending for sync-checkpoint %s\n", hashCheckpoint.ToString().c_str()); + // Ask this guy to fill in what we're missing + if (pfrom) { - // We haven't received the checkpoint chain, keep the checkpoint as pending - Checkpoints::checkpointMessagePending = *this; - printf("ProcessSyncCheckpoint: pending for sync-checkpoint %s\n", hashCheckpoint.ToString().c_str()); - // Ask this guy to fill in what we're missing - if (pfrom) - { - pfrom->PushGetBlocks(pindexBest, hashCheckpoint); - // ask directly as well in case rejected earlier by duplicate - // proof-of-stake because getblocks may not get it this time - pfrom->AskFor(CInv(MSG_BLOCK, mapOrphanBlocks.count(hashCheckpoint)? GetOrphanRoot(mapOrphanBlocks[hashCheckpoint]) : hashCheckpoint)); - } - return false; + pfrom->PushGetBlocks(pindexBest, hashCheckpoint); + // ask directly as well in case rejected earlier by duplicate + // proof-of-stake because getblocks may not get it this time + pfrom->AskFor(CInv(MSG_BLOCK, mapOrphanBlocks.count(hashCheckpoint)? WantedByOrphan(mapOrphanBlocks[hashCheckpoint]) : hashCheckpoint)); } + return false; + } - if (!Checkpoints::ValidateSyncCheckpoint(hashCheckpoint)) - return false; + if (!Checkpoints::ValidateSyncCheckpoint(hashCheckpoint)) + return false; - CTxDB txdb; - CBlockIndex* pindexCheckpoint = mapBlockIndex[hashCheckpoint]; - if (!pindexCheckpoint->IsInMainChain()) + CTxDB txdb; + CBlockIndex* pindexCheckpoint = mapBlockIndex[hashCheckpoint]; + if (!pindexCheckpoint->IsInMainChain()) + { + // checkpoint chain received but not yet main chain + CBlock block; + if (!block.ReadFromDisk(pindexCheckpoint)) + return error("ProcessSyncCheckpoint: ReadFromDisk failed for sync checkpoint %s", hashCheckpoint.ToString().c_str()); + if (!block.SetBestChain(txdb, pindexCheckpoint)) { - // checkpoint chain received but not yet main chain - txdb.TxnBegin(); - if (!Reorganize(txdb, pindexCheckpoint)) - { - txdb.TxnAbort(); - Checkpoints::hashInvalidCheckpoint = hashCheckpoint; - return error("ProcessSyncCheckpoint: Reorganize failed for sync checkpoint %s", hashCheckpoint.ToString().c_str()); - } + Checkpoints::hashInvalidCheckpoint = hashCheckpoint; + return error("ProcessSyncCheckpoint: SetBestChain failed for sync checkpoint %s", hashCheckpoint.ToString().c_str()); } + } - txdb.TxnBegin(); - if (!txdb.WriteSyncCheckpoint(hashCheckpoint)) - { - txdb.TxnAbort(); - return error("ProcessSyncCheckpoint(): failed to write to db sync checkpoint %s", hashCheckpoint.ToString().c_str()); - } - if (!txdb.TxnCommit()) - return error("ProcessSyncCheckpoint(): failed to commit to db sync checkpoint %s", hashCheckpoint.ToString().c_str()); - txdb.Close(); +#ifndef USE_LEVELDB + txdb.Close(); +#endif - Checkpoints::hashSyncCheckpoint = hashCheckpoint; - Checkpoints::checkpointMessage = *this; - Checkpoints::checkpointMessagePending.SetNull(); - printf("ProcessSyncCheckpoint: sync-checkpoint at %s\n", hashCheckpoint.ToString().c_str()); - } + if (!Checkpoints::WriteSyncCheckpoint(hashCheckpoint)) + return error("ProcessSyncCheckpoint(): failed to write sync checkpoint %s", hashCheckpoint.ToString().c_str()); + Checkpoints::checkpointMessage = *this; + Checkpoints::hashPendingCheckpoint = 0; + Checkpoints::checkpointMessagePending.SetNull(); + printf("ProcessSyncCheckpoint: sync-checkpoint at %s\n", hashCheckpoint.ToString().c_str()); return true; }