src/pow.cpp

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2016 The Bitcoin Core developers
   3 // Distributed under the MIT software license, see the accompanying
   4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   5
   6 #include "pow.h"
   7
   8 #include "arith_uint256.h"
   9 #include "chain.h"
  10 #include "primitives/block.h"
  11 #include "uint256.h"
  12
  13 unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params& params)
  14 {
  15     assert(pindexLast != NULL);
  16     unsigned int nProofOfWorkLimit = UintToArith256(params.powLimit).GetCompact();
  17
  18     // Only change once per difficulty adjustment interval
  19     if ((pindexLast->nHeight+1) % params.DifficultyAdjustmentInterval() != 0)
  20     {
  21         if (params.fPowAllowMinDifficultyBlocks)
  22         {
  23             // Special difficulty rule for testnet:
  24             // If the new block's timestamp is more than 2* 10 minutes
  25             // then allow mining of a min-difficulty block.
  26             if (pblock->GetBlockTime() > pindexLast->GetBlockTime() + params.nPowTargetSpacing*2)
  27                 return nProofOfWorkLimit;
  28             else
  29             {
  30                 // Return the last non-special-min-difficulty-rules-block
  31                 const CBlockIndex* pindex = pindexLast;
  32                 while (pindex->pprev && pindex->nHeight % params.DifficultyAdjustmentInterval() != 0 && pindex->nBits == nProofOfWorkLimit)
  33                     pindex = pindex->pprev;
  34                 return pindex->nBits;
  35             }
  36         }
  37         return pindexLast->nBits;
  38     }
  39
  40     // Go back by what we want to be 14 days worth of blocks
  41     int nHeightFirst = pindexLast->nHeight - (params.DifficultyAdjustmentInterval()-1);
  42     assert(nHeightFirst >= 0);
  43     const CBlockIndex* pindexFirst = pindexLast->GetAncestor(nHeightFirst);
  44     assert(pindexFirst);
  45
  46     return CalculateNextWorkRequired(pindexLast, pindexFirst->GetBlockTime(), params);
  47 }
  48
  49 unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nFirstBlockTime, const Consensus::Params& params)
  50 {
  51     if (params.fPowNoRetargeting)
  52         return pindexLast->nBits;
  53
  54     // Limit adjustment step
  55     int64_t nActualTimespan = pindexLast->GetBlockTime() - nFirstBlockTime;
  56     if (nActualTimespan < params.nPowTargetTimespan/4)
  57         nActualTimespan = params.nPowTargetTimespan/4;
  58     if (nActualTimespan > params.nPowTargetTimespan*4)
  59         nActualTimespan = params.nPowTargetTimespan*4;
  60
  61     // Retarget
  62     const arith_uint256 bnPowLimit = UintToArith256(params.powLimit);
  63     arith_uint256 bnNew;
  64     bnNew.SetCompact(pindexLast->nBits);
  65     bnNew *= nActualTimespan;
  66     bnNew /= params.nPowTargetTimespan;
  67
  68     if (bnNew > bnPowLimit)
  69         bnNew = bnPowLimit;
  70
  71     return bnNew.GetCompact();
  72 }
  73
  74 bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params& params)
  75 {
  76     bool fNegative;
  77     bool fOverflow;
  78     arith_uint256 bnTarget;
  79
  80     bnTarget.SetCompact(nBits, &fNegative, &fOverflow);
  81
  82     // Check range
  83     if (fNegative || bnTarget == 0 || fOverflow || bnTarget > UintToArith256(params.powLimit))
  84         return false;
  85
  86     // Check proof of work matches claimed amount
  87     if (UintToArith256(hash) > bnTarget)
  88         return false;
  89
  90     return true;
  91 }