You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

checkpoints.cpp 6.3KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162
  1. // Copyright (c) 2009-2013 The Bitcoin developers
  2. // Distributed under the MIT/X11 software license, see the accompanying
  3. // file COPYING or http://www.opensource.org/licenses/mit-license.php.
  4. #include "checkpoints.h"
  5. #include "main.h"
  6. #include "uint256.h"
  7. #include <stdint.h>
  8. #include <boost/assign/list_of.hpp> // for 'map_list_of()'
  9. #include <boost/foreach.hpp>
  10. namespace Checkpoints
  11. {
  12. typedef std::map<int, uint256> MapCheckpoints;
  13. // How many times we expect transactions after the last checkpoint to
  14. // be slower. This number is a compromise, as it can't be accurate for
  15. // every system. When reindexing from a fast disk with a slow CPU, it
  16. // can be up to 20, while when downloading from a slow network with a
  17. // fast multicore CPU, it won't be much higher than 1.
  18. static const double fSigcheckVerificationFactor = 5.0;
  19. struct CCheckpointData {
  20. const MapCheckpoints *mapCheckpoints;
  21. int64_t nTimeLastCheckpoint;
  22. int64_t nTransactionsLastCheckpoint;
  23. double fTransactionsPerDay;
  24. };
  25. bool fEnabled = true;
  26. // What makes a good checkpoint block?
  27. // + Is surrounded by blocks with reasonable timestamps
  28. // (no blocks before with a timestamp after, none after with
  29. // timestamp before)
  30. // + Contains no strange transactions
  31. static MapCheckpoints mapCheckpoints =
  32. boost::assign::map_list_of
  33. ( 11111, uint256("0x0000000069e244f73d78e8fd29ba2fd2ed618bd6fa2ee92559f542fdb26e7c1d"))
  34. ( 33333, uint256("0x000000002dd5588a74784eaa7ab0507a18ad16a236e7b1ce69f00d7ddfb5d0a6"))
  35. ( 74000, uint256("0x0000000000573993a3c9e41ce34471c079dcf5f52a0e824a81e7f953b8661a20"))
  36. (105000, uint256("0x00000000000291ce28027faea320c8d2b054b2e0fe44a773f3eefb151d6bdc97"))
  37. (134444, uint256("0x00000000000005b12ffd4cd315cd34ffd4a594f430ac814c91184a0d42d2b0fe"))
  38. (168000, uint256("0x000000000000099e61ea72015e79632f216fe6cb33d7899acb35b75c8303b763"))
  39. (193000, uint256("0x000000000000059f452a5f7340de6682a977387c17010ff6e6c3bd83ca8b1317"))
  40. (210000, uint256("0x000000000000048b95347e83192f69cf0366076336c639f9b7228e9ba171342e"))
  41. (216116, uint256("0x00000000000001b4f4b433e81ee46494af945cf96014816a4e2370f11b23df4e"))
  42. (225430, uint256("0x00000000000001c108384350f74090433e7fcf79a606b8e797f065b130575932"))
  43. (250000, uint256("0x000000000000003887df1f29024b06fc2200b55f8af8f35453d7be294df2d214"))
  44. ;
  45. static const CCheckpointData data = {
  46. &mapCheckpoints,
  47. 1375533383, // * UNIX timestamp of last checkpoint block
  48. 21491097, // * total number of transactions between genesis and last checkpoint
  49. // (the tx=... number in the SetBestChain debug.log lines)
  50. 60000.0 // * estimated number of transactions per day after checkpoint
  51. };
  52. static MapCheckpoints mapCheckpointsTestnet =
  53. boost::assign::map_list_of
  54. ( 546, uint256("000000002a936ca763904c3c35fce2f3556c559c0214345d31b1bcebf76acb70"))
  55. ;
  56. static const CCheckpointData dataTestnet = {
  57. &mapCheckpointsTestnet,
  58. 1338180505,
  59. 16341,
  60. 300
  61. };
  62. static MapCheckpoints mapCheckpointsRegtest =
  63. boost::assign::map_list_of
  64. ( 0, uint256("0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"))
  65. ;
  66. static const CCheckpointData dataRegtest = {
  67. &mapCheckpointsRegtest,
  68. 0,
  69. 0,
  70. 0
  71. };
  72. const CCheckpointData &Checkpoints() {
  73. if (Params().NetworkID() == CChainParams::TESTNET)
  74. return dataTestnet;
  75. else if (Params().NetworkID() == CChainParams::MAIN)
  76. return data;
  77. else
  78. return dataRegtest;
  79. }
  80. bool CheckBlock(int nHeight, const uint256& hash)
  81. {
  82. if (!fEnabled)
  83. return true;
  84. const MapCheckpoints& checkpoints = *Checkpoints().mapCheckpoints;
  85. MapCheckpoints::const_iterator i = checkpoints.find(nHeight);
  86. if (i == checkpoints.end()) return true;
  87. return hash == i->second;
  88. }
  89. // Guess how far we are in the verification process at the given block index
  90. double GuessVerificationProgress(CBlockIndex *pindex) {
  91. if (pindex==NULL)
  92. return 0.0;
  93. int64_t nNow = time(NULL);
  94. double fWorkBefore = 0.0; // Amount of work done before pindex
  95. double fWorkAfter = 0.0; // Amount of work left after pindex (estimated)
  96. // Work is defined as: 1.0 per transaction before the last checkoint, and
  97. // fSigcheckVerificationFactor per transaction after.
  98. const CCheckpointData &data = Checkpoints();
  99. if (pindex->nChainTx <= data.nTransactionsLastCheckpoint) {
  100. double nCheapBefore = pindex->nChainTx;
  101. double nCheapAfter = data.nTransactionsLastCheckpoint - pindex->nChainTx;
  102. double nExpensiveAfter = (nNow - data.nTimeLastCheckpoint)/86400.0*data.fTransactionsPerDay;
  103. fWorkBefore = nCheapBefore;
  104. fWorkAfter = nCheapAfter + nExpensiveAfter*fSigcheckVerificationFactor;
  105. } else {
  106. double nCheapBefore = data.nTransactionsLastCheckpoint;
  107. double nExpensiveBefore = pindex->nChainTx - data.nTransactionsLastCheckpoint;
  108. double nExpensiveAfter = (nNow - pindex->nTime)/86400.0*data.fTransactionsPerDay;
  109. fWorkBefore = nCheapBefore + nExpensiveBefore*fSigcheckVerificationFactor;
  110. fWorkAfter = nExpensiveAfter*fSigcheckVerificationFactor;
  111. }
  112. return fWorkBefore / (fWorkBefore + fWorkAfter);
  113. }
  114. int GetTotalBlocksEstimate()
  115. {
  116. if (!fEnabled)
  117. return 0;
  118. const MapCheckpoints& checkpoints = *Checkpoints().mapCheckpoints;
  119. return checkpoints.rbegin()->first;
  120. }
  121. CBlockIndex* GetLastCheckpoint(const std::map<uint256, CBlockIndex*>& mapBlockIndex)
  122. {
  123. if (!fEnabled)
  124. return NULL;
  125. const MapCheckpoints& checkpoints = *Checkpoints().mapCheckpoints;
  126. BOOST_REVERSE_FOREACH(const MapCheckpoints::value_type& i, checkpoints)
  127. {
  128. const uint256& hash = i.second;
  129. std::map<uint256, CBlockIndex*>::const_iterator t = mapBlockIndex.find(hash);
  130. if (t != mapBlockIndex.end())
  131. return t->second;
  132. }
  133. return NULL;
  134. }
  135. }