X-Git-Url: https://git.novaco.in/?a=blobdiff_plain;f=src%2Fcheckpoints.h;h=e411c1205ba069741f041f68aa011634a7230f2e;hb=9c28b3c6a120e07c3a0caea8e17e02c072e686b2;hp=78ccce9d1da62442961241c6652e19c60a409410;hpb=e0fa1f887a2a94fd8beb4f62fe997dc3532c266c;p=novacoin.git

diff --git a/src/checkpoints.h b/src/checkpoints.h
index 78ccce9..e411c12 100644
--- a/src/checkpoints.h
+++ b/src/checkpoints.h
@@ -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.
 #ifndef BITCOIN_CHECKPOINT_H
@@ -8,33 +8,145 @@
 #include <map>
 #include "util.h"
 
-// ppcoin: auto checkpoint min at 1 day; max at 1 week
-#define AUTO_CHECKPOINT_MIN_SPAN (60 * 60 * 24)
-#define AUTO_CHECKPOINT_MAX_SPAN (60 * 60 * 24 * 7)
+// ppcoin: auto checkpoint min at 8 hours; max at 16 hours
+#define AUTO_CHECKPOINT_MIN_SPAN   (60 * 60 * 8)
+#define AUTO_CHECKPOINT_MAX_SPAN   (60 * 60 * 16)
+#define AUTO_CHECKPOINT_TRUST_SPAN (60 * 60 * 24)
 
 class uint256;
 class CBlockIndex;
 
+// ppcoin: synchronized checkpoint
+class CUnsignedSyncCheckpoint
+{
+public:
+    int nVersion;
+    uint256 hashCheckpoint;      // checkpoint block
+
+    IMPLEMENT_SERIALIZE
+    (
+        READWRITE(this->nVersion);
+        nVersion = this->nVersion;
+        READWRITE(hashCheckpoint);
+    )
+
+    void SetNull()
+    {
+        nVersion = 1;
+        hashCheckpoint = 0;
+    }
+
+    std::string ToString() const
+    {
+        return strprintf(
+                "CSyncCheckpoint(\n"
+                "    nVersion       = %d\n"
+                "    hashCheckpoint = %s\n"
+                ")\n",
+            nVersion,
+            hashCheckpoint.ToString().c_str());
+    }
+
+    void print() const
+    {
+        printf("%s", ToString().c_str());
+    }
+};
+
+class CSyncCheckpoint : public CUnsignedSyncCheckpoint
+{
+public:
+    std::vector<unsigned char> vchMsg;
+    std::vector<unsigned char> vchSig;
+
+    CSyncCheckpoint()
+    {
+        SetNull();
+    }
+
+    IMPLEMENT_SERIALIZE
+    (
+        READWRITE(vchMsg);
+        READWRITE(vchSig);
+    )
+
+    void SetNull()
+    {
+        CUnsignedSyncCheckpoint::SetNull();
+        vchMsg.clear();
+        vchSig.clear();
+    }
+
+    bool IsNull() const
+    {
+        return (hashCheckpoint == 0);
+    }
+
+    uint256 GetHash() const
+    {
+        return SerializeHash(*this);
+    }
+
+    bool RelayTo(CNode* pnode) const
+    {
+        // returns true if wasn't already sent
+        if (pnode->hashCheckpointKnown != hashCheckpoint)
+        {
+            pnode->hashCheckpointKnown = hashCheckpoint;
+            pnode->PushMessage("checkpoint", *this);
+            return true;
+        }
+        return false;
+    }
+
+    bool CheckSignature()
+    {
+        CKey key;
+        if (!key.SetPubKey(ParseHex("04ea21daea8c15559870b5e93750ddc2f0c16bd0cb16636ba88c0746cfac07912ec7ad14111cc4aedda12c2687c920c7b7b62fd67ca14eed53f2d1704ec72362ce")))
+            return error("CSyncCheckpoint::CheckSignature() : SetPubKey failed");
+        if (!key.Verify(Hash(vchMsg.begin(), vchMsg.end()), vchSig))
+            return error("CSyncCheckpoint::CheckSignature() : verify signature failed");
+
+        // Now unserialize the data
+        CDataStream sMsg(vchMsg);
+        sMsg >> *(CUnsignedSyncCheckpoint*)this;
+        return true;
+    }
+
+    bool ProcessSyncCheckpoint(CNode* pfrom);
+};
+
 //
 // Block-chain checkpoints are compiled-in sanity checks.
 // They are updated every release or three.
 //
 namespace Checkpoints
 {
-    extern int nAutoCheckpoint;
-
     // Returns true if block passes checkpoint checks
     bool CheckHardened(int nHeight, const uint256& hash);
-    bool CheckAuto(const CBlockIndex *pindex);
-
-    int  GetNextChainCheckpoint(const CBlockIndex *pindex);
-    void AdvanceAutoCheckpoint(int nCheckpoint);
 
     // Return conservative estimate of total number of blocks, 0 if unknown
     int GetTotalBlocksEstimate();
 
     // Returns last CBlockIndex* in mapBlockIndex that is a checkpoint
     CBlockIndex* GetLastCheckpoint(const std::map<uint256, CBlockIndex*>& mapBlockIndex);
+
+    extern uint256 hashSyncCheckpoint;
+    extern CSyncCheckpoint checkpointMessage;
+    extern CCriticalSection cs_hashSyncCheckpoint;
+
+    bool AcceptPendingSyncCheckpoint(uint256 hashAcceptedBlock);
+    uint256 AutoSelectSyncCheckpoint();
+
+    // ppcoin: automatic checkpoint
+    extern int nAutoCheckpoint;
+    extern int nBranchPoint;
+
+    bool CheckAuto(const CBlockIndex *pindex);
+    int  GetNextChainCheckpoint(const CBlockIndex *pindex);
+    int  GetNextAutoCheckpoint(int nCheckpoint);
+    void AdvanceAutoCheckpoint(int nCheckpoint);
+    bool ResetAutoCheckpoint(int nCheckpoint);
 }
 
 #endif