X-Git-Url: https://git.novaco.in/?a=blobdiff_plain;f=src%2Fcheckpoints.h;h=ff815c8650615495db127620e2b9431e1b1be31b;hb=0561bbd1c69263dceb24ffacf850788e6e961a13;hp=372f32b0dcccd1af0e213ee10dcaa3cb657c276d;hpb=3b7edc03821c79a0a8cd6b81346961193d48e938;p=novacoin.git

diff --git a/src/checkpoints.h b/src/checkpoints.h
index 372f32b..ff815c8 100644
--- a/src/checkpoints.h
+++ b/src/checkpoints.h
@@ -1,25 +1,24 @@
-// Copyright (c) 2011 The Bitcoin developers
+// Copyright (c) 2009-2012 The Bitcoin 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.
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #ifndef BITCOIN_CHECKPOINT_H
 #define  BITCOIN_CHECKPOINT_H
 
 #include <map>
+#include "net.h"
 #include "util.h"
 
-// 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)
+#define STAKE_MIN_AGE (60 * 60 * 24)      // minimum age for coin age
+#define CHECKPOINT_MIN_SPAN (60 * 60 * 4) // 4 hours checkpoint
 
 class uint256;
 class CBlockIndex;
+class CSyncCheckpoint;
 
-//
-// Block-chain checkpoints are compiled-in sanity checks.
-// They are updated every release or three.
-//
+/** Block-chain checkpoints are compiled-in sanity checks.
+ * They are updated every release or three.
+ */
 namespace Checkpoints
 {
     // Returns true if block passes checkpoint checks
@@ -31,119 +30,108 @@ namespace Checkpoints
     // Returns last CBlockIndex* in mapBlockIndex that is a checkpoint
     CBlockIndex* GetLastCheckpoint(const std::map<uint256, CBlockIndex*>& mapBlockIndex);
 
-    // 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;
-        }
+    extern uint256 hashSyncCheckpoint;
+    extern CSyncCheckpoint checkpointMessage;
+    extern uint256 hashInvalidCheckpoint;
+    extern CCriticalSection cs_hashSyncCheckpoint;
 
-        std::string ToString() const
-        {
-            return strprintf(
-                    "CSyncCheckpoint(\n"
-                    "    nVersion       = %d\n"
-                    "    hashCheckpoint = %s\n"
-                    ")\n",
-                nVersion,
-                hashCheckpoint.ToString().c_str());
-        }
+    CBlockIndex* GetLastSyncCheckpoint();
+    bool WriteSyncCheckpoint(const uint256& hashCheckpoint);
+    bool AcceptPendingSyncCheckpoint();
+    uint256 AutoSelectSyncCheckpoint();
+    bool CheckSync(const uint256& hashBlock, const CBlockIndex* pindexPrev);
+    bool WantedByPendingSyncCheckpoint(uint256 hashBlock);
+    bool ResetSyncCheckpoint();
+    void AskForPendingSyncCheckpoint(CNode* pfrom);
+}
 
-        void print() const
-        {
-            printf("%s", ToString().c_str());
-        }
-    };
+// 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;
+    }
 
-    class CSyncCheckpoint : public CUnsignedSyncCheckpoint
+    std::string ToString() const
     {
-    public:
-        std::vector<unsigned char> vchMsg;
-        std::vector<unsigned char> vchSig;
+        return strprintf(
+                "CSyncCheckpoint(\n"
+                "    nVersion       = %d\n"
+                "    hashCheckpoint = %s\n"
+                ")\n",
+            nVersion,
+            hashCheckpoint.ToString().c_str());
+    }
+
+    void print() const
+    {
+        printf("%s", ToString().c_str());
+    }
+};
 
-        CSyncCheckpoint()
-        {
-            SetNull();
-        }
+class CSyncCheckpoint : public CUnsignedSyncCheckpoint
+{
+public:
+    static const std::string strMasterPubKey;
 
-        IMPLEMENT_SERIALIZE
-        (
-            READWRITE(vchMsg);
-            READWRITE(vchSig);
-        )
+    std::vector<unsigned char> vchMsg;
+    std::vector<unsigned char> vchSig;
 
-        void SetNull()
-        {
-            CUnsignedSyncCheckpoint::SetNull();
-            vchMsg.clear();
-            vchSig.clear();
-        }
+    CSyncCheckpoint()
+    {
+        SetNull();
+    }
 
-        bool IsNull() const
-        {
-            return (hashCheckpoint == 0);
-        }
+    IMPLEMENT_SERIALIZE
+    (
+        READWRITE(vchMsg);
+        READWRITE(vchSig);
+    )
 
-        uint256 GetHash() const
-        {
-            return SerializeHash(*this);
-        }
+    void SetNull()
+    {
+        CUnsignedSyncCheckpoint::SetNull();
+        vchMsg.clear();
+        vchSig.clear();
+    }
 
-        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 IsNull() const
+    {
+        return (hashCheckpoint == 0);
+    }
 
-        bool CheckSignature()
+    uint256 GetHash() const
+    {
+        return SerializeHash(*this);
+    }
+
+    bool RelayTo(CNode* pnode) const
+    {
+        // returns true if wasn't already sent
+        if (pnode->hashCheckpointKnown != hashCheckpoint)
         {
-            CKey key;
-            if (!key.SetPubKey(ParseHex("0487ca85b6ae9d311f996c7616d20d0c88a5b4f07d25e78f419019f35cce6522acf978b2d99f0e7a58db1f120439e5c1889266927854aa57c93956c2569188a539")))
-                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;
+            pnode->hashCheckpointKnown = hashCheckpoint;
+            pnode->PushMessage("checkpoint", *this);
             return true;
         }
+        return false;
+    }
 
-        bool ProcessSyncCheckpoint(CNode* pfrom);
-    };
-
-    extern uint256 hashSyncCheckpoint;
-    extern CSyncCheckpoint checkpointMessage;
-    extern CCriticalSection cs_hashSyncCheckpoint;
-
-    // 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);
-}
+    bool CheckSignature();
+    bool ProcessSyncCheckpoint(CNode* pfrom);
+};
 
 #endif