block_tracker Class Reference

#include <chaingen.h>

Collaboration diagram for block_tracker:

Public Member Functions
	block_tracker ()=default
	block_tracker (const block_tracker &bt)
map_txid_output_t::iterator	find_out (const crypto::hash &txid, size_t out)
map_txid_output_t::iterator	find_out (const output_hasher &id)
void	process (const std::vector< cryptonote::block > &blockchain, const map_hash2tx_t &mtx)
void	process (const std::vector< const cryptonote::block * > &blockchain, const map_hash2tx_t &mtx)
void	process (const cryptonote::block *blk, const cryptonote::transaction *tx, size_t i)
void	global_indices (const cryptonote::transaction *tx, std::vector< uint64_t > &indices)
void	get_fake_outs (size_t num_outs, uint64_t amount, uint64_t global_index, uint64_t cur_height, std::vector< get_outs_entry > &outs)
std::string	dump_data ()
void	dump_data (const std::string &fname)

Public Attributes
map_output_idx_t	m_outs
map_txid_output_t	m_map_outs
map_block_t	m_blocks

Friends
class	boost::serialization::access

Detailed Description

Definition at line 370 of file chaingen.h.

Constructor & Destructor Documentation

block_tracker() [1/2]

block_tracker::block_tracker ( )

default

Here is the caller graph for this function:

block_tracker() [2/2]

block_tracker::block_tracker ( const block_tracker & bt )

inline

Definition at line 378 of file chaingen.h.

: m_outs(bt.m_outs), m_map_outs(bt.m_map_outs), m_blocks(bt.m_blocks) {};

Here is the call graph for this function:

Member Function Documentation

dump_data() [1/2]

std::string block_tracker::dump_data

(

)

Definition at line 584 of file chaingen.cpp.

{
  ostringstream ss;
  for (auto &m_out : m_outs)
  {
    auto & vct = m_out.second;
    ss << m_out.first << " => |vector| = " << vct.size() << '\n';
 
    for (const auto & oi : vct)
    {
      auto out = boost::get<txout_to_key>(oi.out);
 
      ss << "    idx: " << oi.idx
      << ", rct: " << oi.rct
      << ", etn: " << oi.amount
      << ", key: " << dump_keys(out.key.data)
      << ", msk: " << dump_keys(oi.comm.bytes)
      << ", txid: " << dump_keys(oi.p_tx->hash.data)
      << '\n';
    }
  }
 
  return ss.str();
}

Here is the call graph for this function:

Here is the caller graph for this function:

dump_data() [2/2]

void block_tracker::dump_data

(

const std::string &

fname

)

Definition at line 609 of file chaingen.cpp.

{
  ofstream myfile;
  myfile.open (fname);
  myfile << dump_data();
  myfile.close();
}

Here is the call graph for this function:

find_out() [1/2]

map_txid_output_t::iterator block_tracker::find_out	(	const crypto::hash &	txid,
		size_t	out )

Definition at line 462 of file chaingen.cpp.

{
  return find_out(std::make_pair(txid, out));
}

Here is the call graph for this function:

Here is the caller graph for this function:

find_out() [2/2]

map_txid_output_t::iterator block_tracker::find_out

(

const output_hasher &

id

)

Definition at line 467 of file chaingen.cpp.

{
  return m_map_outs.find(id);
}

get_fake_outs()

void block_tracker::get_fake_outs	(	size_t	num_outs,
		uint64_t	amount,
		uint64_t	global_index,
		uint64_t	cur_height,
		std::vector< get_outs_entry > &	outs )

Definition at line 547 of file chaingen.cpp.

                                                                                                                                              {
  auto & vct = m_outs[amount];
  const size_t n_outs = vct.size();
 
  std::set<size_t> used;
  std::vector<size_t> choices;
  choices.resize(n_outs);
  for(size_t i=0; i < n_outs; ++i) choices[i] = i;
  shuffle(choices.begin(), choices.end(), std::default_random_engine(crypto::rand<unsigned>()));
 
  size_t n_iters = 0;
  ssize_t idx = -1;
  outs.reserve(num_outs);
  while(outs.size() < num_outs){
    n_iters += 1;
    idx = (idx + 1) % n_outs;
    size_t oi_idx = choices[(size_t)idx];
    CHECK_AND_ASSERT_THROW_MES((n_iters / n_outs) <= outs.size(), "Fake out pick selection problem");
 
    auto & oi = vct[oi_idx];
    if (oi.idx == global_index)
      continue;
    if (oi.out.type() != typeid(cryptonote::txout_to_key))
      continue;
    if (oi.unlock_time > cur_height)
      continue;
    if (used.find(oi_idx) != used.end())
      continue;
 
    rct::key comm = oi.commitment();
    auto out = boost::get<txout_to_key>(oi.out);
    auto item = std::make_tuple(oi.idx, out.key, comm);
    outs.push_back(item);
    used.insert(oi_idx);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

global_indices()

void block_tracker::global_indices	(	const cryptonote::transaction *	tx,
		std::vector< uint64_t > &	indices )

Definition at line 535 of file chaingen.cpp.

{
  indices.clear();
 
  for(size_t j=0; j < tx->vout.size(); ++j){
    auto it = find_out(tx->hash, j);
    if (it != m_map_outs.end()){
      indices.push_back(it->second.idx);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

process() [1/3]

void block_tracker::process	(	const cryptonote::block *	blk,
		const cryptonote::transaction *	tx,
		size_t	i )

Definition at line 508 of file chaingen.cpp.

{
  for (size_t j = 0; j < tx->vout.size(); ++j) {
    const tx_out &out = tx->vout[j];
 
    if (typeid(cryptonote::txout_to_key) != out.target.type()) { // out_to_key
      continue;
    }
 
    const uint64_t rct_amount = tx->version == 2 ? 0 : out.amount;
    const output_hasher hid = std::make_pair(tx->hash, j);
    auto it = find_out(hid);
    if (it != m_map_outs.end()){
      continue;
    }
 
    output_index oi(out.target, out.amount, boost::get<txin_gen>(blk->miner_tx.vin.front()).height, i, j, blk, tx);
    oi.set_rct(tx->version == 2);
    oi.idx = m_outs[rct_amount].size();
    oi.unlock_time = tx->unlock_time;
    oi.is_coin_base = tx->vin.size() == 1 && tx->vin.back().type() == typeid(cryptonote::txin_gen);
 
    m_outs[rct_amount].push_back(oi);
    m_map_outs.insert({hid, oi});
  }
}

Here is the call graph for this function:

process() [2/3]

void block_tracker::process	(	const std::vector< const cryptonote::block * > &	blockchain,
		const map_hash2tx_t &	mtx )

Definition at line 490 of file chaingen.cpp.

{
  BOOST_FOREACH (const block* blk, blockchain) {
    vector<const transaction*> vtx;
    vtx.push_back(&(blk->miner_tx));
 
    BOOST_FOREACH(const crypto::hash &h, blk->tx_hashes) {
      const map_hash2tx_t::const_iterator cit = mtx.find(h);
      CHECK_AND_ASSERT_THROW_MES(mtx.end() != cit, "block contains an unknown tx hash");
      vtx.push_back(cit->second);
    }
 
    for (size_t i = 0; i < vtx.size(); i++) {
      process(blk, vtx[i], i);
    }
  }
}

Here is the call graph for this function:

process() [3/3]

void block_tracker::process	(	const std::vector< cryptonote::block > &	blockchain,
		const map_hash2tx_t &	mtx )

Definition at line 472 of file chaingen.cpp.

{
  std::vector<const cryptonote::block*> blks;
  blks.reserve(blockchain.size());
 
  BOOST_FOREACH (const block& blk, blockchain) {
    auto hsh = get_block_hash(blk);
    auto it = m_blocks.find(hsh);
    if (it == m_blocks.end()){
      m_blocks[hsh] = blk;
    }
 
    blks.push_back(&m_blocks[hsh]);
  }
 
  process(blks, mtx);
}

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 391 of file chaingen.h.

Member Data Documentation

m_blocks

map_block_t block_tracker::m_blocks

Definition at line 375 of file chaingen.h.

m_map_outs

map_txid_output_t block_tracker::m_map_outs

Definition at line 374 of file chaingen.h.

m_outs

map_output_idx_t block_tracker::m_outs

Definition at line 373 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