// 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 COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "checkpoints.h"
-#include "db.h"
+#include "txdb.h"
#include "main.h"
#include "uint256.h"
namespace Checkpoints
{
- typedef std::map<int, uint256> MapCheckpoints; // hardened checkpoints
+ typedef std::map<int, std::pair<uint256, unsigned int> > MapCheckpoints;
//
// What makes a good checkpoint block?
//
static MapCheckpoints mapCheckpoints =
boost::assign::map_list_of
- ( 0, hashGenesisBlockOfficial )
- ; // ppcoin: no checkpoint yet; to be created in future releases
+ ( 0, std::make_pair(hashGenesisBlock, 1360105017) )
+ ( 13560, std::make_pair(uint256("0xa1591a0fcbf11f282d671581edb9f0aadcd06fee69761081e0a3245914c13729"), 1364674052) )
+ ( 143990, std::make_pair(uint256("0x00000000001ff5c3940a9f73ad4a990f64955179bde0f743c76dbf0031429efc"), 1418953493) )
+ ( 149000, std::make_pair(uint256("0x7a24acfcadcf43054e7f7d9f273522c0dfc5791ba4006e0273e7521a8d36c525"), 1420872125) )
+ ( 160000, std::make_pair(uint256("0x000000000001cb1133043d38d077c0e93f66c8b2566779f10f182137d1e34a68"), 1425150237) )
+ ( 200000, std::make_pair(uint256("0x0000000000029f8bbf66e6ea6f3e5db55009404aae0fe395a53dd33142b2bff2"), 1441127233) )
+ ( 221047, std::make_pair(uint256("0xa28aef712e7aa0c285bfe29351ca21ed416689139e3063ef770fc826a8b9e9da"), 1449431646) )
+ ;
+
+ // TestNet has no checkpoints
+ static MapCheckpoints mapCheckpointsTestnet =
+ boost::assign::map_list_of
+ ( 0, std::make_pair(hashGenesisBlockTestNet, 1360105017) )
+ ;
bool CheckHardened(int nHeight, const uint256& hash)
{
- if (fTestNet) return true; // Testnet has no checkpoints
+ MapCheckpoints& checkpoints = (fTestNet ? mapCheckpointsTestnet : mapCheckpoints);
- MapCheckpoints::const_iterator i = mapCheckpoints.find(nHeight);
- if (i == mapCheckpoints.end()) return true;
- return hash == i->second;
+ MapCheckpoints::const_iterator i = checkpoints.find(nHeight);
+ if (i == checkpoints.end()) return true;
+ return hash == i->second.first;
}
int GetTotalBlocksEstimate()
{
- if (fTestNet) return 0;
+ MapCheckpoints& checkpoints = (fTestNet ? mapCheckpointsTestnet : mapCheckpoints);
+
+ return checkpoints.rbegin()->first;
+ }
+
+ unsigned int GetLastCheckpointTime()
+ {
+ MapCheckpoints& checkpoints = (fTestNet ? mapCheckpointsTestnet : mapCheckpoints);
- return mapCheckpoints.rbegin()->first;
+ return checkpoints.rbegin()->second.second;
}
CBlockIndex* GetLastCheckpoint(const std::map<uint256, CBlockIndex*>& mapBlockIndex)
{
- if (fTestNet) {
- std::map<uint256, CBlockIndex*>::const_iterator t = mapBlockIndex.find(hashGenesisBlock);
- if (t != mapBlockIndex.end())
- return t->second;
- return NULL;
- }
+ MapCheckpoints& checkpoints = (fTestNet ? mapCheckpointsTestnet : mapCheckpoints);
- BOOST_REVERSE_FOREACH(const MapCheckpoints::value_type& i, mapCheckpoints)
+ BOOST_REVERSE_FOREACH(const MapCheckpoints::value_type& i, checkpoints)
{
- const uint256& hash = i.second;
+ const uint256& hash = i.second.first;
std::map<uint256, CBlockIndex*>::const_iterator t = mapBlockIndex.find(hash);
if (t != mapBlockIndex.end())
return t->second;
CBlockIndex* pindex = pindexSyncCheckpoint;
while (pindex->nHeight > pindexCheckpointRecv->nHeight)
if (!(pindex = pindex->pprev))
- return error("ValidateSyncCheckpoint: pprev1 null - block index structure failure");
+ return error("ValidateSyncCheckpoint: pprev null - block index structure failure");
if (pindex->GetBlockHash() != hashCheckpoint)
{
hashInvalidCheckpoint = hashCheckpoint;
}
if (!txdb.TxnCommit())
return error("WriteSyncCheckpoint(): failed to commit to db sync checkpoint %s", hashCheckpoint.ToString().c_str());
+
+#ifndef USE_LEVELDB
txdb.Close();
+#endif
Checkpoints::hashSyncCheckpoint = hashCheckpoint;
return true;
CBlockIndex* pindexCheckpoint = mapBlockIndex[hashPendingCheckpoint];
if (!pindexCheckpoint->IsInMainChain())
{
- txdb.TxnBegin();
- if (!Reorganize(txdb, pindexCheckpoint))
+ CBlock block;
+ if (!block.ReadFromDisk(pindexCheckpoint))
+ return error("AcceptPendingSyncCheckpoint: ReadFromDisk failed for sync checkpoint %s", hashPendingCheckpoint.ToString().c_str());
+ if (!block.SetBestChain(txdb, pindexCheckpoint))
{
- txdb.TxnAbort();
hashInvalidCheckpoint = hashPendingCheckpoint;
- return error("AcceptPendingSyncCheckpoint: Reorganize failed for sync checkpoint %s", hashPendingCheckpoint.ToString().c_str());
+ return error("AcceptPendingSyncCheckpoint: SetBestChain failed for sync checkpoint %s", hashPendingCheckpoint.ToString().c_str());
}
}
- txdb.Close();
+#ifndef USE_LEVELDB
+ txdb.Close();
+#endif
if (!WriteSyncCheckpoint(hashPendingCheckpoint))
return error("AcceptPendingSyncCheckpoint(): failed to write sync checkpoint %s", hashPendingCheckpoint.ToString().c_str());
hashPendingCheckpoint = 0;
// Automatically select a suitable sync-checkpoint
uint256 AutoSelectSyncCheckpoint()
{
- // Proof-of-work blocks are immediately checkpointed
- // to defend against 51% attack which rejects other miners block
-
- // Select the last proof-of-work block
- const CBlockIndex *pindex = GetLastBlockIndex(pindexBest, false);
- // Search forward for a block within max span and maturity window
- while (pindex->pnext && (pindex->GetBlockTime() + CHECKPOINT_MAX_SPAN <= pindexBest->GetBlockTime() || pindex->nHeight + COINBASE_MATURITY <= pindexBest->nHeight))
- pindex = pindex->pnext;
+ const CBlockIndex *pindex = pindexBest;
+ // Search backward for a block within max span and maturity window
+ while (pindex->pprev && (pindex->GetBlockTime() + CHECKPOINT_MAX_SPAN > pindexBest->GetBlockTime() || pindex->nHeight + 8 > pindexBest->nHeight))
+ pindex = pindex->pprev;
return pindex->GetBlockHash();
}
bool ResetSyncCheckpoint()
{
LOCK(cs_hashSyncCheckpoint);
- const uint256& hash = mapCheckpoints.rbegin()->second;
+ const uint256& hash = mapCheckpoints.rbegin()->second.first;
if (mapBlockIndex.count(hash) && !mapBlockIndex[hash]->IsInMainChain())
{
// checkpoint block accepted but not yet in main chain
- printf("ResetSyncCheckpoint: Reorganize to hardened checkpoint %s\n", hash.ToString().c_str());
+ printf("ResetSyncCheckpoint: SetBestChain to hardened checkpoint %s\n", hash.ToString().c_str());
CTxDB txdb;
- txdb.TxnBegin();
- if (!Reorganize(txdb, mapBlockIndex[hash]))
+ CBlock block;
+ if (!block.ReadFromDisk(mapBlockIndex[hash]))
+ return error("ResetSyncCheckpoint: ReadFromDisk failed for hardened checkpoint %s", hash.ToString().c_str());
+ if (!block.SetBestChain(txdb, mapBlockIndex[hash]))
{
- txdb.TxnAbort();
- return error("ResetSyncCheckpoint: Reorganize failed for hardened checkpoint %s", hash.ToString().c_str());
+ return error("ResetSyncCheckpoint: SetBestChain failed for hardened checkpoint %s", hash.ToString().c_str());
}
+
+#ifndef USE_LEVELDB
txdb.Close();
+#endif
+
}
else if(!mapBlockIndex.count(hash))
{
BOOST_REVERSE_FOREACH(const MapCheckpoints::value_type& i, mapCheckpoints)
{
- const uint256& hash = i.second;
+ const uint256& hash = i.second.first;
if (mapBlockIndex.count(hash) && mapBlockIndex[hash]->IsInMainChain())
{
if (!WriteSyncCheckpoint(hash))
pfrom->AskFor(CInv(MSG_BLOCK, hashPendingCheckpoint));
}
+ bool SetCheckpointPrivKey(std::string strPrivKey)
+ {
+ // Test signing a sync-checkpoint with genesis block
+ CSyncCheckpoint checkpoint;
+ checkpoint.hashCheckpoint = !fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet;
+ CDataStream sMsg(SER_NETWORK, PROTOCOL_VERSION);
+ sMsg << (CUnsignedSyncCheckpoint)checkpoint;
+ checkpoint.vchMsg = std::vector<unsigned char>(sMsg.begin(), sMsg.end());
+
+ std::vector<unsigned char> vchPrivKey = ParseHex(strPrivKey);
+ CKey key;
+ key.SetPrivKey(CPrivKey(vchPrivKey.begin(), vchPrivKey.end())); // if key is not correct openssl may crash
+ if (!key.Sign(Hash(checkpoint.vchMsg.begin(), checkpoint.vchMsg.end()), checkpoint.vchSig))
+ return false;
+
+ // Test signing successful, proceed
+ CSyncCheckpoint::strMasterPrivKey = strPrivKey;
+ return true;
+ }
+
bool SendSyncCheckpoint(uint256 hashCheckpoint)
{
CSyncCheckpoint checkpoint;
return error("SendSyncCheckpoint: Unable to sign checkpoint, check private key?");
if(!checkpoint.ProcessSyncCheckpoint(NULL))
- return error("SendSyncCheckpoint: Failed to process checkpoint.");
+ {
+ printf("WARNING: SendSyncCheckpoint: Failed to process checkpoint.\n");
+ return false;
+ }
+
// Relay checkpoint
{
LOCK(cs_vNodes);
}
return true;
}
+
+ // Is the sync-checkpoint outside maturity window?
+ bool IsMatureSyncCheckpoint()
+ {
+ LOCK(cs_hashSyncCheckpoint);
+ // sync-checkpoint should always be accepted block
+ assert(mapBlockIndex.count(hashSyncCheckpoint));
+ const CBlockIndex* pindexSync = mapBlockIndex[hashSyncCheckpoint];
+ return (nBestHeight >= pindexSync->nHeight + nCoinbaseMaturity ||
+ pindexSync->GetBlockTime() + nStakeMinAge < GetAdjustedTime());
+ }
}
// ppcoin: sync-checkpoint master key
-const std::string CSyncCheckpoint::strMasterPubKey = "0424f20205e5da98ba632bbd278a11a6499585f62bfb2c782377ef59f0251daab8085fc31471bcb8180bc75ed0fa41bb50c7c084511d54015a3a5241d645c7268a";
+const std::string CSyncCheckpoint::strMasterPubKey = "04a51b735f816de4ec3f891d5b38bbc91e1f7245c7c08d17990760b86b4d8fc3910a850ffecf73bfa8886f01739a0c4c4322201282d07b6e48ce931cc92af94850";
std::string CSyncCheckpoint::strMasterPrivKey = "";
return true;
}
-// ppcoin: process synchronized checkpoint
+// process synchronized checkpoint
bool CSyncCheckpoint::ProcessSyncCheckpoint(CNode* pfrom)
{
if (!CheckSignature())
if (!pindexCheckpoint->IsInMainChain())
{
// checkpoint chain received but not yet main chain
- txdb.TxnBegin();
- if (!Reorganize(txdb, pindexCheckpoint))
+ CBlock block;
+ if (!block.ReadFromDisk(pindexCheckpoint))
+ return error("ProcessSyncCheckpoint: ReadFromDisk failed for sync checkpoint %s", hashCheckpoint.ToString().c_str());
+ if (!block.SetBestChain(txdb, pindexCheckpoint))
{
- txdb.TxnAbort();
Checkpoints::hashInvalidCheckpoint = hashCheckpoint;
- return error("ProcessSyncCheckpoint: Reorganize failed for sync checkpoint %s", hashCheckpoint.ToString().c_str());
+ return error("ProcessSyncCheckpoint: SetBestChain failed for sync checkpoint %s", hashCheckpoint.ToString().c_str());
}
}
+
+#ifndef USE_LEVELDB
txdb.Close();
+#endif
if (!Checkpoints::WriteSyncCheckpoint(hashCheckpoint))
return error("ProcessSyncCheckpoint(): failed to write sync checkpoint %s", hashCheckpoint.ToString().c_str());