text: // Copyright (c) 2009-2010 Satoshi Nakamoto
  // Copyright (c) 2009-2014 The Bitcoin developers
  // Distributed under the MIT/X11 software license, see the accompanying
  // file COPYING or http://www.opensource.org/licenses/mit-license.php.
  
  #include "pow.h"
  
  #include "chain.h"
  #include "chainparams.h"
  #include "primitives/block.h"
  #include "auxpow.h"
  #include "uint256.h"
  #include "util.h"
  
  unsigned int static GetNextWorkRequired_V1(const CBlockIndex* pindexLast, const CBlockHeader *pblock)
  {
      unsigned int nProofOfWorkLimit = Params().ProofOfWorkLimit().GetCompact();
  
      // Genesis block
      if (pindexLast == NULL)
          return nProofOfWorkLimit;
  
      // Only change once per interval
      if ((pindexLast->nHeight+1) % Params().Interval() != 0)
      {
          if (Params().AllowMinDifficultyBlocks())
          {
              // Special difficulty rule for testnet:
              // If the new block's timestamp is more than 2* 10 minutes
              // then allow mining of a min-difficulty block.
              if (pblock->GetBlockTime() > pindexLast->GetBlockTime() + Params().TargetSpacing()*2)
                  return nProofOfWorkLimit;
              else
              {
                  // Return the last non-special-min-difficulty-rules-block
                  const CBlockIndex* pindex = pindexLast;
                  while (pindex->pprev && pindex->nHeight % Params().Interval() != 0 && pindex->nBits == nProofOfWorkLimit)
                      pindex = pindex->pprev;
                  return pindex->nBits;
              }
          }
          return pindexLast->nBits;
      }
  
      // Go back by what we want to be 14 days worth of blocks
      const CBlockIndex* pindexFirst = pindexLast;
      for (int i = 0; pindexFirst && i < Params().Interval()-1; i++)
          pindexFirst = pindexFirst->pprev;
      assert(pindexFirst);
  
      // Limit adjustment step
      int64_t nActualTimespan = pindexLast->GetBlockTime() - pindexFirst->GetBlockTime();
      LogPrintf("  nActualTimespan = %d  before bounds\n", nActualTimespan);
      if (nActualTimespan < Params().TargetTimespan()/4)
          nActualTimespan = Params().TargetTimespan()/4;
      if (nActualTimespan > Params().TargetTimespan()*4)
          nActualTimespan = Params().TargetTimespan()*4;
  
      // Retarget
      uint256 bnNew;
      uint256 bnOld;
      bnNew.SetCompact(pindexLast->nBits);
      bnOld = bnNew;
      bnNew *= nActualTimespan;
      bnNew /= Params().TargetTimespan();
  
      if (bnNew > Params().ProofOfWorkLimit())
          bnNew = Params().ProofOfWorkLimit();
  
      /// debug print
      LogPrintf("GetNextWorkRequired RETARGET\n");
      LogPrintf("Params().TargetTimespan() = %d    nActualTimespan = %d\n", Params().TargetTimespan(), nActualTimespan);
      LogPrintf("Before: %08x  %s\n", pindexLast->nBits, bnOld.ToString());
      LogPrintf("After:  %08x  %s\n", bnNew.GetCompact(), bnNew.ToString());
  
      return bnNew.GetCompact();
  }
  
  // AntiGravityWave by reorder, derived from code by Evan Duffield - evan@darkcoin.io
  unsigned int static AntiGravityWave(const CBlockIndex* pindexLast, const CBlockHeader *pblock, int64_t version)
  {
      const CBlockIndex *BlockLastSolved = pindexLast;
      const CBlockIndex *BlockReading = pindexLast;
      int64_t nActualTimespan = 0;
      int64_t LastBlockTime = 0;
      int64_t PastBlocksMin = 24;
      int64_t PastBlocksMax = 24;
  
      if (version == 1) {
          PastBlocksMin = 24;
          PastBlocksMax = 24;
      } else if (version == 2) {
          PastBlocksMin = 72;
          PastBlocksMax = 72;
      }
  
      int64_t CountBlocks = 0;
      uint256 PastDifficultyAverage;
      uint256 PastDifficultyAveragePrev;
  
      if (BlockLastSolved == NULL || BlockLastSolved->nHeight == 0 || BlockLastSolved->nHeight < PastBlocksMin) {
          return Params().ProofOfWorkLimit().GetCompact();
      }
  
      for (unsigned int i = 1; BlockReading && BlockReading->nHeight > 0; i++) {
          if (PastBlocksMax > 0 && i > PastBlocksMax) { break; }
              CountBlocks++;
  
          if (CountBlocks <= PastBlocksMin) {
              if (CountBlocks == 1)
                  PastDifficultyAverage.SetCompact(BlockReading->nBits);
              else { PastDifficultyAverage = ((PastDifficultyAveragePrev * CountBlocks)+(uint256().SetCompact(BlockReading->nBits))) / (CountBlocks+1); }
                  PastDifficultyAveragePrev = PastDifficultyAverage;
          }
  
          if (LastBlockTime > 0) {
              int64_t Diff = (LastBlockTime - BlockReading->GetBlockTime());
              nActualTimespan += Diff;
          }
          LastBlockTime = BlockReading->GetBlockTime();
  
          if (BlockReading->pprev == NULL) { assert(BlockReading); break; }
              BlockReading = BlockReading->pprev;
      }
  
      uint256 bnNew(PastDifficultyAverage);
  
      if (version == 2)
          --CountBlocks;
  
      int64_t nTargetTimespan = CountBlocks*Params().TargetSpacing();
  
      int64_t div = 3;
      if (version == 1)
          div = 3;
      else if (version == 2)
          div = 2;
  
      if (nActualTimespan < nTargetTimespan/div)
          nActualTimespan = nTargetTimespan/div;
      if (nActualTimespan > nTargetTimespan*div)
          nActualTimespan = nTargetTimespan*div;
  
      // Retarget
      bnNew *= nActualTimespan;
      bnNew /= nTargetTimespan;
  
      if (bnNew > Params().ProofOfWorkLimit()) {
          bnNew = Params().ProofOfWorkLimit();
      }
  
      return bnNew.GetCompact();
  }
  
  unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock)
  {
      // -regtest mode: always use testnet rules
      if (Params().AllowMinDifficultyBlocks() && Params().MineBlocksOnDemand()) {
          return GetNextWorkRequired_V1(pindexLast, pblock);
      }
      if (pindexLast->nHeight+1 >= 451000 || (Params().AllowMinDifficultyBlocks() && pindexLast->nHeight+1 >= 300000)) {
          return AntiGravityWave(pindexLast, pblock, 2);
      } else if (pindexLast->nHeight+1 >= 3600) {
          return AntiGravityWave(pindexLast, pblock, 1);
      } else {
          return GetNextWorkRequired_V1(pindexLast, pblock);
      }
  }
  
  bool CheckProofOfWork(uint256 hash, unsigned int nBits)
  {
      bool fNegative;
      bool fOverflow;
      uint256 bnTarget;
  
      if (Params().SkipProofOfWorkCheck())
         return true;
  
      bnTarget.SetCompact(nBits, &fNegative, &fOverflow);
  
      // Check range
      if (fNegative || bnTarget == 0 || fOverflow || bnTarget > Params().ProofOfWorkLimit())
          return error("CheckProofOfWork() : nBits below minimum work");
  
      // Check proof of work matches claimed amount
      if (hash > bnTarget)
          return error("CheckProofOfWork() : hash doesn't match nBits");
  
      return true;
  }
  
  bool CheckBlockProofOfWork(const CBlockHeader *pblock)
  {
      if (!Params().AllowMinDifficultyBlocks() && (pblock->nVersion & BLOCK_VERSION_AUXPOW && pblock->GetChainID() != AUXPOW_CHAIN_ID))
          return error("CheckBlockProofOfWork() : block does not have our chain ID");
  
      if (pblock->auxpow.get() != NULL)
      {
          if (!pblock->auxpow->Check(pblock->GetHash(), pblock->GetChainID()))
              return error("CheckBlockProofOfWork() : AUX POW is not valid");
          // Check proof of work matches claimed amount
          if (!CheckProofOfWork(pblock->auxpow->GetParentBlockHash(), pblock->nBits))
              return error("CheckBlockProofOfWork() : AUX proof of work failed");
      } 
      else
      {
          // Check proof of work matches claimed amount
          if (!CheckProofOfWork(pblock->GetPoWHash(), pblock->nBits))
              return error("CheckBlockProofOfWork() : proof of work failed");
      }
      return true;
  }
  
  uint256 GetBlockProof(const CBlockIndex& block)
  {
      uint256 bnTarget;
      bool fNegative;
      bool fOverflow;
      bnTarget.SetCompact(block.nBits, &fNegative, &fOverflow);
      if (fNegative || fOverflow || bnTarget == 0)
          return 0;
      // We need to compute 2**256 / (bnTarget+1), but we can't represent 2**256
      // as it's too large for a uint256. However, as 2**256 is at least as large
      // as bnTarget+1, it is equal to ((2**256 - bnTarget - 1) / (bnTarget+1)) + 1,
      // or ~bnTarget / (nTarget+1) + 1.
      return (~bnTarget / (bnTarget + 1)) + 1;
  }
  