// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-#include <boost/assign/list_of.hpp> // for 'map_list_of()'
-#include <boost/foreach.hpp>
+#include <algorithm>
#include "checkpoints.h"
-#include "db.h"
+#include "txdb.h"
#include "main.h"
#include "uint256.h"
-namespace Checkpoints
-{
- struct Checkpoint
- {
- uint256 hashCheckPoint;
- unsigned int nTime;
- };
+using namespace std;
- typedef std::map<int, Checkpoint> MapCheckpoints;
+extern unsigned int nStakeMinAge;
- Checkpoint initCheckpoint(uint256 hashCheckPoint, unsigned int nTime)
- {
- Checkpoint item;
- item.hashCheckPoint = hashCheckPoint;
- item.nTime = nTime;
-
- return item;
- }
+namespace Checkpoints
+{
+ typedef map<int, pair<uint256, unsigned int> > MapCheckpoints;
+ typedef list<uint256> ListBannedBlocks;
//
// What makes a good checkpoint block?
// + Contains no strange transactions
//
static MapCheckpoints mapCheckpoints =
- boost::assign::map_list_of
- ( 0, initCheckpoint(hashGenesisBlock, 1360105017) )
- ( 9690, initCheckpoint(uint256("0x00000000026561450859c46868099e0df6068a538f038cb18988fd8d47dcdaf5"), 1362791423) )
- ( 13560, initCheckpoint(uint256("0xa1591a0fcbf11f282d671581edb9f0aadcd06fee69761081e0a3245914c13729"), 1364674052) )
- ( 37092, initCheckpoint(uint256("0x0000000000a38c2f98556f46793b453e92d8fab2d31c0b93fd08bcf78e56099d"), 1376677203) )
- ;
+ {
+ { 0, { hashGenesisBlock, 1360105017 } },
+ { 13560, { uint256("0xa1591a0fcbf11f282d671581edb9f0aadcd06fee69761081e0a3245914c13729"), 1364674052 } },
+ { 143990, { uint256("0x00000000001ff5c3940a9f73ad4a990f64955179bde0f743c76dbf0031429efc"), 1418953493 } },
+ { 149000, { uint256("0x7a24acfcadcf43054e7f7d9f273522c0dfc5791ba4006e0273e7521a8d36c525"), 1420872125 } },
+ { 160000, { uint256("0x000000000001cb1133043d38d077c0e93f66c8b2566779f10f182137d1e34a68"), 1425150237 } },
+ { 200000, { uint256("0x0000000000029f8bbf66e6ea6f3e5db55009404aae0fe395a53dd33142b2bff2"), 1441127233 } },
+ { 221047, { uint256("0xa28aef712e7aa0c285bfe29351ca21ed416689139e3063ef770fc826a8b9e9da"), 1449431646 } },
+ { 243100, { uint256("0x000000000006522d1ebc0734cb0e6b83f5d4da0c3cbc72bd91b82016f611c4f0"), 1458215793 } },
+ };
+
+ static ListBannedBlocks listBanned =
+ {
+ // Invalid block #221047 with future timestamp of 2016/02/23 09:24:17 UTC
+ uint256("0x46223e5432ceffe650d5729b4bb8479dcdf0ca1e534fa8e69382dc87b42ea94b")
+ };
// TestNet has no checkpoints
static MapCheckpoints mapCheckpointsTestnet =
- boost::assign::map_list_of
- ( 0, initCheckpoint(hashGenesisBlockTestNet, 1360105017) )
- ;
+ {
+ { 0, { hashGenesisBlockTestNet, 1360105017 } }
+ };
bool CheckHardened(int nHeight, const uint256& hash)
{
- MapCheckpoints& checkpoints = (fTestNet ? mapCheckpointsTestnet : mapCheckpoints);
+ auto& checkpoints = (fTestNet ? mapCheckpointsTestnet : mapCheckpoints);
- MapCheckpoints::const_iterator i = checkpoints.find(nHeight);
+ auto i = checkpoints.find(nHeight);
if (i == checkpoints.end()) return true;
- return hash == i->second.hashCheckPoint;
+ return hash == i->second.first;
+ }
+
+ bool CheckBanned(const uint256 &nHash)
+ {
+ if (fTestNet) // Testnet has no banned blocks
+ return true;
+ auto it = find(listBanned.begin(), listBanned.end(), nHash);
+ return it == listBanned.end();
}
int GetTotalBlocksEstimate()
{
- MapCheckpoints& checkpoints = (fTestNet ? mapCheckpointsTestnet : mapCheckpoints);
+ auto& checkpoints = (fTestNet ? mapCheckpointsTestnet : mapCheckpoints);
return checkpoints.rbegin()->first;
}
- int GetLastCheckpointTime()
+ unsigned int GetLastCheckpointTime()
{
- MapCheckpoints& checkpoints = (fTestNet ? mapCheckpointsTestnet : mapCheckpoints);
+ auto& checkpoints = (fTestNet ? mapCheckpointsTestnet : mapCheckpoints);
- return checkpoints.rbegin()->second.nTime;
+ return checkpoints.rbegin()->second.second;
}
- CBlockIndex* GetLastCheckpoint(const std::map<uint256, CBlockIndex*>& mapBlockIndex)
+ CBlockIndex* GetLastCheckpoint(const map<uint256, CBlockIndex*>& mapBlockIndex)
{
- MapCheckpoints& checkpoints = (fTestNet ? mapCheckpointsTestnet : mapCheckpoints);
+ auto& checkpoints = (fTestNet ? mapCheckpointsTestnet : mapCheckpoints);
- BOOST_REVERSE_FOREACH(const MapCheckpoints::value_type& i, checkpoints)
+ for(auto it = checkpoints.rbegin(); it != checkpoints.rend(); ++it)
{
- const uint256& hash = i.second.hashCheckPoint;
- std::map<uint256, CBlockIndex*>::const_iterator t = mapBlockIndex.find(hash);
+ auto& hash = it->second.first;
+ auto t = mapBlockIndex.find(hash);
if (t != mapBlockIndex.end())
return t->second;
}
}
// ppcoin: only descendant of current sync-checkpoint is allowed
- bool ValidateSyncCheckpoint(uint256 hashCheckpoint)
+ bool ValidateSyncCheckpoint(const uint256 &hashCheckpoint)
{
if (!mapBlockIndex.count(hashSyncCheckpoint))
return error("ValidateSyncCheckpoint: block index missing for current sync-checkpoint %s", hashSyncCheckpoint.ToString().c_str());
if (!mapBlockIndex.count(hashCheckpoint))
return error("ValidateSyncCheckpoint: block index missing for received sync-checkpoint %s", hashCheckpoint.ToString().c_str());
- CBlockIndex* pindexSyncCheckpoint = mapBlockIndex[hashSyncCheckpoint];
- CBlockIndex* pindexCheckpointRecv = mapBlockIndex[hashCheckpoint];
+ auto pindexSyncCheckpoint = mapBlockIndex[hashSyncCheckpoint];
+ auto pindexCheckpointRecv = mapBlockIndex[hashCheckpoint];
if (pindexCheckpointRecv->nHeight <= pindexSyncCheckpoint->nHeight)
{
// 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;
+ auto pindex = pindexSyncCheckpoint;
while (pindex->nHeight > pindexCheckpointRecv->nHeight)
- if (!(pindex = pindex->pprev))
- return error("ValidateSyncCheckpoint: pprev1 null - block index structure failure");
+ if ((pindex = pindex->pprev) == NULL)
+ return error("ValidateSyncCheckpoint: pprev null - block index structure failure");
if (pindex->GetBlockHash() != hashCheckpoint)
{
hashInvalidCheckpoint = hashCheckpoint;
// 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;
+ auto pindex = pindexCheckpointRecv;
while (pindex->nHeight > pindexSyncCheckpoint->nHeight)
- if (!(pindex = pindex->pprev))
+ if ((pindex = pindex->pprev) == NULL)
return error("ValidateSyncCheckpoint: pprev2 null - block index structure failure");
if (pindex->GetBlockHash() != hashSyncCheckpoint)
{
}
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;
}
CTxDB txdb;
- CBlockIndex* pindexCheckpoint = mapBlockIndex[hashPendingCheckpoint];
+ auto pindexCheckpoint = mapBlockIndex[hashPendingCheckpoint];
if (!pindexCheckpoint->IsInMainChain())
{
CBlock block;
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;
// relay the checkpoint
if (!checkpointMessage.IsNull())
{
- BOOST_FOREACH(CNode* pnode, vNodes)
- checkpointMessage.RelayTo(pnode);
+ for (auto it = vNodes.begin(); it != vNodes.end(); ++it)
+ checkpointMessage.RelayTo(*it);
}
return true;
}
// 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 + std::min(6, nCoinbaseMaturity - 20) <= pindexBest->nHeight))
- pindex = pindex->pnext;
+ auto 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();
}
LOCK(cs_hashSyncCheckpoint);
// sync-checkpoint should always be accepted block
assert(mapBlockIndex.count(hashSyncCheckpoint));
- const CBlockIndex* pindexSync = mapBlockIndex[hashSyncCheckpoint];
+ auto pindexSync = mapBlockIndex[hashSyncCheckpoint];
if (nHeight > pindexSync->nHeight)
{
// trace back to same height as sync-checkpoint
- const CBlockIndex* pindex = pindexPrev;
+ auto pindex = pindexPrev;
while (pindex->nHeight > pindexSync->nHeight)
- if (!(pindex = pindex->pprev))
+ if ((pindex = pindex->pprev) == NULL)
return error("CheckSync: pprev null - block index structure failure");
if (pindex->nHeight < pindexSync->nHeight || pindex->GetBlockHash() != hashSyncCheckpoint)
return false; // only descendant of sync-checkpoint can pass check
return true;
}
- bool WantedByPendingSyncCheckpoint(uint256 hashBlock)
+ bool WantedByPendingSyncCheckpoint(const uint256 &hashBlock)
{
LOCK(cs_hashSyncCheckpoint);
if (hashPendingCheckpoint == 0)
bool ResetSyncCheckpoint()
{
LOCK(cs_hashSyncCheckpoint);
- const uint256& hash = mapCheckpoints.rbegin()->second.hashCheckPoint;
+ const auto& hash = mapCheckpoints.rbegin()->second.first;
if (mapBlockIndex.count(hash) && !mapBlockIndex[hash]->IsInMainChain())
{
// checkpoint block accepted but not yet in main chain
{
return error("ResetSyncCheckpoint: SetBestChain failed for hardened checkpoint %s", hash.ToString().c_str());
}
+
+#ifndef USE_LEVELDB
txdb.Close();
+#endif
+
}
else if(!mapBlockIndex.count(hash))
{
printf("ResetSyncCheckpoint: pending for sync-checkpoint %s\n", hashPendingCheckpoint.ToString().c_str());
}
- BOOST_REVERSE_FOREACH(const MapCheckpoints::value_type& i, mapCheckpoints)
+ for(auto it = mapCheckpoints.rbegin(); it != mapCheckpoints.rend(); ++it)
{
- const uint256& hash = i.second.hashCheckPoint;
+ const auto& hash = it->second.first;
if (mapBlockIndex.count(hash) && mapBlockIndex[hash]->IsInMainChain())
{
if (!WriteSyncCheckpoint(hash))
pfrom->AskFor(CInv(MSG_BLOCK, hashPendingCheckpoint));
}
- bool SetCheckpointPrivKey(std::string strPrivKey)
+ bool SetCheckpointPrivKey(const 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());
+ checkpoint.vchMsg = vector<unsigned char>(sMsg.begin(), sMsg.end());
- std::vector<unsigned char> vchPrivKey = ParseHex(strPrivKey);
+ auto 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 true;
}
- bool SendSyncCheckpoint(uint256 hashCheckpoint)
+ bool SendSyncCheckpoint(const uint256 &hashCheckpoint)
{
CSyncCheckpoint checkpoint;
checkpoint.hashCheckpoint = hashCheckpoint;
CDataStream sMsg(SER_NETWORK, PROTOCOL_VERSION);
sMsg << (CUnsignedSyncCheckpoint)checkpoint;
- checkpoint.vchMsg = std::vector<unsigned char>(sMsg.begin(), sMsg.end());
+ checkpoint.vchMsg = vector<unsigned char>(sMsg.begin(), sMsg.end());
if (CSyncCheckpoint::strMasterPrivKey.empty())
return error("SendSyncCheckpoint: Checkpoint master key unavailable.");
- std::vector<unsigned char> vchPrivKey = ParseHex(CSyncCheckpoint::strMasterPrivKey);
+ auto vchPrivKey = ParseHex(CSyncCheckpoint::strMasterPrivKey);
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))
// Relay checkpoint
{
LOCK(cs_vNodes);
- BOOST_FOREACH(CNode* pnode, vNodes)
+ for(auto pnode : vNodes)
checkpoint.RelayTo(pnode);
}
return true;
LOCK(cs_hashSyncCheckpoint);
// sync-checkpoint should always be accepted block
assert(mapBlockIndex.count(hashSyncCheckpoint));
- const CBlockIndex* pindexSync = mapBlockIndex[hashSyncCheckpoint];
+ const auto pindexSync = mapBlockIndex[hashSyncCheckpoint];
return (nBestHeight >= pindexSync->nHeight + nCoinbaseMaturity ||
pindexSync->GetBlockTime() + nStakeMinAge < GetAdjustedTime());
}
+}
- // Is the sync-checkpoint too old?
- bool IsSyncCheckpointTooOld(unsigned int nSeconds)
- {
- LOCK(cs_hashSyncCheckpoint);
- // sync-checkpoint should always be accepted block
- assert(mapBlockIndex.count(hashSyncCheckpoint));
- const CBlockIndex* pindexSync = mapBlockIndex[hashSyncCheckpoint];
- return (pindexSync->GetBlockTime() + nSeconds < GetAdjustedTime());
- }
+void CUnsignedSyncCheckpoint::SetNull()
+{
+ nVersion = 1;
+ hashCheckpoint = 0;
+}
+
+std::string CUnsignedSyncCheckpoint::ToString() const
+{
+ return strprintf(
+ "CSyncCheckpoint(\n"
+ " nVersion = %" PRId32 "\n"
+ " hashCheckpoint = %s\n"
+ ")\n",
+ nVersion,
+ hashCheckpoint.ToString().c_str());
}
// ppcoin: sync-checkpoint master key
-const std::string CSyncCheckpoint::strMasterPubKey = "04a51b735f816de4ec3f891d5b38bbc91e1f7245c7c08d17990760b86b4d8fc3910a850ffecf73bfa8886f01739a0c4c4322201282d07b6e48ce931cc92af94850";
+const string CSyncCheckpoint::strMasterPubKey = "04a51b735f816de4ec3f891d5b38bbc91e1f7245c7c08d17990760b86b4d8fc3910a850ffecf73bfa8886f01739a0c4c4322201282d07b6e48ce931cc92af94850";
+
+string CSyncCheckpoint::strMasterPrivKey = "";
-std::string CSyncCheckpoint::strMasterPrivKey = "";
+CSyncCheckpoint::CSyncCheckpoint()
+{
+ SetNull();
+}
+
+void CSyncCheckpoint::SetNull()
+{
+ CUnsignedSyncCheckpoint::SetNull();
+ vchMsg.clear();
+ vchSig.clear();
+}
+
+bool CSyncCheckpoint::IsNull() const
+{
+ return (hashCheckpoint == 0);
+}
+
+uint256 CSyncCheckpoint::GetHash() const
+{
+ return SerializeHash(*this);
+}
+
+bool CSyncCheckpoint::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;
+}
// ppcoin: verify signature of sync-checkpoint message
bool CSyncCheckpoint::CheckSignature()
{
- CKey key;
- if (!key.SetPubKey(ParseHex(CSyncCheckpoint::strMasterPubKey)))
- return error("CSyncCheckpoint::CheckSignature() : SetPubKey failed");
+ CPubKey key(ParseHex(CSyncCheckpoint::strMasterPubKey));
if (!key.Verify(Hash(vchMsg.begin(), vchMsg.end()), vchSig))
return error("CSyncCheckpoint::CheckSignature() : verify signature failed");
return true;
}
-// ppcoin: process synchronized checkpoint
+// process synchronized checkpoint
bool CSyncCheckpoint::ProcessSyncCheckpoint(CNode* pfrom)
{
if (!CheckSignature())
return false;
CTxDB txdb;
- CBlockIndex* pindexCheckpoint = mapBlockIndex[hashCheckpoint];
+ auto pindexCheckpoint = mapBlockIndex[hashCheckpoint];
if (!pindexCheckpoint->IsInMainChain())
{
// checkpoint chain received but not yet main chain
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());
git://git.novaco.in / novacoin.git / blobdiff