Topic: ★★DigiByte|极特币★★[DGB]✔ Core v6.16.5.1 - DigiShield, DigiSpeed, Segwit - page 547. (Read 3058816 times)

    int GetAlgoWorkFactor() const
    {
        if (!TestNet() && (nHeight < multiAlgoDiffChangeTarget))
        {
            return 1;
        }
        if (TestNet() && (nHeight < 100))
        {
            return 1;
        }
        switch (GetAlgo())
        {
            case ALGO_SHA256D:
                return 1;
            // work factor = absolute work ratio * optimisation factor
            case ALGO_SCRYPT:
                return 1024 * 4;
            case ALGO_GROESTL:
                return 64 * 8;
            case ALGO_SKEIN:
                return 4 * 6;
            case ALGO_QUBIT:
                return 128 * 8;
            default:
                return 1;
        }
    }

    CBigNum GetBlockWorkAdjusted() const
    {
        if (nHeight < workComputationChangeTarget)
        {
            CBigNum bnRes;
            bnRes = GetBlockWork() * GetAlgoWorkFactor();
            return bnRes;
        }
        else
        {
            CBigNum bnRes = 1;
            CBlockHeader header = GetBlockHeader();
            // multiply the difficulties of all algorithms
            for (int i = 0; i < NUM_ALGOS; i++)
            {
                unsigned int nBits = GetNextWorkRequired(pprev, &header, i,false);
                CBigNum bnTarget;
                bnTarget.SetCompact(nBits);
                if (bnTarget <= 0)
                    return 0;
                bnRes *= (CBigNum(1)<<256) / (bnTarget+1);
            }
            // Compute the geometric mean
            bnRes = bnRes.nthRoot(NUM_ALGOS);
            // Scale to roughly match the old work calculation
            bnRes <<= 7;
            return bnRes;
        }
    }

static unsigned int GetNextWorkRequiredV4(const CBlockIndex* pindexLast, const CBlockHeader *pblock, int algo,bool log)
{
unsigned int nProofOfWorkLimit = Params().ProofOfWorkLimit(algo).GetCompact();

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

if (TestNet())
{
// 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->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;
}
}

if(log)
{
LogPrintf("GetNextWorkRequired RETARGET\n");
LogPrintf("Algo: %s\n", GetAlgoName(algo));
LogPrintf("Height (Before): %s\n", pindexLast->nHeight);
}

// find first block in averaging interval
// Go back by what we want to be nAveragingInterval blocks per algo
const CBlockIndex* pindexFirst = pindexLast;
for (int i = 0; pindexFirst && i < NUM_ALGOS*nAveragingInterval; i++)
{
pindexFirst = pindexFirst->pprev;
}

const CBlockIndex* pindexPrevAlgo = GetLastBlockIndexForAlgo(pindexLast, algo);
if (pindexPrevAlgo == NULL || pindexFirst == NULL)
{
if(log)
LogPrintf("Use default POW Limit\n");
return nProofOfWorkLimit;
}

// Limit adjustment step
// Use medians to prevent time-warp attacks
int64_t nActualTimespan = pindexLast-> GetMedianTimePast() - pindexFirst->GetMedianTimePast();
nActualTimespan = nAveragingTargetTimespanV4 + (nActualTimespan - nAveragingTargetTimespanV4)/4;

if(log)
LogPrintf("nActualTimespan = %d before bounds\n", nActualTimespan);

if (nActualTimespan < nMinActualTimespanV4)
nActualTimespan = nMinActualTimespanV4;
if (nActualTimespan > nMaxActualTimespanV4)
nActualTimespan = nMaxActualTimespanV4;

//Global retarget
CBigNum bnNew;
bnNew.SetCompact(pindexPrevAlgo->nBits);

bnNew *= nActualTimespan;
bnNew /= nAveragingTargetTimespanV4;

//Per-algo retarget
int nAdjustments = pindexPrevAlgo->nHeight + NUM_ALGOS - 1 - pindexLast->nHeight;
if (nAdjustments > 0)
{
for (int i = 0; i < nAdjustments; i++)
{
bnNew *= 100;
bnNew /= (100 + nLocalTargetAdjustment);
}
}
else if (nAdjustments < 0)//make it easier
{
for (int i = 0; i < -nAdjustments; i++)
{
bnNew *= (100 + nLocalTargetAdjustment);
bnNew /= 100;
}
}

if (bnNew > Params().ProofOfWorkLimit(algo))
{
if(log)
{
LogPrintf("bnNew > Params().ProofOfWorkLimit(algo)\n");
}
bnNew = Params().ProofOfWorkLimit(algo);
}

if(log)
{
LogPrintf("nAveragingTargetTimespanV4 = %d; nActualTimespan = %d\n", nAveragingTargetTimespanV4, nActualTimespan);
LogPrintf("Before: %08x  %s\n", pindexPrevAlgo->nBits, CBigNum().SetCompact(pindexPrevAlgo->nBits).getuint256().ToString());
LogPrintf("After:  %08x  %s\n", bnNew.GetCompact(), bnNew.getuint256().ToString());
}

return bnNew.GetCompact();
}