From 67212dab5158eab7a035c2aa40c4f318455e5451 Mon Sep 17 00:00:00 2001 From: cryptozoidberg Date: Sat, 3 Aug 2019 00:22:04 +0200 Subject: [PATCH] fixed few bugs in locked pos mining, implemeted proper test --- src/currency_core/blockchain_storage.cpp | 9 +- src/currency_core/currency_format_utils.cpp | 21 +++- .../currency_format_utils_transactions.cpp | 16 ++- .../currency_format_utils_transactions.h | 2 +- src/wallet/wallet2.cpp | 10 +- src/wallet/wallet2.h | 5 +- tests/core_tests/chaingen.cpp | 2 + tests/core_tests/chaingen_main.cpp | 1 + tests/core_tests/chaingen_tests_list.h | 1 + .../core_tests/hard_fork_1_consensus_test.cpp | 119 ++++++++++++++++++ tests/core_tests/hard_fork_1_consensus_test.h | 40 ++++++ .../hard_fork_1_locked_pos_test.cpp | 96 ++++++-------- .../core_tests/hard_fork_1_locked_pos_test.h | 28 +---- 13 files changed, 249 insertions(+), 101 deletions(-) create mode 100644 tests/core_tests/hard_fork_1_consensus_test.cpp create mode 100644 tests/core_tests/hard_fork_1_consensus_test.h diff --git a/src/currency_core/blockchain_storage.cpp b/src/currency_core/blockchain_storage.cpp index 6106feac..552cc194 100644 --- a/src/currency_core/blockchain_storage.cpp +++ b/src/currency_core/blockchain_storage.cpp @@ -3864,7 +3864,7 @@ bool blockchain_storage::get_output_keys_for_input_with_checks(const transaction //check tx unlock time uint64_t source_out_unlock_time = get_tx_unlock_time(source_tx, out_i); //let coinbase sources for PoS block to have locked inputs, the outputs supposed to be locked same way, except the reward - if (is_coinbase(source_tx) && is_pos_block(source_tx)) + if (is_coinbase(validated_tx) && is_pos_block(validated_tx)) { if (source_out_unlock_time > m_max_unlock_time) m_max_unlock_time = source_out_unlock_time; @@ -4336,9 +4336,16 @@ bool blockchain_storage::validate_coinbase_outs_unlocktime(const transaction& mi uint64_t major_unlock_time = get_tx_x_detail(miner_tx); if (major_unlock_time) { + //if there was etc_tx_details_unlock_time present in tx, then ignore etc_tx_details_unlock_time2 if (major_unlock_time < max_unlock_time) return false; + else + return true; } + + CHECK_AND_ASSERT_MES(get_block_height(miner_tx) > m_core_runtime_config.hard_fork1_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_fork1_starts_after_height); + + //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); CHECK_AND_ASSERT_MES(ut2.unlock_time_array.size() == miner_tx.vout.size(), false, "ut2.unlock_time_array.size()<" << ut2.unlock_time_array.size() diff --git a/src/currency_core/currency_format_utils.cpp b/src/currency_core/currency_format_utils.cpp index 8a3d2087..8f1f5b08 100644 --- a/src/currency_core/currency_format_utils.cpp +++ b/src/currency_core/currency_format_utils.cpp @@ -107,17 +107,29 @@ namespace currency out_amounts.resize(out_amounts.size() - 1); } + std::vector destinations; for (auto a : out_amounts) { tx_destination_entry de = AUTO_VAL_INIT(de); de.addr.push_back(miner_address); de.amount = a; + if (pe.stake_unlock_time && pe.stake_unlock_time > height + CURRENCY_MINED_MONEY_UNLOCK_WINDOW) + { + //this means that block is creating after hardfork_1 and unlock_time is needed to set for every destination separately + de.unlock_time = height + CURRENCY_MINED_MONEY_UNLOCK_WINDOW; + } destinations.push_back(de); } if (pos) - destinations.push_back(tx_destination_entry(pe.amount, stakeholder_address, pe.stake_unlock_time)); + { + uint64_t stake_lock_time = 0; + if (pe.stake_unlock_time && pe.stake_unlock_time > height + CURRENCY_MINED_MONEY_UNLOCK_WINDOW) + stake_lock_time = pe.stake_unlock_time; + destinations.push_back(tx_destination_entry(pe.amount, stakeholder_address, stake_lock_time)); + } + return construct_miner_tx(height, median_size, already_generated_coins, current_block_size, fee, destinations, tx, extra_nonce, max_outs, pos, pe); } @@ -198,7 +210,12 @@ namespace currency tx.version = CURRENT_TRANSACTION_VERSION; - set_tx_unlock_time(tx, height + CURRENCY_MINED_MONEY_UNLOCK_WINDOW); + if (!have_type_in_variant_container(tx.extra)) + { + //if stake unlock time was not set, then we can use simple "whole transaction" lock scheme + set_tx_unlock_time(tx, height + CURRENCY_MINED_MONEY_UNLOCK_WINDOW); + } + return true; } //--------------------------------------------------------------- diff --git a/src/currency_core/currency_format_utils_transactions.cpp b/src/currency_core/currency_format_utils_transactions.cpp index df589f04..3f052373 100644 --- a/src/currency_core/currency_format_utils_transactions.cpp +++ b/src/currency_core/currency_format_utils_transactions.cpp @@ -112,13 +112,19 @@ namespace currency } CHECK_AND_ASSERT_THROW_MES(ut2.unlock_time_array.size() == tx.vout.size(), "unlock_time_array.size=" << ut2.unlock_time_array.size() << " is not equal tx.vout.size()=" << tx.vout.size() << " in tx: " << get_transaction_hash(tx)); - for (size_t i = 0; i != ut2.unlock_time_array.size(); i++) + if (ut2.unlock_time_array.size()) { - if (ut2.unlock_time_array[i] > max_unlock_time) - max_unlock_time = ut2.unlock_time_array[i]; - if (ut2.unlock_time_array[i] < min_unlock_time) - min_unlock_time = ut2.unlock_time_array[i]; + max_unlock_time = min_unlock_time = ut2.unlock_time_array[0]; + for (size_t i = 1; i != ut2.unlock_time_array.size(); i++) + { + if (ut2.unlock_time_array[i] > max_unlock_time) + max_unlock_time = ut2.unlock_time_array[i]; + if (ut2.unlock_time_array[i] < min_unlock_time) + min_unlock_time = ut2.unlock_time_array[i]; + } } + + return true; } //--------------------------------------------------------------- diff --git a/src/currency_core/currency_format_utils_transactions.h b/src/currency_core/currency_format_utils_transactions.h index ebace925..9ce1b000 100644 --- a/src/currency_core/currency_format_utils_transactions.h +++ b/src/currency_core/currency_format_utils_transactions.h @@ -55,7 +55,7 @@ namespace currency tx_destination_entry() : amount(0), minimum_sigs(0), amount_to_provide(0), unlock_time(0){} tx_destination_entry(uint64_t a, const account_public_address& ad) : amount(a), addr(1, ad), minimum_sigs(0), amount_to_provide(0), unlock_time(0){} - tx_destination_entry(uint64_t a, const account_public_address& ad, uint64_t unlock_time) : amount(a), addr(1, ad), minimum_sigs(0), amount_to_provide(0) {} + tx_destination_entry(uint64_t a, const account_public_address& ad, uint64_t ut) : amount(a), addr(1, ad), minimum_sigs(0), amount_to_provide(0), unlock_time(ut) {} tx_destination_entry(uint64_t a, const std::list& addr) : amount(a), addr(addr), minimum_sigs(addr.size()), amount_to_provide(0), unlock_time(0){} BEGIN_SERIALIZE_OBJECT() diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp index b40243eb..9f9209dc 100644 --- a/src/wallet/wallet2.cpp +++ b/src/wallet/wallet2.cpp @@ -35,7 +35,7 @@ namespace tools { //--------------------------------------------------------------- - uint64_t wallet2::get_max_unlock_time_from_receive_indices(const currency::transaction& tx, const tools::wallet_rpc::wallet_transfer_info_details& td) + uint64_t wallet2::get_max_unlock_time_from_receive_indices(const currency::transaction& tx, const money_transfer2_details& td) { uint64_t max_unlock_time = 0; // etc_tx_details_expiration_time have priority over etc_tx_details_expiration_time2 @@ -50,7 +50,7 @@ namespace tools CHECK_AND_ASSERT_THROW_MES(ut2.unlock_time_array.size() == tx.vout.size(), "Internal error: wrong tx transfer details: ut2.unlock_time_array.size()" << ut2.unlock_time_array.size() << " is not equal transaction outputs vector size=" << tx.vout.size()); - for (auto ri : td.rcv) + for (auto ri : td.receive_indices) { CHECK_AND_ASSERT_THROW_MES(ri < tx.vout.size(), "Internal error: wrong tx transfer details: reciev index=" << ri << " is greater than transaction outputs vector " << tx.vout.size()); if (tx.vout[ri].target.type() == typeid(currency::txout_to_key)) @@ -960,7 +960,7 @@ void wallet2::prepare_wti(wallet_rpc::wallet_transfer_info& wti, uint64_t height wti.amount = amount; wti.height = height; fill_transfer_details(tx, td, wti.td); - wti.unlock_time = get_max_unlock_time_from_receive_indices(tx, wti.td); + wti.unlock_time = get_max_unlock_time_from_receive_indices(tx, td); wti.timestamp = timestamp; wti.fee = currency::is_coinbase(tx) ? 0:currency::get_tx_fee(tx); wti.tx_blob_size = static_cast(currency::get_object_blobsize(wti.tx)); @@ -2818,9 +2818,7 @@ void wallet2::cancel_offer_by_id(const crypto::hash& tx_id, uint64_t of_ind, uin crypto::generate_signature(crypto::cn_fast_hash(sig_blob.data(), sig_blob.size()), ephemeral.pub, ephemeral.sec, co.sig); bc_services::put_offer_into_attachment(co, attachments); - destinations.push_back(tx_dest); - uint64_t fee = TX_DEFAULT_FEE; - transfer(destinations, 0, 0, fee, extra, attachments, detail::ssi_digit, tx_dust_policy(DEFAULT_DUST_THRESHOLD), res_tx); + transfer(std::vector(), 0, 0, fee, extra, attachments, detail::ssi_digit, tx_dust_policy(DEFAULT_DUST_THRESHOLD), res_tx); } //---------------------------------------------------------------------------------------------------- void wallet2::update_offer_by_id(const crypto::hash& tx_id, uint64_t of_ind, const bc_services::offer_details_ex& od, currency::transaction& res_tx) diff --git a/src/wallet/wallet2.h b/src/wallet/wallet2.h index 99789e94..a1720f3d 100644 --- a/src/wallet/wallet2.h +++ b/src/wallet/wallet2.h @@ -721,7 +721,7 @@ namespace tools void finalize_transaction(const finalize_tx_param& ftp, currency::transaction& tx, crypto::secret_key& tx_key, bool broadcast_tx); std::string get_log_prefix() const { return m_log_prefix; } - static uint64_t get_max_unlock_time_from_receive_indices(const currency::transaction& tx, const tools::wallet_rpc::wallet_transfer_info_details& td); + static uint64_t get_max_unlock_time_from_receive_indices(const currency::transaction& tx, const money_transfer2_details& td); private: void add_transfers_to_expiration_list(const std::vector& selected_transfers, uint64_t expiration, uint64_t change_amount, const crypto::hash& related_tx_id); void remove_transfer_from_expiration_list(uint64_t transfer_index); @@ -953,10 +953,11 @@ namespace boost a & x.contract; a & x.selected_indicies; a & x.srv_attachments; + a & x.unlock_time; //do not store this items in the file since it's quite easy to restore it from original tx if (Archive::is_loading::value) { - x.unlock_time = tools::wallet2::get_max_unlock_time_from_receive_indices(x.tx, x.td); + x.is_service = currency::is_service_tx(x.tx); x.is_mixing = currency::is_mixin_tx(x.tx); x.is_mining = currency::is_coinbase(x.tx); diff --git a/tests/core_tests/chaingen.cpp b/tests/core_tests/chaingen.cpp index e172221f..6e5be5f7 100644 --- a/tests/core_tests/chaingen.cpp +++ b/tests/core_tests/chaingen.cpp @@ -397,6 +397,7 @@ bool test_generator::build_wallets(const blockchain_vector& blocks, currency::core_runtime_config pc = cc; pc.min_coinstake_age = TESTS_POS_CONFIG_MIN_COINSTAKE_AGE; pc.pos_minimum_heigh = TESTS_POS_CONFIG_POS_MINIMUM_HEIGH; + pc.hard_fork1_starts_after_height = m_hardfork_after_heigh; wallets.back()->set_core_runtime_config(pc); } @@ -481,6 +482,7 @@ bool test_generator::find_kernel(const std::list& accs, uint64_t& found_timestamp, crypto::hash& found_kh) { + bool is_after_hardfork = blck_chain.size() > m_hardfork_after_heigh ? true : false; uint64_t median_timestamp = get_timestamps_median(blck_chain); wide_difficulty_type basic_diff = 0; diff --git a/tests/core_tests/chaingen_main.cpp b/tests/core_tests/chaingen_main.cpp index 8b6bc3cc..63352700 100644 --- a/tests/core_tests/chaingen_main.cpp +++ b/tests/core_tests/chaingen_main.cpp @@ -941,6 +941,7 @@ int main(int argc, char* argv[]) GENERATE_AND_PLAY(before_hard_fork_1_cumulative_difficulty); GENERATE_AND_PLAY(inthe_middle_hard_fork_1_cumulative_difficulty); GENERATE_AND_PLAY(after_hard_fork_1_cumulative_difficulty); + GENERATE_AND_PLAY(hard_fork_1_locked_mining_test); //GENERATE_AND_PLAY(gen_block_reward); */ diff --git a/tests/core_tests/chaingen_tests_list.h b/tests/core_tests/chaingen_tests_list.h index b9c4dc28..8d55633b 100644 --- a/tests/core_tests/chaingen_tests_list.h +++ b/tests/core_tests/chaingen_tests_list.h @@ -34,3 +34,4 @@ #include "misc_tests.h" #include "emission_test.h" #include "hard_fork_1_locked_pos_test.h" +#include "hard_fork_1_consensus_test.h" diff --git a/tests/core_tests/hard_fork_1_consensus_test.cpp b/tests/core_tests/hard_fork_1_consensus_test.cpp new file mode 100644 index 00000000..60bafdb7 --- /dev/null +++ b/tests/core_tests/hard_fork_1_consensus_test.cpp @@ -0,0 +1,119 @@ +// Copyright (c) 2014-2018 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. + +#include "chaingen.h" +#include "pos_validation.h" +#include "tx_builder.h" +#include "hard_fork_1_consensus_test.h" +#include "random_helper.h" + +using namespace epee; +using namespace crypto; +using namespace currency; + +hard_fork_1_cumulative_difficulty_base::hard_fork_1_cumulative_difficulty_base() +{ + REGISTER_CALLBACK_METHOD(hard_fork_1_cumulative_difficulty_base, c1); + REGISTER_CALLBACK_METHOD(hard_fork_1_cumulative_difficulty_base, configure_core); +} + +bool hard_fork_1_cumulative_difficulty_base::generate(std::vector& events) const +{ + random_state_test_restorer::reset_random(); + + GENERATE_ACCOUNT(preminer_acc); + GENERATE_ACCOUNT(miner_acc); + m_accounts.push_back(miner_acc); + std::list miner_acc_lst(1, miner_acc); + + MAKE_GENESIS_BLOCK(events, blk_0, preminer_acc, 1564434616); + generator.set_hardfork_height(get_hardfork_height()); + + DO_CALLBACK(events, "configure_core"); + REWIND_BLOCKS_N_WITH_TIME(events, blk_0r, blk_0, miner_acc, CURRENCY_MINED_MONEY_UNLOCK_WINDOW + 3); + block last_block = blk_0r; + for (size_t i = 0; i != 20; i++) + { + MAKE_NEXT_POS_BLOCK(events, next_blk_pos, last_block, miner_acc, miner_acc_lst); + MAKE_NEXT_BLOCK(events, next_blk_pow, next_blk_pos, miner_acc); + events.push_back(event_core_time(next_blk_pow.timestamp - 10)); + + last_block = next_blk_pow; + } + + generator.set_pos_to_low_timestamp(true); + last_block = blk_0r; + for (size_t i = 0; i != 20; i++) + { + MAKE_NEXT_POS_BLOCK(events, next_blk_pos, last_block, miner_acc, miner_acc_lst); + MAKE_NEXT_BLOCK_TIMESTAMP_ADJUSTMENT(-14, events, next_blk_pow, next_blk_pos, miner_acc); + last_block = next_blk_pow; + } + + + DO_CALLBACK(events, "c1"); + return true; +} + +bool hard_fork_1_cumulative_difficulty_base::configure_core(currency::core& c, size_t ev_index, const std::vector& events) +{ + 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_fork1_starts_after_height = get_hardfork_height(); + + c.get_blockchain_storage().set_core_runtime_config(pc); + return true; +} + +bool before_hard_fork_1_cumulative_difficulty::c1(currency::core& c, size_t ev_index, const std::vector& events) +{ + + std::shared_ptr last_pow_block = c.get_blockchain_storage().get_last_block_of_type(false); + std::shared_ptr last_pos_block = c.get_blockchain_storage().get_last_block_of_type(true); + CHECK_AND_ASSERT_MES(last_pow_block->cumulative_diff_precise == 184, false, "Incorrect condition failed: last_pow_block->cumulative_diff_precise == 184"); + CHECK_AND_ASSERT_MES(last_pos_block->cumulative_diff_precise == 20, false, "Incorrect condition failed: last_pos_block->cumulative_diff_precise == 20"); + // + return true; +} + +uint64_t before_hard_fork_1_cumulative_difficulty::get_hardfork_height()const +{ + return 10000; //just big number which is obviously bigger then test blockchain +} + + + +bool inthe_middle_hard_fork_1_cumulative_difficulty::c1(currency::core& c, size_t ev_index, const std::vector& events) +{ + + std::shared_ptr last_pow_block = c.get_blockchain_storage().get_last_block_of_type(false); + std::shared_ptr last_pos_block = c.get_blockchain_storage().get_last_block_of_type(true); + CHECK_AND_ASSERT_MES(last_pow_block->cumulative_diff_precise == 184, false, "Incorrect condition failed: last_pow_block->cumulative_diff_precise == 184"); + CHECK_AND_ASSERT_MES(last_pos_block->cumulative_diff_precise == 20, false, "Incorrect condition failed: last_pos_block->cumulative_diff_precise == 20"); + // + return true; +} + +uint64_t inthe_middle_hard_fork_1_cumulative_difficulty::get_hardfork_height()const +{ + return 15; +} +bool after_hard_fork_1_cumulative_difficulty::c1(currency::core& c, size_t ev_index, const std::vector& events) +{ + + std::shared_ptr last_pow_block = c.get_blockchain_storage().get_last_block_of_type(false); + std::shared_ptr last_pos_block = c.get_blockchain_storage().get_last_block_of_type(true); + CHECK_AND_ASSERT_MES(last_pow_block->cumulative_diff_precise == 172, false, "Incorrect condition failed: last_pow_block->cumulative_diff_precise == 184"); + CHECK_AND_ASSERT_MES(last_pos_block->cumulative_diff_precise == 199, false, "Incorrect condition failed: last_pos_block->cumulative_diff_precise == 20"); + // + return true; +} + +uint64_t after_hard_fork_1_cumulative_difficulty::get_hardfork_height()const +{ + return 12; +} + diff --git a/tests/core_tests/hard_fork_1_consensus_test.h b/tests/core_tests/hard_fork_1_consensus_test.h new file mode 100644 index 00000000..6898e46c --- /dev/null +++ b/tests/core_tests/hard_fork_1_consensus_test.h @@ -0,0 +1,40 @@ +// Copyright (c) 2014-2018 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 +#include "chaingen.h" +#include "wallet_tests_basic.h" + + +struct hard_fork_1_cumulative_difficulty_base : public wallet_test +{ + hard_fork_1_cumulative_difficulty_base(); + bool generate(std::vector& events) const; + bool configure_core(currency::core& c, size_t ev_index, const std::vector& events); + virtual bool c1(currency::core& c, size_t ev_index, const std::vector& events)= 0; + virtual uint64_t get_hardfork_height()const =0; +}; + +// this test check if code still work same way as it supposed to work before hard fork point +struct before_hard_fork_1_cumulative_difficulty : public hard_fork_1_cumulative_difficulty_base +{ + bool c1(currency::core& c, size_t ev_index, const std::vector& events); + virtual uint64_t get_hardfork_height()const; +}; + +// this test check if code still work same way as it supposed to work is split happened before hard fork point but finished after hard fork point +struct inthe_middle_hard_fork_1_cumulative_difficulty : public hard_fork_1_cumulative_difficulty_base +{ + bool c1(currency::core& c, size_t ev_index, const std::vector& events); + virtual uint64_t get_hardfork_height()const; +}; + +// this test check if code follow the new consensus algorithm and prefer balanced branch of the blockchain tree +struct after_hard_fork_1_cumulative_difficulty : public hard_fork_1_cumulative_difficulty_base +{ + bool c1(currency::core& c, size_t ev_index, const std::vector& events); + virtual uint64_t get_hardfork_height()const; +}; + 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 d2362c7b..3c96e07c 100644 --- a/tests/core_tests/hard_fork_1_locked_pos_test.cpp +++ b/tests/core_tests/hard_fork_1_locked_pos_test.cpp @@ -13,19 +13,21 @@ using namespace epee; using namespace crypto; using namespace currency; -hard_fork_1_cumulative_difficulty_base::hard_fork_1_cumulative_difficulty_base() +hard_fork_1_locked_mining_test::hard_fork_1_locked_mining_test() { - REGISTER_CALLBACK_METHOD(hard_fork_1_cumulative_difficulty_base, c1); - REGISTER_CALLBACK_METHOD(hard_fork_1_cumulative_difficulty_base, configure_core); + REGISTER_CALLBACK_METHOD(hard_fork_1_locked_mining_test, c1); + REGISTER_CALLBACK_METHOD(hard_fork_1_locked_mining_test, configure_core); } -bool hard_fork_1_cumulative_difficulty_base::generate(std::vector& events) const +bool hard_fork_1_locked_mining_test::generate(std::vector& events) const { random_state_test_restorer::reset_random(); GENERATE_ACCOUNT(preminer_acc); GENERATE_ACCOUNT(miner_acc); + GENERATE_ACCOUNT(pos_miner_acc); m_accounts.push_back(miner_acc); + m_accounts.push_back(pos_miner_acc); std::list miner_acc_lst(1, miner_acc); MAKE_GENESIS_BLOCK(events, blk_0, preminer_acc, 1564434616); @@ -33,31 +35,43 @@ bool hard_fork_1_cumulative_difficulty_base::generate(std::vector extra; + + std::vector sources_1; + r = fill_tx_sources(sources_1, events, blk_0r, miner_acc.get_keys(), 2000000000000+TESTS_DEFAULT_FEE, 0); + CHECK_AND_ASSERT_MES(r, false, "fill_tx_sources failed"); + std::vector destinations({ tx_destination_entry(2010000000000, pos_miner_acc.get_public_address()) }); + crypto::secret_key stub; + transaction tx_1 = AUTO_VAL_INIT(tx_1); + r = construct_tx(miner_acc.get_keys(), sources_1, destinations, extra, empty_attachment, tx_1, stub, get_block_height(blk_0r)+2000); + CHECK_AND_ASSERT_MES(r, false, "construct_tx failed"); + events.push_back(tx_1); // push it to the pool + + MAKE_NEXT_BLOCK_TX1(events, blk_0r_tx, blk_0r, miner_acc, tx_1); + + block last_block = blk_0r_tx; + for (size_t i = 0; i != CURRENCY_MINED_MONEY_UNLOCK_WINDOW; i++) { MAKE_NEXT_POS_BLOCK(events, next_blk_pos, last_block, miner_acc, miner_acc_lst); MAKE_NEXT_BLOCK(events, next_blk_pow, next_blk_pos, miner_acc); events.push_back(event_core_time(next_blk_pow.timestamp - 10)); - last_block = next_blk_pow; } - - generator.set_pos_to_low_timestamp(true); - last_block = blk_0r; - for (size_t i = 0; i != 20; i++) - { - MAKE_NEXT_POS_BLOCK(events, next_blk_pos, last_block, miner_acc, miner_acc_lst); - MAKE_NEXT_BLOCK_TIMESTAMP_ADJUSTMENT(-14, events, next_blk_pow, next_blk_pos, miner_acc); - last_block = next_blk_pow; - } - + + std::list accounts_2; + accounts_2.push_back(pos_miner_acc); + //let's try to mint PoS block from locked account + MAKE_NEXT_POS_BLOCK(events, next_blk_pos, last_block, pos_miner_acc, accounts_2); DO_CALLBACK(events, "c1"); return true; } -bool hard_fork_1_cumulative_difficulty_base::configure_core(currency::core& c, size_t ev_index, const std::vector& events) +bool hard_fork_1_locked_mining_test::configure_core(currency::core& c, size_t ev_index, const std::vector& events) { 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 @@ -68,52 +82,16 @@ bool hard_fork_1_cumulative_difficulty_base::configure_core(currency::core& c, s return true; } -bool before_hard_fork_1_cumulative_difficulty::c1(currency::core& c, size_t ev_index, const std::vector& events) +bool hard_fork_1_locked_mining_test::c1(currency::core& c, size_t ev_index, const std::vector& events) { - std::shared_ptr last_pow_block = c.get_blockchain_storage().get_last_block_of_type(false); - std::shared_ptr last_pos_block = c.get_blockchain_storage().get_last_block_of_type(true); - CHECK_AND_ASSERT_MES(last_pow_block->cumulative_diff_precise == 184, false, "Incorrect condition failed: last_pow_block->cumulative_diff_precise == 184"); - CHECK_AND_ASSERT_MES(last_pos_block->cumulative_diff_precise == 20, false, "Incorrect condition failed: last_pos_block->cumulative_diff_precise == 20"); - // + uint64_t h = c.get_blockchain_storage().get_current_blockchain_size(); + CHECK_AND_ASSERT_MES(h == 36, false, "locked pos block is not accepted"); return true; } -uint64_t before_hard_fork_1_cumulative_difficulty::get_hardfork_height()const +uint64_t hard_fork_1_locked_mining_test::get_hardfork_height()const { - return 10000; //just big number which is obviously bigger then test blockchain -} - - - -bool inthe_middle_hard_fork_1_cumulative_difficulty::c1(currency::core& c, size_t ev_index, const std::vector& events) -{ - - std::shared_ptr last_pow_block = c.get_blockchain_storage().get_last_block_of_type(false); - std::shared_ptr last_pos_block = c.get_blockchain_storage().get_last_block_of_type(true); - CHECK_AND_ASSERT_MES(last_pow_block->cumulative_diff_precise == 184, false, "Incorrect condition failed: last_pow_block->cumulative_diff_precise == 184"); - CHECK_AND_ASSERT_MES(last_pos_block->cumulative_diff_precise == 20, false, "Incorrect condition failed: last_pos_block->cumulative_diff_precise == 20"); - // - return true; -} - -uint64_t inthe_middle_hard_fork_1_cumulative_difficulty::get_hardfork_height()const -{ - return 15; -} -bool after_hard_fork_1_cumulative_difficulty::c1(currency::core& c, size_t ev_index, const std::vector& events) -{ - - std::shared_ptr last_pow_block = c.get_blockchain_storage().get_last_block_of_type(false); - std::shared_ptr last_pos_block = c.get_blockchain_storage().get_last_block_of_type(true); - CHECK_AND_ASSERT_MES(last_pow_block->cumulative_diff_precise == 172, false, "Incorrect condition failed: last_pow_block->cumulative_diff_precise == 184"); - CHECK_AND_ASSERT_MES(last_pos_block->cumulative_diff_precise == 199, false, "Incorrect condition failed: last_pos_block->cumulative_diff_precise == 20"); - // - return true; -} - -uint64_t after_hard_fork_1_cumulative_difficulty::get_hardfork_height()const -{ - return 12; + return 10; } diff --git a/tests/core_tests/hard_fork_1_locked_pos_test.h b/tests/core_tests/hard_fork_1_locked_pos_test.h index 6898e46c..34fda63d 100644 --- a/tests/core_tests/hard_fork_1_locked_pos_test.h +++ b/tests/core_tests/hard_fork_1_locked_pos_test.h @@ -8,33 +8,11 @@ #include "wallet_tests_basic.h" -struct hard_fork_1_cumulative_difficulty_base : public wallet_test +struct hard_fork_1_locked_mining_test : public wallet_test { - hard_fork_1_cumulative_difficulty_base(); + hard_fork_1_locked_mining_test(); bool generate(std::vector& events) const; bool configure_core(currency::core& c, size_t ev_index, const std::vector& events); - virtual bool c1(currency::core& c, size_t ev_index, const std::vector& events)= 0; - virtual uint64_t get_hardfork_height()const =0; -}; - -// this test check if code still work same way as it supposed to work before hard fork point -struct before_hard_fork_1_cumulative_difficulty : public hard_fork_1_cumulative_difficulty_base -{ - bool c1(currency::core& c, size_t ev_index, const std::vector& events); + virtual bool c1(currency::core& c, size_t ev_index, const std::vector& events); virtual uint64_t get_hardfork_height()const; }; - -// this test check if code still work same way as it supposed to work is split happened before hard fork point but finished after hard fork point -struct inthe_middle_hard_fork_1_cumulative_difficulty : public hard_fork_1_cumulative_difficulty_base -{ - bool c1(currency::core& c, size_t ev_index, const std::vector& events); - virtual uint64_t get_hardfork_height()const; -}; - -// this test check if code follow the new consensus algorithm and prefer balanced branch of the blockchain tree -struct after_hard_fork_1_cumulative_difficulty : public hard_fork_1_cumulative_difficulty_base -{ - bool c1(currency::core& c, size_t ev_index, const std::vector& events); - virtual uint64_t get_hardfork_height()const; -}; -