PPCoin: Do not reject pending checkpoint with duplicate-stake check

[novacoin.git] / src / checkpoints.cpp

diff --git a/src/checkpoints.cpp b/src/checkpoints.cpp
index 888d106..26cc698 100644 (file)
--- a/src/checkpoints.cpp
+++ b/src/checkpoints.cpp
@@ -60,6 +60,7 @@ namespace Checkpoints
     uint256 hashSyncCheckpoint;
     CSyncCheckpoint checkpointMessage;
     CSyncCheckpoint checkpointMessagePending;
+    uint256 hashInvalidCheckpoint = 0;
     CCriticalSection cs_hashSyncCheckpoint;
 
     // ppcoin: only descendant of current sync-checkpoint is allowed
@@ -72,21 +73,43 @@ namespace Checkpoints
 
         CBlockIndex* pindexSyncCheckpoint = mapBlockIndex[hashSyncCheckpoint];
         CBlockIndex* pindexCheckpointRecv = mapBlockIndex[hashCheckpoint];
+
         if (pindexCheckpointRecv->nHeight <= pindexSyncCheckpoint->nHeight)
-            return false;  // this is an older checkpoint, ignore
+        {
+            // Received an older checkpoint, trace back from current checkpoint
+            // to the same height of the received checkpoint to verify
+            // 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->GetBlockHash() != hashCheckpoint)
+            {
+                hashInvalidCheckpoint = hashCheckpoint;
+                return error("ValidateSyncCheckpoint: new sync-checkpoint %s is conflicting with current sync-checkpoint %s", hashCheckpoint.ToString().c_str(), hashSyncCheckpoint.ToString().c_str());
+            }
+            return false; // ignore older checkpoint
+        }
 
+        // Received checkpoint should be a descendant block of the current
+        // checkpoint. Trace back to the same height of current checkpoint
+        // to verify.
         CBlockIndex* pindex = pindexCheckpointRecv;
         while (pindex->nHeight > pindexSyncCheckpoint->nHeight)
             if (!(pindex = pindex->pprev))
-                return error("ValidateSyncCheckpoint: pprev null - block index structure failure");
+                return error("ValidateSyncCheckpoint: pprev2 null - block index structure failure");
         if (pindex->GetBlockHash() != hashSyncCheckpoint)
+        {
+            hashInvalidCheckpoint = hashCheckpoint;
             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()
     {
         CRITICAL_BLOCK(cs_hashSyncCheckpoint)
+        {
             if ((!checkpointMessagePending.IsNull()) && mapBlockIndex.count(checkpointMessagePending.hashCheckpoint))
             {
                 if (!ValidateSyncCheckpoint(checkpointMessagePending.hashCheckpoint))
@@ -96,8 +119,26 @@ namespace Checkpoints
                 }
 
                 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());
+                    }
+                }
+
+                txdb.TxnBegin();
                 if (!txdb.WriteSyncCheckpoint(checkpointMessagePending.hashCheckpoint))
+                {
+                    txdb.TxnAbort();
                     return error("AcceptPendingSyncCheckpoint() : failed to write to db sync checkpoint %s\n", checkpointMessagePending.hashCheckpoint.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;
@@ -105,10 +146,12 @@ namespace Checkpoints
                 checkpointMessagePending.SetNull();
                 printf("AcceptPendingSyncCheckpoint : sync-checkpoint at %s\n", hashSyncCheckpoint.ToString().c_str());
                 // relay the checkpoint
-                BOOST_FOREACH(CNode* pnode, vNodes)
-                    checkpointMessage.RelayTo(pnode);
+                CRITICAL_BLOCK(cs_hashSyncCheckpoint)
+                    BOOST_FOREACH(CNode* pnode, vNodes)
+                        checkpointMessage.RelayTo(pnode);
                 return true;
             }
+        }
 
         return false;
     }
@@ -152,6 +195,12 @@ namespace Checkpoints
         return true;
     }
 
+    bool IsPendingSyncCheckpoint(uint256 hashBlock)
+    {
+        CRITICAL_BLOCK(cs_hashSyncCheckpoint)
+            return ((!checkpointMessagePending.IsNull()) && hashBlock == checkpointMessagePending.hashCheckpoint);
+    }
+
     // ppcoin: automatic checkpoint (represented by height of checkpoint)
     int nAutoCheckpoint = 0;
     int nBranchPoint = 0;    // branch point to alternative branch
@@ -280,26 +329,51 @@ bool CSyncCheckpoint::ProcessSyncCheckpoint(CNode* pfrom)
     {
         if (!mapBlockIndex.count(hashCheckpoint))
         {
-            // We haven't accepted this block, keep the checkpoint as pending
+            // 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());
+            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;
         }
+
         if (!Checkpoints::ValidateSyncCheckpoint(hashCheckpoint))
             return false;
 
         CTxDB txdb;
-        if (!txdb.WriteSyncCheckpoint(this->hashCheckpoint))
-            return error("ProcessSyncCheckpoint() : failed to write to db sync checkpoint %s\n", this->hashCheckpoint.ToString().c_str());
+        CBlockIndex* pindexCheckpoint = mapBlockIndex[hashCheckpoint];
+        if (!pindexCheckpoint->IsInMainChain())
+        {
+            // 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());
+            }
+        }
+
+        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();
 
-        Checkpoints::hashSyncCheckpoint = this->hashCheckpoint;
+        Checkpoints::hashSyncCheckpoint = hashCheckpoint;
         Checkpoints::checkpointMessage = *this;
         Checkpoints::checkpointMessagePending.SetNull();
-        printf("ProcessSyncCheckpoint : sync-checkpoint at %s\n", Checkpoints::hashSyncCheckpoint.ToString().c_str());
+        printf("ProcessSyncCheckpoint: sync-checkpoint at %s\n", hashCheckpoint.ToString().c_str());
     }
     return true;
 }