gen_block_reward Struct Reference

#include <block_reward.h>

Inheritance diagram for gen_block_reward:

Collaboration diagram for gen_block_reward:

Public Member Functions
	gen_block_reward ()
bool	generate (std::vector< test_event_entry > &events) const
bool	check_block_verification_context (const cryptonote::block_verification_context &bvc, size_t event_idx, const cryptonote::block &blk)
bool	mark_invalid_block (cryptonote::core &c, size_t ev_index, const std::vector< test_event_entry > &events)
bool	mark_checked_block (cryptonote::core &c, size_t ev_index, const std::vector< test_event_entry > &events)
bool	check_block_rewards (cryptonote::core &c, size_t ev_index, const std::vector< test_event_entry > &events)
Public Member Functions inherited from test_chain_unit_base
void	register_callback (const std::string &cb_name, verify_callback cb)
bool	verify (const std::string &cb_name, cryptonote::core &c, size_t ev_index, const std::vector< test_event_entry > &events)
bool	check_block_verification_context (const cryptonote::block_verification_context &bvc, size_t event_idx, const cryptonote::block &)
bool	check_tx_verification_context (const cryptonote::tx_verification_context &tvc, bool, size_t, const cryptonote::transaction &)
bool	check_tx_verification_context_array (const std::vector< cryptonote::tx_verification_context > &tvcs, size_t, size_t, const std::vector< cryptonote::transaction > &)

Additional Inherited Members
Public Types inherited from test_chain_unit_base
typedef boost::function< bool(cryptonote::core &c, size_t ev_index, const std::vector< test_event_entry > &events)>	verify_callback
typedef std::map< std::string, verify_callback >	callbacks_map

Detailed Description

Definition at line 35 of file block_reward.h.

Constructor & Destructor Documentation

gen_block_reward()

gen_block_reward::gen_block_reward

(

)

Definition at line 120 of file block_reward.cpp.

  : m_invalid_block_index(0)
{
  REGISTER_CALLBACK_METHOD(gen_block_reward, mark_invalid_block);
  REGISTER_CALLBACK_METHOD(gen_block_reward, mark_checked_block);
  REGISTER_CALLBACK_METHOD(gen_block_reward, check_block_rewards);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

check_block_rewards()

bool gen_block_reward::check_block_rewards	(	cryptonote::core &	c,
		size_t	ev_index,
		const std::vector< test_event_entry > &	events )

Definition at line 246 of file block_reward.cpp.

{
  DEFINE_TESTS_ERROR_CONTEXT("gen_block_reward_without_txs::check_block_rewards");
 
  std::array<uint64_t, 7> blk_rewards;
  blk_rewards[0] = ETN_SUPPLY >> EMISSION_SPEED_FACTOR_PER_MINUTE;
  // Take into account the premine.
  blk_rewards[1] = 1260000000000;
  uint64_t cumulative_reward = blk_rewards[0] + blk_rewards[1];
  for (size_t i = 2; i < blk_rewards.size(); ++i)
  {
    blk_rewards[i] = (ETN_SUPPLY - cumulative_reward) >> EMISSION_SPEED_FACTOR_PER_MINUTE;
    cumulative_reward += blk_rewards[i];
  }
 
  for (size_t i = 0; i < 5; ++i)
  {
    block blk_i = boost::get<block>(events[m_checked_blocks_indices[i]]);
    CHECK_EQ(blk_rewards[i], get_tx_out_amount(blk_i.miner_tx));
  }
 
  block blk_n1 = boost::get<block>(events[m_checked_blocks_indices[5]]);
  CHECK_EQ(blk_rewards[5] + 3 * TESTS_DEFAULT_FEE, get_tx_out_amount(blk_n1.miner_tx));
 
  block blk_n2 = boost::get<block>(events[m_checked_blocks_indices[6]]);
  CHECK_EQ(blk_rewards[6] + (5 + 7) * TESTS_DEFAULT_FEE, get_tx_out_amount(blk_n2.miner_tx));
 
  block blk_n3 = boost::get<block>(events[m_checked_blocks_indices[7]]);
  CHECK_EQ((11 + 13) * TESTS_DEFAULT_FEE, get_tx_out_amount(blk_n3.miner_tx));
 
  return true;
}

Here is the caller graph for this function:

check_block_verification_context()

bool gen_block_reward::check_block_verification_context	(	const cryptonote::block_verification_context &	bvc,
		size_t	event_idx,
		const cryptonote::block &	blk )

Definition at line 221 of file block_reward.cpp.

{
  if (m_invalid_block_index == event_idx)
  {
    m_invalid_block_index = 0;
    return bvc.m_verification_failed;
  }
  else
  {
    return !bvc.m_verification_failed;
  }
}

generate()

bool gen_block_reward::generate

(

std::vector< test_event_entry > &

events

)

const

Definition at line 128 of file block_reward.cpp.

{
  uint64_t ts_start = 1338224400;
 
  GENERATE_ACCOUNT(miner_account);
  MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start);
  DO_CALLBACK(events, "mark_checked_block");
  MAKE_ACCOUNT(events, bob_account);
 
  // Test: miner transactions without outputs (block reward == 0)
  block blk_0r;
  if (!rewind_blocks(events, generator, blk_0r, blk_0, miner_account, CRYPTONOTE_REWARD_BLOCKS_WINDOW))
    return false;
 
  // Test: block reward is calculated using median of the latest CRYPTONOTE_REWARD_BLOCKS_WINDOW blocks
  DO_CALLBACK(events, "mark_invalid_block");
  block blk_1_bad_1;
  if (!construct_max_weight_block(generator, blk_1_bad_1, blk_0r, miner_account, CRYPTONOTE_REWARD_BLOCKS_WINDOW + 1))
    return false;
  events.push_back(blk_1_bad_1);
 
  DO_CALLBACK(events, "mark_invalid_block");
  block blk_1_bad_2;
  if (!construct_max_weight_block(generator, blk_1_bad_2, blk_0r, miner_account, CRYPTONOTE_REWARD_BLOCKS_WINDOW - 1))
    return false;
  events.push_back(blk_1_bad_2);
 
  block blk_1;
  if (!construct_max_weight_block(generator, blk_1, blk_0r, miner_account))
    return false;
  events.push_back(blk_1);

 
  MAKE_NEXT_BLOCK(events, blk_2, blk_1, miner_account);
  DO_CALLBACK(events, "mark_checked_block");
  MAKE_NEXT_BLOCK(events, blk_3, blk_2, miner_account);
  DO_CALLBACK(events, "mark_checked_block");
  MAKE_NEXT_BLOCK(events, blk_4, blk_3, miner_account);
  DO_CALLBACK(events, "mark_checked_block");
  MAKE_NEXT_BLOCK(events, blk_5, blk_4, miner_account);
  DO_CALLBACK(events, "mark_checked_block");
 
  block blk_5r;
  if (!rewind_blocks(events, generator, blk_5r, blk_5, miner_account, CRYPTONOTE_MINED_ETN_UNLOCK_WINDOW))
    return false;
 
  // Test: fee increases block reward
  transaction tx_0(construct_tx_with_fee(events, blk_5, miner_account, bob_account, MK_COINS(1), 3 * TESTS_DEFAULT_FEE));
  MAKE_NEXT_BLOCK_TX1(events, blk_6, blk_5r, miner_account, tx_0);
  DO_CALLBACK(events, "mark_checked_block");
 
  // Test: fee from all block transactions increase block reward
  std::list<transaction> txs_0;
  txs_0.push_back(construct_tx_with_fee(events, blk_5, miner_account, bob_account, MK_COINS(1), 5 * TESTS_DEFAULT_FEE));
  txs_0.push_back(construct_tx_with_fee(events, blk_5, miner_account, bob_account, MK_COINS(1), 7 * TESTS_DEFAULT_FEE));
  MAKE_NEXT_BLOCK_TX_LIST(events, blk_7, blk_6, miner_account, txs_0);
  DO_CALLBACK(events, "mark_checked_block");
 
  // Test: block reward == transactions fee
  {
    transaction tx_1 = construct_tx_with_fee(events, blk_5, miner_account, bob_account, MK_COINS(1), 11 * TESTS_DEFAULT_FEE);
    transaction tx_2 = construct_tx_with_fee(events, blk_5, miner_account, bob_account, MK_COINS(1), 13 * TESTS_DEFAULT_FEE);
    size_t txs_1_weight = get_transaction_weight(tx_1) + get_transaction_weight(tx_2);
    uint64_t txs_fee = get_tx_fee(tx_1) + get_tx_fee(tx_2);
 
    std::vector<size_t> block_weights;
    generator.get_last_n_block_weights(block_weights, get_block_hash(blk_7), CRYPTONOTE_REWARD_BLOCKS_WINDOW);
    size_t median = misc_utils::median(block_weights);
 
    transaction miner_tx;
    bool r = construct_miner_tx_by_weight(miner_tx, get_block_height(blk_7) + 1, generator.get_already_generated_coins(blk_7),
      miner_account.get_keys().m_account_address, block_weights, 2 * median - txs_1_weight, 2 * median, txs_fee);
    if (!r)
      return false;
 
    std::vector<crypto::hash> txs_1_hashes;
    txs_1_hashes.push_back(get_transaction_hash(tx_1));
    txs_1_hashes.push_back(get_transaction_hash(tx_2));
 
    block blk_8;
    generator.construct_block_manually(blk_8, blk_7, miner_account, test_generator::bf_miner_tx | test_generator::bf_tx_hashes,
      0, 0, 0, crypto::hash(), 0, miner_tx, txs_1_hashes, txs_1_weight);
 
    events.push_back(blk_8);
    DO_CALLBACK(events, "mark_checked_block");
  }
 
  DO_CALLBACK(events, "check_block_rewards");
 
  return true;
}

Here is the call graph for this function:

mark_checked_block()

bool gen_block_reward::mark_checked_block	(	cryptonote::core &	c,
		size_t	ev_index,
		const std::vector< test_event_entry > &	events )

Definition at line 240 of file block_reward.cpp.

{
  m_checked_blocks_indices.push_back(ev_index - 1);
  return true;
}

Here is the caller graph for this function:

mark_invalid_block()

bool gen_block_reward::mark_invalid_block	(	cryptonote::core &	c,
		size_t	ev_index,
		const std::vector< test_event_entry > &	events )

Definition at line 234 of file block_reward.cpp.

{
  m_invalid_block_index = ev_index + 1;
  return true;
}

Here is the caller graph for this function:

---

The documentation for this struct was generated from the following files:

• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/tests/core_tests/block_reward.h
• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/tests/core_tests/block_reward.cpp