diff --git a/src/currency_core/blockchain_storage.cpp b/src/currency_core/blockchain_storage.cpp
index 9e81bee4..749ca1d7 100644
--- a/src/currency_core/blockchain_storage.cpp
+++ b/src/currency_core/blockchain_storage.cpp
@@ -1157,7 +1157,7 @@ wide_difficulty_type blockchain_storage::get_next_diff_conditional(bool pos) con
   wide_difficulty_type& dif = pos ? m_cached_next_pos_difficulty : m_cached_next_pow_difficulty;
   TIME_MEASURE_FINISH_PD(target_calculating_enum_blocks);
   TIME_MEASURE_START_PD(target_calculating_calc);
-  if (m_db_blocks.size() > m_core_runtime_config.hard_forks.hard_fork_01_starts_after_height)
+  if (m_core_runtime_config.is_hardfork_active_for_height(1, m_db_blocks.size()))
   {
     dif = next_difficulty_2(timestamps, commulative_difficulties, pos ? DIFFICULTY_POS_TARGET : DIFFICULTY_POW_TARGET);
   }
@@ -1196,7 +1196,7 @@ wide_difficulty_type blockchain_storage::get_next_diff_conditional2(bool pos, co
   enum_blockchain(cb, alt_chain, split_height);
 
   wide_difficulty_type diff = 0;
-  if(abei.height > m_core_runtime_config.hard_forks.hard_fork_01_starts_after_height)
+  if(m_core_runtime_config.is_hardfork_active_for_height(1, abei.height))
     diff = next_difficulty_2(timestamps, commulative_difficulties, pos ? DIFFICULTY_POS_TARGET : DIFFICULTY_POW_TARGET);
   else
     diff = next_difficulty_1(timestamps, commulative_difficulties, pos ? DIFFICULTY_POS_TARGET : DIFFICULTY_POW_TARGET);
@@ -1276,7 +1276,7 @@ bool blockchain_storage::prevalidate_miner_transaction(const block& b, uint64_t
     CHECK_AND_ASSERT_MES(b.miner_tx.vin[1].type() == typeid(txin_to_key), false, "coinstake transaction in the block has the wrong type");
   }
 
-  if (height > m_core_runtime_config.hard_forks.hard_fork_01_starts_after_height)
+  if (m_core_runtime_config.is_hardfork_active_for_height(1, height))
   {
     // new rules that allow different unlock time in coinbase outputs
     uint64_t max_unlock_time = 0;
@@ -1296,7 +1296,8 @@ bool blockchain_storage::prevalidate_miner_transaction(const block& b, uint64_t
     bool r = get_tx_max_min_unlock_time(b.miner_tx, max_unlock_time, min_unlock_time);
     CHECK_AND_ASSERT_MES(r && max_unlock_time == min_unlock_time && min_unlock_time == height + CURRENCY_MINED_MONEY_UNLOCK_WINDOW,
       false,
-      "coinbase transaction has wrong min_unlock_time: " << min_unlock_time << ", expected: " << height + CURRENCY_MINED_MONEY_UNLOCK_WINDOW);
+      "coinbase transaction has wrong min_unlock_time: " << min_unlock_time << " or max_unlock_time: " << max_unlock_time <<
+      ", expected: " << height + CURRENCY_MINED_MONEY_UNLOCK_WINDOW);
   }
 
 
@@ -1447,9 +1448,9 @@ bool blockchain_storage::create_block_template(const create_block_template_param
   boost::multiprecision::uint128_t already_generated_coins;
   CRITICAL_REGION_BEGIN(m_read_lock);
   height = m_db_blocks.size();
-  if(height <= m_core_runtime_config.hard_forks.hard_fork_01_starts_after_height)
+  if(!m_core_runtime_config.is_hardfork_active_for_height(1, height))
     b.major_version = BLOCK_MAJOR_VERSION_INITIAL;
-  else if(height <= m_core_runtime_config.hard_forks.hard_fork_03_starts_after_height)
+  else if(!m_core_runtime_config.is_hardfork_active_for_height(3, height))
     b.major_version = HF1_BLOCK_MAJOR_VERSION;
   else
     b.major_version = CURRENT_BLOCK_MAJOR_VERSION;
@@ -1846,7 +1847,7 @@ bool blockchain_storage::handle_alternative_block(const block& b, const crypto::
     if (abei.height >= m_core_runtime_config.pos_minimum_heigh)
       cumulative_diff_delta = correct_difficulty_with_sequence_factor(sequence_factor, cumulative_diff_delta);
 
-    if (abei.height > BLOCKCHAIN_HEIGHT_FOR_POS_STRICT_SEQUENCE_LIMITATION && abei.height <= m_core_runtime_config.hard_forks.hard_fork_01_starts_after_height && pos_block && sequence_factor > BLOCK_POS_STRICT_SEQUENCE_LIMIT)
+    if (abei.height > BLOCKCHAIN_HEIGHT_FOR_POS_STRICT_SEQUENCE_LIMITATION && !m_core_runtime_config.is_hardfork_active_for_height(1, abei.height) && pos_block && sequence_factor > BLOCK_POS_STRICT_SEQUENCE_LIMIT)
     {
       LOG_PRINT_RED_L0("Alternative block " << id << " @ " << abei.height << " has too big sequence factor: " << sequence_factor << ", rejected");
       bvc.m_verification_failed = true;
@@ -1971,9 +1972,9 @@ bool blockchain_storage::is_reorganize_required(const block_extended_info& main_
   const block_extended_info& alt_chain_bei = alt_chain.back()->second;
   const block_extended_info& connection_point = alt_chain.front()->second;
 
-  if (connection_point.height <= m_core_runtime_config.hard_forks.hard_fork_01_starts_after_height)
+  if (!m_core_runtime_config.is_hardfork_active_for_height(1, connection_point.height))
   {
-    //use pre-hard fork, old-style comparing
+    //use pre-hard fork #1, old-style comparing
     if (main_chain_bei.cumulative_diff_adjusted < alt_chain_bei.cumulative_diff_adjusted)
       return true;
     else if (main_chain_bei.cumulative_diff_adjusted > alt_chain_bei.cumulative_diff_adjusted)
@@ -1992,7 +1993,7 @@ bool blockchain_storage::is_reorganize_required(const block_extended_info& main_
       return true;
     }
   }
-  else if (alt_chain_bei.height > m_core_runtime_config.hard_forks.hard_fork_01_starts_after_height)
+  else if (m_core_runtime_config.is_hardfork_active_for_height(1, alt_chain_bei.height))
   {
     //new rules, applied after HARD_FORK_1
     //to learn this algo please read https://github.com/hyle-team/docs/blob/master/zano/PoS_Analysis_and_improvements_proposal.pdf
@@ -3360,9 +3361,9 @@ bool blockchain_storage::push_transaction_to_global_outs_index(const transaction
       {
         m_db_outputs.push_back_item(ot.amount, global_output_entry::construct(tx_id, i));
         global_indexes.push_back(m_db_outputs.get_item_size(ot.amount) - 1);
-        if (ot.target.type() == typeid(txout_htlc) && !is_after_hardfork_3_zone())
+        if (ot.target.type() == typeid(txout_htlc) && !is_hardfork_active(3))
         {
-          LOG_ERROR("Error: Transaction with txout_htlc before is_after_hardfork_3_zone(before height " << m_core_runtime_config.hard_forks.hard_fork_03_starts_after_height << ")");
+          LOG_ERROR("Error: Transaction with txout_htlc before hardfork 3 (before height " << m_core_runtime_config.hard_forks.get_str_height_the_hardfork_active_after(3) << ")");
           return false;
         }
       }
@@ -3897,9 +3898,9 @@ namespace currency
     }
     bool operator()(const txin_htlc& in) const
     {
-      if (!m_bcs.is_after_hardfork_3_zone())
+      if (!m_bcs.is_hardfork_active(3))
       {
-        LOG_ERROR("Error: Transaction with txin_htlc before is_after_hardfork_3_zone(before height " << m_bcs.get_core_runtime_config().hard_forks.hard_fork_03_starts_after_height << ")");
+        LOG_ERROR("Error: Transaction with txin_htlc before hardfork 3 (before height " << m_bcs.get_core_runtime_config().hard_forks.get_str_height_the_hardfork_active_after(3) << ")");
         return false;
       }
       return this->operator()(static_cast<const txin_to_key&>(in));
@@ -4337,9 +4338,9 @@ bool blockchain_storage::check_tx_inputs(const transaction& tx, const crypto::ha
     }
     VARIANT_CASE_CONST(txin_htlc, in_htlc)
     {
-      if (!is_after_hardfork_3_zone())
+      if (!is_hardfork_active(3))
       {
-        LOG_ERROR("Error: Transaction with txin_htlc before is_after_hardfork_3_zone(before height " << m_core_runtime_config.hard_forks.hard_fork_03_starts_after_height << ")");
+        LOG_ERROR("Error: Transaction with txin_htlc before hardfork 3 (before height " << m_core_runtime_config.hard_forks.get_str_height_the_hardfork_active_after(3) << ")");
         return false;
       }
 
@@ -5055,10 +5056,10 @@ bool blockchain_storage::validate_tx_for_hardfork_specific_terms(const transacti
     return true;
   };
 
-  bool var_is_after_hardfork_1_zone = is_after_hardfork_1_zone(block_height);
-  bool var_is_after_hardfork_2_zone = is_after_hardfork_2_zone(block_height);
-  bool var_is_after_hardfork_3_zone = is_after_hardfork_3_zone(block_height);
-  bool var_is_after_hardfork_4_zone = is_after_hardfork_4_zone(block_height);
+  bool var_is_after_hardfork_1_zone = m_core_runtime_config.is_hardfork_active_for_height(1, block_height);
+  bool var_is_after_hardfork_2_zone = m_core_runtime_config.is_hardfork_active_for_height(2, block_height);
+  bool var_is_after_hardfork_3_zone = m_core_runtime_config.is_hardfork_active_for_height(3, block_height);
+  bool var_is_after_hardfork_4_zone = m_core_runtime_config.is_hardfork_active_for_height(4, block_height);
   
   //inputs
   for (const auto in : tx.vin)
@@ -5117,11 +5118,13 @@ bool blockchain_storage::validate_pos_coinbase_outs_unlock_time(const transactio
       return true;
   }
   
-  CHECK_AND_ASSERT_MES(get_block_height(miner_tx) > m_core_runtime_config.hard_forks.hard_fork_01_starts_after_height, false, "error in block [" << get_block_height(miner_tx) << "] etc_tx_details_unlock_time2 can exist only after hard fork point : " << m_core_runtime_config.hard_forks.hard_fork_01_starts_after_height);
+  uint64_t block_height = get_block_height(miner_tx);
+  CHECK_AND_ASSERT_MES(m_core_runtime_config.is_hardfork_active_for_height(1, block_height), false, "error in block [" << block_height << "]: etc_tx_details_unlock_time was not found but etc_tx_details_unlock_time2 can exist only after hard fork 1 at height " << m_core_runtime_config.hard_forks.get_str_height_the_hardfork_active_after(1));
 
   //etc_tx_details_unlock_time2 can be kept only after hard_fork_1 point
   etc_tx_details_unlock_time2 ut2 = AUTO_VAL_INIT(ut2);
-  get_type_in_variant_container(miner_tx.extra, ut2);
+  bool found = get_type_in_variant_container(miner_tx.extra, ut2);
+  CHECK_AND_ASSERT_MES(found, false, "etc_tx_details_unlock_time2 was not found in tx extra");
   CHECK_AND_ASSERT_MES(ut2.unlock_time_array.size() == miner_tx.vout.size(), false, "ut2.unlock_time_array.size()<" << ut2.unlock_time_array.size() 
     << "> != miner_tx.vout.size()<" << miner_tx.vout.size() << ">");
   
@@ -5232,7 +5235,7 @@ bool blockchain_storage::validate_pos_block(const block& b,
     r = check_tx_input(b.miner_tx, 1, coinstake_in, id, max_related_block_height, source_max_unlock_time_for_pos_coinbase);
     CHECK_AND_ASSERT_MES(r, false, "Failed to validate coinstake input in miner tx, block_id = " << get_block_hash(b));
 
-    if (get_block_height(b) > m_core_runtime_config.hard_forks.hard_fork_01_starts_after_height)
+    if (m_core_runtime_config.is_hardfork_active_for_height(1, get_block_height(b)))
     {
       uint64_t last_pow_h = get_last_x_block_height(false);
       CHECK_AND_ASSERT_MES(max_related_block_height <= last_pow_h, false, "Failed to validate coinbase in PoS block, condition failed: max_related_block_height(" << max_related_block_height << ") <= last_pow_h(" << last_pow_h << ")");
@@ -5868,65 +5871,23 @@ bool blockchain_storage::update_next_comulative_size_limit()
   return true;
 }
 //------------------------------------------------------------------
-bool blockchain_storage::is_after_hardfork_1_zone()const
+bool blockchain_storage::is_hardfork_active(size_t hardfork_id) const
 {
-  return is_after_hardfork_1_zone(m_db_blocks.size());
-}
-//------------------------------------------------------------------
-bool blockchain_storage::is_after_hardfork_1_zone(uint64_t height)const
-{
-  if (height > m_core_runtime_config.hard_forks.hard_fork_01_starts_after_height)
-    return true;
-  return false;
-}
-//------------------------------------------------------------------
-bool blockchain_storage::is_after_hardfork_2_zone()const
-{
-  return is_after_hardfork_2_zone(m_db_blocks.size());
-}
-//------------------------------------------------------------------
-bool blockchain_storage::is_after_hardfork_3_zone()const
-{
-  return is_after_hardfork_3_zone(m_db_blocks.size());
-}
-//------------------------------------------------------------------
-bool blockchain_storage::is_after_hardfork_2_zone(uint64_t height)const
-{
-  if (height > m_core_runtime_config.hard_forks.hard_fork_02_starts_after_height)
-    return true;
-  return false;
-}
-//------------------------------------------------------------------
-bool blockchain_storage::is_after_hardfork_3_zone(uint64_t height)const
-{
-  if (height > m_core_runtime_config.hard_forks.hard_fork_03_starts_after_height)
-    return true;
-  return false;
-}
-//------------------------------------------------------------------
-bool blockchain_storage::is_after_hardfork_4_zone()const
-{
-  return is_after_hardfork_4_zone(m_db_blocks.size());
-}
-//------------------------------------------------------------------
-bool blockchain_storage::is_after_hardfork_4_zone(uint64_t height)const
-{
-  if (height > m_core_runtime_config.hard_forks.hard_fork_04_starts_after_height)
-    return true;
-  return false;
+  return m_core_runtime_config.is_hardfork_active_for_height(hardfork_id, m_db_blocks.size()); // note using m_db_blocks.size() ( == top_block_height + 1 )
 }
 //------------------------------------------------------------------
 bool blockchain_storage::prevalidate_block(const block& bl)
 {
+  uint64_t block_height = get_block_height(bl);
+
   //before hard_fork1
-  if (bl.major_version == BLOCK_MAJOR_VERSION_INITIAL && get_block_height(bl) <= m_core_runtime_config.hard_forks.hard_fork_01_starts_after_height)
+  if (bl.major_version == BLOCK_MAJOR_VERSION_INITIAL && !m_core_runtime_config.is_hardfork_active_for_height(1, block_height))
     return true;
 
 
   //after hard_fork1 and before hard_fork3
-  if ( get_block_height(bl) > m_core_runtime_config.hard_forks.hard_fork_01_starts_after_height  &&
-       get_block_height(bl) <= m_core_runtime_config.hard_forks.hard_fork_03_starts_after_height
-    )
+  if ( m_core_runtime_config.is_hardfork_active_for_height(1, block_height) &&
+      !m_core_runtime_config.is_hardfork_active_for_height(3, block_height))
   {
     if (bl.major_version <= HF1_BLOCK_MAJOR_VERSION )
       return true;
diff --git a/src/currency_core/blockchain_storage.h b/src/currency_core/blockchain_storage.h
index e927398a..5d0e66c3 100644
--- a/src/currency_core/blockchain_storage.h
+++ b/src/currency_core/blockchain_storage.h
@@ -664,14 +664,9 @@ namespace currency
     bool is_output_allowed_for_input(const output_key_or_htlc_v& out_v, const txin_v& in_v, uint64_t top_minus_source_height)const;
     bool is_output_allowed_for_input(const txout_to_key& out_v, const txin_v& in_v)const;
     bool is_output_allowed_for_input(const txout_htlc& out_v, const txin_v& in_v, uint64_t top_minus_source_height)const;
-    bool is_after_hardfork_1_zone()const;
-    bool is_after_hardfork_1_zone(uint64_t height)const;
-    bool is_after_hardfork_2_zone()const;
-    bool is_after_hardfork_2_zone(uint64_t height)const;
-    bool is_after_hardfork_3_zone()const;
-    bool is_after_hardfork_3_zone(uint64_t height)const;
-    bool is_after_hardfork_4_zone()const;
-    bool is_after_hardfork_4_zone(uint64_t height)const;
+
+    // returns true as soon as the hardfork is active for the NEXT upcoming block (not for the top block in the blockchain storage)
+    bool is_hardfork_active(size_t hardfork_id) const;
 
 
 
diff --git a/src/currency_core/core_runtime_config.h b/src/currency_core/core_runtime_config.h
index 1f8aa1e6..310f697f 100644
--- a/src/currency_core/core_runtime_config.h
+++ b/src/currency_core/core_runtime_config.h
@@ -10,16 +10,52 @@
 
 namespace currency
 {
-  typedef uint64_t (*core_time_func_t)();
-  
   struct hard_forks_descriptor
   {
-    uint64_t hard_fork_01_starts_after_height = 0;
-    uint64_t hard_fork_02_starts_after_height = 0;
-    uint64_t hard_fork_03_starts_after_height = 0;
-    uint64_t hard_fork_04_starts_after_height = UINT64_MAX;
+    constexpr static size_t m_total_count = 5;
+    std::array<uint64_t, m_total_count> m_height_the_hardfork_n_active_after;
+
+    hard_forks_descriptor()
+    {
+      m_height_the_hardfork_n_active_after.fill(CURRENCY_MAX_BLOCK_NUMBER);
+    }
+
+    void set_hardfork_height(size_t hardfork_id, uint64_t height_the_hardfork_is_active_after)
+    {
+      CHECK_AND_ASSERT_THROW_MES(hardfork_id < m_total_count, "invalid hardfork id: " << hardfork_id);
+      m_height_the_hardfork_n_active_after[hardfork_id] = height_the_hardfork_is_active_after;
+    }
+
+    bool is_hardfork_active_for_height(size_t hardfork_id, uint64_t height) const
+    {
+      if (hardfork_id == 0)
+        return true; // hardfork #0 is a special case that is considered always active 
+      CHECK_AND_ASSERT_THROW_MES(hardfork_id < m_total_count, "invalid hardfork id: " << hardfork_id);
+      return height > m_height_the_hardfork_n_active_after[hardfork_id];
+    }
+
+    std::string get_str_height_the_hardfork_active_after(size_t hardfork_id) const
+    {
+      if (hardfork_id == 0)
+        return "0"; // hardfork #0 is a special case that is considered always active 
+      CHECK_AND_ASSERT_THROW_MES(hardfork_id < m_total_count, "invalid hardfork id: " << hardfork_id);
+      return epee::string_tools::num_to_string_fast(m_height_the_hardfork_n_active_after[hardfork_id]);
+    }
+
+    size_t get_the_most_recent_hardfork_id_for_height(uint64_t height) const
+    {
+      for(size_t hid = m_total_count - 1; hid != 0; --hid) // 0 is not including
+      {
+        if(is_hardfork_active_for_height(hid, height))
+          return hid;
+      }
+      return 0;
+    }
   };
 
+
+  typedef uint64_t (*core_time_func_t)();
+
   struct core_runtime_config
   {
     uint64_t min_coinstake_age;
@@ -34,15 +70,7 @@ namespace currency
 
     bool is_hardfork_active_for_height(size_t hardfork_id, uint64_t height) const
     {
-      switch (hardfork_id)
-      {
-      case ZANO_HARDFORK_00_INITAL: return true;
-      case ZANO_HARDFORK_01: return height > hard_forks.hard_fork_01_starts_after_height;
-      case ZANO_HARDFORK_02: return height > hard_forks.hard_fork_02_starts_after_height;
-      case ZANO_HARDFORK_03: return height > hard_forks.hard_fork_03_starts_after_height;
-      case ZANO_HARDFORK_04_ZARCANUM: return height > hard_forks.hard_fork_04_starts_after_height;
-      default: return false;
-      }
+      return hard_forks.is_hardfork_active_for_height(hardfork_id, height);
     }
 
     static uint64_t _default_core_time_function()
@@ -60,10 +88,11 @@ namespace currency
     pc.tx_default_fee = TX_DEFAULT_FEE;
     pc.max_alt_blocks = CURRENCY_ALT_BLOCK_MAX_COUNT;
     
-    pc.hard_forks.hard_fork_01_starts_after_height = ZANO_HARDFORK_01_AFTER_HEIGHT;
-    pc.hard_forks.hard_fork_02_starts_after_height = ZANO_HARDFORK_02_AFTER_HEIGHT;
-    pc.hard_forks.hard_fork_03_starts_after_height = ZANO_HARDFORK_03_AFTER_HEIGHT;
-    pc.hard_forks.hard_fork_04_starts_after_height = ZANO_HARDFORK_04_AFTER_HEIGHT;
+    // TODO: refactor the following
+    pc.hard_forks.set_hardfork_height(1, ZANO_HARDFORK_01_AFTER_HEIGHT);
+    pc.hard_forks.set_hardfork_height(2, ZANO_HARDFORK_02_AFTER_HEIGHT);
+    pc.hard_forks.set_hardfork_height(3, ZANO_HARDFORK_03_AFTER_HEIGHT);
+    pc.hard_forks.set_hardfork_height(4, ZANO_HARDFORK_04_AFTER_HEIGHT);
     
     pc.get_core_time = &core_runtime_config::_default_core_time_function;
     bool r = epee::string_tools::hex_to_pod(ALIAS_SHORT_NAMES_VALIDATION_PUB_KEY, pc.alias_validation_pubkey);
diff --git a/src/currency_core/currency_basic.h b/src/currency_core/currency_basic.h
index 3f17ca18..85641f31 100644
--- a/src/currency_core/currency_basic.h
+++ b/src/currency_core/currency_basic.h
@@ -954,7 +954,7 @@ SET_VARIANT_TAGS(crypto::bpp_signature_serialized, 40, "bpp_signature_serialized
 SET_VARIANT_TAGS(crypto::bppe_signature_serialized, 41, "bppe_signature_serialized");
 SET_VARIANT_TAGS(currency::NLSAG_sig, 42, "NLSAG_sig");
 SET_VARIANT_TAGS(currency::zarcanum_sig, 43, "zarcanum_sig");
-SET_VARIANT_TAGS(currency::void_sig, 43, "void_sig");
+SET_VARIANT_TAGS(currency::void_sig, 44, "void_sig");
 
 
 
diff --git a/src/currency_core/currency_basic_backward_comp.inl b/src/currency_core/currency_basic_backward_comp.inl
index b6e9a684..4e3bf92a 100644
--- a/src/currency_core/currency_basic_backward_comp.inl
+++ b/src/currency_core/currency_basic_backward_comp.inl
@@ -100,11 +100,12 @@ bool transition_convert(const transaction_current_t& from, transaction_v1& to)
   }
   return true;
 }
+
 template<typename transaction_current_t>
 bool transition_convert(const transaction_v1& from, transaction_current_t& to)
 {
+  // TODO: consider using move semantic for 'from'
   to.attachment = from.attachment;
-  to.signature = NLSAG_sig();
-  boost::get<NLSAG_sig>(to.signature).s = from.signatures;
+  to.signature = NLSAG_sig({from.signatures});
   return true;
-}
\ No newline at end of file
+}
diff --git a/src/currency_core/currency_core.cpp b/src/currency_core/currency_core.cpp
index 0f526c7a..b4c3d25c 100644
--- a/src/currency_core/currency_core.cpp
+++ b/src/currency_core/currency_core.cpp
@@ -508,11 +508,16 @@ namespace currency
     if (r && bvc.m_added_to_main_chain)
     {
       uint64_t h = get_block_height(b);
-      auto& crc = m_blockchain_storage.get_core_runtime_config();
-      if (h == crc.hard_forks.hard_fork_01_starts_after_height + 1)
-      { LOG_PRINT_GREEN("Hardfork 1 activated at height " << h, LOG_LEVEL_0); }
-      else if (h == crc.hard_forks.hard_fork_02_starts_after_height + 1)
-      { LOG_PRINT_GREEN("Hardfork 2 activated at height " << h, LOG_LEVEL_0); }
+      if (h > 0)
+      {
+        auto& crc = m_blockchain_storage.get_core_runtime_config();
+        size_t hardfork_id_for_prev_block = crc.hard_forks.get_the_most_recent_hardfork_id_for_height(h - 1);
+        size_t hardfork_id_for_curr_block = crc.hard_forks.get_the_most_recent_hardfork_id_for_height(h);
+        if (hardfork_id_for_prev_block != hardfork_id_for_curr_block)
+        {
+          LOG_PRINT_GREEN("Hardfork " << hardfork_id_for_curr_block << " activated at height " << h, LOG_LEVEL_0);
+        }
+      }
 
       if (h == m_stop_after_height)
       {
diff --git a/src/currency_core/currency_format_utils.cpp b/src/currency_core/currency_format_utils.cpp
index 83a807da..7b5cd146 100644
--- a/src/currency_core/currency_format_utils.cpp
+++ b/src/currency_core/currency_format_utils.cpp
@@ -1584,7 +1584,7 @@ namespace currency
   //---------------------------------------------------------------
   uint64_t get_tx_version(uint64_t h, const hard_forks_descriptor& hfd)
   {
-    if (h <= hfd.hard_fork_04_starts_after_height)
+    if (!hfd.is_hardfork_active_for_height(4, h))
     {
       return TRANSACTION_VERSION_PRE_HF4;
     }
diff --git a/src/currency_core/currency_format_utils.h b/src/currency_core/currency_format_utils.h
index d6f9fd3c..21e0cea4 100644
--- a/src/currency_core/currency_format_utils.h
+++ b/src/currency_core/currency_format_utils.h
@@ -714,7 +714,7 @@ namespace currency
   template <typename container_t>
   void create_and_add_tx_payer_to_container_from_address(container_t& container, const account_public_address& addr, uint64_t top_block_height, const core_runtime_config& crc)
   {
-    if (top_block_height > crc.hard_forks.hard_fork_02_starts_after_height)
+    if (crc.is_hardfork_active_for_height(2, top_block_height))
     {
       // after hardfork 2
       tx_payer result = AUTO_VAL_INIT(result);
@@ -736,7 +736,7 @@ namespace currency
   template <typename container_t>
   void create_and_add_tx_receiver_to_container_from_address(container_t& container, const account_public_address& addr, uint64_t top_block_height, const core_runtime_config& crc)
   {
-    if (top_block_height > crc.hard_forks.hard_fork_02_starts_after_height)
+    if (crc.is_hardfork_active_for_height(2, top_block_height))
     {
       // after hardfork 2
       tx_receiver result = AUTO_VAL_INIT(result);
diff --git a/src/daemon/daemon_commands_handler.h b/src/daemon/daemon_commands_handler.h
index 78d2ffef..ac7de2c8 100644
--- a/src/daemon/daemon_commands_handler.h
+++ b/src/daemon/daemon_commands_handler.h
@@ -663,11 +663,18 @@ private:
         auto ptx = bcs.get_tx(h);
         CHECK_AND_ASSERT_MES(ptx != nullptr, false, "failed to find transaction " << h << " in blockchain index, in block on height = " << height);
 
-        if (ptx->signatures.size() == 0)
-          pruned_txs += 1;
+        VARIANT_SWITCH_BEGIN(ptx->signature);
+        VARIANT_CASE(currency::NLSAG_sig, nlsag)
+        {
+          if (nlsag.s.size() == 0)
+            pruned_txs += 1;
+          signatures += nlsag.s.size();
+        }
+        VARIANT_CASE(currency::zarcanum_sig, zs);
+        // @#@
+        VARIANT_SWITCH_END();
 
         txs += 1;
-        signatures += ptx->signatures.size();
         attachments += ptx->attachment.size();
       }
     }
diff --git a/src/gui/qt-daemon/layout b/src/gui/qt-daemon/layout
index 32b34f8e..b091d45a 160000
--- a/src/gui/qt-daemon/layout
+++ b/src/gui/qt-daemon/layout
@@ -1 +1 @@
-Subproject commit 32b34f8ea235b91360d4bc5eb5eefde293680759
+Subproject commit b091d45ad697db2d35e94de41be3f175bad0f71d
diff --git a/src/serialization/serialization.h b/src/serialization/serialization.h
index 5af187fa..fa1565b0 100644
--- a/src/serialization/serialization.h
+++ b/src/serialization/serialization.h
@@ -235,6 +235,7 @@ struct transition_t<false, destination_t>
   template <typename archive, typename origin_type>
   static bool chain_serialize(archive &ar, origin_type& origin_tx)
   {
+    // TODO: consider using move semantic for temporary 'dst_tx'
     destination_t dst_tx = AUTO_VAL_INIT(dst_tx);
     bool r = dst_tx.do_serialize(ar);
     if (!r) return r;
diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp
index 19b981cb..2bc3b1b0 100644
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@@ -3759,7 +3759,7 @@ bool wallet2::is_transfer_unlocked(const transfer_details& td, bool for_pos_mini
   
 
   uint64_t unlock_time = get_tx_unlock_time(td.m_ptx_wallet_info->m_tx, td.m_internal_output_index);
-  if (for_pos_mining && get_blockchain_current_size() > m_core_runtime_config.hard_forks.hard_fork_01_starts_after_height)
+  if (for_pos_mining && m_core_runtime_config.is_hardfork_active_for_height(1, get_blockchain_current_size()))
   {
     //allowed of staking locked coins with 
     stake_lock_time = unlock_time;
@@ -3845,7 +3845,7 @@ void wallet2::update_offer_by_id(const crypto::hash& tx_id, uint64_t of_ind, con
 //----------------------------------------------------------------------------------------------------
 void wallet2::push_alias_info_to_extra_according_to_hf_status(const currency::extra_alias_entry& ai, std::vector<currency::extra_v>& extra)
 {
-  if (get_top_block_height() > m_core_runtime_config.hard_forks.hard_fork_02_starts_after_height)
+  if (m_core_runtime_config.is_hardfork_active_for_height(2, get_top_block_height()))
   {
     // after HF2
     extra.push_back(ai);
diff --git a/tests/core_tests/alias_tests.cpp b/tests/core_tests/alias_tests.cpp
index 6156e7a2..108ed432 100644
--- a/tests/core_tests/alias_tests.cpp
+++ b/tests/core_tests/alias_tests.cpp
@@ -96,8 +96,8 @@ gen_alias_tests::gen_alias_tests()
   REGISTER_CALLBACK_METHOD(gen_alias_tests, check_height_changed);
   REGISTER_CALLBACK_METHOD(gen_alias_tests, check_too_many_aliases_registration);
 
-  m_hardforks.hard_fork_01_starts_after_height = 0;
-  m_hardforks.hard_fork_02_starts_after_height = 0;
+  m_hardforks.set_hardfork_height(1, 0);
+  m_hardforks.set_hardfork_height(2, 0);
 }
 
 bool gen_alias_tests::generate(std::vector<test_event_entry>& events) const
diff --git a/tests/core_tests/atomic_tests.cpp b/tests/core_tests/atomic_tests.cpp
index 05d54d3e..bf852eda 100644
--- a/tests/core_tests/atomic_tests.cpp
+++ b/tests/core_tests/atomic_tests.cpp
@@ -72,9 +72,10 @@ bool atomic_base_test::configure_core(currency::core& c, size_t ev_index, const
   currency::core_runtime_config pc = c.get_blockchain_storage().get_core_runtime_config();
   pc.min_coinstake_age = TESTS_POS_CONFIG_MIN_COINSTAKE_AGE; //four blocks
   pc.pos_minimum_heigh = TESTS_POS_CONFIG_POS_MINIMUM_HEIGH; //four blocks
-  pc.hard_forks.hard_fork_01_starts_after_height = 10;
-  pc.hard_forks.hard_fork_02_starts_after_height = 11;
-  pc.hard_forks.hard_fork_03_starts_after_height = 12;
+
+  pc.hard_forks.set_hardfork_height(1, 10);
+  pc.hard_forks.set_hardfork_height(2, 11);
+  pc.hard_forks.set_hardfork_height(3, 12);
   c.get_blockchain_storage().set_core_runtime_config(pc);
   return true;
 }
@@ -635,9 +636,9 @@ bool atomic_test_check_hardfork_rules::configure_core(currency::core& c, size_t
   currency::core_runtime_config pc = c.get_blockchain_storage().get_core_runtime_config();
   pc.min_coinstake_age = TESTS_POS_CONFIG_MIN_COINSTAKE_AGE; //four blocks
   pc.pos_minimum_heigh = TESTS_POS_CONFIG_POS_MINIMUM_HEIGH; //four blocks
-  pc.hard_forks.hard_fork_01_starts_after_height = 10;
-  pc.hard_forks.hard_fork_02_starts_after_height = 10;
-  pc.hard_forks.hard_fork_03_starts_after_height = 10;
+  pc.hard_forks.set_hardfork_height(1, 10);
+  pc.hard_forks.set_hardfork_height(2, 10);
+  pc.hard_forks.set_hardfork_height(3, 10);
   c.get_blockchain_storage().set_core_runtime_config(pc);
   return true;
 }
@@ -668,9 +669,9 @@ bool atomic_test_check_hardfork_rules::c1(currency::core& c, size_t ev_index, co
   currency::core_runtime_config pc = c.get_blockchain_storage().get_core_runtime_config();
   pc.min_coinstake_age = TESTS_POS_CONFIG_MIN_COINSTAKE_AGE; //four blocks
   pc.pos_minimum_heigh = TESTS_POS_CONFIG_POS_MINIMUM_HEIGH; //four blocks
-  pc.hard_forks.hard_fork_01_starts_after_height = 10;
-  pc.hard_forks.hard_fork_02_starts_after_height = 10;
-  pc.hard_forks.hard_fork_03_starts_after_height = 30;
+  pc.hard_forks.set_hardfork_height(1, 10);
+  pc.hard_forks.set_hardfork_height(2, 10);
+  pc.hard_forks.set_hardfork_height(3, 30);
   c.get_blockchain_storage().set_core_runtime_config(pc);
 
   bool r = mine_next_pow_block_in_playtime(m_mining_accunt.get_public_address(), c);
diff --git a/tests/core_tests/block_validation.cpp b/tests/core_tests/block_validation.cpp
index 8f39feb0..b9d1962e 100644
--- a/tests/core_tests/block_validation.cpp
+++ b/tests/core_tests/block_validation.cpp
@@ -626,9 +626,9 @@ bool gen_block_wrong_version_agains_hardfork::c1(currency::core& c, size_t ev_in
   currency::core_runtime_config pc = c.get_blockchain_storage().get_core_runtime_config();
   pc.min_coinstake_age = TESTS_POS_CONFIG_MIN_COINSTAKE_AGE; //four blocks
   pc.pos_minimum_heigh = TESTS_POS_CONFIG_POS_MINIMUM_HEIGH; //four blocks
-  pc.hard_forks.hard_fork_01_starts_after_height = 10;
-  pc.hard_forks.hard_fork_02_starts_after_height = 10;
-  pc.hard_forks.hard_fork_03_starts_after_height = 10;
+  pc.hard_forks.set_hardfork_height(1, 10);
+  pc.hard_forks.set_hardfork_height(2, 10);
+  pc.hard_forks.set_hardfork_height(3, 10);
   c.get_blockchain_storage().set_core_runtime_config(pc);
 
   currency::account_base mining_accunt;
@@ -645,9 +645,9 @@ bool gen_block_wrong_version_agains_hardfork::c1(currency::core& c, size_t ev_in
   };
 
   //between 1 and 2 hardforks
-  pc.hard_forks.hard_fork_01_starts_after_height = 1;
-  pc.hard_forks.hard_fork_02_starts_after_height = 10;
-  pc.hard_forks.hard_fork_03_starts_after_height = 20;
+  pc.hard_forks.set_hardfork_height(1, 1);
+  pc.hard_forks.set_hardfork_height(2, 10);
+  pc.hard_forks.set_hardfork_height(3, 20);
   c.get_blockchain_storage().set_core_runtime_config(pc);
 
   //major unknown
@@ -663,9 +663,9 @@ bool gen_block_wrong_version_agains_hardfork::c1(currency::core& c, size_t ev_in
   CHECK_TEST_CONDITION(r);
 
   //between 1 and 2 hardforks
-  pc.hard_forks.hard_fork_01_starts_after_height = 1;
-  pc.hard_forks.hard_fork_02_starts_after_height = 1;
-  pc.hard_forks.hard_fork_03_starts_after_height = 1;
+  pc.hard_forks.set_hardfork_height(1, 1);
+  pc.hard_forks.set_hardfork_height(2, 1);
+  pc.hard_forks.set_hardfork_height(3, 1);
   c.get_blockchain_storage().set_core_runtime_config(pc);
 
 
diff --git a/tests/core_tests/block_validation.h b/tests/core_tests/block_validation.h
index 95f9cef4..0ce700ba 100644
--- a/tests/core_tests/block_validation.h
+++ b/tests/core_tests/block_validation.h
@@ -13,10 +13,7 @@ class gen_block_verification_base : public test_chain_unit_base
 public:
   gen_block_verification_base()
   {
-    m_hardforks.hard_fork_01_starts_after_height = 0;
-    m_hardforks.hard_fork_02_starts_after_height = 0;
-    m_hardforks.hard_fork_03_starts_after_height = 0;
-    m_hardforks.hard_fork_04_starts_after_height = 0;
+    m_hardforks.m_height_the_hardfork_n_active_after.fill(0);
 
     REGISTER_CALLBACK("check_block_purged", gen_block_verification_base<invalid_block_idx>::check_block_purged);
   }
diff --git a/tests/core_tests/chain_switch_pow_pos.cpp b/tests/core_tests/chain_switch_pow_pos.cpp
index f036dd5c..73512246 100644
--- a/tests/core_tests/chain_switch_pow_pos.cpp
+++ b/tests/core_tests/chain_switch_pow_pos.cpp
@@ -81,7 +81,7 @@ bool gen_chain_switch_pow_pos::generate(std::vector<test_event_entry>& events) c
   block plk_2 = AUTO_VAL_INIT(plk_2);
   generator.construct_block(events, plk_2, blk_1, miner_acc, std::list<transaction>(1, tx_2), miner_stake_sources);
   events.push_back(plk_2);                                                                    // N+10
-  PRINT_EVENT_NO(events);
+  PRINT_EVENT_N(events);
 
   /* legend: (n) - PoW block, !m! - PoS block
      0....10    11    12   <-- blockchain height
diff --git a/tests/core_tests/chaingen.cpp b/tests/core_tests/chaingen.cpp
index a70b691c..b4d8993b 100644
--- a/tests/core_tests/chaingen.cpp
+++ b/tests/core_tests/chaingen.cpp
@@ -53,10 +53,6 @@ test_generator::test_generator()
   , m_ignore_last_pow_in_wallets(false)
   , m_last_found_timestamp(0)
 {
-  m_hardforks.hard_fork_01_starts_after_height = CURRENCY_MAX_BLOCK_NUMBER;
-  m_hardforks.hard_fork_02_starts_after_height = CURRENCY_MAX_BLOCK_NUMBER;
-  m_hardforks.hard_fork_03_starts_after_height = CURRENCY_MAX_BLOCK_NUMBER;
-  m_hardforks.hard_fork_04_starts_after_height = CURRENCY_MAX_BLOCK_NUMBER;
 }
 
 
@@ -67,14 +63,7 @@ void test_generator::set_hardforks(const currency::hard_forks_descriptor& hardfo
 
 void test_generator::set_hardfork_height(size_t hardfork_id, uint64_t h)
 {
-  switch (hardfork_id)
-  {
-  case 1: m_hardforks.hard_fork_01_starts_after_height = h; break;
-  case 2: m_hardforks.hard_fork_02_starts_after_height = h; break;
-  case 3: m_hardforks.hard_fork_03_starts_after_height = h; break;
-  case 4: m_hardforks.hard_fork_04_starts_after_height = h; break;
-  default: CHECK_AND_ASSERT_THROW_MES(false, "invalid hardfork id: " << hardfork_id)
-  }
+  m_hardforks.set_hardfork_height(hardfork_id, h);
 }
 
 void test_generator::get_block_chain(std::vector<const block_info*>& blockchain, const crypto::hash& head, size_t n) const
@@ -168,7 +157,8 @@ void test_generator::add_block(const currency::block& blk,
   uint64_t block_reward;
   get_block_reward(is_pos_block(blk), misc_utils::median(block_sizes), block_size, already_generated_coins, block_reward, currency::get_block_height(blk));
 
-  m_blocks_info[get_block_hash(blk)] = block_info(blk, already_generated_coins + block_reward, block_size, cum_diff, tx_list, ks_hash);
+  crypto::hash block_hash = get_block_hash(blk);
+  m_blocks_info[block_hash] = block_info(blk, already_generated_coins + block_reward, block_size, cum_diff, tx_list, ks_hash);
  
   
   std::stringstream ss_tx_hashes;
@@ -177,7 +167,7 @@ void test_generator::add_block(const currency::block& blk,
     ss_tx_hashes << "    [tx]: " << h << ENDL;
   }
 
-  LOG_PRINT_MAGENTA("ADDED_BLOCK[" << get_block_hash(blk) << "][" << (is_pos_block(blk)? "PoS":"PoW") <<"][" << get_block_height(blk) << "][cumul_diff:" << cum_diff << "]" << ENDL << ss_tx_hashes.str(), LOG_LEVEL_0);
+  LOG_PRINT_MAGENTA("ADDED_BLOCK[" << block_hash << "][" << (is_pos_block(blk)? "PoS":"PoW") <<"][" << get_block_height(blk) << "][cumul_diff:" << cum_diff << "]" << ENDL << ss_tx_hashes.str(), LOG_LEVEL_0);
 }
 
 void test_generator::add_block_info(const block_info& bi)
@@ -232,9 +222,9 @@ bool test_generator::construct_block(currency::block& blk,
 //   else
 //     blk.major_version = BLOCK_MAJOR_VERSION_INITIAL;
 
-  if (height <= m_hardforks.hard_fork_01_starts_after_height)
+  if (!m_hardforks.is_hardfork_active_for_height(1, height))
     blk.major_version = BLOCK_MAJOR_VERSION_INITIAL;
-  else if (height <= m_hardforks.hard_fork_03_starts_after_height)
+  else if (!m_hardforks.is_hardfork_active_for_height(3, height))
     blk.major_version = HF1_BLOCK_MAJOR_VERSION;
   else
     blk.major_version = CURRENT_BLOCK_MAJOR_VERSION;
@@ -523,7 +513,7 @@ bool test_generator::find_kernel(const std::list<currency::account_base>& accs,
   uint64_t& found_timestamp,
   crypto::hash& found_kh)
 {
-  bool is_after_hardfork_01 = blck_chain.size() > m_hardforks.hard_fork_01_starts_after_height ? true : false;
+  //bool is_after_hardfork_01 = m_hardforks.is_hardfork_active_for_height(1, blck_chain.size());
   uint64_t median_timestamp = get_timestamps_median(blck_chain);
   wide_difficulty_type basic_diff = 0;
 
@@ -845,7 +835,7 @@ bool test_generator::construct_block(int64_t manual_timestamp_adjustment,
   std::vector<currency::block> blockchain;
   map_hash2tx_t mtx;
   bool r = find_block_chain(events, blockchain, mtx, get_block_hash(blk_prev));
-  CHECK_AND_ASSERT_MES(r, false, "can't find a blockchain up from given blk_prev");
+  CHECK_AND_ASSERT_MES(r, false, "can't find a blockchain up from given blk_prev with hash " << get_block_hash(blk_prev) << " @ height " << get_block_height(blk_prev));
   bool pos_bl = coin_stake_sources.size();
   bool adjust_timestamp_finished = have_n_blocks_of_type(blockchain, pos_bl);
   uint64_t diff_up_timestamp_delta = POW_DIFF_UP_TIMESTAMP_DELTA;
@@ -1647,14 +1637,17 @@ void get_confirmed_txs(const std::vector<currency::block>& blockchain, const map
   }
 }
 
-bool find_block_chain(const std::vector<test_event_entry>& events, std::vector<currency::block>& blockchain, map_hash2tx_t& mtx, const crypto::hash& head) {
+bool find_block_chain(const std::vector<test_event_entry>& events, std::vector<currency::block>& blockchain, map_hash2tx_t& mtx, const crypto::hash& head)
+{
   std::unordered_map<crypto::hash, const block*> block_index;
-  BOOST_FOREACH(const test_event_entry& ev, events)
+  for(size_t i = 0, sz = events.size(); i < sz; ++i)
   {
+    const test_event_entry& ev = events[i];
     if (typeid(currency::block) == ev.type())
     {
       const block* blk = &boost::get<block>(ev);
-      block_index[get_block_hash(*blk)] = blk;
+      crypto::hash h = get_block_hash(*blk);
+      block_index[h] = blk;
     }
     else if (typeid(event_special_block) == ev.type())
     {
@@ -2125,11 +2118,6 @@ test_chain_unit_enchanced::test_chain_unit_enchanced()
   , m_invalid_tx_index(std::numeric_limits<size_t>::max())
   , m_unverifiable_tx_index(std::numeric_limits<size_t>::max())
 {
-  m_hardforks.hard_fork_01_starts_after_height = CURRENCY_MAX_BLOCK_NUMBER;
-  m_hardforks.hard_fork_01_starts_after_height = CURRENCY_MAX_BLOCK_NUMBER;
-  m_hardforks.hard_fork_01_starts_after_height = CURRENCY_MAX_BLOCK_NUMBER;
-  m_hardforks.hard_fork_01_starts_after_height = CURRENCY_MAX_BLOCK_NUMBER;
-
 
   REGISTER_CALLBACK_METHOD(test_chain_unit_enchanced, configure_core);
   REGISTER_CALLBACK_METHOD(test_chain_unit_enchanced, mark_invalid_tx);
diff --git a/tests/core_tests/chaingen.h b/tests/core_tests/chaingen.h
index 6a3d7f5d..c1a9a9e7 100644
--- a/tests/core_tests/chaingen.h
+++ b/tests/core_tests/chaingen.h
@@ -235,8 +235,10 @@ public:
   bool need_core_proxy() const { return false; }  // tests can override this in order to obtain core proxy (e.g. for wallet)
   void set_core_proxy(std::shared_ptr<tools::i_core_proxy>) { /* do nothing */ }
   uint64_t get_tx_version_from_events(const std::vector<test_event_entry> &events) const;
+
 private:
   callbacks_map m_callbacks;
+
 protected: 
   currency::hard_forks_descriptor m_hardforks;
 };
@@ -326,9 +328,6 @@ protected:
   size_t m_invalid_tx_index;
   size_t m_unverifiable_tx_index;
   size_t m_orphan_block_index;
-
-  // the following members is intended to be set by coretests with specific HF-related needs 
-  //currency::hard_forks_descriptor m_hardforks;
 };
 
 struct wallet_test_core_proxy;
@@ -533,6 +532,8 @@ public:
   void set_ignore_last_pow_in_wallets(bool ignore_last_pow_in_wallets) { m_ignore_last_pow_in_wallets = ignore_last_pow_in_wallets; }
   void set_hardfork_height(size_t hardfork_id, uint64_t h);
   void set_hardforks(const currency::hard_forks_descriptor& hardforks);
+  const currency::hard_forks_descriptor& get_hardforks() const { return m_hardforks; }
+
 
 private:
   bool m_do_pos_to_low_timestamp;
@@ -544,7 +545,7 @@ private:
   std::unordered_map<crypto::hash, block_info> m_blocks_info;
   static test_gentime_settings m_test_gentime_settings;
   static test_gentime_settings m_test_gentime_settings_default;
-};
+}; // class class test_generator
 
 extern const crypto::signature invalid_signature; // invalid non-null signature for test purpose
 static const std::vector<currency::extra_v> empty_extra;
@@ -959,42 +960,44 @@ void append_vector_by_another_vector(U& dst, const V& src)
 //--------------------------------------------------------------------------
 
 
-#define PRINT_EVENT_NO(VEC_EVENTS) std::cout << concolor::yellow << "+EVENT # " << VEC_EVENTS.size()-1 << ": line " << STR(__LINE__) << concolor::normal << std::endl;
+#define PRINT_EVENT_N(VEC_EVENTS)            std::cout << concolor::yellow << ">EVENT # " << VEC_EVENTS.size() << ", line " << STR(__LINE__) << concolor::normal << std::endl
+#define PRINT_EVENT_N_TEXT(VEC_EVENTS, text) std::cout << concolor::yellow << ">EVENT # " << VEC_EVENTS.size() << ", line " << STR(__LINE__) << "  " << text << concolor::normal << std::endl
 
 
-#define GENERATE_ACCOUNT(account) \
-  currency::account_base account; \
-  account.generate();
+#define GENERATE_ACCOUNT(account)                                                     \
+  currency::account_base account;                                                     \
+  account.generate()
 
-#define MAKE_ACCOUNT(VEC_EVENTS, account) \
-  currency::account_base account; \
-  account.generate(); \
-  VEC_EVENTS.push_back(account);
+#define MAKE_ACCOUNT(VEC_EVENTS, account)                                             \
+  PRINT_EVENT_N_TEXT(VEC_EVENTS, "MAKE_ACCOUNT(" << #account << ")");                 \
+  currency::account_base account;                                                     \
+  account.generate();                                                                 \
+  VEC_EVENTS.push_back(account)
 
 #define DO_CALLBACK(VEC_EVENTS, CB_NAME) \
-    { \
-  callback_entry CALLBACK_ENTRY; \
-  CALLBACK_ENTRY.callback_name = CB_NAME; \
-  VEC_EVENTS.push_back(CALLBACK_ENTRY); \
-  PRINT_EVENT_NO(VEC_EVENTS); \
-    }
+  {                                                                                   \
+    PRINT_EVENT_N_TEXT(VEC_EVENTS, "DO_CALLBACK(" << #CB_NAME << ")");                \
+    callback_entry CALLBACK_ENTRY;                                                    \
+    CALLBACK_ENTRY.callback_name = CB_NAME;                                           \
+    VEC_EVENTS.push_back(CALLBACK_ENTRY);                                             \
+  }
 
 #define DO_CALLBACK_PARAMS(VEC_EVENTS, CB_NAME, PARAMS_POD_OBJ)                       \
   {                                                                                   \
+    PRINT_EVENT_N_TEXT(VEC_EVENTS, "DO_CALLBACK_PARAMS(" << #CB_NAME << ")");         \
     callback_entry ce = AUTO_VAL_INIT(ce);                                            \
     ce.callback_name = CB_NAME;                                                       \
     ce.callback_params = epst::pod_to_hex(PARAMS_POD_OBJ);                            \
     VEC_EVENTS.push_back(ce);                                                         \
-    PRINT_EVENT_NO(VEC_EVENTS);                                                       \
   }
 
 #define DO_CALLBACK_PARAMS_STR(VEC_EVENTS, CB_NAME, STR_PARAMS)                       \
   {                                                                                   \
+    PRINT_EVENT_N_TEXT(VEC_EVENTS, "DO_CALLBACK_PARAMS_STR(" << #CB_NAME << ")");     \
     callback_entry ce = AUTO_VAL_INIT(ce);                                            \
     ce.callback_name = CB_NAME;                                                       \
     ce.callback_params = STR_PARAMS;                                                  \
     VEC_EVENTS.push_back(ce);                                                         \
-    PRINT_EVENT_NO(VEC_EVENTS);                                                       \
   }
 
 
@@ -1007,113 +1010,113 @@ void append_vector_by_another_vector(U& dst, const V& src)
   register_callback(#METHOD, boost::bind(&CLASS::METHOD, this, boost::placeholders::_1, boost::placeholders::_2, boost::placeholders::_3))
 
 #define MAKE_GENESIS_BLOCK(VEC_EVENTS, BLK_NAME, MINER_ACC, TS)                       \
+  PRINT_EVENT_N_TEXT(VEC_EVENTS, "MAKE_GENESIS_BLOCK(" << #BLK_NAME << ")");          \
   test_generator generator;                                                           \
   currency::block BLK_NAME = AUTO_VAL_INIT(BLK_NAME);                                 \
   generator.construct_genesis_block(BLK_NAME, MINER_ACC, TS);                         \
-  VEC_EVENTS.push_back(BLK_NAME);                                                     \
-  PRINT_EVENT_NO(VEC_EVENTS);
+  VEC_EVENTS.push_back(BLK_NAME)
 
 #define MAKE_NEXT_BLOCK(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC)                  \
+  PRINT_EVENT_N_TEXT(VEC_EVENTS, "MAKE_NEXT_BLOCK(" << #BLK_NAME << ")");             \
   currency::block BLK_NAME = AUTO_VAL_INIT(BLK_NAME);                                 \
   generator.construct_block(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC);             \
-  VEC_EVENTS.push_back(BLK_NAME);                                                     \
-  PRINT_EVENT_NO(VEC_EVENTS);
+  VEC_EVENTS.push_back(BLK_NAME)
 
 
 
-#define MAKE_NEXT_BLOCK_TIMESTAMP_ADJUSTMENT(ADJ, VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC)                  \
+#define MAKE_NEXT_BLOCK_TIMESTAMP_ADJUSTMENT(ADJ, VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC) \
+  PRINT_EVENT_N(VEC_EVENTS);                                                          \
   currency::block BLK_NAME = AUTO_VAL_INIT(BLK_NAME);                                 \
-  generator.construct_block(ADJ, VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC);             \
-  VEC_EVENTS.push_back(BLK_NAME);                                                     \
-  PRINT_EVENT_NO(VEC_EVENTS);
+  generator.construct_block(ADJ, VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC);        \
+  VEC_EVENTS.push_back(BLK_NAME)
 
-#define MAKE_NEXT_POS_BLOCK(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC, MINERS_ACC_LIST)         \
+#define MAKE_NEXT_POS_BLOCK(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC, MINERS_ACC_LIST) \
+  PRINT_EVENT_N(VEC_EVENTS);                                                          \
   currency::block BLK_NAME = AUTO_VAL_INIT(BLK_NAME);                                 \
-  generator.construct_block(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC, std::list<currency::transaction>(), MINERS_ACC_LIST);  \
-  VEC_EVENTS.push_back(BLK_NAME);                                                     \
-  PRINT_EVENT_NO(VEC_EVENTS)
+  generator.construct_block(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC, std::list<currency::transaction>(), MINERS_ACC_LIST); \
+  VEC_EVENTS.push_back(BLK_NAME)
 
 #define MAKE_NEXT_POS_BLOCK_TX1(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC, MINERS_ACC_LIST, TX_1)         \
+  PRINT_EVENT_N(VEC_EVENTS);                                                                                \
   currency::block BLK_NAME = AUTO_VAL_INIT(BLK_NAME);                                                       \
   {                                                                                                         \
     std::list<currency::transaction>tx_list;                                                                \
     tx_list.push_back(TX_1);                                                                                \
     generator.construct_block(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC, tx_list, MINERS_ACC_LIST);       \
   }                                                                                                         \
-  VEC_EVENTS.push_back(BLK_NAME);                                                                           \
-  PRINT_EVENT_NO(VEC_EVENTS)
+  VEC_EVENTS.push_back(BLK_NAME)
 
 #define MAKE_NEXT_BLOCK_NO_ADD(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC)           \
+  PRINT_EVENT_N(VEC_EVENTS);                                                          \
   currency::block BLK_NAME = AUTO_VAL_INIT(BLK_NAME);                                 \
   generator.construct_block(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC);             \
-  VEC_EVENTS.push_back(event_special_block(BLK_NAME, event_special_block::flag_skip)); \
-  PRINT_EVENT_NO(VEC_EVENTS)
+  VEC_EVENTS.push_back(event_special_block(BLK_NAME, event_special_block::flag_skip))
 
 #define ADD_BLOCK(VEC_EVENTS, BLK_NAME)                                               \
-  VEC_EVENTS.push_back(BLK_NAME);                                                     \
-  PRINT_EVENT_NO(VEC_EVENTS)
+  PRINT_EVENT_N_TEXT(VEC_EVENTS, "ADD_BLOCK(" << #BLK_NAME << ")");                   \
+  VEC_EVENTS.push_back(BLK_NAME)
 
 #define MAKE_NEXT_BLOCK_TX1(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC, TX1)         \
+  PRINT_EVENT_N_TEXT(VEC_EVENTS, "MAKE_NEXT_BLOCK_TX1(" << #BLK_NAME << ")");         \
   currency::block BLK_NAME = AUTO_VAL_INIT(BLK_NAME);                                 \
-    {                                                                                   \
-  std::list<currency::transaction> tx_list;                                         \
-  tx_list.push_back(TX1);                                                           \
-  generator.construct_block(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC, tx_list);              \
-    }                                                                                   \
-  VEC_EVENTS.push_back(BLK_NAME);                                                   \
-  PRINT_EVENT_NO(VEC_EVENTS)
+  {                                                                                   \
+    std::list<currency::transaction> tx_list;                                         \
+    tx_list.push_back(TX1);                                                           \
+    generator.construct_block(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC, tx_list);  \
+  }                                                                                   \
+  VEC_EVENTS.push_back(BLK_NAME)
 
 
 #define MAKE_NEXT_BLOCK_TX_LIST(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC, TXLIST)  \
+  PRINT_EVENT_N(VEC_EVENTS);                                                          \
   currency::block BLK_NAME = AUTO_VAL_INIT(BLK_NAME);                                 \
   generator.construct_block(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC, TXLIST);     \
-  VEC_EVENTS.push_back(BLK_NAME);                                                     \
-  PRINT_EVENT_NO(VEC_EVENTS)
+  VEC_EVENTS.push_back(BLK_NAME)
 
 #define REWIND_BLOCKS_N(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC, COUNT)           \
   currency::block BLK_NAME = AUTO_VAL_INIT(BLK_NAME);                                 \
-    {                                                                                   \
-  currency::block blk_last = PREV_BLOCK;                                            \
-  for (size_t i = 0; i < COUNT; ++i)                                                \
+  {                                                                                   \
+    currency::block blk_last = PREV_BLOCK;                                            \
+    for (size_t i = 0; i < COUNT; ++i)                                                \
     {                                                                                 \
-  MAKE_NEXT_BLOCK(VEC_EVENTS, blk, blk_last, MINER_ACC);                          \
-  blk_last = blk;                                                                 \
+      MAKE_NEXT_BLOCK(VEC_EVENTS, blk, blk_last, MINER_ACC);                          \
+      blk_last = blk;                                                                 \
     }                                                                                 \
-  BLK_NAME = blk_last;                                                              \
-    }
+    BLK_NAME = blk_last;                                                              \
+  }
 
 #define REWIND_BLOCKS_N_WITH_TIME(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC, COUNT) \
   currency::block BLK_NAME = PREV_BLOCK;                                              \
   for (size_t i = 0; i < COUNT; ++i)                                                  \
   {                                                                                   \
+    PRINT_EVENT_N_TEXT(VEC_EVENTS, "REWIND_BLOCKS_N_WITH_TIME(" << #BLK_NAME << ", " << #PREV_BLOCK << ", " << #MINER_ACC << ", " << #COUNT << ")"); \
     currency::block next_block = AUTO_VAL_INIT(next_block);                           \
     generator.construct_block(VEC_EVENTS, next_block, BLK_NAME, MINER_ACC);           \
     VEC_EVENTS.push_back(event_core_time(next_block.timestamp - 10));                 \
     VEC_EVENTS.push_back(next_block);                                                 \
     BLK_NAME = next_block;                                                            \
-    PRINT_EVENT_NO(VEC_EVENTS)                                                        \
   }                                                                                 
 
 #define REWIND_BLOCKS(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC) REWIND_BLOCKS_N(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC, CURRENCY_MINED_MONEY_UNLOCK_WINDOW)
 
 
-#define MAKE_TX_MIX_ATTR_EXTRA(VEC_EVENTS, TX_NAME, FROM, TO, AMOUNT, NMIX, HEAD, MIX_ATTR, EXTRA, CHECK_SPENDS)                   \
-  currency::transaction TX_NAME;                                                                                      \
-  { \
-    bool txr = construct_tx_to_key(m_hardforks, VEC_EVENTS, TX_NAME, HEAD, FROM, TO, AMOUNT, TESTS_DEFAULT_FEE, NMIX, generator.last_tx_generated_secret_key, MIX_ATTR, EXTRA, std::vector<currency::attachment_v>(), CHECK_SPENDS);  \
-    CHECK_AND_ASSERT_THROW_MES(txr, "failed to construct transaction"); \
-  } \
-  VEC_EVENTS.push_back(TX_NAME); \
-  PRINT_EVENT_NO(VEC_EVENTS)
+#define MAKE_TX_MIX_ATTR_EXTRA(VEC_EVENTS, TX_NAME, FROM, TO, AMOUNT, NMIX, HEAD, MIX_ATTR, EXTRA, CHECK_SPENDS) \
+  PRINT_EVENT_N(VEC_EVENTS);                                                           \
+  currency::transaction TX_NAME;                                                       \
+  {                                                                                    \
+    bool txr = construct_tx_to_key(generator.get_hardforks(), VEC_EVENTS, TX_NAME, HEAD, FROM, TO, AMOUNT, TESTS_DEFAULT_FEE, NMIX, generator.last_tx_generated_secret_key, MIX_ATTR, EXTRA, std::vector<currency::attachment_v>(), CHECK_SPENDS);  \
+    CHECK_AND_ASSERT_THROW_MES(txr, "failed to construct transaction");                \
+  }                                                                                    \
+  VEC_EVENTS.push_back(TX_NAME)
 
 #define MAKE_TX_FEE_MIX_ATTR_EXTRA(VEC_EVENTS, TX_NAME, FROM, TO, AMOUNT, FEE, NMIX, HEAD, MIX_ATTR, EXTRA, CHECK_SPENDS) \
-  currency::transaction TX_NAME; \
-  { \
-    bool txr = construct_tx_to_key(m_hardforks, VEC_EVENTS, TX_NAME, HEAD, FROM, TO, AMOUNT, FEE, NMIX, generator.last_tx_generated_secret_key, MIX_ATTR, EXTRA, std::vector<currency::attachment_v>(), CHECK_SPENDS); \
-    CHECK_AND_ASSERT_THROW_MES(txr, "failed to construct transaction"); \
-  } \
-  VEC_EVENTS.push_back(TX_NAME); \
-  PRINT_EVENT_NO(VEC_EVENTS)
+  PRINT_EVENT_N(VEC_EVENTS);                                                           \
+  currency::transaction TX_NAME;                                                       \
+  {                                                                                    \
+    bool txr = construct_tx_to_key(generator.get_hardforks(), VEC_EVENTS, TX_NAME, HEAD, FROM, TO, AMOUNT, FEE, NMIX, generator.last_tx_generated_secret_key, MIX_ATTR, EXTRA, std::vector<currency::attachment_v>(), CHECK_SPENDS); \
+    CHECK_AND_ASSERT_THROW_MES(txr, "failed to construct transaction");                \
+  }                                                                                    \
+  VEC_EVENTS.push_back(TX_NAME)
 
 #define MAKE_TX_MIX_ATTR(VEC_EVENTS, TX_NAME, FROM, TO, AMOUNT, NMIX, HEAD, MIX_ATTR, CHECK_SPENDS) \
   MAKE_TX_MIX_ATTR_EXTRA(VEC_EVENTS, TX_NAME, FROM, TO, AMOUNT, NMIX, HEAD, MIX_ATTR, std::vector<currency::extra_v>(), CHECK_SPENDS);
@@ -1130,15 +1133,15 @@ void append_vector_by_another_vector(U& dst, const V& src)
 #define MAKE_TX_FEE(VEC_EVENTS, TX_NAME, FROM, TO, AMOUNT, FEE, HEAD) MAKE_TX_FEE_MIX(VEC_EVENTS, TX_NAME, FROM, TO, AMOUNT, FEE, 0, HEAD)
 
 
-#define MAKE_TX_MIX_LIST_EXTRA_MIX_ATTR(VEC_EVENTS, SET_NAME, FROM, TO, AMOUNT, NMIX, HEAD, MIX_ATTR, EXTRA, ATTACH)    \
+#define MAKE_TX_MIX_LIST_EXTRA_MIX_ATTR(VEC_EVENTS, SET_NAME, FROM, TO, AMOUNT, NMIX, HEAD, MIX_ATTR, EXTRA, ATTACH) \
   {                                                                                                \
+    PRINT_EVENT_N(VEC_EVENTS);                                                                     \
     currency::transaction t;                                                                       \
-    bool r = construct_tx_to_key(m_hardforks, VEC_EVENTS, t, HEAD, FROM, TO, AMOUNT, TESTS_DEFAULT_FEE, NMIX, generator.last_tx_generated_secret_key, MIX_ATTR, EXTRA, ATTACH); \
+    bool r = construct_tx_to_key(generator.get_hardforks(), VEC_EVENTS, t, HEAD, FROM, TO, AMOUNT, TESTS_DEFAULT_FEE, NMIX, generator.last_tx_generated_secret_key, MIX_ATTR, EXTRA, ATTACH); \
     if (!r) { LOG_PRINT_YELLOW("ERROR in tx @ EVENT #" << VEC_EVENTS.size(), LOG_LEVEL_0); }       \
     CHECK_AND_ASSERT_THROW_MES(r, "failed to construct transaction");                              \
     SET_NAME.push_back(t);                                                                         \
     VEC_EVENTS.push_back(t);                                                                       \
-    PRINT_EVENT_NO(VEC_EVENTS)                                                                     \
   }
 
 #define MAKE_TX_MIX_LIST_MIX_ATTR(VEC_EVENTS, SET_NAME, FROM, TO, AMOUNT, NMIX, HEAD, MIX_ATTR, ATTACH)    \
@@ -1156,15 +1159,16 @@ void append_vector_by_another_vector(U& dst, const V& src)
 
 #define MAKE_TX_LIST_START_MIX_ATTR(VEC_EVENTS, SET_NAME, FROM, TO, AMOUNT, HEAD, MIX_ATTR, ATTACHS) \
     std::list<currency::transaction> SET_NAME; \
-    MAKE_TX_MIX_LIST_MIX_ATTR(VEC_EVENTS, SET_NAME, FROM, TO, AMOUNT, 0, HEAD, MIX_ATTR, ATTACHS);
+    MAKE_TX_MIX_LIST_MIX_ATTR(VEC_EVENTS, SET_NAME, FROM, TO, AMOUNT, 0, HEAD, MIX_ATTR, ATTACHS)
 
 #define MAKE_TX_LIST_START(VEC_EVENTS, SET_NAME, FROM, TO, AMOUNT, HEAD) MAKE_TX_LIST_START_MIX_ATTR(VEC_EVENTS, SET_NAME, FROM, TO, AMOUNT, HEAD, CURRENCY_TO_KEY_OUT_RELAXED, std::vector<currency::attachment_v>())
 
 #define MAKE_TX_LIST_START_WITH_ATTACHS(VEC_EVENTS, SET_NAME, FROM, TO, AMOUNT, HEAD, ATTACHS) MAKE_TX_LIST_START_MIX_ATTR(VEC_EVENTS, SET_NAME, FROM, TO, AMOUNT, HEAD, CURRENCY_TO_KEY_OUT_RELAXED, ATTACHS)
 
-#define MAKE_TX_ATTACH_FEE(EVENTS, TX_VAR, FROM, TO, AMOUNT, FEE, HEAD, ATTACH)   \
-  currency::transaction TX_VAR = AUTO_VAL_INIT(TX_VAR);                           \
-  CHECK_AND_ASSERT_MES(construct_tx_to_key(m_hardforks, EVENTS, TX_VAR, HEAD, FROM, TO, AMOUNT, FEE, 0, generator.last_tx_generated_secret_key, CURRENCY_TO_KEY_OUT_RELAXED, empty_extra, ATTACH), false, "construct_tx_to_key failed"); \
+#define MAKE_TX_ATTACH_FEE(EVENTS, TX_VAR, FROM, TO, AMOUNT, FEE, HEAD, ATTACH)        \
+  PRINT_EVENT_N(EVENTS);                                                               \
+  currency::transaction TX_VAR = AUTO_VAL_INIT(TX_VAR);                                \
+  CHECK_AND_ASSERT_MES(construct_tx_to_key(generator.get_hardforks(), EVENTS, TX_VAR, HEAD, FROM, TO, AMOUNT, FEE, 0, generator.last_tx_generated_secret_key, CURRENCY_TO_KEY_OUT_RELAXED, empty_extra, ATTACH), false, "construct_tx_to_key failed"); \
   EVENTS.push_back(TX_VAR)
 
 #define MAKE_TX_ATTACH(EVENTS, TX_VAR, FROM, TO, AMOUNT, HEAD, ATTACH) MAKE_TX_ATTACH_FEE(EVENTS, TX_VAR, FROM, TO, AMOUNT, TESTS_DEFAULT_FEE, HEAD, ATTACH)
@@ -1186,8 +1190,9 @@ void append_vector_by_another_vector(U& dst, const V& src)
 #define CHECK_V_EQ_EXPECTED_AND_ASSERT(value, expected) CHECK_AND_ASSERT_MES((value) == (expected), false, QUOTEME(value) << " has wrong value: " << value << ", expected: " << expected)
 
 // Adjust gentime and playtime "time" at once
-#define ADJUST_TEST_CORE_TIME(desired_time)            \
-  test_core_time::adjust(desired_time);                \
+#define ADJUST_TEST_CORE_TIME(desired_time)                                            \
+  PRINT_EVENT_N(events);                                                               \
+  test_core_time::adjust(desired_time);                                                \
   events.push_back(event_core_time(desired_time))
 
 // --- gentime wallet helpers -----------------------------------------------------------------------
@@ -1202,28 +1207,31 @@ void append_vector_by_another_vector(U& dst, const V& src)
     CHECK_AND_ASSERT_MES(r, false, "refresh_test_wallet failed"); \
   }
 
-#define MAKE_TEST_WALLET_TX(EVENTS_VEC, TX_VAR, WLT_WAR, MONEY, DEST_ACC) \
-  transaction TX_VAR = AUTO_VAL_INIT(TX_VAR); \
-  {                   \
+#define MAKE_TEST_WALLET_TX(EVENTS_VEC, TX_VAR, WLT_WAR, MONEY, DEST_ACC)              \
+  PRINT_EVENT_N(EVENTS_VEC);                                                           \
+  transaction TX_VAR = AUTO_VAL_INIT(TX_VAR);                                          \
+  {                                                                                    \
     std::vector<tx_destination_entry> destinations(1, tx_destination_entry(MONEY, DEST_ACC.get_public_address())); \
     WLT_WAR->transfer(destinations, 0, 0, TESTS_DEFAULT_FEE, std::vector<extra_v>(), std::vector<attachment_v>(), TX_VAR); \
-  } \
+  }                                                                                    \
   EVENTS_VEC.push_back(TX_VAR)
 
 #define MAKE_TEST_WALLET_TX_ATTACH(EVENTS_VEC, TX_VAR, WLT_WAR, MONEY, DEST_ACC, ATTACH) \
-  transaction TX_VAR = AUTO_VAL_INIT(TX_VAR); \
-  {                   \
+  PRINT_EVENT_N(EVENTS_VEC);                                                           \
+  transaction TX_VAR = AUTO_VAL_INIT(TX_VAR);                                          \
+  {                                                                                    \
     std::vector<tx_destination_entry> destinations(1, tx_destination_entry(MONEY, DEST_ACC.get_public_address())); \
     WLT_WAR->transfer(destinations, 0, 0, TESTS_DEFAULT_FEE, std::vector<extra_v>(), ATTACH, TX_VAR); \
-  } \
+  }                                                                                    \
   EVENTS_VEC.push_back(TX_VAR)
 
 #define MAKE_TEST_WALLET_TX_EXTRA(EVENTS_VEC, TX_VAR, WLT_WAR, MONEY, DEST_ACC, EXTRA) \
-  transaction TX_VAR = AUTO_VAL_INIT(TX_VAR); \
-  {                   \
+  PRINT_EVENT_N(EVENTS_VEC);                                                           \
+  transaction TX_VAR = AUTO_VAL_INIT(TX_VAR);                                          \
+  {                                                                                    \
     std::vector<tx_destination_entry> destinations(1, tx_destination_entry(MONEY, DEST_ACC.get_public_address())); \
     WLT_WAR->transfer(destinations, 0, 0, TESTS_DEFAULT_FEE, EXTRA, std::vector<attachment_v>(), TX_VAR); \
-  } \
+  }                                                                                    \
   EVENTS_VEC.push_back(TX_VAR)
 
 #define CHECK_TEST_WALLET_BALANCE_AT_GEN_TIME(WLT_WAR, TOTAL_BALANCE) \
diff --git a/tests/core_tests/chaingen_helpers.h b/tests/core_tests/chaingen_helpers.h
index 823df8fc..1f4a45f1 100644
--- a/tests/core_tests/chaingen_helpers.h
+++ b/tests/core_tests/chaingen_helpers.h
@@ -281,7 +281,7 @@ inline std::string gen_random_alias(size_t len)
 }
 
 template<typename alias_entry_t>
-inline bool put_alias_via_tx_to_list(const currency::hard_forks_descriptor& hf,
+inline bool put_alias_via_tx_to_list(const currency::hard_forks_descriptor& hf, // <-- TODO: remove this
     std::vector<test_event_entry>& events,
     std::list<currency::transaction>& tx_set,
     const currency::block& head_block,
@@ -289,7 +289,6 @@ inline bool put_alias_via_tx_to_list(const currency::hard_forks_descriptor& hf,
     const alias_entry_t& ae,
     test_generator& generator)
 {
-  const currency::hard_forks_descriptor& m_hardforks = hf; //a name to feed macro MAKE_TX_MIX_LIST_EXTRA_MIX_ATTR
   std::vector<currency::extra_v> ex;
   ex.push_back(ae);
   currency::account_base reward_acc;
diff --git a/tests/core_tests/checkpoints_tests.cpp b/tests/core_tests/checkpoints_tests.cpp
index f2dca325..debf4200 100644
--- a/tests/core_tests/checkpoints_tests.cpp
+++ b/tests/core_tests/checkpoints_tests.cpp
@@ -628,8 +628,6 @@ gen_no_attchments_in_coinbase::gen_no_attchments_in_coinbase()
 
   REGISTER_CALLBACK_METHOD(gen_no_attchments_in_coinbase, c1);
   REGISTER_CALLBACK_METHOD(gen_no_attchments_in_coinbase, init_config_set_cp);
-
-  m_hardforks.hard_fork_04_starts_after_height = UINT64_MAX;
 }
 
 bool gen_no_attchments_in_coinbase::generate(std::vector<test_event_entry>& events) const
diff --git a/tests/core_tests/hard_fork_1.cpp b/tests/core_tests/hard_fork_1.cpp
index bf38636f..ab49fb94 100644
--- a/tests/core_tests/hard_fork_1.cpp
+++ b/tests/core_tests/hard_fork_1.cpp
@@ -35,7 +35,7 @@ bool hard_fork_1_base_test::configure_core(currency::core& c, size_t ev_index, c
   currency::core_runtime_config pc = c.get_blockchain_storage().get_core_runtime_config();
   pc.min_coinstake_age = TESTS_POS_CONFIG_MIN_COINSTAKE_AGE;
   pc.pos_minimum_heigh = TESTS_POS_CONFIG_POS_MINIMUM_HEIGH;
-  pc.hard_forks.hard_fork_01_starts_after_height = m_hardfork_height;
+  pc.hard_forks.set_hardfork_height(1, m_hardfork_height);
   c.get_blockchain_storage().set_core_runtime_config(pc);
   return true;
 }
diff --git a/tests/core_tests/hard_fork_1_bad_pos_source.cpp b/tests/core_tests/hard_fork_1_bad_pos_source.cpp
index 5c78a33d..b60a1d08 100644
--- a/tests/core_tests/hard_fork_1_bad_pos_source.cpp
+++ b/tests/core_tests/hard_fork_1_bad_pos_source.cpp
@@ -72,7 +72,7 @@ bool hard_fork_1_bad_pos_source::configure_core(currency::core& c, size_t ev_ind
   currency::core_runtime_config pc = c.get_blockchain_storage().get_core_runtime_config();
   pc.min_coinstake_age = TESTS_POS_CONFIG_MIN_COINSTAKE_AGE; //four blocks
   pc.pos_minimum_heigh = TESTS_POS_CONFIG_POS_MINIMUM_HEIGH; //four blocks
-  pc.hard_forks.hard_fork_01_starts_after_height = get_hardfork_height();
+  pc.hard_forks.set_hardfork_height(1, get_hardfork_height());
 
   c.get_blockchain_storage().set_core_runtime_config(pc);
   return true;
diff --git a/tests/core_tests/hard_fork_1_consensus_test.cpp b/tests/core_tests/hard_fork_1_consensus_test.cpp
index 744b99db..09753840 100644
--- a/tests/core_tests/hard_fork_1_consensus_test.cpp
+++ b/tests/core_tests/hard_fork_1_consensus_test.cpp
@@ -62,7 +62,7 @@ bool hard_fork_1_cumulative_difficulty_base::configure_core(currency::core& c, s
   currency::core_runtime_config pc = c.get_blockchain_storage().get_core_runtime_config();
   pc.min_coinstake_age = TESTS_POS_CONFIG_MIN_COINSTAKE_AGE; //four blocks
   pc.pos_minimum_heigh = TESTS_POS_CONFIG_POS_MINIMUM_HEIGH; //four blocks
-  pc.hard_forks.hard_fork_01_starts_after_height = get_hardfork_height();
+  pc.hard_forks.set_hardfork_height(1, get_hardfork_height());
 
   c.get_blockchain_storage().set_core_runtime_config(pc);
   return true;
diff --git a/tests/core_tests/hard_fork_1_locked_pos_test.cpp b/tests/core_tests/hard_fork_1_locked_pos_test.cpp
index 9175d469..ef525c5e 100644
--- a/tests/core_tests/hard_fork_1_locked_pos_test.cpp
+++ b/tests/core_tests/hard_fork_1_locked_pos_test.cpp
@@ -103,7 +103,7 @@ bool hard_fork_1_locked_mining_test::configure_core(currency::core& c, size_t ev
   currency::core_runtime_config pc = c.get_blockchain_storage().get_core_runtime_config();
   pc.min_coinstake_age = TESTS_POS_CONFIG_MIN_COINSTAKE_AGE; //four blocks
   pc.pos_minimum_heigh = TESTS_POS_CONFIG_POS_MINIMUM_HEIGH; //four blocks
-  pc.hard_forks.hard_fork_01_starts_after_height = get_hardfork_height();
+  pc.hard_forks.set_hardfork_height(1, get_hardfork_height());
 
   c.get_blockchain_storage().set_core_runtime_config(pc);
   return true;
diff --git a/tests/core_tests/hard_fork_2.cpp b/tests/core_tests/hard_fork_2.cpp
index c7bd2c45..fbe68459 100644
--- a/tests/core_tests/hard_fork_2.cpp
+++ b/tests/core_tests/hard_fork_2.cpp
@@ -29,9 +29,9 @@ bool hard_fork_2_base_test::configure_core(currency::core& c, size_t ev_index, c
   currency::core_runtime_config pc = c.get_blockchain_storage().get_core_runtime_config();
   pc.min_coinstake_age = TESTS_POS_CONFIG_MIN_COINSTAKE_AGE;
   pc.pos_minimum_heigh = TESTS_POS_CONFIG_POS_MINIMUM_HEIGH;
-  pc.hard_forks.hard_fork_01_starts_after_height = m_hardfork_01_height;
-  pc.hard_forks.hard_fork_02_starts_after_height = m_hardfork_02_height;
-  pc.hard_forks.hard_fork_03_starts_after_height = m_hardfork_03_height;
+  pc.hard_forks.set_hardfork_height(1, m_hardfork_01_height);
+  pc.hard_forks.set_hardfork_height(2, m_hardfork_02_height);
+  pc.hard_forks.set_hardfork_height(3, m_hardfork_03_height);
   c.get_blockchain_storage().set_core_runtime_config(pc);
   return true;
 }
diff --git a/tests/core_tests/tx_validation.cpp b/tests/core_tests/tx_validation.cpp
index 60a18a43..0a15203b 100644
--- a/tests/core_tests/tx_validation.cpp
+++ b/tests/core_tests/tx_validation.cpp
@@ -775,8 +775,8 @@ gen_crypted_attachments::gen_crypted_attachments()
   REGISTER_CALLBACK("check_offers_count_befor_cancel", gen_crypted_attachments::check_offers_count_befor_cancel);
   REGISTER_CALLBACK("check_offers_count_after_cancel", gen_crypted_attachments::check_offers_count_after_cancel);
 
-  m_hardforks.hard_fork_01_starts_after_height = 0;
-  m_hardforks.hard_fork_02_starts_after_height = 0; // tx_payer is allowed only after HF2
+  m_hardforks.set_hardfork_height(1, 0);
+  m_hardforks.set_hardfork_height(2, 0); // tx_payer is allowed only after HF2
 }
 
 bool gen_crypted_attachments::generate(std::vector<test_event_entry>& events) const
@@ -989,8 +989,8 @@ bool gen_tx_extra_double_entry::configure_core(currency::core& c, size_t ev_inde
   currency::core_runtime_config pc = c.get_blockchain_storage().get_core_runtime_config();
   pc.min_coinstake_age = TESTS_POS_CONFIG_MIN_COINSTAKE_AGE;
   pc.pos_minimum_heigh = TESTS_POS_CONFIG_POS_MINIMUM_HEIGH;
-  pc.hard_forks.hard_fork_01_starts_after_height = 0;
-  pc.hard_forks.hard_fork_02_starts_after_height = 0;
+  pc.hard_forks.set_hardfork_height(1, 0);
+  pc.hard_forks.set_hardfork_height(2, 0);
   c.get_blockchain_storage().set_core_runtime_config(pc);
   return true;
 }
diff --git a/tests/core_tests/wallet_rpc_tests.cpp b/tests/core_tests/wallet_rpc_tests.cpp
index 31a7018e..a953576a 100644
--- a/tests/core_tests/wallet_rpc_tests.cpp
+++ b/tests/core_tests/wallet_rpc_tests.cpp
@@ -216,9 +216,9 @@ bool wallet_rpc_transfer::generate(std::vector<test_event_entry>& events) const
 bool wallet_rpc_transfer::configure_core(currency::core& c, size_t ev_index, const std::vector<test_event_entry>& events)
 {
   currency::core_runtime_config pc = c.get_blockchain_storage().get_core_runtime_config();
-  pc.hard_forks.hard_fork_01_starts_after_height = 1;
-  pc.hard_forks.hard_fork_02_starts_after_height = 1;
-  pc.hard_forks.hard_fork_03_starts_after_height = 1;
+  pc.hard_forks.set_hardfork_height(1, 1);
+  pc.hard_forks.set_hardfork_height(2, 1);
+  pc.hard_forks.set_hardfork_height(3, 1);
   c.get_blockchain_storage().set_core_runtime_config(pc);
   return true;
 }
diff --git a/tests/core_tests/wallet_tests.cpp b/tests/core_tests/wallet_tests.cpp
index 54333221..b1cea099 100644
--- a/tests/core_tests/wallet_tests.cpp
+++ b/tests/core_tests/wallet_tests.cpp
@@ -1382,8 +1382,8 @@ bool gen_wallet_transfers_and_chain_switch::generate(std::vector<test_event_entr
 gen_wallet_decrypted_attachments::gen_wallet_decrypted_attachments()
   : m_on_transfer2_called(false)
 {
-    m_hardforks.hard_fork_01_starts_after_height = 0;
-    m_hardforks.hard_fork_02_starts_after_height = 0; // tx_payer requires HF2
+    m_hardforks.set_hardfork_height(1, 0);
+    m_hardforks.set_hardfork_height(2, 0); // tx_payer requires HF2
 }
 
 bool gen_wallet_decrypted_attachments::generate(std::vector<test_event_entry>& events) const
@@ -1563,8 +1563,8 @@ void gen_wallet_decrypted_attachments::on_transfer2(const tools::wallet_public::
 
 gen_wallet_alias_and_unconfirmed_txs::gen_wallet_alias_and_unconfirmed_txs()
 {
-  m_hardforks.hard_fork_01_starts_after_height = 0;
-  m_hardforks.hard_fork_02_starts_after_height = 0;
+  m_hardforks.set_hardfork_height(1, 0);
+  m_hardforks.set_hardfork_height(2, 0);
 
   REGISTER_CALLBACK_METHOD(gen_wallet_alias_and_unconfirmed_txs, c1);
   REGISTER_CALLBACK_METHOD(gen_wallet_alias_and_unconfirmed_txs, c2);
@@ -1712,8 +1712,8 @@ bool gen_wallet_alias_and_unconfirmed_txs::c3(currency::core& c, size_t ev_index
 gen_wallet_alias_via_special_wallet_funcs::gen_wallet_alias_via_special_wallet_funcs()
 {
   // start hardfork from block 0 in order to use extra_alias_entry (allowed only since HF2)
-  m_hardforks.hard_fork_01_starts_after_height = 0;
-  m_hardforks.hard_fork_02_starts_after_height = 0;
+  m_hardforks.set_hardfork_height(1, 0);
+  m_hardforks.set_hardfork_height(2, 0);
   REGISTER_CALLBACK_METHOD(gen_wallet_alias_via_special_wallet_funcs, c1);
 }
 
diff --git a/tests/functional_tests/transactions_flow_test.cpp b/tests/functional_tests/transactions_flow_test.cpp
index 41dd6f45..03589f14 100644
--- a/tests/functional_tests/transactions_flow_test.cpp
+++ b/tests/functional_tests/transactions_flow_test.cpp
@@ -17,6 +17,8 @@ using namespace epee;
 #include "wallet/wallet2.h"
 #include "string_coding.h"
 #include "math_helper.h"
+#include "common/variant_helper.h"
+
 using namespace currency;
 
 #define TESTS_DEFAULT_FEE                   TX_DEFAULT_FEE 
@@ -451,11 +453,16 @@ bool transactions_flow_test(
         if (td.is_spent())
           continue;
 
-        if (td.m_ptx_wallet_info->m_tx.vout[td.m_internal_output_index].amount <= transfer_size + TX_DEFAULT_FEE)
-        {
-          ++prepared_transfers;
-          continue;
-        }
+        VARIANT_SWITCH_BEGIN(td.m_ptx_wallet_info->m_tx.vout[td.m_internal_output_index]);
+        VARIANT_CASE(currency::tx_out_bare, ob);
+          if (ob.amount <= transfer_size + TX_DEFAULT_FEE)
+          {
+            ++prepared_transfers;
+            continue;
+          }
+        VARIANT_CASE(currency::tx_out_zarcanum, oz);
+          // @#@
+        VARIANT_SWITCH_END();
 
         ++count;
         currency::transaction tx_s;