Adjusted the new difficulty algorithm

Adjusted the new difficulty algorithm

Author: X-CASH-official

README.md

@@ -46,7 +46,8 @@ If you want to help out, see [CONTRIBUTING](CONTRIBUTING.md) for a set of guidel
 | 0                       | 22-07-2018 | v1                 |  Genesis block       |
 | 1                       | 22-07-2018 | v7                 |  Start of the blockchain       |
 | 95085                   | 08-10-2018 | v8                 | changing difficulty algorithm to [LWMA-2 developed by Zawy12](https://github.com/zawy12/difficulty-algorithms/issues/3)       |
-| 145000                  | 01-11-2018 | v9                 | Adding public transactions, bullet proofs, increased and static ringsize and more!       |
+| 106000                  | 01-11-2018 | v9                 | Adjusting the new difficulty algorithm       |
+| 145000                  | 01-11-2018 | v10                 | Adding public transactions, bullet proofs, increased and static ringsize and more!       |
 
 Note future releases block heights and dates may change, so make sure to frequently check github, our website, the forums, etc. for the most up to date information.
 

src/cryptonote_basic/difficulty.cpp

@@ -33,6 +33,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <vector>
+#include <boost/math/special_functions/round.hpp>
 
 #include "common/int-util.h"
 #include "crypto/hash.h"
@@ -185,7 +186,6 @@ namespace cryptonote {
   //  > 50% hash power.  If this is too small, it can be increased to 1000 at a cost in protection.
   // Cryptonote clones:  #define DIFFICULTY_BLOCKS_COUNT_V2 DIFFICULTY_WINDOW_V2 + 1
 // difficulty_type should be uint64_t
-
 difficulty_type next_difficulty_V8(std::vector<std::uint64_t> timestamps,std::vector<difficulty_type> cumulative_difficulties, uint64_t block_height)    {
 int64_t T    = DIFFICULTY_TARGET_V8; // target solvetime seconds
 int64_t N   = DIFFICULTY_WINDOW_V8; //  N=45, 60, and 90 for T=600, 120, 60.
@@ -224,4 +224,78 @@ return static_cast<uint64_t>(next_D);
 // next_Target = sumTargets*L*2/0.998/T/(N+1)/N/N; // To show the difference.
 }
 
+
+
+
+
+
+
+// LWMA difficulty algorithm
+// Background:  https://github.com/zawy12/difficulty-algorithms/issues/3
+// Copyright (c) 2017-2018 Zawy (pseudocode)
+// MIT license http://www.opensource.org/licenses/mit-license.php
+// Copyright (c) 2018 The Stellite Project
+// Copyright (c) 2018 The Masari Project (10x for quicker recoveries, minimum to be symmetric with FTL)
+// Copyright (c) 2018 Wownero Inc., a Monero Enterprise Alliance partner company
+// Copyright (c) 2018 The Karbowanec developers (initial code)
+// Copyright (c) 2018 Haven Protocol (refinements)
+// Degnr8, Karbowanec, Masari, Bitcoin Gold, Bitcoin Candy, and Haven have contributed.
+// This algorithm is: next_difficulty = harmonic_mean(Difficulties) * T / LWMA(Solvetimes)
+// The harmonic_mean(Difficulties) = 1/average(Targets) so it is also:
+// next_target = avg(Targets) * LWMA(Solvetimes) / T.
+// This is "the best algorithm" because it has lowest root-mean-square error between
+// needed & actual difficulty during hash attacks while having the lowest standard
+// deviation during stable hashrate. That is, it's the fastest for a given stability and vice versa.
+// Do not use "if solvetime < 1 then solvetime = 1" which allows a catastrophic exploit.
+// Do not sort timestamps.  "Solvetimes" and "LWMA" variables must allow negatives.
+// Do not use MTP as most recent block.  Do not use (POW)Limits, filtering, or tempering.
+// Do not forget to set N (aka DIFFICULTY_WINDOW in Cryptonote) to recommendation below.
+// The nodes' future time limit (FTL) aka CRYPTONOTE_BLOCK_FUTURE_TIME_LIMIT needs to
+// be reduced from 60*60*2 to 500 seconds to prevent timestamp manipulation from miner's with
+//  > 50% hash power.  If this is too small, it can be increased to 1000 at a cost in protection.
+difficulty_type next_difficulty_V9(std::vector<std::uint64_t> timestamps, std::vector<difficulty_type> cumulative_difficulties, size_t target_seconds) {
+    const int64_t T = static_cast<int64_t>(target_seconds);
+    size_t N = DIFFICULTY_WINDOW_V9;
+    int64_t FTL = static_cast<int64_t>(CRYPTONOTE_BLOCK_FUTURE_TIME_LIMIT_V9);
+    // Return a difficulty of 1 for first 3 blocks if it's the start of the chain.
+    if (timestamps.size() < 4) {
+        return 1;
+    }
+    // Otherwise, use a smaller N if the start of the chain is less than N+1.
+    else if ( timestamps.size() < N+1 ) {
+        N = timestamps.size() - 1;
+    }
+    // Otherwise make sure timestamps and cumulative_difficulties are correct size.
+    else {
+        timestamps.resize(N+1);
+        cumulative_difficulties.resize(N+1);
+    }
+    // To get an average solvetime to within +/- ~0.1%, use an adjustment factor.
+    // adjust=0.998 for N = 60
+    const double adjust = 0.998;
+    // The divisor k normalizes the LWMA sum to a standard LWMA.
+    const double k = N * (N + 1) / 2;
+    double LWMA(0), sum_inverse_D(0), harmonic_mean_D(0), nextDifficulty(0);
+    int64_t solveTime(0);
+    uint64_t difficulty(0), next_difficulty(0);
+    // Loop through N most recent blocks. N is most recently solved block.
+    for (size_t i = 1; i <= N; i++) {
+        solveTime = static_cast<int64_t>(timestamps[i]) - static_cast<int64_t>(timestamps[i - 1]);
+        solveTime = std::min<int64_t>((T * 10), std::max<int64_t>(solveTime, -FTL));
+        difficulty = cumulative_difficulties[i] - cumulative_difficulties[i - 1];
+        LWMA += (int64_t)(solveTime * i) / k;
+        sum_inverse_D += 1 / static_cast<double>(difficulty);
+    }
+    harmonic_mean_D = N / sum_inverse_D;
+    // Limit LWMA same as Bitcoin's 1/4 in case something unforeseen occurs.
+    if (static_cast<int64_t>(boost::math::round(LWMA)) < T / 4)
+        LWMA = static_cast<double>(T / 4);
+    nextDifficulty = harmonic_mean_D * T / LWMA * adjust;
+    // No limits should be employed, but this is correct way to employ a 20% symmetrical limit:
+    // nextDifficulty=max(previous_Difficulty*0.8,min(previous_Difficulty/0.8, next_Difficulty));
+    next_difficulty = static_cast<uint64_t>(nextDifficulty);
+    return next_difficulty;
+}
+
+
 }

src/cryptonote_basic/difficulty.h

@@ -54,4 +54,5 @@ namespace cryptonote
     bool check_hash(const crypto::hash &hash, difficulty_type difficulty);
     difficulty_type next_difficulty(std::vector<std::uint64_t> timestamps, std::vector<difficulty_type> cumulative_difficulties, size_t target_seconds);
     difficulty_type next_difficulty_V8(std::vector<std::uint64_t> timestamps,std::vector<difficulty_type> cumulative_difficulties, uint64_t block_height);
+    difficulty_type next_difficulty_V9(std::vector<std::uint64_t> timestamps, std::vector<difficulty_type> cumulative_difficulties, size_t target_seconds);
 }

src/cryptonote_config.h

@@ -84,7 +84,7 @@
 #define PREMINE_BLOCK_HEIGHT								1
 #define PREMINE_BLOCK_REWARD							((uint64_t)(40000000000000000))
 
-// LWMA difficulty
+// LWMA difficulty V8
 #define HF_VERSION_LWMA_DIFFICULTY 8
 #define HF_VERSION_LWMA_DIFFICULTY_BLOCK_HEIGHT 95085
 #define HF_VERSION_LWMA_STARTING_DIFFICULTY 30000000
@@ -94,6 +94,14 @@
 #define DIFFICULTY_WINDOW_V8 120 // (60)
 #define DIFFICULTY_BLOCKS_COUNT_V8 121 //DIFFICULTY_WINDOW_V8 + 1 has to be +1 so N = N
 
+// LWMA difficulty V9
+#define DIFFICULTY_WINDOW_V9                            120
+#define DIFFICULTY_BLOCKS_COUNT_V9                      121
+#define CRYPTONOTE_BLOCK_FUTURE_TIME_LIMIT_V9           60*4
+#define BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW_V9            30
+#define DIFFICULTY_TARGET_V9                            60  // seconds
+
+
 #define CRYPTONOTE_LOCKED_TX_ALLOWED_DELTA_SECONDS_V1   DIFFICULTY_TARGET_V1 * CRYPTONOTE_LOCKED_TX_ALLOWED_DELTA_BLOCKS
 #define CRYPTONOTE_LOCKED_TX_ALLOWED_DELTA_SECONDS_V2   DIFFICULTY_TARGET_V2 * CRYPTONOTE_LOCKED_TX_ALLOWED_DELTA_BLOCKS
 #define CRYPTONOTE_LOCKED_TX_ALLOWED_DELTA_BLOCKS       1