Charon/blockchain
1
0
Fork 0
forked from lthn/blockchain
Code Pull requests Activity
blockchain/tests/core_tests/pos_validation.cpp

1226 lines
58 KiB
C++
Raw Blame History

// 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 "pos_block_builder.h"
#include "random_helper.h"
using namespace epee;
using namespace crypto;
using namespace currency;
pos_validation::pos_validation()
: m_invalid_block_index(std::numeric_limits<size_t>::max())
, m_invalid_tx_index(std::numeric_limits<size_t>::max())
{
REGISTER_CALLBACK_METHOD(pos_validation, configure_core);
REGISTER_CALLBACK_METHOD(pos_validation, mark_invalid_tx);
REGISTER_CALLBACK_METHOD(pos_validation, mark_invalid_block);
}
bool pos_validation::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.min_coinstake_age = TESTS_POS_CONFIG_MIN_COINSTAKE_AGE; //four blocks
pc.pos_minimum_heigh = TESTS_POS_CONFIG_POS_MINIMUM_HEIGH; //four blocks
c.get_blockchain_storage().set_core_runtime_config(pc);
return true;
}
bool gen_pos_coinstake_already_spent::generate(std::vector<test_event_entry>& events) const
{
//test_gentime_settings s = test_generator::get_test_gentime_settings();
//s.miner_tx_max_outs = 11; // limit genesis outs for speed-up, as we going to spend all premine
//test_generator::set_test_gentime_settings(s);
GENERATE_ACCOUNT(preminer);
GENERATE_ACCOUNT(miner);
GENERATE_ACCOUNT(alice);
MAKE_GENESIS_BLOCK(events, blk_0, preminer, test_core_time::get_time());
DO_CALLBACK(events, "configure_core");
MAKE_NEXT_BLOCK(events, blk_1, blk_0, miner);
REWIND_BLOCKS_N(events, blk_1r, blk_1, miner, CURRENCY_MINED_MONEY_UNLOCK_WINDOW - 1);
// spend all money earned from block 1
uint64_t amount = get_outs_money_amount(blk_1.miner_tx);
MAKE_TX(events, tx_0, miner, alice, amount - TESTS_DEFAULT_FEE, blk_1r);
MAKE_NEXT_BLOCK_TX1(events, blk_2, blk_1r, alice, tx_0);
CREATE_TEST_WALLET(miner_wlt, miner, blk_0);
REFRESH_TEST_WALLET_AT_GEN_TIME(events, miner_wlt, blk_2, CURRENCY_MINED_MONEY_UNLOCK_WINDOW + 1);
LOG_PRINT_L0("miner's transfers:" << ENDL << miner_wlt->dump_transfers(false));
// Legend: (n) - PoW block, [m] - PoS block
// 0 1 11 12 13 <-- blockchain height (assuming CURRENCY_MINED_MONEY_UNLOCK_WINDOW == 10)
// (0 )--(1 )--(1r)--(2 )--[3 ] main chain
// try to make a PoS block referring to genesis' miner tx out, that is already spent
// create PoS block manually
block& prev_block = blk_2;
crypto::hash prev_id = get_block_hash(prev_block);
size_t height = get_block_height(prev_block) + 1;
currency::wide_difficulty_type diff = generator.get_difficulty_for_next_block(prev_id, false);
const transaction& stake = blk_1.miner_tx;
crypto::public_key stake_tx_pub_key = get_tx_pub_key_from_extra(stake);
size_t stake_output_idx = 0;
uint64_t stake_output_gidx = 0;
bool r = find_global_index_for_output(events, prev_id, stake, stake_output_idx, stake_output_gidx);
CHECK_AND_ASSERT_MES(r, false, "find_global_index_for_output failed");
uint64_t stake_output_amount =boost::get<currency::tx_out_bare>( stake.vout[stake_output_idx]).amount;
crypto::key_image stake_output_key_image;
keypair kp;
generate_key_image_helper(miner.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;
pos_block_builder pb;
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());
pb.step5_sign(stake_tx_pub_key, stake_output_idx, stake_output_pubkey, miner);
block blk_3 = pb.m_block;
// EXPECTED: blk_2 is rejected as invalid, because coinstake refers to already spent output
DO_CALLBACK(events, "mark_invalid_block");
events.push_back(blk_3);
return true;
}
bool gen_pos_incorrect_timestamp::generate(std::vector<test_event_entry>& events) const
{
uint64_t genesis_ts = 1450000000;
GENERATE_ACCOUNT(miner);
GENERATE_ACCOUNT(alice);
MAKE_GENESIS_BLOCK(events, blk_0, miner, genesis_ts);
DO_CALLBACK(events, "configure_core");
REWIND_BLOCKS_N_WITH_TIME(events, blk_0r, blk_0, miner, BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW);
// Legend: (n) - PoW block, [m] - PoS block
// 0 60 61 <-- blockchain height (assuming BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW == 60)
// (0 )--(0r)--[1 ] main chain
/* // se
uint64_t tiny_little_money = 1;
MAKE_TX(events, tx_0, miner, alice, tiny_little_money, blk_0r);
MAKE_NEXT_BLOCK_TX1(events, blk_1, blk_0r, miner, tx_0);
*/
// make a PoS block manually with incorrect timestamp
crypto::hash prev_id = get_block_hash(blk_0r);
size_t height = BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW + 1;
currency::wide_difficulty_type diff = generator.get_difficulty_for_next_block(prev_id, false);
const transaction& stake = blk_0.miner_tx;
crypto::public_key stake_tx_pub_key = get_tx_pub_key_from_extra(stake);
size_t stake_output_idx = 0;
size_t stake_output_gidx = 0;
uint64_t stake_output_amount =boost::get<currency::tx_out_bare>( stake.vout[stake_output_idx]).amount;
crypto::key_image stake_output_key_image;
keypair kp;
generate_key_image_helper(miner.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;
pos_block_builder pb;
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);
pb.step4_generate_coinbase_tx(generator.get_timestamps_median(prev_id), generator.get_already_generated_coins(blk_0r), alice.get_public_address());
pb.step5_sign(stake_tx_pub_key, stake_output_idx, stake_output_pubkey, miner);
block blk_1 = pb.m_block;
// EXPECTED: blk_1 is rejected as invalid, because it's timestamps % POS_SCAN_STEP != 0
DO_CALLBACK(events, "mark_invalid_block");
events.push_back(blk_1);
// shift core time a little
uint64_t ts = blk_0r.timestamp + 60;
events.push_back(event_core_time(ts));
// Now try PoS timestamp window boundaries.
pb.clear();
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);
pb.step4_generate_coinbase_tx(generator.get_timestamps_median(prev_id), generator.get_already_generated_coins(blk_0r), alice.get_public_address());
pb.step5_sign(stake_tx_pub_key, stake_output_idx, stake_output_pubkey, miner);
block blk_2 = pb.m_block;
// EXPECTED: blk_2 is rejected as invalid, because its timestamp is beyond upper limit
DO_CALLBACK(events, "mark_invalid_block");
events.push_back(blk_2);
// lower limit
pb.clear();
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);
pb.step4_generate_coinbase_tx(generator.get_timestamps_median(prev_id), generator.get_already_generated_coins(blk_0r), alice.get_public_address());
pb.step5_sign(stake_tx_pub_key, stake_output_idx, stake_output_pubkey, miner);
block blk_3 = pb.m_block;
// EXPECTED: blk_3 is rejected as invalid, because its timestamp is beyond lower limit
DO_CALLBACK(events, "mark_invalid_block");
events.push_back(blk_3);
return true;
}
//------------------------------------------------------------------
gen_pos_too_early_pos_block::gen_pos_too_early_pos_block()
: m_pos_min_height(CURRENCY_MINED_MONEY_UNLOCK_WINDOW + TESTS_POS_CONFIG_POS_MINIMUM_HEIGH)
{
REGISTER_CALLBACK_METHOD(gen_pos_too_early_pos_block, configure_core);
}
bool gen_pos_too_early_pos_block::generate(std::vector<test_event_entry>& events) const
{
uint64_t ts = time(NULL);
GENERATE_ACCOUNT(miner);
MAKE_GENESIS_BLOCK(events, blk_0, miner, ts);
DO_CALLBACK(events, "configure_core");
REWIND_BLOCKS_N(events, blk_0r, blk_0, miner, m_pos_min_height - 2);
// Legend: (n) - PoW block, [m] - PoS block
// 0 N N+1 <-- blockchain height (N= CURRENCY_MINED_MONEY_UNLOCK_WINDOW + TESTS_POS_CONFIG_POS_MINIMUM_HEIGH - 2, now is 12)
// (0 )--(0r)--[1 ] main chain
// EXPECTED: blk_1 is rejected as invalid, because PoS blocks are not allowed on that height
DO_CALLBACK(events, "mark_invalid_block");
MAKE_NEXT_POS_BLOCK(events, blk_1, blk_0r, miner, std::list<account_base>(1, miner));
return true;
}
bool gen_pos_too_early_pos_block::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.min_coinstake_age = TESTS_POS_CONFIG_MIN_COINSTAKE_AGE;
pc.pos_minimum_heigh = m_pos_min_height;
c.get_blockchain_storage().set_core_runtime_config(pc);
return true;
}
//------------------------------------------------------------------
bool gen_pos_extra_nonce::configure_core(currency::core& c, size_t ev_index, const std::vector<test_event_entry>&)
{
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.hf4_minimum_mixins = 0;
pc.hard_forks = m_hardforks;
c.get_blockchain_storage().set_core_runtime_config(pc);
return true;
}
gen_pos_extra_nonce::gen_pos_extra_nonce()
{
REGISTER_CALLBACK_METHOD(gen_pos_extra_nonce, configure_core);
REGISTER_CALLBACK_METHOD(gen_pos_extra_nonce, request_pow_template_with_nonce);
REGISTER_CALLBACK_METHOD(gen_pos_extra_nonce, check_pow_nonce);
REGISTER_CALLBACK_METHOD(gen_pos_extra_nonce, check_pos_nonce);
}
// Test: verify custom extra_nonce in blocks and templates
/*
* Scenarios:
* 1. PoW block contains m_pow_nonce
* 2. PoS block contains m_pos_nonce
* 3. PoW mining template contains m_pow_template_nonce
*/
bool gen_pos_extra_nonce::generate(std::vector<test_event_entry>& events) const
{
GENERATE_ACCOUNT(miner);
GENERATE_ACCOUNT(alice);
m_accounts.push_back(miner);
m_accounts.push_back(alice);
m_pow_nonce = currency::blobdata(254, 'w');
m_pos_nonce = currency::blobdata(255, 's');
m_pow_template_nonce = "POW_TEMPLATE123";
uint64_t ts = test_core_time::get_time();
MAKE_GENESIS_BLOCK(events, blk_0, miner, ts);
DO_CALLBACK(events, "configure_core");
MAKE_NEXT_BLOCK(events, blk_1, blk_0, miner);
block blk_2 = AUTO_VAL_INIT(blk_2);
ts = blk_2.timestamp + DIFFICULTY_BLOCKS_ESTIMATE_TIMESPAN / 2; // to increase main chain difficulty
bool r = generator.construct_block_manually(blk_2, blk_1, miner, test_generator::bf_timestamp, 0, 0,
ts, crypto::hash(), 1, transaction(), std::vector<crypto::hash>(), 0, m_pow_nonce);
CHECK_AND_ASSERT_MES(r, false, "construct_block_manually failed");
events.push_back(blk_2);
DO_CALLBACK(events, "check_pow_nonce");
REWIND_BLOCKS(events, blk_0r, blk_2, miner);
// setup params for PoS
const currency::transaction& stake = blk_2.miner_tx;
currency::block new_pos_block;
bool ok = generate_pos_block_with_extra_nonce(generator, events, miner, alice, blk_0r, stake, m_pos_nonce, new_pos_block);
CHECK_AND_ASSERT_MES(ok, false, "generate_pos_block_with_extra_nonce failed");
events.push_back(new_pos_block);
DO_CALLBACK(events, "check_pos_nonce");
DO_CALLBACK(events, "request_pow_template_with_nonce");
return true;
}
bool gen_pos_extra_nonce::request_pow_template_with_nonce(currency::core& c, size_t ev_index, const std::vector<test_event_entry>& events)
{
block bl;
wide_difficulty_type diff;
uint64_t height;
bool ok = c.get_block_template(bl, m_accounts[0].get_public_address(), m_accounts[0].get_public_address(), diff, height, m_pow_template_nonce);
CHECK_AND_ASSERT_MES(ok, false, "get_block_template failed");
CHECK_AND_ASSERT_MES(has_extra_nonce(bl, m_pow_template_nonce), false, "PoW extra_nonce not found");
return true;
}
bool gen_pos_extra_nonce::check_pow_nonce(currency::core& c, size_t ev_index, const std::vector<test_event_entry>& events)
{
block top;
bool ok = c.get_blockchain_storage().get_top_block(top);
CHECK_AND_ASSERT_MES(ok, false, "get_top_block failed");
CHECK_AND_ASSERT_MES(has_extra_nonce(top, m_pow_nonce), false, "PoW extra_nonce not found");
return true;
}
bool gen_pos_extra_nonce::check_pos_nonce(currency::core& c, size_t ev_index, const std::vector<test_event_entry>& events)
{
block top;
bool ok = c.get_blockchain_storage().get_top_block(top);
CHECK_AND_ASSERT_MES(ok, false, "get_top_block failed");
CHECK_AND_ASSERT_MES(has_extra_nonce(top, m_pos_nonce), false, "PoS extra_nonce not found");
return true;
}
bool gen_pos_extra_nonce::has_extra_nonce(currency::block& blk, const std::string& expected_nonce)
{
if (auto const* ud = get_type_in_variant_container<extra_user_data>(blk.miner_tx.extra)) {
LOG_PRINT_L0("Found extra nonce: '" << ud->buff << "' expected: '" << expected_nonce << "'");
return ud->buff == expected_nonce;
}
return false;
}
//------------------------------------------------------------------
gen_pos_min_allowed_height::gen_pos_min_allowed_height()
{
REGISTER_CALLBACK_METHOD(gen_pos_min_allowed_height, configure_core);
}
bool gen_pos_min_allowed_height::generate(std::vector<test_event_entry>& events) const
{
GENERATE_ACCOUNT(miner);
GENERATE_ACCOUNT(alice);
MAKE_GENESIS_BLOCK(events, blk_0, miner, test_core_time::get_time());
DO_CALLBACK(events, "configure_core");
REWIND_BLOCKS_N_WITH_TIME(events, blk_0r, blk_0, alice, CURRENCY_MINED_MONEY_UNLOCK_WINDOW);
// Legend: (n) - PoW block, [m] - PoS block
// 0 N N+1 <-- blockchain height (assuming CURRENCY_MINED_MONEY_UNLOCK_WINDOW == N)
// (0 )--(0r)--[1 ] main chain
MAKE_TX(events, tx_1, alice, miner, MK_TEST_COINS(1), blk_0r);
crypto::hash prev_id = get_block_hash(blk_0r);
size_t height = CURRENCY_MINED_MONEY_UNLOCK_WINDOW + 1;
currency::wide_difficulty_type diff = generator.get_difficulty_for_next_block(prev_id, false);
const transaction& stake = blk_0.miner_tx;
crypto::public_key stake_tx_pub_key = get_tx_pub_key_from_extra(stake);
size_t stake_output_idx = 0;
size_t stake_output_gidx = 0;
uint64_t stake_output_amount =boost::get<currency::tx_out_bare>( stake.vout[stake_output_idx]).amount;
crypto::key_image stake_output_key_image;
keypair kp;
generate_key_image_helper(miner.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;
pos_block_builder pb;
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());
pb.step5_sign(stake_tx_pub_key, stake_output_idx, stake_output_pubkey, miner);
block blk_1 = pb.m_block;
// EXPECTED: blk_1 is accepted
events.push_back(blk_1);
return true;
}
bool gen_pos_min_allowed_height::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.min_coinstake_age = TESTS_POS_CONFIG_MIN_COINSTAKE_AGE; //four blocks
pc.pos_minimum_heigh = CURRENCY_MINED_MONEY_UNLOCK_WINDOW + 1;
c.get_blockchain_storage().set_core_runtime_config(pc);
return true;
}
//------------------------------------------------------------------
bool gen_pos_invalid_coinbase::generate(std::vector<test_event_entry>& events) const
{
// Test idea: make a PoS block with zero signature in miner_tx (exploits a bug).
GENERATE_ACCOUNT(miner_acc);
GENERATE_ACCOUNT(alice_acc);
MAKE_GENESIS_BLOCK(events, blk_0, miner_acc, test_core_time::get_time());
DO_CALLBACK(events, "configure_core");
REWIND_BLOCKS_N_WITH_TIME(events, blk_0r, blk_0, miner_acc, CURRENCY_MINED_MONEY_UNLOCK_WINDOW);
// create PoS block manually
const block& prev_block = blk_0r;
crypto::hash prev_id = get_block_hash(prev_block);
size_t height = CURRENCY_MINED_MONEY_UNLOCK_WINDOW + 1;
currency::wide_difficulty_type diff = generator.get_difficulty_for_next_block(prev_id, false);
const transaction& stake = blk_0.miner_tx;
crypto::public_key stake_tx_pub_key = get_tx_pub_key_from_extra(stake);
size_t stake_output_idx = 0;
size_t stake_output_gidx = 0;
uint64_t stake_output_amount =boost::get<currency::tx_out_bare>( stake.vout[stake_output_idx]).amount;
crypto::key_image stake_output_key_image;
keypair kp;
generate_key_image_helper(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;
pos_block_builder pb;
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());
pb.step5_sign(stake_tx_pub_key, stake_output_idx, stake_output_pubkey, miner_acc);
pb.m_block.miner_tx.signatures.clear(); // remove signatures
block blk_1 = pb.m_block;
// EXPECTED: blk_1 is rejected as invalid, because coinbase cointains no signatures
DO_CALLBACK(events, "mark_invalid_block");
events.push_back(blk_1);
return true;
}
//------------------------------------------------------------------
void decompose_amount_into_exact_number_of_pos_entries(uint64_t amount, size_t pos_entries_count, std::vector<uint64_t> &pos_amounts)
{
std::list<uint64_t> pos_amounts_list;
// decompose algorithm: we need exactly 'pos_entries_count' entries of power-10 which will give 'amount' in sum
auto f = [&pos_amounts_list](uint64_t a){ pos_amounts_list.push_back(a); };
decompose_amount_into_digits(amount, DEFAULT_DUST_THRESHOLD, f, f); // get some initial decomposition
while (pos_amounts_list.size() < pos_entries_count)
{
for (auto it = pos_amounts_list.begin(); it != pos_amounts_list.end() && pos_amounts_list.size() < pos_entries_count; /* nothing */)
{
if (*it >= 2 * TESTS_DEFAULT_FEE)
{
// each iteration pops one element 'a' and pushes two elements: c1 and c2, so that a == c1 + c2 (sum is invariant)
uint64_t a = *it;
// remove zeros form the tail of 'a': a = 1230000 -> c = 123 * pow = 10000
uint64_t c = a, pow = 1;
for(;;)
{
uint64_t tc = c / 10, tpow = pow * 10;
if (tc * tpow != a)
break;
c = tc;
pow = tpow;
}
if (c == 1)
{
c = 10;
pow /= 10;
}
// randomly split 'a' into sum of c1 and c2
// c in [2; 10], pow in [1...10^^n]
uint64_t c1 = random_in_range(1, c - 1); // c1: [1; c-1]
uint64_t c2 = c - c1; // c2: [c1; c], c1 + c2 == c
pos_amounts_list.push_front(c1 * pow);
pos_amounts_list.push_front(c2 * pow);
it = pos_amounts_list.erase(it);
continue;
}
++it;
}
}
// random shuffle pos amounts to get rid of any kind of order
pos_amounts.assign(pos_amounts_list.begin(), pos_amounts_list.end());
std::shuffle(pos_amounts.begin(), pos_amounts.end(), crypto::uniform_random_bit_generator());
}
bool populate_wallet_with_stake_coins(std::shared_ptr<tools::wallet2> w, std::shared_ptr<tools::wallet2> money_source_w, size_t pos_entries_count, uint64_t amount, const std::vector<uint64_t>& pos_amounts)
{
#define WALLET_TRY_CATCH(statement) \
try \
{ \
statement; \
} \
catch (std::exception& e) \
{ \
LOG_ERROR("Wallet operation failed: " << e.what()); \
return false; \
}
LOG_PRINT_L0("populate_wallet_with_stake_coins: amount: " << print_money(amount) << ", pos_entries_count: " << pos_entries_count);
// make sure w is empty
w->refresh();
uint64_t balance_unlocked = 0;
uint64_t balance = w->balance(balance_unlocked);
CHECK_AND_ASSERT_MES(balance == balance_unlocked, false, "WARNING: balance is " << balance << " NOT EQUAL TO unlocked balance, which is " << balance_unlocked);
if (balance_unlocked > TESTS_DEFAULT_FEE)
WALLET_TRY_CATCH(w->transfer(balance_unlocked, money_source_w->get_account().get_public_address()));
uint64_t sum = 0;
for(auto a : pos_amounts)
sum += a;
CHECK_AND_ASSERT_MES(pos_amounts.size() == pos_entries_count && sum == amount, false, "Failed to decompose " << print_money(amount) << " into " << pos_entries_count << " entries: pos_amounts.size is " << pos_amounts.size() << ", sum is " << sum);
// populate current wallet with pos entries from scratch
money_source_w->refresh();
balance = money_source_w->balance(balance_unlocked);
CHECK_AND_ASSERT_MES(balance_unlocked > amount + TESTS_DEFAULT_FEE * pos_entries_count, false, "source wallet has not enough money: balance_unlocked: " << balance_unlocked << ", balance: " << balance << ", required amount: " << amount + TESTS_DEFAULT_FEE * pos_entries_count);
const account_public_address& wallet_address = w->get_account().get_public_address();
std::vector<tx_destination_entry> destinations;
destinations.reserve(pos_amounts.size());
for(auto pos_amount : pos_amounts)
destinations.push_back(tx_destination_entry(pos_amount, wallet_address));
WALLET_TRY_CATCH(money_source_w->transfer(destinations, 0, 0, TESTS_DEFAULT_FEE, empty_extra, empty_attachment));
return true;
#undef WALLET_TRY_CATCH
}
bool pos_wallet_minting_same_amount_diff_outs::prepare_wallets_0(currency::core& c, const std::vector<test_event_entry>& events, std::vector<wlt_info_t> &minting_wallets, std::vector<size_t>& minting_wallets_order)
{
// Prepare equal wallets: same amount, same transfers (count and amount), same pos entries
// This is to test evenness of simulation environment and the stuff beyound wallet pos entries.
bool r = false;
block b = AUTO_VAL_INIT(b);
std::shared_ptr<tools::wallet2> alice_wlt = init_playtime_test_wallet(events, c, ALICE_ACC_IDX); // Alice is preminer
size_t pos_entries_count = 990;
std::vector<uint64_t> pos_amounts; // use the same stake decomposition for all wallets
decompose_amount_into_exact_number_of_pos_entries(m_wallet_stake_amount, pos_entries_count, pos_amounts);
std::vector<pos_entry> first_wallet_pos_entries;
// populate minting wallets with money
for (size_t i = 0; i < m_minting_wallets_count; ++i)
{
minting_wallets_order[i] = i;
auto& w = minting_wallets[i];
w.w = init_playtime_test_wallet(events, c, ALICE_ACC_IDX + 1 + i);
//w.pos_entries_count = random_in_range(m_pos_entries_count_min, m_pos_entries_count_max);
w.pos_entries_count = pos_entries_count;
r = populate_wallet_with_stake_coins(w.w, alice_wlt, w.pos_entries_count, m_wallet_stake_amount, pos_amounts);
CHECK_AND_ASSERT_MES(r, false, "populate_wallet_with_stake_coins failed");
r = mine_next_pow_blocks_in_playtime(alice_wlt->get_account().get_public_address(), c, WALLET_DEFAULT_TX_SPENDABLE_AGE + 1); // to preventing run out of the money for Alice
CHECK_AND_ASSERT_MES(r, false, "mine_next_pow_blocks_in_playtime failed");
c.get_blockchain_storage().get_top_block(b);
uint64_t ts = b.timestamp;
test_core_time::adjust(ts);
// check pos entries actually available
w.w->refresh();
std::vector<pos_entry> pos_entries;
r = w.w->get_pos_entries(pos_entries);
CHECK_AND_ASSERT_MES(r, false, "get_pos_entries failed");
CHECK_AND_ASSERT_MES(pos_entries.size() == w.pos_entries_count, false, "incorrect pos entries count in the wallet: " << pos_entries.size() << ", expected: " << w.pos_entries_count);
uint64_t balance_unlocked = 0;
w.w->balance(balance_unlocked);
CHECK_AND_ASSERT_MES(balance_unlocked == m_wallet_stake_amount, false, "incorrect wallet unlocked balance: " << print_money(balance_unlocked) << ", expected: " << print_money(m_wallet_stake_amount));
// make sure all wallets has the same distribution of pos_entries
if (i == 0)
{
first_wallet_pos_entries = pos_entries;
}
else
{
for(size_t i = 0; i < pos_amounts.size(); ++i)
{
CHECK_AND_ASSERT_MES(pos_entries[i].amount == first_wallet_pos_entries[i].amount, false, "Wallet pos entry #" << i << " has incorrect amount: " << print_money(pos_entries[i].amount) << ", expected (as in 1st wallet): " << print_money(first_wallet_pos_entries[i].amount));
}
}
}
return true;
}
bool pos_wallet_minting_same_amount_diff_outs::prepare_wallets_1(currency::core& c, const std::vector<test_event_entry>& events, std::vector<wlt_info_t> &minting_wallets, std::vector<size_t>& minting_wallets_order)
{
// prepare five wallets with the same total amount but different pos entries distribution to test how it influence minting efficiency
size_t pos_entries_count_values[] = {100, 1000, 300, 990, 2000};
CHECK_AND_ASSERT_MES(m_minting_wallets_count == (sizeof pos_entries_count_values / sizeof pos_entries_count_values[0]), false, "sizeof pos_entries_count_values != m_minting_wallets_count");
bool r = false;
block b = AUTO_VAL_INIT(b);
std::shared_ptr<tools::wallet2> alice_wlt = init_playtime_test_wallet(events, c, ALICE_ACC_IDX); // Alice is preminer
// populate minting wallets with money
for (size_t i = 0; i < m_minting_wallets_count; ++i)
{
minting_wallets_order[i] = i;
auto& w = minting_wallets[i];
w.w = init_playtime_test_wallet(events, c, ALICE_ACC_IDX + 1 + i);
//w.pos_entries_count = random_in_range(m_pos_entries_count_min, m_pos_entries_count_max);
w.pos_entries_count = pos_entries_count_values[i % (sizeof pos_entries_count_values / sizeof pos_entries_count_values[0])];
std::vector<uint64_t> pos_amounts;
decompose_amount_into_exact_number_of_pos_entries(m_wallet_stake_amount, w.pos_entries_count, pos_amounts);
r = populate_wallet_with_stake_coins(w.w, alice_wlt, w.pos_entries_count, m_wallet_stake_amount, pos_amounts);
CHECK_AND_ASSERT_MES(r, false, "populate_wallet_with_stake_coins failed");
r = mine_next_pow_blocks_in_playtime(alice_wlt->get_account().get_public_address(), c, WALLET_DEFAULT_TX_SPENDABLE_AGE + 1); // to preventing run out of the money for Alice
CHECK_AND_ASSERT_MES(r, false, "mine_next_pow_blocks_in_playtime failed");
c.get_blockchain_storage().get_top_block(b);
uint64_t ts = b.timestamp;
test_core_time::adjust(ts);
// check pos entries actually available
w.w->refresh();
size_t pos_entries_count = w.w->get_pos_entries_count();
CHECK_AND_ASSERT_MES(pos_entries_count == w.pos_entries_count, false, "incorrect pos entries count in the wallet: " << pos_entries_count << ", expected: " << w.pos_entries_count);
uint64_t balance_unlocked = 0;
w.w->balance(balance_unlocked);
CHECK_AND_ASSERT_MES(balance_unlocked == m_wallet_stake_amount, false, "incorrect wallet unlocked balance: " << print_money(balance_unlocked) << ", expected: " << print_money(m_wallet_stake_amount));
}
return true;
}
pos_wallet_minting_same_amount_diff_outs::pos_wallet_minting_same_amount_diff_outs()
{
REGISTER_CALLBACK_METHOD(pos_wallet_minting_same_amount_diff_outs, c1);
m_minting_wallets_count = 5;
m_wallet_stake_amount = 1000 * COIN;
}
bool pos_wallet_minting_same_amount_diff_outs::generate(std::vector<test_event_entry>& events) const
{
GENERATE_ACCOUNT(miner_acc);
GENERATE_ACCOUNT(alice_acc);
m_accounts.resize(ALICE_ACC_IDX + 1 + m_minting_wallets_count);
m_accounts[MINER_ACC_IDX] = miner_acc;
m_accounts[ALICE_ACC_IDX] = alice_acc;
for (size_t i = 0; i < m_minting_wallets_count; ++i)
m_accounts[ALICE_ACC_IDX + 1 + i].generate();
MAKE_GENESIS_BLOCK(events, blk_0, alice_acc, test_core_time::get_time()); // Alice is a preminer!
REWIND_BLOCKS_N_WITH_TIME(events, blk_0r, blk_0, miner_acc, CURRENCY_MINED_MONEY_UNLOCK_WINDOW);
DO_CALLBACK(events, "c1");
return true;
}
bool pos_wallet_minting_same_amount_diff_outs::c1(currency::core& c, size_t ev_index, const std::vector<test_event_entry>& events)
{
// Test idea: few wallets with the same total amount but different transfers are mining simultaneously.
// All generated money is calculated and goes to Miner, so wallets' balances are constant.
// Generated amounts per each wallet should be more or less the same, as far they have the same stakes.
uint64_t ts = test_core_time::get_time();
bool r = false;
block b = AUTO_VAL_INIT(b);
//
// 1/2 prepare wallets
//
std::vector<size_t> minting_wallets_order(m_minting_wallets_count); // to iterate wallets in random order while minting
std::vector<wlt_info_t> minting_wallets(m_minting_wallets_count);
r = prepare_wallets_0(c, events, minting_wallets, minting_wallets_order);
CHECK_AND_ASSERT_MES(r, false, "prepare wallets failed");
//
// 2/2 simulate the mining process
//
uint64_t pos_target = DIFFICULTY_POS_TARGET;
uint64_t pow_target = DIFFICULTY_POW_TARGET;
uint64_t last_pow_block_ts = ts - pow_target;
//uint64_t last_pos_block_ts = ts - pos_target; // block_header::ts
//uint64_t last_pos_block_ts_real = ts - pos_target; // real time at the moment of successfull minting
wide_difficulty_type last_pos_diff = 0;
size_t pos_blocks = 0;
uint64_t total_minted_coins = 0;
#define LOG1_FILENAME "pos_wallet_minting_same_amount_diff_outs.log" // use custom log to store data sheet-friendly
// print header to the log
std::stringstream ss;
ss << "\t" << "height" << "\t" << "pos %" << "\t" << "mnt.coins/pos blks" << "\t" << "last_pos_diff" << "\t" << "stake_to_diff_coeff" << "\t" << "pow_seq_factor" << "\t" << "pos_seq_factor";
for (size_t w_idx = 0; w_idx < m_minting_wallets_count; ++w_idx)
ss << "\tw#" << w_idx << "_" << minting_wallets[w_idx].pos_entries_count;
LOG_PRINT2(LOG1_FILENAME, ss.str(), LOG_LEVEL_0);
for(size_t n = 0; n < 30000; ++n)
{
// log status
c.get_blockchain_storage().get_top_block(b);
size_t height = get_block_height(b);
size_t pow_seq_factor = c.get_blockchain_storage().get_current_sequence_factor(false);
size_t pos_seq_factor = c.get_blockchain_storage().get_current_sequence_factor(true);
double pos_total_stake_to_diff_coeff = static_cast<double>(last_pos_diff / COIN) / static_cast<double>(m_minting_wallets_count * m_wallet_stake_amount / COIN);
float pos_blocks_proportion = static_cast<float>(pos_blocks) / height;
uint64_t minted_coins_per_pos_block = total_minted_coins / height;
ss.str(""); // <-- just a wired way to clear stringstream, have a good day!
ss << "\t" << height << "\t" << pos_blocks_proportion << "\t" << print_money(minted_coins_per_pos_block) << "\t" << last_pos_diff << "\t" << pos_total_stake_to_diff_coeff << "\t" << pow_seq_factor << "\t" << pos_seq_factor;
for (size_t w_idx = 0; w_idx < m_minting_wallets_count; ++w_idx)
ss << "\t" << print_money(minting_wallets[w_idx].mined_coins);
LOG_PRINT2(LOG1_FILENAME, ss.str(), LOG_LEVEL_0);
if (n % 250 == 0)
dump_wallets_entries(minting_wallets);
// pow
uint64_t ideal_next_pow_block_ts = last_pow_block_ts + pow_target;
if (ts < ideal_next_pow_block_ts)
ts = ideal_next_pow_block_ts; // "wait" until ideal_next_pow_block_ts if it was not already happened (fast forward but don't wayback the time)
test_core_time::adjust(ts);
size_t tx_count_before = c.get_pool_transactions_count();
r = mine_next_pow_block_in_playtime(m_accounts[MINER_ACC_IDX].get_public_address(), c);
CHECK_AND_ASSERT_MES(r, false, "mine_next_pow_block_in_playtime failed");
CHECK_AND_ASSERT_MES(tx_count_before == 0 || c.get_pool_transactions_count() < tx_count_before, false, "invalid number of txs in tx pool: " << c.get_pool_transactions_count() << ", was: " << tx_count_before);
last_pow_block_ts = ts;
// pos
uint64_t pos_ts_upper_bound = ts + pos_target / 2;
while(ts <= pos_ts_upper_bound)
{
// every POS_SCAN_STEP all wallets tries to mint a PoS block simultaneously
std::shuffle(minting_wallets_order.begin(), minting_wallets_order.end(), crypto::uniform_random_bit_generator()); // shuffle to iterate in random order
bool a_block_was_minted = true;
do
{
a_block_was_minted = false;
for(size_t i = 0; i < m_minting_wallets_count; ++i)
{
size_t w_idx = minting_wallets_order[i];
LOG_PRINT_L0("Minting with wallet #" << w_idx);
auto& current_wallet = minting_wallets[w_idx];
current_wallet.w->refresh();
if (n % 10 == 0) // check balances every 10 PoW blocks in a sake of speed
{
uint64_t balance = current_wallet.w->balance();
CHECK_AND_ASSERT_MES(balance == m_wallet_stake_amount, false, "Wallet #" << w_idx << " has incorrect balance: " << print_money(balance) << ", expected: " << print_money(m_wallet_stake_amount));
}
last_pos_diff = c.get_blockchain_storage().get_next_diff_conditional(true);
uint64_t bc_height_before = c.get_blockchain_storage().get_current_blockchain_size();
size_t pos_entries_count = 0;
if (mine_next_pos_block_in_playtime_with_wallet(*current_wallet.w.get(), m_accounts[MINER_ACC_IDX].get_public_address(), pos_entries_count))
{
++pos_blocks;
a_block_was_minted = true;
height = c.get_blockchain_storage().get_current_blockchain_size();
CHECK_AND_ASSERT_MES(bc_height_before < height, false, "didn't mint a block!");
LOG_PRINT_GREEN(">>>>>>>>>>>>>> Minted a PoS block by wallet #" << w_idx << " at height " << height << " and time " << ts << " with difficuly: " << last_pos_diff << " using " << pos_entries_count << " pos entries", LOG_LEVEL_0);
CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 0, false, "invalid number of txs in tx pool: " << c.get_pool_transactions_count());
c.get_blockchain_storage().get_top_block(b);
//last_pos_block_ts = b.timestamp;
//last_pos_block_ts_real = ts;
CHECK_AND_ASSERT_MES(is_pos_block(b), false, "Top block is not a PoS block!");
uint64_t generated_coins = get_outs_money_amount(b.miner_tx) - boost::get<txin_to_key>(b.miner_tx.vin[1]).amount;
current_wallet.mined_coins += generated_coins;
total_minted_coins += generated_coins;
}
}
}
while(a_block_was_minted);
ts += POS_SCAN_STEP;
test_core_time::adjust(ts);
}
}
// Todo: add generated money comparation
return true;
#undef LOG1_FILENAME
}
void pos_wallet_minting_same_amount_diff_outs::dump_wallets_entries(const std::vector<wlt_info_t>& minting_wallets)
{
#define LOG2_FILENAME "pos_wallet_minting_same_amount_diff_outs.wallets_dumps.log"
LOG_PRINT2(LOG2_FILENAME, ENDL << ENDL << ENDL << ENDL << ENDL << ENDL, LOG_LEVEL_0);
for (size_t i = 0; i < minting_wallets.size(); ++i)
{
LOG_PRINT2(LOG2_FILENAME, "wallet #" << i << ":" << ENDL << minting_wallets[i].w->dump_transfers() << ENDL, LOG_LEVEL_0);
}
#undef LOG2_FILENAME
}
//------------------------------------------------------------------
pos_wallet_big_block_test::pos_wallet_big_block_test()
{
REGISTER_CALLBACK_METHOD(pos_wallet_big_block_test, c1);
REGISTER_CALLBACK_METHOD(pos_wallet_big_block_test, configure_core);
}
bool pos_wallet_big_block_test::generate(std::vector<test_event_entry>& events) const
{
// Test idea: check PoS mining via wallet for block size greather than median (of sizes of last N block)
GENERATE_ACCOUNT(preminer_acc);
GENERATE_ACCOUNT(miner_acc);
m_accounts.push_back(miner_acc);
MAKE_GENESIS_BLOCK(events, blk_0, preminer_acc, test_core_time::get_time());
DO_CALLBACK(events, "configure_core");
REWIND_BLOCKS_N_WITH_TIME(events, blk_0r, blk_0, miner_acc, CURRENCY_MINED_MONEY_UNLOCK_WINDOW + 3);
// make a couple of huge txs
bool r = false;
size_t padding_size = CURRENCY_MAX_TRANSACTION_BLOB_SIZE * 5 / 8; // to get over one median (of sizes of last N blocks) but not to exceed 2 medians
extra_padding padding = AUTO_VAL_INIT(padding);
padding.buff.resize(padding_size);
std::vector<extra_v> extra({ padding });
std::vector<tx_source_entry> sources_1, sources_2;
r = fill_tx_sources(sources_1, events, blk_0r, miner_acc.get_keys(), MK_TEST_COINS(3), 0);
CHECK_AND_ASSERT_MES(r, false, "fill_tx_sources failed");
r = fill_tx_sources(sources_2, events, blk_0r, miner_acc.get_keys(), MK_TEST_COINS(3), 0, sources_1);
CHECK_AND_ASSERT_MES(r, false, "fill_tx_sources failed");
std::vector<tx_destination_entry> destinations({ tx_destination_entry(MK_TEST_COINS(1), miner_acc.get_public_address())}); // yep, it will be bigger fee than usual, don't mind
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, get_tx_version_from_events(events), stub, 0);
CHECK_AND_ASSERT_MES(r, false, "construct_tx failed");
size_t tx_size = get_object_blobsize(tx_1);
CHECK_AND_ASSERT_MES(tx_size > padding_size, false, "Tx size is: " << tx_size << ", expected to be bigger than: " << padding_size);
events.push_back(tx_1); // push it to the pool
transaction tx_2 = AUTO_VAL_INIT(tx_2);
r = construct_tx(miner_acc.get_keys(), sources_2, destinations, extra, empty_attachment, tx_2, get_tx_version_from_events(events), stub, 0);
CHECK_AND_ASSERT_MES(r, false, "construct_tx failed");
tx_size = get_object_blobsize(tx_2);
CHECK_AND_ASSERT_MES(tx_size > padding_size, false, "Tx size is: " << tx_size << ", expected to be bigger than: " << padding_size);
events.push_back(tx_2); // push it to the pool
DO_CALLBACK(events, "c1");
return true;
}
bool pos_wallet_big_block_test::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.min_coinstake_age = TESTS_POS_CONFIG_MIN_COINSTAKE_AGE; //four blocks
pc.pos_minimum_heigh = TESTS_POS_CONFIG_POS_MINIMUM_HEIGH; //four blocks
c.get_blockchain_storage().set_core_runtime_config(pc);
return true;
}
bool pos_wallet_big_block_test::c1(currency::core& c, size_t ev_index, const std::vector<test_event_entry>& events)
{
bool r = false, stub_bool;
std::shared_ptr<tools::wallet2> miner_wlt = init_playtime_test_wallet(events, c, MINER_ACC_IDX);
miner_wlt->refresh();
miner_wlt->scan_tx_pool(stub_bool);
LOG_PRINT_L0("miner transfers:" << ENDL << miner_wlt->dump_transfers(false));
CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 2, false, "Incorrect number of txs in the pool: " << c.get_pool_transactions_count());
try
{
r = miner_wlt->try_mint_pos();
}
catch (std::exception& e)
{
LOG_ERROR("Got exception in try_mint_pos(): " << e.what());
return false;
}
CHECK_AND_ASSERT_MES(r, false, "try_mint_pos failed");
// make sure the tx has gone
CHECK_AND_ASSERT_MES(c.get_pool_transactions_count() == 0, false, "Incorrect number of txs in the pool: " << c.get_pool_transactions_count());
// check top block - should be PoS with certain size
block b = AUTO_VAL_INIT(b);
r = c.get_blockchain_storage().get_top_block(b);
CHECK_AND_ASSERT_MES(r, false, "get_top_block failed");
CHECK_AND_ASSERT_MES(is_pos_block(b), false, "top block is not PoS");
size_t block_size = get_object_blobsize(b.miner_tx);
for (const crypto::hash& h : b.tx_hashes)
{
transaction t = AUTO_VAL_INIT(t);
r = c.get_transaction(h, t);
CHECK_AND_ASSERT_MES(r, false, "get_transaction failed");
block_size += get_object_blobsize(t);
}
uint64_t block_size_median = c.get_blockchain_storage().get_current_comulative_blocksize_limit() / 2;
CHECK_AND_ASSERT_MES(block_size_median < block_size && block_size < 2 * block_size_median, false, "Incorrect PoS block size: " << block_size << ", expected to be between median and 2 medinas: " << block_size_median);
return true;
}
//------------------------------------------------------------------
pos_altblocks_validation::pos_altblocks_validation()
{
//test_chain_unit_base::set_hardforks_for_old_tests();
}
bool pos_altblocks_validation::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.min_coinstake_age = 1;
pc.pos_minimum_heigh = 1;
c.get_blockchain_storage().set_core_runtime_config(pc);
return true;
}
bool pos_altblocks_validation::generate(std::vector<test_event_entry>& events) const
{
bool r = false;
m_accounts.resize(TOTAL_ACCS_COUNT);
account_base& miner_acc = m_accounts[MINER_ACC_IDX]; miner_acc.generate();
account_base& alice_acc = m_accounts[ALICE_ACC_IDX]; alice_acc.generate();
std::list<account_base> miner_acc_lst(1, miner_acc);
MAKE_GENESIS_BLOCK(events, blk_0, miner_acc, test_core_time::get_time());
DO_CALLBACK(events, "configure_core");
REWIND_BLOCKS_N_WITH_TIME(events, blk_0r, blk_0, miner_acc, CURRENCY_MINED_MONEY_UNLOCK_WINDOW);
MAKE_NEXT_BLOCK(events, blk_1, blk_0r, alice_acc);
REWIND_BLOCKS_N_WITH_TIME(events, blk_1r, blk_1, miner_acc, CURRENCY_MINED_MONEY_UNLOCK_WINDOW);
bool HF4_active = m_hardforks.is_hardfork_active_for_height(ZANO_HARDFORK_04_ZARCANUM, get_block_height(blk_1r) + 1);
MAKE_NEXT_BLOCK(events, blk_2, blk_1r, miner_acc);
const transaction& stake_tx = blk_1.miner_tx;
uint64_t stake_tx_out_id = 0;
uint64_t alice_money = decode_native_output_amount_or_throw(alice_acc, blk_1.miner_tx, stake_tx_out_id);
//// select stake_tx_out_id as an output with the biggest amount
//for (size_t i = 1; i < stake_tx.vout.size(); ++i)
//{
// if (boost::get<currency::tx_out_bare>(stake_tx.vout[i]).amount > boost::get<currency::tx_out_bare>( stake_tx.vout[stake_tx_out_id]).amount)
// stake_tx_out_id = i;
//}
MAKE_TX_FEE(events, tx_0, alice_acc, alice_acc, alice_money - TESTS_DEFAULT_FEE * 17, TESTS_DEFAULT_FEE * 17, blk_2);
// tx_0 transfers all Alice's money, so it effectevily spends all outputs in stake_ts, make sure it does
//CHECK_AND_ASSERT_MES(tx_0.vin.size() == stake_tx.vout.size(), false, "probably, tx_0 doesn't spend all Alice's money as expected, tx_0.vin.size()=" << tx_0.vin.size() << ", stake_tx.vout.size()=" << stake_tx.vout.size());
MAKE_NEXT_BLOCK_TX1(events, blk_3, blk_2, miner_acc, tx_0);
// remember some tx_0's output info for further reference
size_t tx_0_some_output_idx = 0;
uint64_t tx_0_some_output_gindex = UINT64_MAX;
r = find_global_index_for_output(events, get_block_hash(blk_3), tx_0, tx_0_some_output_idx, tx_0_some_output_gindex);
CHECK_AND_ASSERT_MES(r, false, "find_global_index_for_output failed");
REWIND_BLOCKS_N_WITH_TIME(events, blk_3r, blk_3, miner_acc, CURRENCY_MINED_MONEY_UNLOCK_WINDOW);
MAKE_NEXT_POS_BLOCK(events, blk_4, blk_3r, miner_acc, miner_acc_lst);
MAKE_NEXT_BLOCK(events, blk_5, blk_4, miner_acc);
MAKE_NEXT_POS_BLOCK(events, blk_6, blk_5, miner_acc, miner_acc_lst);
// 0 11 21 22 23 33 34 35 36 <- height
//
// +------- blk_1 mined by Alice
// |
// (0 )- (1 )-...(1r)- (2 )- (3 )-...(3r)- (4 )- (5 )- (6 )- <- main chain
// | tx_0
// +---<<---uses-blk_1-out--+
// Case 1 (should pass)
// alt PoS block (blk_2a) refers in its coinstake to an output (stake_tx_out_id) already spent in the main chain
block blk_2a = AUTO_VAL_INIT(blk_2a);
r = generate_pos_block_with_given_coinstake(generator, events, alice_acc, blk_1r, stake_tx, stake_tx_out_id, blk_2a);
CHECK_AND_ASSERT_MES(r, false, "generate_pos_block_with_given_coinstake failed");
ADD_CUSTOM_EVENT(events, blk_2a);
CHECK_AND_ASSERT_MES(generator.add_block_info(blk_2a, std::list<transaction>()), false, "add_block_info failed");
// 0 11 21 22 23 33 34 35 36 <- height
//
// +-----------------------+
// | tx_0 tx_0 spends all outputs in blk_1 (main chain)
// (0 )- (1 )-...(1r)- (2 )- (3 )-...(3r)- (4 )- (5 )- (6 )- <- main chain
// | \
// | \- (2a)- <- alt chain
// +--------------+ PoS block 2a uses stake already spent in main chain
// Case 2a (should fail)
// alt PoS block (blk_3a) refers in its coinstake to an output (stake_tx_out_id) already spent in this alt chain (in blk_2a)
block blk_3a = AUTO_VAL_INIT(blk_3a);
r = generate_pos_block_with_given_coinstake(generator, events, alice_acc, blk_2a, stake_tx, stake_tx_out_id, blk_3a);
CHECK_AND_ASSERT_MES(r, false, "generate_pos_block_with_given_coinstake failed");
DO_CALLBACK(events, "mark_invalid_block");
ADD_CUSTOM_EVENT(events, blk_3a);
// 0 11 21 22 23 33 34 35 36 <- height
//
// +-----------------------+
// | tx_0 tx_0 spends all outputs in blk_1 (main chain)
// (0 )- (1 )-...(1r)- (2 )- (3 )-...(3r)- (4 )- (5 )- (6 )- <- main chain
// || \
// || \- (2a)- #3a#- <- alt chain
// |+--------------+ | PoS block 2a uses stake already spent in main chain (okay)
// +-----------------------+ PoS block 3a uses stake already spent in current alt chain (fail)
// Case 2b (should fail)
// alt PoS block (blk_3aa) has invalid signature
block blk_3aa{};
r = generate_pos_block_with_given_coinstake(generator, events, miner_acc, blk_2a, blk_0r.miner_tx, 0, blk_3aa);
CHECK_AND_ASSERT_MES(r, false, "generate_pos_block_with_given_coinstake failed");
if (HF4_active)
boost::get<zarcanum_sig>(blk_3aa.miner_tx.signatures[0]).y0.m_u64[1] = 5; // invalidate signature
else
boost::get<NLSAG_sig>(blk_3aa.miner_tx.signatures[0]).s[0].c.data[5] = 7; // invalidate signature
DO_CALLBACK(events, "mark_invalid_block");
ADD_CUSTOM_EVENT(events, blk_3aa);
// 0 11 21 22 23 33 34 35 36 <- height
//
// +-----------------------+
// | tx_0 tx_0 spends all outputs in blk_1 (main chain)
// (0 )- (1 )-...(1r)- (2 )- (3 )-...(3r)- (4 )- (5 )- (6 )- <- main chain
// || \
// || \- (2a)- #3aa#- <- alt chain
// |+--------------+ | PoS block 2a uses stake already spent in main chain (okay)
// +-----------------------+ PoS block 3aa has incorrect signature (fail)
REWIND_BLOCKS_N_WITH_TIME(events, blk_2br, blk_2a, miner_acc, CURRENCY_MINED_MONEY_UNLOCK_WINDOW);
// Case 3 (should pass)
// alt PoS block (blk_3b) in its coinstake refers to an output from current altchain (from blk_2a)
block blk_3b = AUTO_VAL_INIT(blk_3b);
r = generate_pos_block_with_given_coinstake(generator, events, alice_acc, blk_2br, blk_2a.miner_tx, 0, blk_3b);
CHECK_AND_ASSERT_MES(r, false, "generate_pos_block_with_given_coinstake failed");
ADD_CUSTOM_EVENT(events, blk_3b);
CHECK_AND_ASSERT_MES(generator.add_block_info(blk_3b, std::list<transaction>()), false, "add_block_info failed");
// 0 11 21 22 23 33 34 35 36 <- height
//
// +-----------------------+
// | tx_0 tx_0 spends all outputs in blk_1 (main chain)
// (0 )- (1 )-...(1r)- (2 )- (3 )- ........ (3r)- (4 )- (5 )- (6 )- <- main chain
// || \
// || \- (2a)- #3a#- <- alt chain
// |+--------------+ \ | PoS block 2a uses stake already spent in main chain (okay)
// +---------------|-------+ PoS block 3a uses stake already spent in current alt chain (fail)
// | \
// | \ ...... (2br)- (3b)- <- alt chain
// | |
// +-----------------------+ PoS block 3b uses as stake an output, created in current alt chain (2a)
// Case 4 (should fail)
// alt PoS block (blk_4b) in its coinstake refers to an output (tx_0) that appeared in the main chain (blk_3) above split height
block blk_4b = AUTO_VAL_INIT(blk_4b);
r = generate_pos_block_with_given_coinstake(generator, events, alice_acc, blk_3b, tx_0, tx_0_some_output_idx, blk_4b, tx_0_some_output_gindex);
if (HF4_active)
{
CHECK_AND_ASSERT_MES(!r, false, "generate_pos_block_with_given_coinstake not failed as expected");
}
else
{
CHECK_AND_ASSERT_MES(r, false, "generate_pos_block_with_given_coinstake failed");
DO_CALLBACK(events, "mark_invalid_block");
ADD_CUSTOM_EVENT(events, blk_4b);
}
// 0 11 21 22 23 33 34 35 36 <- height
// +------------------+
// +-----------------------+ | |
// | tx_0 | tx_0 spends all outputs in blk_1 (main chain)
// (0 )- (1 )-...(1r)- (2 )- (3 )- ........ (3r)- (4 )- (5 )- (6 )- <- main chain
// || \ |
// || \- (2a)- #3a#- | <- alt chain
// |+--------------+ \ | \ PoS block 2a uses stake already spent in main chain (okay)
// +---------------|-------+ \ PoS block 3a uses stake already spent in current alt chain (fail)
// | \ \
// | \ ...... (2br)- (3b)- #4b# <- alt chain
// | |
// +-----------------------+ PoS block 3b uses as stake an output, created in current alt chain (2a)
DO_CALLBACK_PARAMS(events, "check_top_block", params_top_block(get_block_height(blk_6), get_block_hash(blk_6)));
// Final check: switch the chains
MAKE_NEXT_BLOCK(events, blk_4c, blk_3b, miner_acc);
MAKE_NEXT_BLOCK(events, blk_5c, blk_4c, miner_acc);
MAKE_NEXT_BLOCK(events, blk_6c, blk_5c, miner_acc);
MAKE_NEXT_BLOCK(events, blk_7c, blk_6c, miner_acc);
DO_CALLBACK_PARAMS(events, "check_top_block", params_top_block(get_block_height(blk_7c), get_block_hash(blk_7c)));
size_t txs_count = 1;
DO_CALLBACK_PARAMS(events, "check_tx_pool_count", txs_count); // tx_0 should left in the pool
return true;
}
//------------------------------------------------------------------
pos_minting_tx_packing::pos_minting_tx_packing()
: m_pos_mint_packing_size(5)
{
REGISTER_CALLBACK_METHOD(pos_minting_tx_packing, configure_core);
REGISTER_CALLBACK_METHOD(pos_minting_tx_packing, c1);
}
bool pos_minting_tx_packing::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.min_coinstake_age = 1;
pc.pos_minimum_heigh = 1;
c.get_blockchain_storage().set_core_runtime_config(pc);
return true;
}
bool pos_minting_tx_packing::pos_minting_tx_packing::generate(std::vector<test_event_entry>& events) const
{
bool r = false;
m_accounts.resize(TOTAL_ACCS_COUNT);
account_base& miner_acc = m_accounts[MINER_ACC_IDX]; miner_acc.generate();
account_base& alice_acc = m_accounts[ALICE_ACC_IDX]; alice_acc.generate();
std::list<account_base> miner_acc_lst(1, miner_acc);
MAKE_GENESIS_BLOCK(events, blk_0, miner_acc, test_core_time::get_time());
DO_CALLBACK(events, "configure_core");
REWIND_BLOCKS_N_WITH_TIME(events, blk_0r, blk_0, miner_acc, CURRENCY_MINED_MONEY_UNLOCK_WINDOW + 5);
m_alice_start_amount = 10 * CURRENCY_BLOCK_REWARD * m_pos_mint_packing_size;// +TESTS_DEFAULT_FEE;
// 10 outputs each of (CURRENCY_BLOCK_REWARD * m_pos_mint_packing_size) coins
transaction tx_1 = AUTO_VAL_INIT(tx_1);
r = construct_tx_with_many_outputs(m_hardforks, events, blk_0r, miner_acc.get_keys(), alice_acc.get_public_address(), m_alice_start_amount, 10, TESTS_DEFAULT_FEE, tx_1);
CHECK_AND_ASSERT_MES(r, false, "construct_tx_with_many_outputs failed");
events.push_back(tx_1);
MAKE_NEXT_BLOCK_TX1(events, blk_1, blk_0r, miner_acc, tx_1);
REWIND_BLOCKS_N_WITH_TIME(events, blk_1r, blk_1, miner_acc, WALLET_DEFAULT_TX_SPENDABLE_AGE);
DO_CALLBACK(events, "c1");
return true;
}
bool pos_minting_tx_packing::c1(currency::core& c, size_t ev_index, const std::vector<test_event_entry>& events)
{
bool r = false;
std::shared_ptr<tools::wallet2> alice_wlt = init_playtime_test_wallet(events, c, ALICE_ACC_IDX);
CHECK_AND_ASSERT_MES(refresh_wallet_and_check_balance("", "Alice", alice_wlt, m_alice_start_amount, true, UINT64_MAX, m_alice_start_amount), false, "");
size_t pos_entries_count = 0;
for (size_t i = 0; i < m_pos_mint_packing_size; ++i)
{
r = mine_next_pos_block_in_playtime_with_wallet(*alice_wlt, m_accounts[ALICE_ACC_IDX].get_public_address(), pos_entries_count);
CHECK_AND_ASSERT_MES(r, false, "mine_next_pos_block_in_playtime_with_wallet failed");
alice_wlt->refresh();
}
CHECK_AND_ASSERT_MES(refresh_wallet_and_check_balance("", "Alice", alice_wlt, m_alice_start_amount + CURRENCY_BLOCK_REWARD * m_pos_mint_packing_size, true, UINT64_MAX), false, "");
r = mine_next_pow_blocks_in_playtime(m_accounts[MINER_ACC_IDX].get_public_address(), c, WALLET_DEFAULT_TX_SPENDABLE_AGE);
CHECK_AND_ASSERT_MES(r, false, "mine_next_pow_blocks_in_playtime failed");
CHECK_AND_ASSERT_MES(refresh_wallet_and_check_balance("", "Alice", alice_wlt,
m_alice_start_amount + CURRENCY_BLOCK_REWARD * m_pos_mint_packing_size, // total
true,
UINT64_MAX,
m_alice_start_amount + CURRENCY_BLOCK_REWARD * m_pos_mint_packing_size // unlocked
), false, "");
alice_wlt->set_defragmentation_tx_settings(true, m_pos_mint_packing_size + 1, m_pos_mint_packing_size + 1); // +1 because previous implementation () had an error with this limit
// no coinbase tx outputs should be packed
r = alice_wlt->try_mint_pos();
CHECK_AND_ASSERT_MES(r, false, "try_mint_pos failed");
// make sure the wallet has only received new locked incoming reward
CHECK_AND_ASSERT_MES(refresh_wallet_and_check_balance("", "Alice", alice_wlt,
m_alice_start_amount + CURRENCY_BLOCK_REWARD * (m_pos_mint_packing_size + 1), // total
true,
UINT64_MAX,
m_alice_start_amount // unlocked (one output with amount == CURRENCY_BLOCK_REWARD * m_pos_mint_packing_size was spent as stake)
), false, "");
r = mine_next_pow_blocks_in_playtime(m_accounts[MINER_ACC_IDX].get_public_address(), c, WALLET_DEFAULT_TX_SPENDABLE_AGE);
CHECK_AND_ASSERT_MES(r, false, "mine_next_pow_blocks_in_playtime failed");
CHECK_AND_ASSERT_MES(refresh_wallet_and_check_balance("", "Alice", alice_wlt,
m_alice_start_amount + CURRENCY_BLOCK_REWARD * (m_pos_mint_packing_size + 1), // total
true,
UINT64_MAX,
m_alice_start_amount + CURRENCY_BLOCK_REWARD * (m_pos_mint_packing_size + 1) // unlocked
), false, "");
// coinbase tx outputs should be packed now, there's enough coinbase outputs (> m_pos_mint_packing_size)
r = alice_wlt->try_mint_pos();
CHECK_AND_ASSERT_MES(r, false, "try_mint_pos failed");
CHECK_AND_ASSERT_MES(refresh_wallet_and_check_balance("", "Alice", alice_wlt,
m_alice_start_amount + CURRENCY_BLOCK_REWARD * (m_pos_mint_packing_size + 2), // total (+1 one block reward)
true,
UINT64_MAX,
// CURRENCY_BLOCK_REWARD * m_pos_mint_packing_size locked for stake
// CURRENCY_BLOCK_REWARD * (m_pos_mint_packing_size + 1) locked for packing tx
m_alice_start_amount + CURRENCY_BLOCK_REWARD - CURRENCY_BLOCK_REWARD * (m_pos_mint_packing_size + 1) // unlocked
), false, "");
r = alice_wlt->try_mint_pos();
CHECK_AND_ASSERT_MES(r, false, "try_mint_pos failed");
CHECK_AND_ASSERT_MES(refresh_wallet_and_check_balance("", "Alice", alice_wlt,
m_alice_start_amount + CURRENCY_BLOCK_REWARD * (m_pos_mint_packing_size + 3), // total (+1 one block reward)
true,
UINT64_MAX,
// CURRENCY_BLOCK_REWARD * m_pos_mint_packing_size locked for stake
m_alice_start_amount + CURRENCY_BLOCK_REWARD - CURRENCY_BLOCK_REWARD * (m_pos_mint_packing_size + 1) - CURRENCY_BLOCK_REWARD * m_pos_mint_packing_size // unlocked
), false, "");
return true;
}
View git blame Copy permalink