coretests: pos_block_builder adaptation

src/currency_core/core_runtime_config.h

@@ -57,7 +57,7 @@ namespace currency
       return 0;
     }
 
-    uint8_t get_block_major_version_by_height(uint64_t height)
+    uint8_t get_block_major_version_by_height(uint64_t height) const
     {      
       if (!this->is_hardfork_active_for_height(1, height))
         return BLOCK_MAJOR_VERSION_INITIAL;

tests/core_tests/chain_switch_pow_pos.cpp

@@ -136,7 +136,7 @@ bool gen_chain_switch_pow_pos::generate(std::vector<test_event_entry>& events) c
     crypto::public_key stake_output_pubkey = boost::get<txout_to_key>(boost::get<currency::tx_out_bare>(stake.vout[stake_output_idx]).target).key;
 
     pos_block_builder pb;
-    pb.step1_init_header(height, prev_id);
+    pb.step1_init_header(generator.get_hardforks(), height, prev_id);
     pb.step2_set_txs(std::vector<transaction>());
     pb.step3_build_stake_kernel(stake_output_amount, stake_output_gidx, stake_output_key_image, diff, prev_id, null_hash, prev_block.timestamp);
     pb.step4_generate_coinbase_tx(generator.get_timestamps_median(prev_id), generator.get_already_generated_coins(prev_block), alice.get_public_address());

tests/core_tests/chaingen.cpp

@@ -1926,7 +1926,7 @@ bool generate_pos_block_with_given_coinstake(test_generator& generator, const st
     crypto::public_key stake_output_pubkey = boost::get<txout_to_key>(boost::get<currency::tx_out_bare>(stake_tx.vout[stake_output_idx]).target).key;
 
     pos_block_builder pb;
-    pb.step1_init_header(height, prev_id);
+    pb.step1_init_header(generator.get_hardforks(), height, prev_id);
     pb.step2_set_txs(std::vector<transaction>());
     pb.step3_build_stake_kernel(stake_output_amount, stake_output_gidx, stake_output_key_image, diff, prev_id, null_hash, prev_block.timestamp);
     pb.step4_generate_coinbase_tx(generator.get_timestamps_median(prev_id), generator.get_already_generated_coins(prev_block), miner.get_public_address());

tests/core_tests/checkpoints_tests.cpp

@@ -559,7 +559,7 @@ bool gen_checkpoints_pos_validation_on_altchain::generate(std::vector<test_event
     crypto::public_key stake_output_pubkey = boost::get<txout_to_key>(boost::get<currency::tx_out_bare>(stake.vout[stake_output_idx]).target).key;
 
     pos_block_builder pb;
-    pb.step1_init_header(height, prev_id);
+    pb.step1_init_header(generator.get_hardforks(), height, prev_id);
     pb.step2_set_txs(std::vector<transaction>());
     pb.step3_build_stake_kernel(stake_output_amount, stake_output_gidx, stake_output_key_image, diff, prev_id, null_hash, blk_0r.timestamp);
     pb.step4_generate_coinbase_tx(generator.get_timestamps_median(prev_id), generator.get_already_generated_coins(blk_0r), miner_acc.get_public_address());
@@ -588,7 +588,7 @@ bool gen_checkpoints_pos_validation_on_altchain::generate(std::vector<test_event
     //crypto::public_key stake_output_pubkey = boost::get<txout_to_key>(boost::get<currency::tx_out_bare>(stake.vout[stake_output_idx]).target).key;
 
     pos_block_builder pb;
-    pb.step1_init_header(height, prev_id);
+    pb.step1_init_header(generator.get_hardforks(), height, prev_id);
     pb.step2_set_txs(std::vector<transaction>());
     pb.step3_build_stake_kernel(stake_output_amount, stake_output_gidx, stake_output_key_image, diff, prev_id, null_hash, blk_0r.timestamp);
     pb.step4_generate_coinbase_tx(generator.get_timestamps_median(prev_id), generator.get_already_generated_coins(blk_0r), miner_acc.get_public_address());

tests/core_tests/emission_test.cpp

@@ -92,7 +92,7 @@ bool emission_test::c1(currency::core& c, size_t ev_index, const std::vector<tes
       crypto::hash prev_id = get_block_hash(b);
       crypto::hash stake_tx_hash = stake_tx_outs.front().first;
       size_t stake_output_idx    = stake_tx_outs.front().second;
-      auto tce_ptr = c.get_blockchain_storage().get_tx_chain_entry(stake_tx_hash);
+      auto tce_ptr = bcs.get_tx_chain_entry(stake_tx_hash);
       CHECK_AND_ASSERT_MES(tce_ptr, false, "");
       CHECK_AND_ASSERT_MES(stake_output_idx < tce_ptr->m_global_output_indexes.size(), false, "");
 
@@ -105,11 +105,11 @@ bool emission_test::c1(currency::core& c, size_t ev_index, const std::vector<tes
       generate_key_image_helper(m_miner_acc.get_keys(), stake_tx_pub_key, stake_output_idx, kp, stake_output_key_image);
       crypto::public_key stake_output_pubkey = boost::get<txout_to_key>(boost::get<currency::tx_out_bare>(stake.vout[stake_output_idx]).target).key;
 
-      difficulty = c.get_blockchain_storage().get_next_diff_conditional(true);
+      difficulty = bcs.get_next_diff_conditional(true);
       //size_t median_size = 0; // little hack: we're using small blocks (only coinbase tx), so we're in CURRENCY_BLOCK_GRANTED_FULL_REWARD_ZONE - don't need to calc median size
 
       pb.clear();
-      pb.step1_init_header(get_block_height(b) + 1, prev_id);
+      pb.step1_init_header(bcs.get_core_runtime_config().hard_forks, get_block_height(b) + 1, prev_id);
       pb.step2_set_txs(std::vector<transaction>());
       pb.step3_build_stake_kernel(stake_output_amount, stake_output_gidx, stake_output_key_image, difficulty, prev_id, null_hash, timestamp);
       pb.step4_generate_coinbase_tx(0, already_generated_coins, m_miner_acc.get_public_address());

tests/core_tests/hard_fork_1.cpp

@@ -397,7 +397,7 @@ bool hard_fork_1_checkpoint_basic_test::generate(std::vector<test_event_entry>&
     crypto::public_key stake_output_pubkey = boost::get<txout_to_key>(boost::get<currency::tx_out_bare>(stake.vout[stake_output_idx]).target).key;
 
     pos_block_builder pb;
-    pb.step1_init_header(height, prev_id);
+    pb.step1_init_header(generator.get_hardforks(), height, prev_id);
     pb.m_block.major_version = HF1_BLOCK_MAJOR_VERSION;
     pb.step2_set_txs(std::vector<transaction>());
     pb.step3_build_stake_kernel(stake_output_amount, stake_output_gidx, stake_output_key_image, diff, prev_id, null_hash, prev_block.timestamp);
@@ -573,7 +573,7 @@ bool hard_fork_1_pos_and_locked_coins::generate(std::vector<test_event_entry>& e
     crypto::public_key stake_output_pubkey = boost::get<txout_to_key>(boost::get<currency::tx_out_bare>(stake.vout[stake_output_idx]).target).key;
 
     pos_block_builder pb;
-    pb.step1_init_header(height, prev_id);
+    pb.step1_init_header(generator.get_hardforks(), height, prev_id);
     pb.step2_set_txs(std::vector<transaction>());
     pb.step3_build_stake_kernel(stake_output_amount, stake_output_gidx, stake_output_key_image, diff, prev_id, null_hash, prev_block.timestamp);
     pb.step4_generate_coinbase_tx(generator.get_timestamps_median(prev_id), generator.get_already_generated_coins(prev_block), miner_acc.get_public_address());
@@ -612,7 +612,7 @@ bool hard_fork_1_pos_and_locked_coins::generate(std::vector<test_event_entry>& e
     crypto::public_key stake_output_pubkey = boost::get<txout_to_key>(boost::get<currency::tx_out_bare>(stake.vout[stake_output_idx]).target).key;
 
     pos_block_builder pb;
-    pb.step1_init_header(height, prev_id);
+    pb.step1_init_header(generator.get_hardforks(), height, prev_id);
     pb.m_block.major_version = HF1_BLOCK_MAJOR_VERSION;
     pb.step2_set_txs(std::vector<transaction>());
     pb.step3_build_stake_kernel(stake_output_amount, stake_output_gidx, stake_output_key_image, diff, prev_id, null_hash, prev_block.timestamp);
@@ -660,7 +660,7 @@ bool hard_fork_1_pos_and_locked_coins::generate(std::vector<test_event_entry>& e
     crypto::public_key stake_output_pubkey = boost::get<txout_to_key>(boost::get<currency::tx_out_bare>(stake.vout[stake_output_idx]).target).key;
 
     pos_block_builder pb;
-    pb.step1_init_header(height, prev_id);
+    pb.step1_init_header(generator.get_hardforks(), height, prev_id);
     pb.m_block.major_version = HF1_BLOCK_MAJOR_VERSION;
     pb.step2_set_txs(std::vector<transaction>());
     pb.step3_build_stake_kernel(stake_output_amount, stake_output_gidx, stake_output_key_image, diff, prev_id, null_hash, prev_block.timestamp);
@@ -757,7 +757,7 @@ bool hard_fork_1_pos_locked_height_vs_time::generate(std::vector<test_event_entr
     crypto::public_key stake_output_pubkey = boost::get<txout_to_key>(boost::get<currency::tx_out_bare>(stake.vout[stake_output_idx]).target).key;
 
     pos_block_builder pb;
-    pb.step1_init_header(height, prev_id);
+    pb.step1_init_header(generator.get_hardforks(), height, prev_id);
     pb.m_block.major_version = HF1_BLOCK_MAJOR_VERSION;
     pb.step2_set_txs(std::vector<transaction>());
     pb.step3_build_stake_kernel(stake_output_amount, stake_output_gidx, stake_output_key_image, diff, prev_id, null_hash, prev_block.timestamp);
@@ -802,7 +802,7 @@ bool hard_fork_1_pos_locked_height_vs_time::generate(std::vector<test_event_entr
     crypto::public_key stake_output_pubkey = boost::get<txout_to_key>(boost::get<currency::tx_out_bare>(stake.vout[stake_output_idx]).target).key;
 
     pos_block_builder pb;
-    pb.step1_init_header(height, prev_id);
+    pb.step1_init_header(generator.get_hardforks(), height, prev_id);
     pb.m_block.major_version = HF1_BLOCK_MAJOR_VERSION;
     pb.step2_set_txs(std::vector<transaction>());
     pb.step3_build_stake_kernel(stake_output_amount, stake_output_gidx, stake_output_key_image, diff, prev_id, null_hash, prev_block.timestamp);
@@ -846,7 +846,7 @@ bool hard_fork_1_pos_locked_height_vs_time::generate(std::vector<test_event_entr
     crypto::public_key stake_output_pubkey = boost::get<txout_to_key>(boost::get<currency::tx_out_bare>(stake.vout[stake_output_idx]).target).key;
 
     pos_block_builder pb;
-    pb.step1_init_header(height, prev_id);
+    pb.step1_init_header(generator.get_hardforks(), height, prev_id);
     pb.m_block.major_version = HF1_BLOCK_MAJOR_VERSION;
     pb.step2_set_txs(std::vector<transaction>());
     pb.step3_build_stake_kernel(stake_output_amount, stake_output_gidx, stake_output_key_image, diff, prev_id, null_hash, prev_block.timestamp);

tests/core_tests/multisig_wallet_tests.cpp

@@ -1362,7 +1362,7 @@ bool multisig_and_coinbase::generate(std::vector<test_event_entry>& events) cons
     keypair tx_key = keypair::generate();
 
     pos_block_builder pb;
-    pb.step1_init_header(height, prev_id);
+    pb.step1_init_header(generator.get_hardforks(), height, prev_id);
     pb.step2_set_txs(std::vector<transaction>());
     pb.step3_build_stake_kernel(stake_output_amount, stake_output_gidx, stake_output_key_image, diff, prev_id, null_hash, prev_block.timestamp);
     pb.step4_generate_coinbase_tx(generator.get_timestamps_median(prev_id), generator.get_already_generated_coins(prev_block), miner_acc.get_public_address(),

tests/core_tests/pos_block_builder.cpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2018 Zano Project
+// Copyright (c) 2014-2022 Zano Project
 // Copyright (c) 2014-2018 The Louisdor Project
 // Distributed under the MIT/X11 software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
@@ -9,23 +9,16 @@
 using namespace epee;
 using namespace currency;
 
-pos_block_builder::pos_block_builder()
-{
-  clear();
-}
-
 void pos_block_builder::clear()
 {
-  m_block = AUTO_VAL_INIT(m_block);
-  m_stake_kernel = AUTO_VAL_INIT(m_stake_kernel);
-  m_step = 0;
+  *this = AUTO_VAL_INIT_T(pos_block_builder);
 }
 
-void pos_block_builder::step1_init_header(size_t block_height, crypto::hash& prev_block_hash)
+void pos_block_builder::step1_init_header(const hard_forks_descriptor& hardforks, size_t block_height, crypto::hash& prev_block_hash)
 {
   CHECK_AND_ASSERT_THROW_MES(m_step == 0, "pos_block_builder: incorrect step sequence");
   m_block.minor_version = CURRENT_BLOCK_MINOR_VERSION;
-  m_block.major_version = BLOCK_MAJOR_VERSION_INITIAL;
+  m_block.major_version = hardforks.get_block_major_version_by_height(block_height);
   m_block.timestamp = 0; // to be set at step 3
   m_block.prev_id = prev_block_hash;
   m_block.flags = CURRENCY_BLOCK_FLAG_POS_BLOCK;
@@ -73,7 +66,7 @@ void pos_block_builder::step3_build_stake_kernel(
   m_pos_stake_output_gindex = stake_output_gindex;
 
   m_stake_kernel.kimage = stake_output_key_image;
-  m_stake_kernel.block_timestamp = m_block.timestamp;
+  m_stake_kernel.block_timestamp = 0;
   m_stake_kernel.stake_modifier.last_pow_id = last_pow_block_hash;
   m_stake_kernel.stake_modifier.last_pos_kernel_id = last_pos_block_kernel_hash;
   if (last_pos_block_kernel_hash == null_hash)
@@ -281,16 +274,18 @@ bool construct_homemade_pos_miner_tx(size_t height, size_t median_size, const bo
 bool mine_next_pos_block_in_playtime_sign_cb(currency::core& c, const currency::block& prev_block, const currency::block& coinstake_scr_block, const currency::account_base& acc,
   std::function<bool(currency::block&)> before_sign_cb, currency::block& output)
 {
+  blockchain_storage& bcs = c.get_blockchain_storage();
+
   // these values (median and diff) are correct only for the next main chain block, it's incorrect for altblocks, especially for old altblocks
   // but for now we assume they will work fine
-  uint64_t block_size_median = c.get_blockchain_storage().get_current_comulative_blocksize_limit() / 2;
-  currency::wide_difficulty_type difficulty = c.get_blockchain_storage().get_next_diff_conditional(true);
+  uint64_t block_size_median = bcs.get_current_comulative_blocksize_limit() / 2;
+  currency::wide_difficulty_type difficulty = bcs.get_next_diff_conditional(true);
 
   crypto::hash prev_id = get_block_hash(prev_block);
   size_t height = get_block_height(prev_block) + 1;
 
   block_extended_info bei = AUTO_VAL_INIT(bei);
-  bool r = c.get_blockchain_storage().get_block_extended_info_by_hash(prev_id, bei);
+  bool r = bcs.get_block_extended_info_by_hash(prev_id, bei);
   CHECK_AND_ASSERT_MES(r, false, "get_block_extended_info_by_hash failed for hash = " << prev_id);
 
 
@@ -305,7 +300,7 @@ bool mine_next_pos_block_in_playtime_sign_cb(currency::core& c, const currency::
   crypto::public_key stake_output_pubkey = boost::get<txout_to_key>(boost::get<currency::tx_out_bare>(stake.vout[stake_output_idx]).target).key;
 
   pos_block_builder pb;
-  pb.step1_init_header(height, prev_id);
+  pb.step1_init_header(bcs.get_core_runtime_config().hard_forks, height, prev_id);
   pb.step2_set_txs(std::vector<transaction>());
   pb.step3_build_stake_kernel(stake_output_amount, stake_output_gidx, stake_output_key_image, difficulty, prev_id, null_hash, prev_block.timestamp);
   pb.step4_generate_coinbase_tx(block_size_median, bei.already_generated_coins, acc.get_public_address());

tests/core_tests/pos_block_builder.h

@@ -1,16 +1,20 @@
-// Copyright (c) 2014-2018 Zano Project
+// Copyright (c) 2014-2022 Zano Project
 // Copyright (c) 2014-2018 The Louisdor Project
 // Distributed under the MIT/X11 software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
+#pragma once
 
-#pragma once 
+namespace currency
+{
+  struct hard_forks_descriptor;
+}
 
 struct pos_block_builder
 {
-  pos_block_builder();
+  pos_block_builder() = default;
   void clear();
   
-  void step1_init_header(size_t block_height, crypto::hash& prev_block_hash);
+  void step1_init_header(const currency::hard_forks_descriptor& hardforks, size_t block_height, crypto::hash& prev_block_hash);
   
   void step2_set_txs(const std::vector<currency::transaction>& txs);
   
@@ -51,6 +55,8 @@ struct pos_block_builder
   size_t                  m_height;
   size_t                  m_pos_stake_output_gindex;
   uint64_t                m_pos_stake_amount;
+
+  bool                    m_zarcanum;
 };
 
 bool construct_homemade_pos_miner_tx(size_t height, size_t median_size, const boost::multiprecision::uint128_t& already_generated_coins,

tests/core_tests/pos_validation.cpp

@@ -79,7 +79,7 @@ bool gen_pos_coinstake_already_spent::generate(std::vector<test_event_entry>& ev
   crypto::public_key stake_output_pubkey = boost::get<txout_to_key>(boost::get<currency::tx_out_bare>(stake.vout[stake_output_idx]).target).key;
 
   pos_block_builder pb;
-  pb.step1_init_header(height, prev_id);
+  pb.step1_init_header(generator.get_hardforks(), height, prev_id);
   pb.step2_set_txs(std::vector<transaction>());
   pb.step3_build_stake_kernel(stake_output_amount, stake_output_gidx, stake_output_key_image, diff, prev_id, null_hash, prev_block.timestamp);
   pb.step4_generate_coinbase_tx(generator.get_timestamps_median(prev_id), generator.get_already_generated_coins(prev_block), alice.get_public_address());
@@ -130,7 +130,7 @@ bool gen_pos_incorrect_timestamp::generate(std::vector<test_event_entry>& events
   crypto::public_key stake_output_pubkey = boost::get<txout_to_key>(boost::get<currency::tx_out_bare>(stake.vout[stake_output_idx]).target).key;
 
   pos_block_builder pb;
-  pb.step1_init_header(height, prev_id);
+  pb.step1_init_header(generator.get_hardforks(), height, prev_id);
   pb.step2_set_txs(std::vector<transaction>());
   // use incorrect timestamp_step
   pb.step3_build_stake_kernel(stake_output_amount, stake_output_gidx, stake_output_key_image, diff, prev_id, null_hash, blk_0r.timestamp - 1, POS_SCAN_WINDOW, POS_SCAN_STEP - 1);
@@ -148,7 +148,7 @@ bool gen_pos_incorrect_timestamp::generate(std::vector<test_event_entry>& events
 
   // Now try PoS timestamp window boundaries.
   pb.clear();
-  pb.step1_init_header(height, prev_id);
+  pb.step1_init_header(generator.get_hardforks(), height, prev_id);
   pb.step2_set_txs(std::vector<transaction>());
   // move timestamp to the future
   pb.step3_build_stake_kernel(stake_output_amount, stake_output_gidx, stake_output_key_image, diff, prev_id, null_hash, ts + CURRENCY_POS_BLOCK_FUTURE_TIME_LIMIT + 1, POS_SCAN_WINDOW, POS_SCAN_STEP);
@@ -162,7 +162,7 @@ bool gen_pos_incorrect_timestamp::generate(std::vector<test_event_entry>& events
 
   // lower limit
   pb.clear();
-  pb.step1_init_header(height, prev_id);
+  pb.step1_init_header(generator.get_hardforks(), height, prev_id);
   pb.step2_set_txs(std::vector<transaction>());
   // move timestamp to the future
   pb.step3_build_stake_kernel(stake_output_amount, stake_output_gidx, stake_output_key_image, diff, prev_id, null_hash, genesis_ts - POS_SCAN_WINDOW, POS_SCAN_WINDOW, POS_SCAN_STEP);
@@ -247,7 +247,7 @@ bool gen_pos_extra_nonce::generate(std::vector<test_event_entry>& events) const
   crypto::public_key stake_output_pubkey = boost::get<txout_to_key>(boost::get<currency::tx_out_bare>(stake.vout[stake_output_idx]).target).key;
 
   pos_block_builder pb;
-  pb.step1_init_header(height, prev_id);
+  pb.step1_init_header(generator.get_hardforks(), height, prev_id);
   pb.step2_set_txs(std::vector<transaction>());
   pb.step3_build_stake_kernel(stake_output_amount, stake_output_gidx, stake_output_key_image, diff, prev_id, null_hash, blk_0r.timestamp);
 
@@ -301,7 +301,7 @@ bool gen_pos_min_allowed_height::generate(std::vector<test_event_entry>& events)
   crypto::public_key stake_output_pubkey = boost::get<txout_to_key>(boost::get<currency::tx_out_bare>(stake.vout[stake_output_idx]).target).key;
 
   pos_block_builder pb;
-  pb.step1_init_header(height, prev_id);
+  pb.step1_init_header(generator.get_hardforks(), height, prev_id);
   pb.step2_set_txs(std::vector<transaction>(1, tx_1));
   pb.step3_build_stake_kernel(stake_output_amount, stake_output_gidx, stake_output_key_image, diff, prev_id, null_hash, blk_0r.timestamp);
   pb.step4_generate_coinbase_tx(generator.get_timestamps_median(prev_id), generator.get_already_generated_coins(blk_0r), alice.get_public_address());
@@ -353,7 +353,7 @@ bool gen_pos_invalid_coinbase::generate(std::vector<test_event_entry>& events) c
   crypto::public_key stake_output_pubkey = boost::get<txout_to_key>(boost::get<currency::tx_out_bare>(stake.vout[stake_output_idx]).target).key;
 
   pos_block_builder pb;
-  pb.step1_init_header(height, prev_id);
+  pb.step1_init_header(generator.get_hardforks(), height, prev_id);
   pb.step2_set_txs(std::vector<transaction>());
   pb.step3_build_stake_kernel(stake_output_amount, stake_output_gidx, stake_output_key_image, diff, prev_id, null_hash, prev_block.timestamp);
   pb.step4_generate_coinbase_tx(generator.get_timestamps_median(prev_id), generator.get_already_generated_coins(prev_block), alice_acc.get_public_address());