KGW at block 14112

dobbscoin · Apr 13, 2014 · 093ddca · 093ddca
1 parent bf8bc8e
commit 093ddca
Showing 1 changed file with 83 additions and 1 deletion.
diff --git a/src/main.cpp b/src/main.cpp
@@ -1111,7 +1111,7 @@ unsigned int ComputeMinWork(unsigned int nBase, int64 nTime)
     return bnResult.GetCompact();
 }
 
-unsigned int static GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock)
+unsigned int static GetNextWorkRequired_V1(const CBlockIndex* pindexLast, const CBlock *pblock)
 {
     unsigned int nProofOfWorkLimit = bnProofOfWorkLimit.GetCompact();
 
@@ -1174,6 +1174,88 @@ unsigned int static GetNextWorkRequired(const CBlockIndex* pindexLast, const CBl
     return bnNew.GetCompact();
 }
 
+unsigned int static KimotoGravityWell(const CBlockIndex* pindexLast, const CBlock *pblock, uint64 TargetBlocksSpacingSeconds, uint64 PastBlocksMin, uint64 PastBlocksMax) {
+
+         const CBlockIndex  *BlockLastSolved                              = pindexLast;
+         const CBlockIndex  *BlockReading                                 = pindexLast;
+         const CBlock       *BlockCreating                                = pblock;
+                                              BlockCreating                                  = BlockCreating;
+         uint64                               PastBlocksMass                                 = 0;
+         int64                                PastRateActualSeconds                          = 0;
+         int64                                PastRateTargetSeconds                          = 0;
+         double                               PastRateAdjustmentRatio                        = double(1);
+         CBigNum                              PastDifficultyAverage;
+         CBigNum                              PastDifficultyAveragePrev;
+         double                               EventHorizonDeviation;
+         double                               EventHorizonDeviationFast;
+         double                               EventHorizonDeviationSlow;
+
+     if (BlockLastSolved == NULL || BlockLastSolved->nHeight == 0 || (uint64)BlockLastSolved->nHeight < PastBlocksMin) { return bnProofOfWorkLimit.GetCompact(); }
+
+         for (unsigned int i = 1; BlockReading && BlockReading->nHeight > 0; i++) {
+                 if (PastBlocksMax > 0 && i > PastBlocksMax) { break; }
+                 PastBlocksMass++;
+
+                 if (i == 1)        { PastDifficultyAverage.SetCompact(BlockReading->nBits); }
+                 else                { PastDifficultyAverage = ((CBigNum().SetCompact(BlockReading->nBits) - PastDifficultyAveragePrev) / i) + PastDifficultyAveragePrev; }
+                 PastDifficultyAveragePrev = PastDifficultyAverage;
+
+                 PastRateActualSeconds                        = BlockLastSolved->GetBlockTime() - BlockReading->GetBlockTime();
+                 PastRateTargetSeconds                        = TargetBlocksSpacingSeconds * PastBlocksMass;
+                 PastRateAdjustmentRatio                        = double(1);
+                 if (PastRateActualSeconds < 0) { PastRateActualSeconds = 0; }
+                 if (PastRateActualSeconds != 0 && PastRateTargetSeconds != 0) {
+                 PastRateAdjustmentRatio                        = double(PastRateTargetSeconds) / double(PastRateActualSeconds);
+                 }
+                 EventHorizonDeviation                        = 1 + (0.7084 * pow((double(PastBlocksMass)/double(28.2)), -1.228));
+                 EventHorizonDeviationFast                = EventHorizonDeviation;
+                 EventHorizonDeviationSlow                = 1 / EventHorizonDeviation;
+
+                 if (PastBlocksMass >= PastBlocksMin) {
+                         if ((PastRateAdjustmentRatio <= EventHorizonDeviationSlow) || (PastRateAdjustmentRatio >= EventHorizonDeviationFast)) { assert(BlockReading); break; }
+                 }
+                 if (BlockReading->pprev == NULL) { assert(BlockReading); break; }
+                 BlockReading = BlockReading->pprev;
+         }
+
+         CBigNum bnNew(PastDifficultyAverage);
+         if (PastRateActualSeconds != 0 && PastRateTargetSeconds != 0) {
+                 bnNew *= PastRateActualSeconds;
+                 bnNew /= PastRateTargetSeconds;
+         }
+     if (bnNew > bnProofOfWorkLimit) { bnNew = bnProofOfWorkLimit; }
+
+     /// debug print
+     printf("Difficulty Retarget - Kimoto Gravity Well\n");
+     printf("PastRateAdjustmentRatio = %g\n", PastRateAdjustmentRatio);
+     printf("Before: %08x  %s\n", BlockLastSolved->nBits, CBigNum().SetCompact(BlockLastSolved->nBits).getuint256().ToString().c_str());
+     printf("After:  %08x  %s\n", bnNew.GetCompact(), bnNew.getuint256().ToString().c_str());
+
+         return bnNew.GetCompact();
+ }
+
+ unsigned int static GetNextWorkRequired_V2(const CBlockIndex* pindexLast, const CBlock *pblock)
+ {
+         static const int64          BlocksTargetSpacing                          = 10 * 60; 
+         unsigned int                TimeDaySeconds                               = 60 * 60 * 24;
+         int64                       PastSecondsMin                               = TimeDaySeconds * 2.5;
+         int64                       PastSecondsMax                               = TimeDaySeconds * 10;
+         uint64                      PastBlocksMin                                = PastSecondsMin / BlocksTargetSpacing;
+         uint64                      PastBlocksMax                                = PastSecondsMax / BlocksTargetSpacing;        
+
+         return KimotoGravityWell(pindexLast, pblock, BlocksTargetSpacing, PastBlocksMin, PastBlocksMax);
+ }
+
+ unsigned int static GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlock *pblock)
+ {
+         int DiffMode = 1;
+		 if (pindexLast->nHeight+1 >= 14112) { DiffMode = 2; }
+
+         if             (DiffMode == 1) { return GetNextWorkRequired_V1(pindexLast, pblock); }
+         else if        (DiffMode == 2) { return GetNextWorkRequired_V2(pindexLast, pblock); }
+         return GetNextWorkRequired_V2(pindexLast, pblock);
+ }
+
 bool CheckProofOfWork(uint256 hash, unsigned int nBits)
 {
     CBigNum bnTarget;