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.5KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165
  1. // Copyright (c) 2009-2014 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. typedef std::map<int, uint256> MapCheckpoints;
  12. // How many times we expect transactions after the last checkpoint to
  13. // be slower. This number is a compromise, as it can't be accurate for
  14. // every system. When reindexing from a fast disk with a slow CPU, it
  15. // can be up to 20, while when downloading from a slow network with a
  16. // fast multicore CPU, it won't be much higher than 1.
  17. static const double SIGCHECK_VERIFICATION_FACTOR = 5.0;
  18. struct CCheckpointData {
  19. const MapCheckpoints *mapCheckpoints;
  20. int64_t nTimeLastCheckpoint;
  21. int64_t nTransactionsLastCheckpoint;
  22. double fTransactionsPerDay;
  23. };
  24. bool fEnabled = true;
  25. // What makes a good checkpoint block?
  26. // + Is surrounded by blocks with reasonable timestamps
  27. // (no blocks before with a timestamp after, none after with
  28. // timestamp before)
  29. // + Contains no strange transactions
  30. static MapCheckpoints mapCheckpoints =
  31. boost::assign::map_list_of
  32. ( 11111, uint256("0x0000000069e244f73d78e8fd29ba2fd2ed618bd6fa2ee92559f542fdb26e7c1d"))
  33. ( 33333, uint256("0x000000002dd5588a74784eaa7ab0507a18ad16a236e7b1ce69f00d7ddfb5d0a6"))
  34. ( 74000, uint256("0x0000000000573993a3c9e41ce34471c079dcf5f52a0e824a81e7f953b8661a20"))
  35. (105000, uint256("0x00000000000291ce28027faea320c8d2b054b2e0fe44a773f3eefb151d6bdc97"))
  36. (134444, uint256("0x00000000000005b12ffd4cd315cd34ffd4a594f430ac814c91184a0d42d2b0fe"))
  37. (168000, uint256("0x000000000000099e61ea72015e79632f216fe6cb33d7899acb35b75c8303b763"))
  38. (193000, uint256("0x000000000000059f452a5f7340de6682a977387c17010ff6e6c3bd83ca8b1317"))
  39. (210000, uint256("0x000000000000048b95347e83192f69cf0366076336c639f9b7228e9ba171342e"))
  40. (216116, uint256("0x00000000000001b4f4b433e81ee46494af945cf96014816a4e2370f11b23df4e"))
  41. (225430, uint256("0x00000000000001c108384350f74090433e7fcf79a606b8e797f065b130575932"))
  42. (250000, uint256("0x000000000000003887df1f29024b06fc2200b55f8af8f35453d7be294df2d214"))
  43. (279000, uint256("0x0000000000000001ae8c72a0b0c301f67e3afca10e819efa9041e458e9bd7e40"))
  44. ;
  45. static const CCheckpointData data = {
  46. &mapCheckpoints,
  47. 1389047471, // * UNIX timestamp of last checkpoint block
  48. 30549816, // * 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. 1337966069,
  59. 1488,
  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() == CBaseChainParams::TESTNET)
  74. return dataTestnet;
  75. else if (Params().NetworkID() == CBaseChainParams::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, bool fSigchecks) {
  91. if (pindex==NULL)
  92. return 0.0;
  93. int64_t nNow = time(NULL);
  94. double fSigcheckVerificationFactor = fSigchecks ? SIGCHECK_VERIFICATION_FACTOR : 1.0;
  95. double fWorkBefore = 0.0; // Amount of work done before pindex
  96. double fWorkAfter = 0.0; // Amount of work left after pindex (estimated)
  97. // Work is defined as: 1.0 per transaction before the last checkpoint, and
  98. // fSigcheckVerificationFactor per transaction after.
  99. const CCheckpointData &data = Checkpoints();
  100. if (pindex->nChainTx <= data.nTransactionsLastCheckpoint) {
  101. double nCheapBefore = pindex->nChainTx;
  102. double nCheapAfter = data.nTransactionsLastCheckpoint - pindex->nChainTx;
  103. double nExpensiveAfter = (nNow - data.nTimeLastCheckpoint)/86400.0*data.fTransactionsPerDay;
  104. fWorkBefore = nCheapBefore;
  105. fWorkAfter = nCheapAfter + nExpensiveAfter*fSigcheckVerificationFactor;
  106. } else {
  107. double nCheapBefore = data.nTransactionsLastCheckpoint;
  108. double nExpensiveBefore = pindex->nChainTx - data.nTransactionsLastCheckpoint;
  109. double nExpensiveAfter = (nNow - pindex->nTime)/86400.0*data.fTransactionsPerDay;
  110. fWorkBefore = nCheapBefore + nExpensiveBefore*fSigcheckVerificationFactor;
  111. fWorkAfter = nExpensiveAfter*fSigcheckVerificationFactor;
  112. }
  113. return fWorkBefore / (fWorkBefore + fWorkAfter);
  114. }
  115. int GetTotalBlocksEstimate()
  116. {
  117. if (!fEnabled)
  118. return 0;
  119. const MapCheckpoints& checkpoints = *Checkpoints().mapCheckpoints;
  120. return checkpoints.rbegin()->first;
  121. }
  122. CBlockIndex* GetLastCheckpoint(const std::map<uint256, CBlockIndex*>& mapBlockIndex)
  123. {
  124. if (!fEnabled)
  125. return NULL;
  126. const MapCheckpoints& checkpoints = *Checkpoints().mapCheckpoints;
  127. BOOST_REVERSE_FOREACH(const MapCheckpoints::value_type& i, checkpoints)
  128. {
  129. const uint256& hash = i.second;
  130. std::map<uint256, CBlockIndex*>::const_iterator t = mapBlockIndex.find(hash);
  131. if (t != mapBlockIndex.end())
  132. return t->second;
  133. }
  134. return NULL;
  135. }
  136. } // namespace Checkpoints