test_generator Class Reference

#include <chaingen.h>

Classes
struct	block_info

Public Types
enum	block_fields {   bf_none = 0 , bf_major_ver = 1 << 0 , bf_minor_ver = 1 << 1 , bf_timestamp = 1 << 2 ,   bf_prev_id = 1 << 3 , bf_miner_tx = 1 << 4 , bf_tx_hashes = 1 << 5 , bf_diffic = 1 << 6 ,   bf_max_outs = 1 << 7 , bf_hf_version = 1 << 8 }

Public Member Functions
	test_generator ()
	test_generator (const test_generator &other)
void	get_block_chain (std::vector< block_info > &blockchain, const crypto::hash &head, size_t n) const
void	get_last_n_block_weights (std::vector< size_t > &block_weights, const crypto::hash &head, size_t n) const
uint64_t	get_already_generated_coins (const crypto::hash &blk_id) const
uint64_t	get_already_generated_coins (const cryptonote::block &blk) const
void	add_block (const cryptonote::block &blk, size_t tsx_size, std::vector< size_t > &block_weights, uint64_t already_generated_coins, uint8_t hf_version=1)
bool	construct_block (cryptonote::block &blk, uint64_t height, const crypto::hash &prev_id, const cryptonote::account_base &miner_acc, uint64_t timestamp, uint64_t already_generated_coins, std::vector< size_t > &block_weights, const std::list< cryptonote::transaction > &tx_list, const boost::optional< uint8_t > &hf_ver=boost::none)
bool	construct_block (cryptonote::block &blk, const cryptonote::account_base &miner_acc, uint64_t timestamp)
bool	construct_block (cryptonote::block &blk, const cryptonote::block &blk_prev, const cryptonote::account_base &miner_acc, const std::list< cryptonote::transaction > &tx_list=std::list< cryptonote::transaction >(), const boost::optional< uint8_t > &hf_ver=boost::none)
bool	construct_block_manually (cryptonote::block &blk, const cryptonote::block &prev_block, const cryptonote::account_base &miner_acc, int actual_params=bf_none, uint8_t major_ver=0, uint8_t minor_ver=0, uint64_t timestamp=0, const crypto::hash &prev_id=crypto::hash(), const cryptonote::difficulty_type &diffic=1, const cryptonote::transaction &miner_tx=cryptonote::transaction(), const std::vector< crypto::hash > &tx_hashes=std::vector< crypto::hash >(), size_t txs_sizes=0, size_t max_outs=999, uint8_t hf_version=1)
bool	construct_block_manually_tx (cryptonote::block &blk, const cryptonote::block &prev_block, const cryptonote::account_base &miner_acc, const std::vector< crypto::hash > &tx_hashes, size_t txs_size)

Friends
class	boost::serialization::access

Detailed Description

Definition at line 182 of file chaingen.h.

Member Enumeration Documentation

block_fields

enum test_generator::block_fields

Enumerator
bf_none
bf_major_ver
bf_minor_ver
bf_timestamp
bf_prev_id
bf_miner_tx
bf_tx_hashes
bf_diffic
bf_max_outs
bf_hf_version

Definition at line 217 of file chaingen.h.

  {
    bf_none      = 0,
    bf_major_ver = 1 << 0,
    bf_minor_ver = 1 << 1,
    bf_timestamp = 1 << 2,
    bf_prev_id   = 1 << 3,
    bf_miner_tx  = 1 << 4,
    bf_tx_hashes = 1 << 5,
    bf_diffic    = 1 << 6,
    bf_max_outs  = 1 << 7,
    bf_hf_version= 1 << 8
  };

Constructor & Destructor Documentation

test_generator() [1/2]

test_generator::test_generator ( )

inline

Definition at line 231 of file chaingen.h.

{}

Here is the caller graph for this function:

test_generator() [2/2]

test_generator::test_generator ( const test_generator & other )

inline

Definition at line 232 of file chaingen.h.

: m_blocks_info(other.m_blocks_info) {}

Here is the call graph for this function:

Member Function Documentation

add_block()

void test_generator::add_block	(	const cryptonote::block &	blk,
		size_t	tsx_size,
		std::vector< size_t > &	block_weights,
		uint64_t	already_generated_coins,
		uint8_t	hf_version = 1 )

Definition at line 104 of file chaingen.cpp.

{
  const size_t block_weight = txs_weight + get_transaction_weight(blk.miner_tx);
  uint64_t block_reward;
  get_block_reward(misc_utils::median(block_weights), block_weight, already_generated_coins, block_reward, hf_version, get_block_height(blk));
  m_blocks_info[get_block_hash(blk)] = block_info(blk.prev_id, already_generated_coins + block_reward, block_weight);
}

Here is the call graph for this function:

Here is the caller graph for this function:

construct_block() [1/3]

bool test_generator::construct_block	(	cryptonote::block &	blk,
		const cryptonote::account_base &	miner_acc,
		uint64_t	timestamp )

Definition at line 198 of file chaingen.cpp.

{
  std::vector<size_t> block_weights;
  std::list<cryptonote::transaction> tx_list;
  return construct_block(blk, 0, null_hash, miner_acc, timestamp, 0, block_weights, tx_list);
}

Here is the call graph for this function:

construct_block() [2/3]

bool test_generator::construct_block	(	cryptonote::block &	blk,
		const cryptonote::block &	blk_prev,
		const cryptonote::account_base &	miner_acc,
		const std::list< cryptonote::transaction > &	tx_list = std::list<cryptonote::transaction>(),
		const boost::optional< uint8_t > &	hf_ver = boost::none )

Definition at line 205 of file chaingen.cpp.

{
  uint64_t height = boost::get<txin_gen>(blk_prev.miner_tx.vin.front()).height + 1;
  crypto::hash prev_id = get_block_hash(blk_prev);
  // Keep difficulty unchanged
  uint64_t timestamp = blk_prev.timestamp + current_difficulty_window(hf_ver); // DIFFICULTY_BLOCKS_ESTIMATE_TIMESPAN;
  uint64_t already_generated_coins = get_already_generated_coins(prev_id);
  std::vector<size_t> block_weights;
  get_last_n_block_weights(block_weights, prev_id, CRYPTONOTE_REWARD_BLOCKS_WINDOW);
 
  return construct_block(blk, height, prev_id, miner_acc, timestamp, already_generated_coins, block_weights, tx_list, hf_ver);
}

Here is the call graph for this function:

construct_block() [3/3]

bool test_generator::construct_block	(	cryptonote::block &	blk,
		uint64_t	height,
		const crypto::hash &	prev_id,
		const cryptonote::account_base &	miner_acc,
		uint64_t	timestamp,
		uint64_t	already_generated_coins,
		std::vector< size_t > &	block_weights,
		const std::list< cryptonote::transaction > &	tx_list,
		const boost::optional< uint8_t > &	hf_ver = boost::none )

Definition at line 112 of file chaingen.cpp.

{
  blk.major_version = hf_ver ? hf_ver.get() : CURRENT_BLOCK_MAJOR_VERSION;
  blk.minor_version = hf_ver ? hf_ver.get() : CURRENT_BLOCK_MINOR_VERSION;
  blk.timestamp = timestamp;
  blk.prev_id = prev_id;
 
  blk.tx_hashes.reserve(tx_list.size());
  BOOST_FOREACH(const transaction &tx, tx_list)
  {
    crypto::hash tx_hash;
    get_transaction_hash(tx, tx_hash);
    blk.tx_hashes.push_back(tx_hash);
  }
 
  uint64_t total_fee = 0;
  size_t txs_weight = 0;
  BOOST_FOREACH(auto& tx, tx_list)
  {
    uint64_t fee = 0;
    bool r = get_tx_fee(tx, fee);
    CHECK_AND_ASSERT_MES(r, false, "wrong transaction passed to construct_block");
    total_fee += fee;
    txs_weight += get_transaction_weight(tx);
  }
 
  blk.miner_tx = AUTO_VAL_INIT(blk.miner_tx);
  size_t target_block_weight = txs_weight + get_transaction_weight(blk.miner_tx);
  while (true)
  {
    if (!construct_miner_tx(height, misc_utils::median(block_weights), already_generated_coins, target_block_weight, total_fee, miner_acc.get_keys().m_account_address, blk.miner_tx, blobdata(), 10, hf_ver ? hf_ver.get() : 1))
      return false;
 
    size_t actual_block_weight = txs_weight + get_transaction_weight(blk.miner_tx);
    if (target_block_weight < actual_block_weight)
    {
      target_block_weight = actual_block_weight;
    }
    else if (actual_block_weight < target_block_weight)
    {
      size_t delta = target_block_weight - actual_block_weight;
      blk.miner_tx.extra.resize(blk.miner_tx.extra.size() + delta, 0);
      actual_block_weight = txs_weight + get_transaction_weight(blk.miner_tx);
      if (actual_block_weight == target_block_weight)
      {
        break;
      }
      else
      {
        CHECK_AND_ASSERT_MES(target_block_weight < actual_block_weight, false, "Unexpected block size");
        delta = actual_block_weight - target_block_weight;
        blk.miner_tx.extra.resize(blk.miner_tx.extra.size() - delta);
        actual_block_weight = txs_weight + get_transaction_weight(blk.miner_tx);
        if (actual_block_weight == target_block_weight)
        {
          break;
        }
        else
        {
          CHECK_AND_ASSERT_MES(actual_block_weight < target_block_weight, false, "Unexpected block size");
          blk.miner_tx.extra.resize(blk.miner_tx.extra.size() + delta, 0);
          target_block_weight = txs_weight + get_transaction_weight(blk.miner_tx);
        }
      }
    }
    else
    {
      break;
    }
  }
 
  //blk.tree_root_hash = get_tx_tree_hash(blk);
 
  // Nonce search...
  blk.nonce = 0;
  while (!miner::find_nonce_for_given_block(blk, get_test_difficulty(hf_ver), height))
    blk.timestamp++;
 
  add_block(blk, txs_weight, block_weights, already_generated_coins, hf_ver ? hf_ver.get() : 1);
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

construct_block_manually()

bool test_generator::construct_block_manually	(	cryptonote::block &	blk,
		const cryptonote::block &	prev_block,
		const cryptonote::account_base &	miner_acc,
		int	actual_params = bf_none,
		uint8_t	major_ver = 0,
		uint8_t	minor_ver = 0,
		uint64_t	timestamp = 0,
		const crypto::hash &	prev_id = crypto::hash(),
		const cryptonote::difficulty_type &	diffic = 1,
		const cryptonote::transaction &	miner_tx = cryptonote::transaction(),
		const std::vector< crypto::hash > &	tx_hashes = std::vector<crypto::hash>(),
		size_t	txs_sizes = 0,
		size_t	max_outs = 999,
		uint8_t	hf_version = 1 )

Definition at line 221 of file chaingen.cpp.

{
  blk.major_version = actual_params & bf_major_ver ? major_ver : CURRENT_BLOCK_MAJOR_VERSION;
  blk.minor_version = actual_params & bf_minor_ver ? minor_ver : CURRENT_BLOCK_MINOR_VERSION;
  blk.timestamp     = actual_params & bf_timestamp ? timestamp : prev_block.timestamp + DIFFICULTY_BLOCKS_ESTIMATE_TIMESPAN; // Keep difficulty unchanged
  blk.prev_id       = actual_params & bf_prev_id   ? prev_id   : get_block_hash(prev_block);
  blk.tx_hashes     = actual_params & bf_tx_hashes ? tx_hashes : std::vector<crypto::hash>();
  max_outs          = actual_params & bf_max_outs ? max_outs : 9999;
  hf_version        = actual_params & bf_hf_version ? hf_version : 1;
 
  size_t height = get_block_height(prev_block) + 1;
  uint64_t already_generated_coins = get_already_generated_coins(prev_block);
  std::vector<size_t> block_weights;
  get_last_n_block_weights(block_weights, get_block_hash(prev_block), CRYPTONOTE_REWARD_BLOCKS_WINDOW);
  if (actual_params & bf_miner_tx)
  {
    blk.miner_tx = miner_tx;
  }
  else
  {
    size_t current_block_weight = txs_weight + get_transaction_weight(blk.miner_tx);
    // TODO: This will work, until size of constructed block is less then CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE
    if (!construct_miner_tx(height, misc_utils::median(block_weights), already_generated_coins, current_block_weight, 0, miner_acc.get_keys().m_account_address, blk.miner_tx, blobdata(), max_outs, hf_version))
      return false;
  }
 
  //blk.tree_root_hash = get_tx_tree_hash(blk);
 
  difficulty_type a_diffic = actual_params & bf_diffic ? diffic : get_test_difficulty(hf_version);
  fill_nonce(blk, a_diffic, height);
 
  add_block(blk, txs_weight, block_weights, already_generated_coins, hf_version);
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

construct_block_manually_tx()

bool test_generator::construct_block_manually_tx	(	cryptonote::block &	blk,
		const cryptonote::block &	prev_block,
		const cryptonote::account_base &	miner_acc,
		const std::vector< crypto::hash > &	tx_hashes,
		size_t	txs_size )

Definition at line 263 of file chaingen.cpp.

{
  return construct_block_manually(blk, prev_block, miner_acc, bf_tx_hashes, 0, 0, 0, crypto::hash(), 0, transaction(), tx_hashes, txs_weight);
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_already_generated_coins() [1/2]

uint64_t test_generator::get_already_generated_coins

(

const crypto::hash &

blk_id

)

const

Definition at line 88 of file chaingen.cpp.

{
  auto it = m_blocks_info.find(blk_id);
  if (it == m_blocks_info.end())
    throw std::runtime_error("block hash wasn't found");
 
  return it->second.already_generated_coins;
}

Here is the caller graph for this function:

get_already_generated_coins() [2/2]

uint64_t test_generator::get_already_generated_coins

(

const cryptonote::block &

blk

)

const

Definition at line 97 of file chaingen.cpp.

{
  crypto::hash blk_hash;
  get_block_hash(blk, blk_hash);
  return get_already_generated_coins(blk_hash);
}

Here is the call graph for this function:

get_block_chain()

void test_generator::get_block_chain	(	std::vector< block_info > &	blockchain,
		const crypto::hash &	head,
		size_t	n ) const

Definition at line 60 of file chaingen.cpp.

{
  crypto::hash curr = head;
  while (null_hash != curr && blockchain.size() < n)
  {
    auto it = m_blocks_info.find(curr);
    if (m_blocks_info.end() == it)
    {
      throw std::runtime_error("block hash wasn't found");
    }
 
    blockchain.push_back(it->second);
    curr = it->second.prev_id;
  }
 
  std::reverse(blockchain.begin(), blockchain.end());
}

Here is the caller graph for this function:

get_last_n_block_weights()

void test_generator::get_last_n_block_weights	(	std::vector< size_t > &	block_weights,
		const crypto::hash &	head,
		size_t	n ) const

Definition at line 78 of file chaingen.cpp.

{
  std::vector<block_info> blockchain;
  get_block_chain(blockchain, head, n);
  BOOST_FOREACH(auto& bi, blockchain)
  {
    block_weights.push_back(bi.block_weight);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

boost::serialization::access

friend class boost::serialization::access

friend

Definition at line 261 of file chaingen.h.

---

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

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