mirror of
https://github.com/kvazar-network/kevacoin.git
synced 2025-01-26 23:04:39 +00:00
fee6799b12
0) Adjust BIP30 enforcement values 1) Reduce amount that peers can adjust our time to eliminate an attack vector. Thanks to coblee for this fix. 2) Zeitgeist2 patch - thanks to Lolcust and ArtForz. 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. 3) Avoid overflow in CalculateNextWorkRequired(). Thanks to pooler for the overflow fix. 4) Zeitgeist2 bool fshift bnNew.bits(). Thanks to romanornr for this path. 5) SegWit ContextualCheckBlockHeader adjustment and extra coverage. 6) Reject peer proto version below 70002. Thanks to wtogami for this patch. 7) Send final alert message to nodes warning about removal of the alert system. Thanks to coblee for this patch. 8) Adjust default settings for Litecoin.
109 lines
3.8 KiB
C++
109 lines
3.8 KiB
C++
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
|
// Copyright (c) 2009-2017 The Bitcoin Core developers
|
|
// Distributed under the MIT software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#include <pow.h>
|
|
|
|
#include <arith_uint256.h>
|
|
#include <chain.h>
|
|
#include <primitives/block.h>
|
|
#include <uint256.h>
|
|
#include <util.h>
|
|
|
|
unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params& params)
|
|
{
|
|
assert(pindexLast != nullptr);
|
|
unsigned int nProofOfWorkLimit = UintToArith256(params.powLimit).GetCompact();
|
|
|
|
// Only change once per difficulty adjustment interval
|
|
if ((pindexLast->nHeight+1) % params.DifficultyAdjustmentInterval() != 0)
|
|
{
|
|
if (params.fPowAllowMinDifficultyBlocks)
|
|
{
|
|
// 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.nPowTargetSpacing*2)
|
|
return nProofOfWorkLimit;
|
|
else
|
|
{
|
|
// Return the last non-special-min-difficulty-rules-block
|
|
const CBlockIndex* pindex = pindexLast;
|
|
while (pindex->pprev && pindex->nHeight % params.DifficultyAdjustmentInterval() != 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
|
|
// Litecoin: 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 = params.DifficultyAdjustmentInterval()-1;
|
|
if ((pindexLast->nHeight+1) != params.DifficultyAdjustmentInterval())
|
|
blockstogoback = params.DifficultyAdjustmentInterval();
|
|
|
|
// 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);
|
|
|
|
return CalculateNextWorkRequired(pindexLast, pindexFirst->GetBlockTime(), params);
|
|
}
|
|
|
|
unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nFirstBlockTime, const Consensus::Params& params)
|
|
{
|
|
if (params.fPowNoRetargeting)
|
|
return pindexLast->nBits;
|
|
|
|
// Limit adjustment step
|
|
int64_t nActualTimespan = pindexLast->GetBlockTime() - nFirstBlockTime;
|
|
if (nActualTimespan < params.nPowTargetTimespan/4)
|
|
nActualTimespan = params.nPowTargetTimespan/4;
|
|
if (nActualTimespan > params.nPowTargetTimespan*4)
|
|
nActualTimespan = params.nPowTargetTimespan*4;
|
|
|
|
// Retarget
|
|
arith_uint256 bnNew;
|
|
arith_uint256 bnOld;
|
|
bnNew.SetCompact(pindexLast->nBits);
|
|
bnOld = bnNew;
|
|
// Litecoin: intermediate uint256 can overflow by 1 bit
|
|
const arith_uint256 bnPowLimit = UintToArith256(params.powLimit);
|
|
bool fShift = bnNew.bits() > bnPowLimit.bits() - 1;
|
|
if (fShift)
|
|
bnNew >>= 1;
|
|
bnNew *= nActualTimespan;
|
|
bnNew /= params.nPowTargetTimespan;
|
|
if (fShift)
|
|
bnNew <<= 1;
|
|
|
|
if (bnNew > bnPowLimit)
|
|
bnNew = bnPowLimit;
|
|
|
|
return bnNew.GetCompact();
|
|
}
|
|
|
|
bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params& params)
|
|
{
|
|
bool fNegative;
|
|
bool fOverflow;
|
|
arith_uint256 bnTarget;
|
|
|
|
bnTarget.SetCompact(nBits, &fNegative, &fOverflow);
|
|
|
|
// Check range
|
|
if (fNegative || bnTarget == 0 || fOverflow || bnTarget > UintToArith256(params.powLimit))
|
|
return false;
|
|
|
|
// Check proof of work matches claimed amount
|
|
if (UintToArith256(hash) > bnTarget)
|
|
return false;
|
|
|
|
return true;
|
|
}
|