Topic: 'CACHE'Project [VALM-Cache difficulty recalculation algorithm, SpamHash Control] - page 8. (Read 8135 times)

static const int64 nTargetSpacingWorkMaxPow = 12 * nPowTargetSpacing; // 14400
static const int64 nTargetSpacingWorkMaxPos = 12 * nPosTargetSpacing; // 7200
static const int64 nTargetTimespanPow = nTargetSpacingWorkMaxPow * 6 * 12; // 1036800  matrix
static const int64 nTargetTimespanPos = nTargetSpacingWorkMaxPos * 6 * 12; // 518400   matrix

// ppcoin: 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;
}
const CBlockIndex* GetLastBlockIndexPow(const CBlockIndex* powpindex, bool fProofOfWork)
{
    while (powpindex && powpindex->pprev && (powpindex->IsProofOfWork() == fProofOfWork))
        powpindex = powpindex->pprev;
    return powpindex;
}
const CBlockIndex* GetLastBlockIndexPos(const CBlockIndex* pospindex, bool fProofOfStake)
{
    while (pospindex && pospindex->pprev && (pospindex->IsProofOfStake() != fProofOfStake))
        pospindex = pospindex->pprev;
    return pospindex;
}

unsigned int GetNextTargetRequiredPos(const CBlockIndex* pospindexLast, bool fProofOfStake)
{
    CBigNum bnTargetLimitPos = bnProofOfStakeHardLimit;

    if (pospindexLast == NULL)
        return bnTargetLimitPos.GetCompact(); // last block
    const CBlockIndex* pospindexPrev = GetLastBlockIndexPos(pospindexLast, fProofOfStake);
    if (pospindexPrev->pprev == NULL)
        return bnInitialHashTarget.GetCompact(); // first block
    const CBlockIndex* pospindexPrevPrev = GetLastBlockIndexPos(pospindexPrev->pprev, fProofOfStake);
    if (pospindexPrevPrev->pprev == NULL)
        return bnInitialHashTarget.GetCompact(); // second block 1
    const CBlockIndex* pospindexPrevPrevPrev = GetLastBlockIndexPos(pospindexPrevPrev->pprev, fProofOfStake);
    if (pospindexPrevPrevPrev->pprev == NULL)
        return bnInitialHashTarget.GetCompact(); // second block 2
    const CBlockIndex* pospindexPrevPrevPrevPrev = GetLastBlockIndexPos(pospindexPrevPrevPrev->pprev, fProofOfStake);
    if (pospindexPrevPrevPrevPrev->pprev == NULL)
        return bnInitialHashTarget.GetCompact(); // second block 3
    const CBlockIndex* pospindexPrevPrevPrevPrevPrev = 
	                                            GetLastBlockIndexPos(pospindexPrevPrevPrevPrev->pprev, fProofOfStake);
    if (pospindexPrevPrevPrevPrevPrev->pprev == NULL)
        return bnInitialHashTarget.GetCompact(); // second block 4
    const CBlockIndex* pospindexPrevPrevPrevPrevPrevPrev = 
	                                            GetLastBlockIndexPos(pospindexPrevPrevPrevPrevPrev->pprev, fProofOfStake);
    if (pospindexPrevPrevPrevPrevPrevPrev->pprev == NULL)
        return bnInitialHashTarget.GetCompact(); // second block 5

    int64 nLastCoinSearchTime = GetAdjustedTime();

    if(pospindexPrev->IsProofOfStake() && pospindexPrevPrev->IsProofOfStake() &&
       pospindexPrevPrevPrev->IsProofOfStake() && pospindexPrevPrevPrevPrev->IsProofOfStake())
    {
    nLastCoinPosSearchInterval = ( nLastCoinSearchTime - PosPindexPrevPrevTime ) - 
	                                                                   ( nLastCoinSearchTime - PosPindexPrevTime );
    nLastCoinPosSearchIntervalPrev = ( nLastCoinSearchTime - PosPindexPrevPrevPrevTime ) - 
	                                                                   ( nLastCoinSearchTime - PosPindexPrevPrevTime );
    nLastCoinPosSearchIntervalPrevPrev = ( nLastCoinSearchTime - PosPindexPrevPrevPrevPrevTime ) - 
	                                                                   ( nLastCoinSearchTime - PosPindexPrevPrevPrevTime );
    }

    nUnixCachChainTime = nLastCoinSearchTime - 1 + nNewTimeBlock;

    double nPosTargetSpacingTest = 0;
    if(pospindexPrev->GetBlockTime() > nPowForceTimestamp && pospindexPrev->GetBlockTime() < nPowForceTimestamp + NTest)
       nPosTargetSpacingTest = nPosTargetSpacing / nPosTargetSpacing * 600;
       else
           nPosTargetSpacingTest = nPosTargetSpacing;
    int64 nActualTimeIntervalLongPosVeryFirst = nLastCoinPosSearchInterval;
    if(nActualTimeIntervalLongPosVeryFirst < 0)
       nActualTimeIntervalLongPosVeryFirst = nPosTargetSpacingTest / 100 * nSpamHashControl;
    int64 nActualTimeIntervalLongPosFirst = nLastCoinPosSearchIntervalPrev;
    if(nActualTimeIntervalLongPosFirst < 0)
       nActualTimeIntervalLongPosFirst = nPosTargetSpacingTest / 100 * nSpamHashControl;
    int64 nActualTimeIntervalLongPosSecond = nLastCoinPosSearchIntervalPrevPrev;
    if(nActualTimeIntervalLongPosSecond < 0)
       nActualTimeIntervalLongPosSecond = nPosTargetSpacingTest / 100 * nSpamHashControl;
    double nActualSpacingTotalsPos = ( nActualTimeIntervalLongPosVeryFirst + nActualTimeIntervalLongPosFirst ) / 2;
    double nActualTimeIntervalNvar = nActualTimeIntervalLongPosVeryFirst;

    // cacheproject retarget
    // VALM-Cache /logical analysis - mathematically variable/
    int64 nActualSpacingPos = 0;
    double nVar = nPosTargetSpacingTest / 3;
    int64 nNonAccelerating = 0; // sec +0-
          PosPindexPrevTime = pospindexPrev->GetBlockTime();
          PosPindexPrevPrevTime = pospindexPrevPrev->GetBlockTime();
          PosPindexPrevPrevPrevTime = pospindexPrevPrevPrev->GetBlockTime();
          PosPindexPrevPrevPrevPrevTime = pospindexPrevPrevPrevPrev->GetBlockTime();
          nLastCoinPosTwoInterval = nActualSpacingTotalsPos;
          nActualSpacingPos = ( nActualSpacingTotalsPos + nActualTimeIntervalLongPosSecond ) / 2;
    if(nActualTimeIntervalNvar >= nNonAccelerating && nActualTimeIntervalNvar < nPosTargetSpacingTest - nNonAccelerating)
       nPosTargetSpacingVar = (( nPosTargetSpacingTest - 1 + nVar ) - 
                                                              ( nActualTimeIntervalNvar * nVar / nPosTargetSpacingTest ));
       else if
              (nActualTimeIntervalNvar > nPosTargetSpacingTest + nNonAccelerating && 
			                                                  nActualTimeIntervalNvar <= nPosTargetSpacingTest * 2)
               nPosTargetSpacingVar = (( nPosTargetSpacingTest + 1 + nVar ) - 
			                                                  ( nActualTimeIntervalNvar * nVar / nPosTargetSpacingTest ));
               else if
                      (nActualTimeIntervalNvar > nPosTargetSpacingTest * 2)
                       nPosTargetSpacingVar = nPosTargetSpacingTest - nVar + 1;
                       else
                           nPosTargetSpacingVar = nPosTargetSpacingTest;
    double nSTSp = nPosTargetSpacingTest; // 1200 sec
    int64 posUppermin = 0;
    double posUppermax = nSTSp - nNonAccelerating; // 1199 sec
    double posLowermin = nSTSp + nNonAccelerating; // 1201 sec
    int64 posLowermax = nTargetSpacingWorkMaxPos;  // 2400 sec
    if(nActualTimeIntervalLongPosVeryFirst > posLowermin && nActualSpacingTotalsPos < posUppermax)
       nActualTimeIntervalXUXLpos = nActualTimeIntervalLongPosVeryFirst;
       else if(nActualTimeIntervalLongPosVeryFirst > posLowermin && nActualSpacingTotalsPos > posLowermin)
               nActualTimeIntervalXUXLpos = min((double) nActualTimeIntervalLongPosVeryFirst, (double) nActualSpacingTotalsPos);
       else if(nActualTimeIntervalLongPosVeryFirst < posUppermax && nActualSpacingTotalsPos < posUppermax)
               nActualTimeIntervalXUXLpos = max((double) nActualTimeIntervalLongPosVeryFirst, (double) nActualSpacingTotalsPos);
       else if(nActualSpacingTotalsPos < posUppermax && nActualSpacingTotalsPos > nActualSpacingPos)
               nActualTimeIntervalXUXLpos = nActualSpacingTotalsPos;
       else if(nActualSpacingTotalsPos > posLowermin && nActualSpacingTotalsPos < nActualSpacingPos)
               nActualTimeIntervalXUXLpos = nActualSpacingTotalsPos;
               else
                   nActualTimeIntervalXUXLpos = nActualSpacingPos;
    double nNix = nSTSp / 100 * 70;
    double nReverseEffectPos = 0;
    if(nActualTimeIntervalXUXLpos < nNix)
       nReverseEffectPos = nActualTimeIntervalXUXLpos / nNix;
       else if(nActualTimeIntervalXUXLpos > nSTSp && nActualTimeIntervalXUXLpos <= nSTSp + ( nSTSp - nNix))
               nReverseEffectPos = ( nSTSp / nSTSp ) / 2;
       else if(nActualTimeIntervalXUXLpos > nSTSp + ( nSTSp - nNix) && nActualTimeIntervalXUXLpos < posLowermax)
               nReverseEffectPos = (( nSTSp + ( nSTSp - nNix )) / nActualTimeIntervalXUXLpos ) / 2;
               else
                   nReverseEffectPos = 1;
       posUpperLower = ( nSTSp / 2 ) * nReverseEffectPos; // interval sampling 2:1 variable
    if(nActualSpacingTotalsPos < nNix / 1.30 && nActualTimeIntervalLongPosVeryFirst < posUppermax)
       posUpperLower = posUpperLower * (( nNix / 1.30 ) / nActualSpacingTotalsPos );
    double XUXL = nPosTargetSpacingTest / 100 * 4;
    double U = 0;
    double L = 0;
    double XU = XUXL + ( posUppermax * posUpperLower / nSTSp ); // 100.9166 +%
    double XL = XUXL + ( nSTSp * posUpperLower / posLowermin ); // 100.9167 +%
    double nBalance = 1.0;
    double nN = XUXL - ( XUXL / nBalance );
    int64 nTargetTimespanMin = nTargetTimespanPos / XL - 1; // min
    int64 nActualTimeIntervalXU = nActualTimeIntervalXUXLpos;
    int64 nActualTimeIntervalXL = nActualTimeIntervalXUXLpos;
    if(nActualTimeIntervalXU >= posUppermin && nActualTimeIntervalXU < posUppermax)
       U = nN + (( XU - ( nActualTimeIntervalXU * posUpperLower / nSTSp )) / nBalance );
       else U = 1;
    if(nActualTimeIntervalXL > posLowermin && nActualTimeIntervalXL < posLowermax)
       L = XL - ( nSTSp * posUpperLower / nActualTimeIntervalXL );
       else if(nActualTimeIntervalXL >= posLowermax)
               L = XL / 2;
               else L = 1;
    int64 nTargetTimespanControlu = nTargetTimespanPos / U; // min
    int64 nTargetTimespanControll = nTargetTimespanPos / L; // min
    if(nTargetTimespanControlu >= nTargetTimespanMin)
       XUpperPos = U;
       else if(nTargetTimespanControlu < nTargetTimespanMin)
               XUpperPos = XU;
               else
                   XUpperPos = 1;
    if(nTargetTimespanControll >= nTargetTimespanMin)
       XLowerPos = L;
       else if(nTargetTimespanControll < nTargetTimespanMin)
               XLowerPos = XL;
               else
                   XLowerPos = 1;
    CBigNum bnNewPos;
    bnNewPos.SetCompact(pospindexPrev->nBits);
    double nTargetTimespanBn = nTargetTimespanPos / max( XUpperPos, XLowerPos );
    double nInterval = nTargetTimespanBn / nPosTargetSpacingTest;
    if(pospindexPrev->GetBlockTime() > nPowForceTimestamp)
    {
       if(pospindexPrev->GetBlockTime() > nPowForceTimestamp && pospindexPrev->IsProofOfStake())

       bnNewPos *= (( (int64) nInterval - 1) * (int64) nPosTargetSpacingVar + (int64) nActualTimeIntervalXUXLpos + 
	                                                                                  (int64) nActualTimeIntervalXUXLpos);
       bnNewPos /= (( (int64) nInterval + 1) * (int64) nPosTargetSpacingVar);

       if(bnNewPos > bnTargetLimitPos)
          bnNewPos = bnTargetLimitPos;
       //if(bnNewPos < bnTargetLimitPos + bnTargetLimitPos)
          //bnNewPos = bnTargetLimitPos;
    }
    return bnNewPos.GetCompact();
}

int  nHardForkOneValue = 15 * COIN;
int  nHardForkTwoValue = 10 * COIN;
int  nHardForkThreeValue = 5 * COIN;
bool fHardForkOne = false;
bool fHardForkTwo = false;
bool fHardForkThree = false;

    if (nValueHardForkControlAddress <= nHardForkOneValue)
    {
        fHardForkOne = true;
        printf(" 'CWallet' - fHardForkOne = true\n");
    }
    if (nValueHardForkControlAddress <= nHardForkTwoValue)
    {
        fHardForkTwo = true;
        printf(" 'CWallet' - fHardForkTwo = true\n");
    }
    if (nValueHardForkControlAddress <= nHardForkThreeValue)
    {
        fHardForkThree = true;
        printf(" 'CWallet' - fHardForkThree = true\n");
    }

connection timeout
ERROR: FetchInputs() : 77c01bb195 mempool Tx prev not found d82f384072
stored orphan tx 77c01bb195 (mapsz 1)
ERROR: FetchInputs() : 232e3ad4eb mempool Tx prev not found 7305c2bbb6
stored orphan tx 232e3ad4eb (mapsz 2)
ERROR: FetchInputs() : 8ee218abb3 mempool Tx prev not found 77c01bb195
stored orphan tx 8ee218abb3 (mapsz 3)
ERROR: FetchInputs() : 8d46091608 mempool Tx prev not found 8ce31acefa
stored orphan tx 8d46091608 (mapsz 4)
ERROR: FetchInputs() : d00e372090 mempool Tx prev not found 8d46091608
stored orphan tx d00e372090 (mapsz 5)
ERROR: FetchInputs() : fe0f1a9c0a mempool Tx prev not found 01200c5384
stored orphan tx fe0f1a9c0a (mapsz 6)
ERROR: FetchInputs() : 27712e34e4 mempool Tx prev not found c577996957
stored orphan tx 27712e34e4 (mapsz 7)
ERROR: FetchInputs() : cc41f90986 mempool Tx prev not found c0ea949a19
stored orphan tx cc41f90986 (mapsz 8)
ERROR: FetchInputs() : 5a8a23adb5 mempool Tx prev not found 99ec48c825
stored orphan tx 5a8a23adb5 (mapsz 9)
ERROR: FetchInputs() : 0cc9ee7471 mempool Tx prev not found 5a8a23adb5
stored orphan tx 0cc9ee7471 (mapsz 10)
trying connection 76.121.62.235:8922 lastseen=3.2hrs
connection timeout