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 "main.h"
  #include "primitives/block.h"
  #include "uint256.h"
  #include "util.h"
  
  #include <math.h>
  
  // Lux modified: find last block index up to pindex
  const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake)
  {
      while (pindex && pindex->pprev && (pindex->IsProofOfStake() != fProofOfStake))
          pindex = pindex->pprev;
      return pindex;
  }
  
  unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader* pblock, bool fProofOfStake)
  {
      int64_t nTargetSpacing = 120;
      int64_t nTargetTimespan = 30 * 60;
      uint256 bnTargetLimit(Params().ProofOfWorkLimit());
      if(fProofOfStake) {
          bnTargetLimit = GetProofOfStakeLimit(pindexLast->nHeight);
      }
  
      if (pindexLast == nullptr) // Lux Modified
          return bnTargetLimit.GetCompact();
  
      const CBlockIndex* pindexPrev = GetLastBlockIndex(pindexLast, fProofOfStake);
      if (pindexPrev->pprev == nullptr)
          return bnTargetLimit.GetCompact(); // first block
      const CBlockIndex* pindexPrevPrev = GetLastBlockIndex(pindexPrev->pprev, fProofOfStake);
      if (pindexPrevPrev->pprev == nullptr)
          return bnTargetLimit.GetCompact(); // second block
  
      int64_t nActualSpacing = pindexPrev->GetBlockTime() - pindexPrevPrev->GetBlockTime();
      if (nActualSpacing < 0)
          nActualSpacing = nTargetSpacing;
  
      // ppcoin: target change every block
      // ppcoin: retarget with exponential moving toward target spacing
      uint256 bnNew;
      bnNew.SetCompact(pindexPrev->nBits); // Replaced pindexLast to avoid bugs
  
      int64_t nInterval = nTargetTimespan / nTargetSpacing;
      bnNew *= ((nInterval - 1) * nTargetSpacing + nActualSpacing + nActualSpacing);
      bnNew /= ((nInterval + 1) * nTargetSpacing);
  
      if (bnNew <= 0 || bnNew > bnTargetLimit)
          bnNew = bnTargetLimit;
  
      return bnNew.GetCompact();
  }
  
  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 false; //error("CheckProofOfWork() : nBits below minimum work");
  
      // Check proof of work matches claimed amount
      if (hash > bnTarget)
          return false; //error("CheckProofOfWork() : hash doesn't match nBits");
  
      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;
  }
  