test, stagenets: add hardfork blocks, diardi: fix mining without view tags

Author: hayzamjs

src/cryptonote_basic/miner.cpp

@@ -131,7 +131,7 @@ const command_line::arg_descriptor<std::string> arg_spendkey = {
 
 miner::miner(i_miner_handler *phandler, const get_block_hash_t &gbh)
  : m_stop(1), m_template{}, m_template_no(0), m_diffic(0), m_thread_index(0),
- m_phandler(phandler), m_gbh(gbh), m_height(0), m_threads_active(0),
+ m_phandler(phandler), m_gbh(gbh), m_height(0), m_last_mined(0), m_threads_active(0),
  m_pausers_count(0), m_threads_total(0), m_starter_nonce(0),
  m_last_hr_merge_time(0), m_hashes(0), m_total_hashes(0),
  m_do_print_hashrate(false), m_do_mining(false), m_current_hash_rate(0),
@@ -545,6 +545,15 @@ void miner::resume() {
  MDEBUG("MINING RESUMED");
 }
 //-----------------------------------------------------------------------------------------------------
+void miner::stop_mining_for(uint64_t seconds) {
+ CRITICAL_REGION_LOCAL(m_miners_count_lock);
+ MGINFO("Mining paused for "
+ << seconds << " seconds, since we mined the last diardi block");
+ ++m_pausers_count;
+ misc_utils::sleep_no_w(seconds * 1000);
+ --m_pausers_count;
+}
+//-----------------------------------------------------------------------------------------------------
 bool miner::worker_thread() {
  const uint32_t th_local_index =
  m_thread_index++; // atomically increment, getting value before increment
@@ -610,6 +619,10 @@ bool miner::worker_thread() {
  continue;
  }
 
+ if(m_last_mined == height) {
+ continue;
+ }
+
  b.nonce = nonce;
  crypto::hash h;
 
@@ -621,8 +634,8 @@ bool miner::worker_thread() {
  m_gbh(b, height, NULL, tools::get_max_concurrency(), h);
 
  if (check_hash(h, local_diff)) {
- // we lucky!
  ++m_config.current_extra_message_index;
+ m_last_mined = height;
  MGINFO_GREEN("Found block " << get_block_hash(b) << " at height "
  << height
  << " for difficulty: " << local_diff);

src/cryptonote_basic/miner.h

@@ -87,6 +87,7 @@ class miner {
  uint32_t get_threads_count() const;
  void send_stop_signal();
  bool stop();
+ void stop_mining_for(uint64_t seconds);
  bool is_mining() const;
  const account_public_address &get_mining_address() const;
  bool on_idle();
@@ -149,6 +150,7 @@ class miner {
  std::atomic<uint32_t> m_starter_nonce;
  difficulty_type m_diffic;
  uint64_t m_height;
+ uint64_t m_last_mined;
  std::atomic<uint32_t> m_thread_index;
  volatile uint32_t m_threads_total;
  std::atomic<uint32_t> m_threads_active;

src/cryptonote_basic/verification_context.h

@@ -75,6 +75,7 @@ struct tx_verification_context {
 struct block_verification_context {
  bool m_added_to_main_chain;
  bool m_verifivation_failed; // bad block, should drop connection
+ bool m_last_diardi_mined;
  bool m_marked_as_orphaned;
  bool m_already_exists;
  bool m_partial_block_reward;

src/cryptonote_config.h

@@ -191,7 +191,7 @@
 #define HF_VERSION_CLSAG 13
 #define HF_VERSION_DETERMINISTIC_UNLOCK_TIME 13
 #define HF_VERSION_BULLETPROOF_PLUS 15
-#define HF_VERSION_VIEW_TAGS 15
+#define HF_VERSION_VIEW_TAGS 17
 #define HF_VERSION_2021_SCALING 15
 
 #define PER_KB_FEE_QUANTIZATION_DECIMALS 1

src/cryptonote_core/blockchain.cpp

@@ -859,10 +859,10 @@ difficulty_type Blockchain::get_difficulty_for_next_block() {
  return (difficulty_type)120000000;
  }
 
- // Stagenet will start with difficulty of 1 KH/s
+ // Stagenet will start with difficulty of 33.3 H/s
  if (m_nettype == STAGENET && (uint64_t)height >= 20 &&
  (uint64_t)height <= 20 + (uint64_t)DIFFICULTY_BLOCKS_COUNT) {
- return (difficulty_type)40000;
+ return (difficulty_type)4000;
  }
 
  // Testnet will start with difficulty of 16 KH/s
@@ -1441,72 +1441,59 @@ bool Blockchain::validate_diardi_miner_v2(const block &b) {
  b.miner_tx.vin[0].type() != typeid(txin_gen))
  ? m_db->height()
  : boost::get<txin_gen>(b.miner_tx.vin[0]).height;
- bool isDiardiBlock = (version >= 13 && block_height % 4 == 0);
 
- if (!isDiardiBlock) {
+ if (!(version >= 13 && block_height % 4 == 0)) {
  return true;
  }
 
  std::list<std::string> diardi_miners_list = diardi_addresses_v2(m_nettype);
-
- std::string tM;
- std::string dM;
  std::string vM;
+ cryptonote::address_parse_info pVm;
 
- cryptonote::address_parse_info temp_miner_address;
- cryptonote::address_parse_info diardi_miner_address;
-
- for (auto const &sM : diardi_miners_list) {
- cryptonote::get_account_address_from_str(temp_miner_address, m_nettype, tM);
- cryptonote::get_account_address_from_str(diardi_miner_address, m_nettype,
- sM);
+ for(auto const& sM : diardi_miners_list) {
+ public_key pKey = boost::get<txout_to_key>(b.miner_tx.vout.back().target).key;
+ if(validate_diardi_reward_key(block_height, sM, 0, pKey, m_nettype)) {
+ vM = sM;
+ cryptonote::get_account_address_from_str(pVm, m_nettype, vM);
+ break;
+ }
+ }
 
- if (temp_miner_address.address == diardi_miner_address.address) {
- if (temp_miner_address.address.m_view_public_key ==
- diardi_miner_address.address.m_view_public_key) {
- crypto::hash sig_data = get_sig_data(block_height);
- crypto::signature signature = b.signature;
- crypto::public_key o_pspendkey =
- diardi_miner_address.address.m_spend_public_key;
+ if (vM.empty()) {
+ return true;
+ }
 
- vM = sM;
+ crypto::hash sig_data = get_sig_data(block_height);
+ crypto::signature signature = b.signature;
 
-  if (!crypto::check_signature(sig_data, o_pspendkey, signature)) {
-  LOG_PRINT_L1("Diardi: Miner Signature incorrect");
-  return false;
-  }
+ if (!crypto::check_signature(sig_data, pVm.address.m_spend_public_key, signature)) {
+ LOG_PRINT_L1("Diardi: Miner signature incorrect");
+ return false;
+ }
 
-  cryptonote::block oDb;
-  bool oOb = false;
-  bool getOldBlock = get_block_by_hash(
+ cryptonote::block oDb;
+ bool oOb = false;
+ bool getOldBlock = get_block_by_hash(
  m_db->get_block_hash_from_height((block_height - 4)), oDb, &oOb);
 
- if (!getOldBlock) {
- LOG_PRINT_L1("Diardi: Could not get old block");
- return false;
- }
-
- if (check_last_diardi_miner(this, vM, m_nettype)) {
- LOG_PRINT_L1("Diardi: Miner already mined a block < 4 blocks ago");
- return false;
- }
+ if (!getOldBlock) {
+ LOG_PRINT_L1("Diardi: Could not get old block");
+ return false;
+ }
 
-  return true;
- }
- }
+ if (check_last_diardi_miner(this, vM, m_nettype)) {
+  LOG_PRINT_L1("Diardi: Miner already mined a block < 4 blocks ago");
+  return false;
  }
 
- LOG_PRINT_L1("Diardi: Miner not in list");
- return false;
+ return true;
 }
 //------------------------------------------------------------------
 // This function validates the miner transaction reward
-bool Blockchain::validate_miner_transaction(const block &b,
- size_t cumulative_block_weight,
- uint64_t fee, uint64_t &base_reward,
- uint64_t already_generated_coins,
- bool &partial_block_reward,
- uint8_t version) {
+bool Blockchain::validate_miner_transaction(
+ const block &b, size_t cumulative_block_weight, uint64_t fee,
+ uint64_t &base_reward, uint64_t already_generated_coins,
+ bool &partial_block_reward, uint8_t version, bool &last_diardi_mined) {
  LOG_PRINT_L3("Blockchain::" << __func__);
  // validate reward
  uint64_t money_in_use = 0;
@@ -1544,33 +1531,6 @@ bool Blockchain::validate_miner_transaction(const block &b,
  return false;
  }
 
- if ((version >= 2) && (version <= 12) && (block_height >= 16)) {
- std::string diardi_maintainer_address;
- diardi_maintainer_address = diardi_index_to_reward_v1(block_height);
-
- if (already_generated_coins != 0) {
- uint64_t diardi_reward = get_diardi_reward(block_height, base_reward);
- if (b.miner_tx.vout.back().amount != diardi_reward) {
- MERROR("Diardi V1 reward amount incorrect. Should be: "
- << print_money(diardi_reward)
- << ", is: " << print_money(b.miner_tx.vout.back().amount));
- return false;
- }
-
- if (m_nettype == cryptonote::MAINNET) {
- if (!validate_diardi_reward_key(
- block_height, diardi_maintainer_address,
- b.miner_tx.vout.size() - 1,
- boost::get<txout_to_key>(b.miner_tx.vout.back().target).key)) {
- MERROR("Diardi V1 reward public key incorrect.");
- return false;
- }
- } else {
- return true;
- }
- }
- }
-
  if (base_reward + fee < money_in_use) {
  MERROR_VER("coinbase transaction spend too much money ("
  << print_money(money_in_use) << "). Block reward is "
@@ -1601,6 +1561,73 @@ bool Blockchain::validate_miner_transaction(const block &b,
  partial_block_reward = true;
  base_reward = money_in_use - fee;
  }
+
+ if ((version >= 2) && (version <= 12) && (block_height >= 16)) {
+ std::string diardi_maintainer_address;
+ diardi_maintainer_address = diardi_index_to_reward_v1(block_height);
+
+ if (already_generated_coins != 0) {
+ uint64_t diardi_reward = get_diardi_reward(block_height, base_reward);
+ if (b.miner_tx.vout.back().amount != diardi_reward) {
+ MERROR("Diardi V1 reward amount incorrect. Should be: "
+ << print_money(diardi_reward)
+ << ", is: " << print_money(b.miner_tx.vout.back().amount));
+ return false;
+ }
+
+ if (m_nettype == cryptonote::MAINNET) {
+ if (!validate_diardi_reward_key(
+ block_height, diardi_maintainer_address,
+ b.miner_tx.vout.size() - 1,
+ boost::get<txout_to_key>(b.miner_tx.vout.back().target).key)) {
+ MERROR("Diardi V1 reward public key incorrect.");
+ return false;
+ }
+ } else {
+ return true;
+ }
+ }
+ }
+
+ if (version >= HF_VERSION_DIARDI_V2 && m_db->height() % 4 == 0) {
+ std::string vM;
+ std::list<std::string> diardi_miners_list = diardi_addresses_v2(m_nettype);
+ cryptonote::address_parse_info diardi_miner_address;
+
+ for (auto const &sM : diardi_miners_list) {
+ if (validate_diardi_reward_key(
+ m_db->height(), sM, b.miner_tx.vout.size() - 1,
+ boost::get<txout_to_key>(b.miner_tx.vout.back().target).key,
+ m_nettype)) {
+ vM = sM;
+ break;
+ }
+ }
+
+ if (vM.empty()) {
+ MERROR("Diardi: V2 reward public key incorrect");
+ return false;
+ }
+
+ cryptonote::get_account_address_from_str(diardi_miner_address, m_nettype,
+ vM);
+
+ crypto::hash sig_data = get_sig_data(m_db->height());
+ crypto::signature signature = b.signature;
+ if (!crypto::check_signature(
+ sig_data, diardi_miner_address.address.m_spend_public_key,
+ signature)) {
+ MERROR("Diardi: Block signature incorrect");
+ return false;
+ }
+
+ if (check_last_diardi_miner(this, vM, m_nettype)) {
+ last_diardi_mined = true;
+ MERROR("Diardi: Cannot mine 2 diardi blocks in a row");
+ return false;
+ }
+ }
+
  return true;
 }
 //------------------------------------------------------------------
@@ -4712,12 +4739,18 @@ bool Blockchain::handle_block_to_main_chain(const block &bl,
  blockchain_height
  ? m_db->get_block_already_generated_coins(blockchain_height - 1)
  : 0;
- if (!validate_miner_transaction(bl, cumulative_block_weight, fee_summary,
- base_reward, already_generated_coins,
- bvc.m_partial_block_reward,
- m_hardfork->get_current_version())) {
- MERROR_VER("Block with id: " << id << " has incorrect miner transaction");
- bvc.m_verifivation_failed = true;
+ bool last_diardi_miner = false;
+ if (!validate_miner_transaction(
+ bl, cumulative_block_weight, fee_summary, base_reward,
+ already_generated_coins, bvc.m_partial_block_reward,
+ m_hardfork->get_current_version(), last_diardi_miner)) {
+ if (last_diardi_miner) {
+ bvc.m_last_diardi_mined = true;
+ } else {
+ MERROR_VER("Block with id: " << id << " has incorrect miner transaction");
+ bvc.m_verifivation_failed = true;
+ }
+
  return_tx_to_pool(txs);
  goto leave;
  }
@@ -5030,10 +5063,11 @@ bool Blockchain::add_new_block(const block &bl,
  }
 
  if (!validate_diardi_miner_v2(bl)) {
- LOG_PRINT_L1("Diardi validation failed for block with id <" << id << ">");
+ LOG_PRINT_L1("Diardi: validation failed for block with id <" << id
+ << ">");
  bvc.m_added_to_main_chain = false;
  m_blocks_txs_check.clear();
- return true;
+ return false;
  }
 
  // check that block refers to chain tail

src/cryptonote_core/blockchain.h

@@ -1654,7 +1654,8 @@ class Blockchain {
  size_t cumulative_block_weight, uint64_t fee,
  uint64_t &base_reward,
  uint64_t already_generated_coins,
- bool &partial_block_reward, uint8_t version);
+ bool &partial_block_reward, uint8_t version,
+ bool &last_diardi_mined);
 
  /**
  * @brief reverts the blockchain to its previous state following a failed

src/cryptonote_core/cryptonote_core.cpp

@@ -1529,6 +1529,11 @@ bool core::handle_block_found(block &b, block_verification_context &bvc) {
 
  CHECK_AND_ASSERT_MES(!bvc.m_verifivation_failed, false,
  "mined block failed verification");
+
+ if (bvc.m_last_diardi_mined) {
+ m_miner.stop_mining_for(550);
+ }
+
  if (bvc.m_added_to_main_chain) {
  cryptonote_connection_context exclude_context = {};
  NOTIFY_NEW_BLOCK::request arg = AUTO_VAL_INIT(arg);

src/cryptonote_core/cryptonote_tx_utils.cpp

@@ -449,8 +449,11 @@ bool construct_miner_tx(size_t height, size_t median_weight,
  tk.key = out_eph_public_key;
 
  tx_out out;
+ uint64_t amount = out_amounts[no];
  summary_amounts += out.amount = out_amounts[no];
+
  out.target = tk;
+
  tx.vout.push_back(out);
 
  if (hard_fork_version >= 2 && hard_fork_version <= 12 && (height >= 16)) {

src/cryptonote_core/tx_pool.cpp

@@ -58,7 +58,7 @@
 #define scala_DEFAULT_LOG_CATEGORY "txpool"
 
 DISABLE_VS_WARNINGS(4244 4345 4503) //'boost::foreach_detail_::or_' : decorated
- //name length exceeded, name was truncated
+ // name length exceeded, name was truncated
 
 using namespace crypto;