src/checkpoints.h

   1 // Copyright (c) 2009-2012 The Bitcoin developers
   2 // Distributed under the MIT/X11 software license, see the accompanying
   3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   4 #ifndef BITCOIN_CHECKPOINT_H
   5 #define  BITCOIN_CHECKPOINT_H
   6
   7 #include <map>
   8 #include "util.h"
   9 #include "net.h"
  10
  11 // max 1 hour before latest block
  12 static const int64_t CHECKPOINT_MAX_SPAN = nOneHour;
  13
  14 #ifdef WIN32
  15 #undef STRICT
  16 #undef PERMISSIVE
  17 #undef ADVISORY
  18 #endif
  19
  20 class uint256;
  21 class CBlockIndex;
  22 class CSyncCheckpoint;
  23
  24 /** Block-chain checkpoints are compiled-in sanity checks.
  25  * They are updated every release or three.
  26  */
  27 namespace Checkpoints
  28 {
  29     /** Checkpointing mode */
  30     enum CPMode
  31     {
  32         // Scrict checkpoints policy, perform conflicts verification and resolve conflicts
  33         STRICT = 0,
  34         // Advisory checkpoints policy, perform conflicts verification but don't try to resolve them
  35         ADVISORY = 1,
  36         // Permissive checkpoints policy, don't perform any checking
  37         PERMISSIVE = 2
  38     };
  39
  40     // Returns true if block passes checkpoint checks
  41     bool CheckHardened(int nHeight, const uint256& hash);
  42
  43     // Returns true if block passes banlist checks
  44     bool CheckBanned(const uint256 &nHash);
  45
  46     // Return conservative estimate of total number of blocks, 0 if unknown
  47     int GetTotalBlocksEstimate();
  48
  49     // Returns last CBlockIndex* in mapBlockIndex that is a checkpoint
  50     CBlockIndex* GetLastCheckpoint(const std::map<uint256, CBlockIndex*>& mapBlockIndex);
  51
  52     // Returns last checkpoint timestamp
  53     unsigned int GetLastCheckpointTime();
  54
  55     extern uint256 hashSyncCheckpoint;
  56     extern CSyncCheckpoint checkpointMessage;
  57     extern uint256 hashInvalidCheckpoint;
  58     extern CCriticalSection cs_hashSyncCheckpoint;
  59
  60     CBlockIndex* GetLastSyncCheckpoint();
  61     bool WriteSyncCheckpoint(const uint256& hashCheckpoint);
  62     bool AcceptPendingSyncCheckpoint();
  63     uint256 AutoSelectSyncCheckpoint();
  64     bool CheckSync(const uint256& hashBlock, const CBlockIndex* pindexPrev);
  65     bool WantedByPendingSyncCheckpoint(uint256 hashBlock);
  66     bool ResetSyncCheckpoint();
  67     void AskForPendingSyncCheckpoint(CNode* pfrom);
  68     bool SetCheckpointPrivKey(std::string strPrivKey);
  69     bool SendSyncCheckpoint(uint256 hashCheckpoint);
  70     bool IsMatureSyncCheckpoint();
  71 }
  72
  73 // ppcoin: synchronized checkpoint
  74 class CUnsignedSyncCheckpoint
  75 {
  76 public:
  77     int nVersion;
  78     uint256 hashCheckpoint;      // checkpoint block
  79
  80     IMPLEMENT_SERIALIZE
  81     (
  82         READWRITE(this->nVersion);
  83         nVersion = this->nVersion;
  84         READWRITE(hashCheckpoint);
  85     )
  86
  87     void SetNull()
  88     {
  89         nVersion = 1;
  90         hashCheckpoint = 0;
  91     }
  92
  93     std::string ToString() const
  94     {
  95         return strprintf(
  96                 "CSyncCheckpoint(\n"
  97                 "    nVersion       = %d\n"
  98                 "    hashCheckpoint = %s\n"
  99                 ")\n",
 100             nVersion,
 101             hashCheckpoint.ToString().c_str());
 102     }
 103 };
 104
 105 class CSyncCheckpoint : public CUnsignedSyncCheckpoint
 106 {
 107 public:
 108     static const std::string strMasterPubKey;
 109     static std::string strMasterPrivKey;
 110
 111     std::vector<unsigned char> vchMsg;
 112     std::vector<unsigned char> vchSig;
 113
 114     CSyncCheckpoint()
 115     {
 116         SetNull();
 117     }
 118
 119     IMPLEMENT_SERIALIZE
 120     (
 121         READWRITE(vchMsg);
 122         READWRITE(vchSig);
 123     )
 124
 125     void SetNull()
 126     {
 127         CUnsignedSyncCheckpoint::SetNull();
 128         vchMsg.clear();
 129         vchSig.clear();
 130     }
 131
 132     bool IsNull() const
 133     {
 134         return (hashCheckpoint == 0);
 135     }
 136
 137     uint256 GetHash() const
 138     {
 139         return SerializeHash(*this);
 140     }
 141
 142     bool RelayTo(CNode* pnode) const
 143     {
 144         // returns true if wasn't already sent
 145         if (pnode->hashCheckpointKnown != hashCheckpoint)
 146         {
 147             pnode->hashCheckpointKnown = hashCheckpoint;
 148             pnode->PushMessage("checkpoint", *this);
 149             return true;
 150         }
 151         return false;
 152     }
 153
 154     bool CheckSignature();
 155     bool ProcessSyncCheckpoint(CNode* pfrom);
 156 };
 157
 158 #endif