How possible fix adjustment atack ?

the sample of pow code used on altcoin ( scrypt coin based on old sources of litecoin)

main.cpp

Code:

int64 static GetBlockValue(int nHeight, int64 nFees)
{
   int64 nSubsidy = 500 * COIN;

   if(nHeight == 1)
   {
   nSubsidy = 160000000 * COIN;
   }

   // Subsidy is cut in half every 840000 blocks
   nSubsidy >>= (nHeight / 840000);

   return nSubsidy + nFees;
}

static const int64 nTargetTimespan = 10 * 60;
static const int64 nTargetSpacing = 5 * 60;
static const int64 nInterval = nTargetTimespan / nTargetSpacing;

//
// minimum amount of work that could possibly be required nTime after
// minimum work required was nBase
//
unsigned int ComputeMinWork(unsigned int nBase, int64 nTime)
{
   // Testnet has min-difficulty blocks
   // after nTargetSpacing*2 time between blocks:
   if (fTestNet && nTime > nTargetSpacing*2)
   return bnProofOfWorkLimit.GetCompact();

   CBigNum bnResult;
   bnResult.SetCompact(nBase);
   while (nTime > 0 && bnResult < bnProofOfWorkLimit)
   {
   // Maximum 400% adjustment...
   bnResult *= 4;
   // ... in best-case exactly 4-times-normal target time
   nTime -= nTargetTimespan*4;
   }
   if (bnResult > bnProofOfWorkLimit)
   bnResult = bnProofOfWorkLimit;
   return bnResult.GetCompact();
}

unsigned int static GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock)
{
   unsigned int nProofOfWorkLimit = bnProofOfWorkLimit.GetCompact();

   // Genesis block
   if (pindexLast == NULL)
   return nProofOfWorkLimit;

   // Only change once per interval
   if ((pindexLast->nHeight+1) % nInterval != 0)
   {
   // Special difficulty rule for testnet:
   if (fTestNet)
   {
   // If the new block's timestamp is more than 2* 10 minutes
   // then allow mining of a min-difficulty block.
   if (pblock->nTime > pindexLast->nTime + nTargetSpacing*2)
   return nProofOfWorkLimit;
   else
   {
   // Return the last non-special-min-difficulty-rules-block
   const CBlockIndex* pindex = pindexLast;
   while (pindex->pprev && pindex->nHeight % nInterval != 0 && pindex->nBits == nProofOfWorkLimit)
   pindex = pindex->pprev;
   return pindex->nBits;
   }
   }

   return pindexLast->nBits;
   }

   // LiteBitcoin: This fixes an issue where a 51% attack can change difficulty at will.
   // Go back the full period unless it's the first retarget after genesis. Code courtesy of Art Forz
   int blockstogoback = nInterval-1;
   if ((pindexLast->nHeight+1) != nInterval)
   blockstogoback = nInterval;

   // Go back by what we want to be 14 days worth of blocks
   const CBlockIndex* pindexFirst = pindexLast;
   for (int i = 0; pindexFirst && i < blockstogoback; i++)
   pindexFirst = pindexFirst->pprev;
   assert(pindexFirst);

   // Limit adjustment step
   int64 nActualTimespan = pindexLast->GetBlockTime() - pindexFirst->GetBlockTime();
   printf(" nActualTimespan = %"PRI64d" before bounds\n", nActualTimespan);
   if (nActualTimespan < nTargetTimespan/4)
   nActualTimespan = nTargetTimespan/4;
   if (nActualTimespan > nTargetTimespan*4)
   nActualTimespan = nTargetTimespan*4;

   // Retarget
   CBigNum bnNew;
   bnNew.SetCompact(pindexLast->nBits);
   bnNew *= nActualTimespan;
   bnNew /= nTargetTimespan;

   if (bnNew > bnProofOfWorkLimit)
   bnNew = bnProofOfWorkLimit;

   /// debug print
   printf("GetNextWorkRequired RETARGET\n");
   printf("nTargetTimespan = %"PRI64d" nActualTimespan = %"PRI64d"\n", nTargetTimespan, nActualTimespan);
   printf("Before: %08x %s\n", pindexLast->nBits, CBigNum().SetCompact(pindexLast->nBits).getuint256().ToString().c_str());
   printf("After: %08x %s\n", bnNew.GetCompact(), bnNew.getuint256().ToString().c_str());

   return bnNew.GetCompact();
}

bool CheckProofOfWork(uint256 hash, unsigned int nBits)
{
   CBigNum bnTarget;
   bnTarget.SetCompact(nBits);

   // Check range
   if (bnTarget <= 0 || bnTarget > bnProofOfWorkLimit)
   return error("CheckProofOfWork() : nBits below minimum work");

   // Check proof of work matches claimed amount
   if (hash > bnTarget.getuint256())
   return error("CheckProofOfWork() : hash doesn't match nBits");

   return true;
}

// Return maximum amount of blocks that other nodes claim to have
int GetNumBlocksOfPeers()
{
   return std::max(cPeerBlockCounts.median(), Checkpoints::GetTotalBlocksEstimate());
}