Changing difficulty algorithm to Zawy12's LWMA-2

Changing difficulty algorithm to Zawy12's LWMA-2

Author: X-CASH-official

README.md

@@ -45,7 +45,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       |
-| 95000                   | 01-10-2018 | v8                 | Adding public transactions (transactions with mixin 0)       |
+| 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!       |
 
 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

@@ -162,4 +162,66 @@ namespace cryptonote {
     return (low + time_span - 1) / time_span;
   }
 
+// 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 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.
+  // 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.
+int64_t L(0), ST, sum_3_ST(0), next_D, prev_D;
+ 
+    // Make sure timestamps & CD vectors are not bigger than they are supposed to be.
+    assert(timestamps.size() == cumulative_difficulties.size() && 
+                     timestamps.size() <= static_cast<uint64_t>(N+1) );
+    // If it's a new coin, do startup code. 
+    // Increase difficulty_guess if it needs to be much higher, but guess lower than lowest guess.
+    uint64_t difficulty_guess = HF_VERSION_LWMA_STARTING_DIFFICULTY; 
+    if (timestamps.size() <= 10 ) {   return difficulty_guess;   }
+    // code to lower the difficulty if the blockchain is already at a too high difficulty and its not a new coin
+    if (block_height <= (HF_VERSION_LWMA_DIFFICULTY_BLOCK_HEIGHT + static_cast<uint64_t>(N +1))) {return difficulty_guess;}
+    // Use "if" instead of "else if" in case vectors are incorrectly N all the time instead of N+1.
+    if ( timestamps.size() < static_cast<uint64_t>(N +1) ) { N = timestamps.size()-1;  }
+    
+// N is most recently solved block. i must be signed
+for ( int64_t i = 1; i <= N; i++) {  
+    ST = static_cast<int64_t>(timestamps[i]) - static_cast<int64_t>(timestamps[i-1]);
+    ST = std::max(-5*T, std::min(ST, 6*T));
+    L +=  ST * i ; // Give more weight to most recent blocks.
+    // Do following inside loop to capture -FTL and +6*T limitations.
+    if ( i > N-3 ) { sum_3_ST += ST; }      
+}
+// Calculate next_D = avgD * T / LWMA(STs) using integer math
+// Do a cast in case L goes negative. Do not limit L. That's done by limiting next_D below.
+    next_D = (static_cast<int64_t>(cumulative_difficulties[N] - cumulative_difficulties[0])*T*(N+1)*99)/(100*2*L);
+// implement LWMA-2 changes from LWMA. 
+prev_D = cumulative_difficulties[N] - cumulative_difficulties[N-1];
+// The following limits are the generous max that should reasonably occur.  
+next_D = std::max( (prev_D*67)/100, std::min(next_D, (prev_D*150)/100 ));
+// N = 90 coins change 108 to 106.
+if ( sum_3_ST < (8*T)/10) {  next_D = std::max(next_D,(prev_D*108)/100); }
+return static_cast<uint64_t>(next_D);
+// next_Target = sumTargets*L*2/0.998/T/(N+1)/N/N; // To show the difference.
+}
+
 }

src/cryptonote_basic/difficulty.h

@@ -53,4 +53,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);
 }

src/cryptonote_config.h

@@ -84,6 +84,16 @@
 #define PREMINE_BLOCK_HEIGHT								1
 #define PREMINE_BLOCK_REWARD							((uint64_t)(40000000000000000))
 
+// LWMA difficulty
+#define HF_VERSION_LWMA_DIFFICULTY 8
+#define HF_VERSION_LWMA_DIFFICULTY_BLOCK_HEIGHT 95085
+#define HF_VERSION_LWMA_STARTING_DIFFICULTY 30000000
+#define DIFFICULTY_TARGET_V8 60 // seconds
+#define BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW_V8 30 // (11)
+#define CRYPTONOTE_BLOCK_FUTURE_TIME_LIMIT_V8 60*4 // (60*10)
+#define DIFFICULTY_WINDOW_V8 120 // (60)
+#define DIFFICULTY_BLOCKS_COUNT_V8 121 //DIFFICULTY_WINDOW_V8 + 1 has to be +1 so N = N
+
 #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

src/cryptonote_core/blockchain.cpp

@@ -95,8 +95,10 @@ static const struct {
   // version 7 starts from block 1, which is on or around July 18, 2018. This version includes the new POW cryptonight_v7 algorithm.
   { 7, 1, 0, 1531962000 },
 
-  // version 8 starts from block 157000, which is on or around Nov 14, 2018. This version includes bullet proofs, a substantial increase in the ringsize, a fixed ring size, and a few other items.
-  { 8, 157000, 0, 1541809000 },
+  // version 8 starts from block 95085, which is on or around Oct 8, 2018. This version includes a new difficulty algorithm.
+  { 8, 95085, 0, 1538524800 },
+
+  // version 9 starts from block 157000, which is on or around Nov 14, 2018. This version includes bullet proofs, public transactions,  a substantial increase in the ringsize, a fixed ring size, and a few other items.
 };
 static const uint64_t mainnet_hard_fork_version_1_till = 1;
 
@@ -112,8 +114,10 @@ static const struct {
   // version 7 starts from block 1, which is on or around July 18, 2018. This version includes the new POW cryptonight_v7 algorithm.
   { 7, 1, 0, 1531962000 },
 
-  // version 8 starts from block 146000, which is on or around Nov 7, 2018. This version includes bullet proofs, a substantial increase in the ringsize, a fixed ring size, and a few other items.
-  { 8, 146000, 0, 1541203200 },
+  // version 8 starts from block 105000, which is on or around Oct 8, 2018. This version includes a new difficulty algorithm.
+  { 8, 105000, 0, 1538524800 },
+
+  // version 9 starts from block 146000, which is on or around Nov 14, 2018. This version includes bullet proofs, public transactions,  a substantial increase in the ringsize, a fixed ring size, and a few other items.
 };
 static const uint64_t testnet_hard_fork_version_1_till = 1;
 
@@ -784,11 +788,16 @@ bool Blockchain::get_block_by_hash(const crypto::hash &h, block &blk, bool *orph
 // less blocks than desired if there aren't enough.
 difficulty_type Blockchain::get_difficulty_for_next_block()
 {
+  difficulty_type diff;
+  uint64_t block_height = m_db->height();
+  uint8_t version = get_current_hard_fork_version();
+  if (version < HF_VERSION_LWMA_DIFFICULTY)
+  {
   LOG_PRINT_L3("Blockchain::" << __func__);
   CRITICAL_REGION_LOCAL(m_blockchain_lock);
   std::vector<uint64_t> timestamps;
   std::vector<difficulty_type> difficulties;
-  auto height = m_db->height();
+  auto height = m_db->height();  
   // ND: Speedup
   // 1. Keep a list of the last 735 (or less) blocks that is used to compute difficulty,
   //    then when the next block difficulty is queried, push the latest height data and
@@ -799,12 +808,10 @@ difficulty_type Blockchain::get_difficulty_for_next_block()
     uint64_t index = height - 1;
     m_timestamps.push_back(m_db->get_block_timestamp(index));
     m_difficulties.push_back(m_db->get_block_cumulative_difficulty(index));
-
     while (m_timestamps.size() > DIFFICULTY_BLOCKS_COUNT)
       m_timestamps.erase(m_timestamps.begin());
     while (m_difficulties.size() > DIFFICULTY_BLOCKS_COUNT)
       m_difficulties.erase(m_difficulties.begin());
-
     m_timestamps_and_difficulties_height = height;
     timestamps = m_timestamps;
     difficulties = m_difficulties;
@@ -814,21 +821,71 @@ difficulty_type Blockchain::get_difficulty_for_next_block()
     size_t offset = height - std::min < size_t > (height, static_cast<size_t>(DIFFICULTY_BLOCKS_COUNT));
     if (offset == 0)
       ++offset;
-
     timestamps.clear();
     difficulties.clear();
     for (; offset < height; offset++)
     {
       timestamps.push_back(m_db->get_block_timestamp(offset));
       difficulties.push_back(m_db->get_block_cumulative_difficulty(offset));
     }
-
     m_timestamps_and_difficulties_height = height;
     m_timestamps = timestamps;
     m_difficulties = difficulties;
   }
   size_t target = get_difficulty_target();
-  return next_difficulty(timestamps, difficulties, target);
+  diff = next_difficulty(timestamps, difficulties, target);
+  }
+if (version >= HF_VERSION_LWMA_DIFFICULTY)
+  {
+  LOG_PRINT_L3("Blockchain::" << __func__);
+  CRITICAL_REGION_LOCAL(m_blockchain_lock);
+  std::vector<uint64_t> timestamps;
+  std::vector<difficulty_type> difficulties;
+  auto height = m_db->height();
+  size_t difficulty_blocks_count = DIFFICULTY_BLOCKS_COUNT_V8;
+  // ND: Speedup
+  // 1. Keep a list of the last 735 (or less) blocks that is used to compute difficulty,
+  //    then when the next block difficulty is queried, push the latest height data and
+  //    pop the oldest one from the list. This only requires 1x read per height instead
+  //    of doing 735 (DIFFICULTY_BLOCKS_COUNT).
+  if (m_timestamps_and_difficulties_height != 0 && ((height - m_timestamps_and_difficulties_height) == 1) && m_timestamps.size() >= difficulty_blocks_count)
+  {
+    uint64_t index = height - 1;
+    m_timestamps.push_back(m_db->get_block_timestamp(index));
+    m_difficulties.push_back(m_db->get_block_cumulative_difficulty(index));
+    while (m_timestamps.size() > difficulty_blocks_count)
+      m_timestamps.erase(m_timestamps.begin());
+    while (m_difficulties.size() > difficulty_blocks_count)
+      m_difficulties.erase(m_difficulties.begin());
+    m_timestamps_and_difficulties_height = height;
+    timestamps = m_timestamps;
+    difficulties = m_difficulties;
+  }
+  else
+  {
+    size_t offset = height - std::min < size_t > (height, static_cast<size_t>(difficulty_blocks_count));
+    if (offset == 0)
+      ++offset;
+    timestamps.clear();
+    difficulties.clear();
+    if (height > offset)
+    {
+      timestamps.reserve(height - offset);
+      difficulties.reserve(height - offset);
+    }
+    for (; offset < height; offset++)
+    {
+      timestamps.push_back(m_db->get_block_timestamp(offset));
+      difficulties.push_back(m_db->get_block_cumulative_difficulty(offset));
+    }
+    m_timestamps_and_difficulties_height = height;
+    m_timestamps = timestamps;
+    m_difficulties = difficulties;
+  }
+  size_t target = get_difficulty_target();
+  diff = next_difficulty_V8(timestamps, difficulties, block_height);
+  }
+return diff;
 }
 //------------------------------------------------------------------
 // This function removes blocks from the blockchain until it gets to the
@@ -2487,12 +2544,12 @@ bool Blockchain::check_tx_outputs(const transaction& tx, tx_verification_context
     }
   }
 
-  // from v8, allow bulletproofs
-  if (hf_version < 8) {
+  // from v9, allow bulletproofs
+  if (hf_version < 9) {
     const bool bulletproof = tx.rct_signatures.type == rct::RCTTypeFullBulletproof || tx.rct_signatures.type == rct::RCTTypeSimpleBulletproof;
     if (bulletproof || !tx.rct_signatures.p.bulletproofs.empty())
     {
-      MERROR("Bulletproofs are not allowed before v8");
+      MERROR("Bulletproofs are not allowed before v9");
       tvc.m_invalid_output = true;
       return false;
     }

src/version.cpp.in

@@ -1,5 +1,5 @@
 #define DEF_XCASH_VERSION_TAG "@VERSIONTAG@"
-#define DEF_XCASH_VERSION "1.2.2"
+#define DEF_XCASH_VERSION "1.3.0"
 #define DEF_XCASH_RELEASE_NAME ""
 #define DEF_XCASH_VERSION_FULL DEF_XCASH_VERSION "-" DEF_XCASH_VERSION_TAG
 

src/wallet/wallet2.cpp

@@ -576,7 +576,7 @@ size_t estimate_tx_size(bool use_rct, int n_inputs, int mixin, int n_outputs, si
 
 uint8_t get_bulletproof_fork()
 {
-  return 8;
+  return 9;
 }
 
 crypto::hash8 get_short_payment_id(const tools::wallet2::pending_tx &ptx, hw::device &hwdev)