X-Git-Url: https://git.novaco.in/?a=blobdiff_plain;f=src%2Fcheckpoints.cpp;h=4afdab9ade4f03890b02637d36c969bccf482ed4;hb=d56fde1346ccd32ca6a6e98d9a0a84c8fa9939e7;hp=8898ca123e4856ea239840a728197ddb66722f4a;hpb=e0fa1f887a2a94fd8beb4f62fe997dc3532c266c;p=novacoin.git diff --git a/src/checkpoints.cpp b/src/checkpoints.cpp index 8898ca1..4afdab9 100644 --- a/src/checkpoints.cpp +++ b/src/checkpoints.cpp @@ -1,5 +1,5 @@ // Copyright (c) 2011 The Bitcoin developers -// Copyright (c) 2011 The PPCoin developers +// Copyright (c) 2011-2012 The PPCoin developers // Distributed under the MIT/X11 software license, see the accompanying // file license.txt or http://www.opensource.org/licenses/mit-license.php. @@ -25,9 +25,6 @@ namespace Checkpoints ( 0, hashGenesisBlock ) ; // ppcoin: no checkpoint yet; to be created in future releases - // ppcoin: automatic checkpoint (represented by height of checkpoint) - int nAutoCheckpoint = 0; - bool CheckHardened(int nHeight, const uint256& hash) { if (fTestNet) return true; // Testnet has no checkpoints @@ -37,6 +34,85 @@ namespace Checkpoints return hash == i->second; } + int GetTotalBlocksEstimate() + { + if (fTestNet) return 0; + + return mapCheckpoints.rbegin()->first; + } + + CBlockIndex* GetLastCheckpoint(const std::map& mapBlockIndex) + { + if (fTestNet) return NULL; + + int64 nResult; + BOOST_REVERSE_FOREACH(const MapCheckpoints::value_type& i, mapCheckpoints) + { + const uint256& hash = i.second; + std::map::const_iterator t = mapBlockIndex.find(hash); + if (t != mapBlockIndex.end()) + return t->second; + } + return NULL; + } + + // ppcoin: synchronized checkpoint (centrally broadcasted) + uint256 hashSyncCheckpoint; + CSyncCheckpoint checkpointMessage; + CSyncCheckpoint checkpointMessagePending; + CCriticalSection cs_hashSyncCheckpoint; + + // ppcoin: only descendant of current sync-checkpoint is allowed + bool ValidateSyncCheckpoint(uint256 hashCheckpoint) + { + if (!mapBlockIndex.count(hashSyncCheckpoint)) + return error("ValidateSyncCheckpoint: block index missing for current sync-checkpoint %s", hashSyncCheckpoint.ToString().c_str()); + if (!mapBlockIndex.count(hashCheckpoint)) + return error("ValidateSyncCheckpoint: block index missing for received sync-checkpoint %s", hashCheckpoint.ToString().c_str()); + + CBlockIndex* pindexSyncCheckpoint = mapBlockIndex[hashSyncCheckpoint]; + CBlockIndex* pindexCheckpointRecv = mapBlockIndex[hashCheckpoint]; + if (pindexCheckpointRecv->nHeight <= pindexSyncCheckpoint->nHeight) + return false; // this is an older checkpoint, ignore + + CBlockIndex* pindex = pindexCheckpointRecv; + while (pindex->nHeight > pindexSyncCheckpoint->nHeight) + pindex = pindex->pprev; + if (pindex->GetBlockHash() != hashSyncCheckpoint) + return error("ValidateSyncCheckpoint: new sync-checkpoint %s is not a descendant of current sync-checkpoint %s", hashCheckpoint.ToString().c_str(), hashSyncCheckpoint.ToString().c_str()); + return true; + } + + bool AcceptPendingSyncCheckpoint(uint256 hashAcceptedBlock) + { + if (!mapBlockIndex.count(hashAcceptedBlock)) + return false; + + CRITICAL_BLOCK(cs_hashSyncCheckpoint) + if ((!checkpointMessagePending.IsNull()) && checkpointMessagePending.hashCheckpoint == hashAcceptedBlock) + { + if (!ValidateSyncCheckpoint(checkpointMessagePending.hashCheckpoint)) + { + checkpointMessagePending.SetNull(); + return false; + } + hashSyncCheckpoint = checkpointMessagePending.hashCheckpoint; + checkpointMessage = checkpointMessagePending; + checkpointMessagePending.SetNull(); + printf("AcceptPendingSyncCheckpoint : sync-checkpoint at %s\n", hashSyncCheckpoint.ToString().c_str()); + // relay the checkpoint + BOOST_FOREACH(CNode* pnode, vNodes) + checkpointMessage.RelayTo(pnode); + 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 @@ -51,7 +127,10 @@ namespace Checkpoints 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); + } } else pindex = pindex->pprev; @@ -59,13 +138,13 @@ namespace Checkpoints return error("Checkpoints: failed to find any ancestor on main chain for the new block - internal error"); } - // ppcoin: get next auto checkpoint in the chain + // 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 since checkpoint + 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; @@ -103,37 +182,75 @@ namespace Checkpoints if (bnTargetMin * 100 > bnTargetMax * 90) return nCheckpointMax; if (bnTarget * 100 > bnTargetMax * 90) - return std::min(nCheckpointMax, nMinTargetHeight); + return nMinTargetHeight; else return nCheckpointMin; } + // ppcoin: get next auto checkpoint from the new chain checkpoint + int GetNextAutoCheckpoint(int nCheckpoint) + { + return (std::max(nAutoCheckpoint, nCheckpoint)); + } + // ppcoin: advance to next automatic checkpoint void AdvanceAutoCheckpoint(int nCheckpoint) { - nAutoCheckpoint = std::max(nAutoCheckpoint, nCheckpoint); + nAutoCheckpoint = GetNextAutoCheckpoint(nCheckpoint); printf("Checkpoints: auto checkpoint now at height=%d\n", nAutoCheckpoint); } - int GetTotalBlocksEstimate() + // ppcoin: reset auto checkpoint + bool ResetAutoCheckpoint(int nCheckpoint) { - if (fTestNet) return 0; + 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 - return mapCheckpoints.rbegin()->first; + // clear ban list to accept alternative branches + CRITICAL_BLOCK(cs_vNodes) + { + BOOST_FOREACH(CNode* pnode, vNodes) + pnode->ClearBanned(); + } + + return true; } +} - CBlockIndex* GetLastCheckpoint(const std::map& mapBlockIndex) - { - if (fTestNet) return NULL; +// ppcoin: process synchronized checkpoint +bool CSyncCheckpoint::ProcessSyncCheckpoint(CNode* pfrom) +{ + if (!CheckSignature()) + return false; - int64 nResult; - BOOST_REVERSE_FOREACH(const MapCheckpoints::value_type& i, mapCheckpoints) + CRITICAL_BLOCK(Checkpoints::cs_hashSyncCheckpoint) + { + if (!mapBlockIndex.count(hashCheckpoint)) { - const uint256& hash = i.second; - std::map::const_iterator t = mapBlockIndex.find(hash); - if (t != mapBlockIndex.end()) - return t->second; + // We haven't accepted this block, 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); + return false; } - return NULL; + if (!Checkpoints::ValidateSyncCheckpoint(hashCheckpoint)) + return false; + Checkpoints::hashSyncCheckpoint = this->hashCheckpoint; + Checkpoints::checkpointMessage = *this; + Checkpoints::checkpointMessagePending.SetNull(); + printf("ProcessSyncCheckpoint : sync-checkpoint at %s\n", Checkpoints::hashSyncCheckpoint.ToString().c_str()); } + return true; }