chaingen.cpp File Reference

#include <vector>
#include <iostream>
#include <sstream>
#include <algorithm>
#include <array>
#include <random>
#include <fstream>
#include "include_base_utils.h"
#include "console_handler.h"
#include "p2p/net_node.h"
#include "cryptonote_basic/cryptonote_basic.h"
#include "cryptonote_basic/cryptonote_basic_impl.h"
#include "cryptonote_basic/cryptonote_format_utils.h"
#include "cryptonote_basic/miner.h"
#include "chaingen.h"
#include "device/device.hpp"

Include dependency graph for chaingen.cpp:

Go to the source code of this file.

Functions
bool	init_output_indices (map_output_idx_t &outs, std::map< uint64_t, std::vector< size_t > > &outs_mine, const std::vector< cryptonote::block > &blockchain, const map_hash2tx_t &mtx, const cryptonote::account_base &from)
bool	init_spent_output_indices (map_output_idx_t &outs, map_output_t &outs_mine, const std::vector< cryptonote::block > &blockchain, const map_hash2tx_t &mtx, const cryptonote::account_base &from)
bool	fill_output_entries (std::vector< output_index > &out_indices, size_t sender_out, size_t nmix, size_t &real_entry_idx, std::vector< tx_source_entry::output_entry > &output_entries)
bool	fill_tx_sources (std::vector< tx_source_entry > &sources, const std::vector< test_event_entry > &events, const block &blk_head, const cryptonote::account_base &from, uint64_t amount, size_t nmix)
bool	fill_tx_destination (tx_destination_entry &de, const cryptonote::account_public_address &to, uint64_t amount)
std::string	dump_data (const cryptonote::transaction &tx)
cryptonote::account_public_address	get_address (const var_addr_t &inp)
cryptonote::account_public_address	get_address (const cryptonote::account_public_address &inp)
cryptonote::account_public_address	get_address (const cryptonote::account_keys &inp)
cryptonote::account_public_address	get_address (const cryptonote::account_base &inp)
cryptonote::account_public_address	get_address (const cryptonote::tx_destination_entry &inp)
uint64_t	sum_amount (const std::vector< tx_destination_entry > &destinations)
uint64_t	sum_amount (const std::vector< cryptonote::tx_source_entry > &sources)
void	fill_tx_destinations (const var_addr_t &from, const std::vector< tx_destination_entry > &dests, uint64_t fee, const std::vector< tx_source_entry > &sources, std::vector< tx_destination_entry > &destinations, bool always_change)
void	fill_tx_destinations (const var_addr_t &from, const cryptonote::account_public_address &to, uint64_t amount, uint64_t fee, const std::vector< tx_source_entry > &sources, std::vector< tx_destination_entry > &destinations, std::vector< tx_destination_entry > &destinations_pure, bool always_change)
void	fill_tx_destinations (const var_addr_t &from, const cryptonote::account_public_address &to, uint64_t amount, uint64_t fee, const std::vector< tx_source_entry > &sources, std::vector< tx_destination_entry > &destinations, bool always_change)
void	fill_tx_sources_and_destinations (const std::vector< test_event_entry > &events, const block &blk_head, const cryptonote::account_base &from, const cryptonote::account_public_address &to, uint64_t amount, uint64_t fee, size_t nmix, std::vector< tx_source_entry > &sources, std::vector< tx_destination_entry > &destinations)
void	fill_tx_sources_and_destinations (const std::vector< test_event_entry > &events, const block &blk_head, const cryptonote::account_base &from, const cryptonote::account_base &to, uint64_t amount, uint64_t fee, size_t nmix, std::vector< tx_source_entry > &sources, std::vector< tx_destination_entry > &destinations)
void	fill_nonce (cryptonote::block &blk, const difficulty_type &diffic, uint64_t height)
cryptonote::tx_destination_entry	build_dst (const var_addr_t &to, bool is_subaddr, uint64_t amount)
std::vector< cryptonote::tx_destination_entry >	build_dsts (const var_addr_t &to1, bool sub1, uint64_t am1)
std::vector< cryptonote::tx_destination_entry >	build_dsts (std::initializer_list< dest_wrapper_t > inps)
bool	construct_miner_tx_manually (size_t height, uint64_t already_generated_coins, const account_public_address &miner_address, transaction &tx, uint64_t fee, keypair *p_txkey)
bool	construct_tx_to_key (const std::vector< test_event_entry > &events, cryptonote::transaction &tx, const cryptonote::block &blk_head, const cryptonote::account_base &from, const var_addr_t &to, uint64_t amount, uint64_t fee, size_t nmix, bool rct, rct::RangeProofType range_proof_type, int bp_version)
bool	construct_tx_to_key (const std::vector< test_event_entry > &events, cryptonote::transaction &tx, const cryptonote::block &blk_head, const cryptonote::account_base &from, std::vector< cryptonote::tx_destination_entry > destinations, uint64_t fee, size_t nmix, bool rct, rct::RangeProofType range_proof_type, int bp_version)
bool	construct_tx_to_key (cryptonote::transaction &tx, const cryptonote::account_base &from, const var_addr_t &to, uint64_t amount, std::vector< cryptonote::tx_source_entry > &sources, uint64_t fee, bool rct, rct::RangeProofType range_proof_type, int bp_version)
bool	construct_tx_to_key (cryptonote::transaction &tx, const cryptonote::account_base &from, const std::vector< cryptonote::tx_destination_entry > &destinations, std::vector< cryptonote::tx_source_entry > &sources, uint64_t fee, bool rct, rct::RangeProofType range_proof_type, int bp_version)
bool	construct_tx_rct (const cryptonote::account_keys &sender_account_keys, std::vector< cryptonote::tx_source_entry > &sources, const std::vector< cryptonote::tx_destination_entry > &destinations, const boost::optional< cryptonote::account_public_address > &change_addr, std::vector< uint8_t > extra, cryptonote::transaction &tx, uint64_t unlock_time, bool rct, rct::RangeProofType range_proof_type, int bp_version)
transaction	construct_tx_with_fee (std::vector< test_event_entry > &events, const block &blk_head, const account_base &acc_from, const var_addr_t &to, uint64_t amount, uint64_t fee)
uint64_t	get_balance (const cryptonote::account_base &addr, const std::vector< cryptonote::block > &blockchain, const map_hash2tx_t &mtx)
bool	extract_hard_forks (const std::vector< test_event_entry > &events, v_hardforks_t &hard_forks)
void	get_confirmed_txs (const std::vector< cryptonote::block > &blockchain, const map_hash2tx_t &mtx, map_hash2tx_t &confirmed_txs)
bool	trim_block_chain (std::vector< cryptonote::block > &blockchain, const crypto::hash &tail)
bool	trim_block_chain (std::vector< const cryptonote::block * > &blockchain, const crypto::hash &tail)
uint64_t	num_blocks (const std::vector< test_event_entry > &events)
cryptonote::block	get_head_block (const std::vector< test_event_entry > &events)
bool	find_block_chain (const std::vector< test_event_entry > &events, std::vector< cryptonote::block > &blockchain, map_hash2tx_t &mtx, const crypto::hash &head)
bool	find_block_chain (const std::vector< test_event_entry > &events, std::vector< const cryptonote::block * > &blockchain, map_hash2tx_t &mtx, const crypto::hash &head)

Function Documentation

build_dst()

cryptonote::tx_destination_entry build_dst	(	const var_addr_t &	to,
		bool	is_subaddr,
		uint64_t	amount )

Definition at line 804 of file chaingen.cpp.

{
  tx_destination_entry de;
  de.amount = amount;
  de.addr = get_address(to);
  de.is_subaddress = is_subaddr;
  return de;
}

Here is the call graph for this function:

Here is the caller graph for this function:

build_dsts() [1/2]

std::vector< cryptonote::tx_destination_entry > build_dsts	(	const var_addr_t &	to1,
		bool	sub1,
		uint64_t	am1 )

Definition at line 813 of file chaingen.cpp.

{
  std::vector<cryptonote::tx_destination_entry> res;
  res.push_back(build_dst(to1, sub1, am1));
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

build_dsts() [2/2]

std::vector< cryptonote::tx_destination_entry > build_dsts

(

std::initializer_list< dest_wrapper_t >

inps

)

Definition at line 820 of file chaingen.cpp.

{
  std::vector<cryptonote::tx_destination_entry> res;
  res.reserve(inps.size());
  for(auto & c : inps){
    res.push_back(build_dst(c.addr, c.is_subaddr, c.amount));
  }
  return res;
}

Here is the call graph for this function:

construct_miner_tx_manually()

bool construct_miner_tx_manually	(	size_t	height,
		uint64_t	already_generated_coins,
		const account_public_address &	miner_address,
		transaction &	tx,
		uint64_t	fee,
		keypair *	p_txkey )

Definition at line 830 of file chaingen.cpp.

{
  keypair txkey;
  txkey = keypair::generate(hw::get_device("default"));
  add_tx_pub_key_to_extra(tx, txkey.pub);
 
  if (0 != p_txkey)
    *p_txkey = txkey;
 
  txin_gen in;
  in.height = height;
  tx.vin.push_back(in);
 
  // This will work, until size of constructed block is less then CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE
  uint64_t block_reward;
  //Deal with premine implementation. 
  if (height == 1){block_reward = 1260000000000;}
  else if (!get_block_reward(0, 0, already_generated_coins, block_reward, 1, height))
  {
    LOG_PRINT_L0("Block is too big");
    return false;
  }
  block_reward += fee;
 
  crypto::key_derivation derivation;
  crypto::public_key out_eph_public_key;
  crypto::generate_key_derivation(miner_address.m_view_public_key, txkey.sec, derivation);
  crypto::derive_public_key(derivation, 0, miner_address.m_spend_public_key, out_eph_public_key);
 
  tx_out out;
  out.amount = block_reward;
  out.target = txout_to_key(out_eph_public_key);
  tx.vout.push_back(out);
 
  tx.version = 1;
  tx.unlock_time = height + CRYPTONOTE_MINED_ETN_UNLOCK_WINDOW;
 
  return true;
}

Here is the call graph for this function:

construct_tx_rct()

bool construct_tx_rct	(	const cryptonote::account_keys &	sender_account_keys,
		std::vector< cryptonote::tx_source_entry > &	sources,
		const std::vector< cryptonote::tx_destination_entry > &	destinations,
		const boost::optional< cryptonote::account_public_address > &	change_addr,
		std::vector< uint8_t >	extra,
		cryptonote::transaction &	tx,
		uint64_t	unlock_time,
		bool	rct,
		rct::RangeProofType	range_proof_type,
		int	bp_version )

Definition at line 920 of file chaingen.cpp.

{
  std::unordered_map<crypto::public_key, cryptonote::subaddress_index> subaddresses;
  subaddresses[sender_account_keys.m_account_address.m_spend_public_key] = {0, 0};
  crypto::secret_key tx_key;
  std::vector<crypto::secret_key> additional_tx_keys;
  std::vector<tx_destination_entry> destinations_copy = destinations;
  rct::RCTConfig rct_config = {range_proof_type, bp_version};
  return construct_tx_and_get_tx_key(sender_account_keys, subaddresses, sources, destinations_copy, change_addr, extra, tx, unlock_time, tx_key, additional_tx_keys, rct, rct_config, nullptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

construct_tx_to_key() [1/4]

bool construct_tx_to_key	(	const std::vector< test_event_entry > &	events,
		cryptonote::transaction &	tx,
		const cryptonote::block &	blk_head,
		const cryptonote::account_base &	from,
		const var_addr_t &	to,
		uint64_t	amount,
		uint64_t	fee,
		size_t	nmix,
		bool	rct,
		rct::RangeProofType	range_proof_type,
		int	bp_version )

Definition at line 872 of file chaingen.cpp.

{
  vector<tx_source_entry> sources;
  vector<tx_destination_entry> destinations;
  fill_tx_sources_and_destinations(events, blk_head, from, get_address(to), amount, fee, nmix, sources, destinations);
 
  return construct_tx_rct(from.get_keys(), sources, destinations, from.get_keys().m_account_address, std::vector<uint8_t>(), tx, 0, rct, range_proof_type, bp_version);
}

Here is the call graph for this function:

Here is the caller graph for this function:

construct_tx_to_key() [2/4]

bool construct_tx_to_key	(	const std::vector< test_event_entry > &	events,
		cryptonote::transaction &	tx,
		const cryptonote::block &	blk_head,
		const cryptonote::account_base &	from,
		std::vector< cryptonote::tx_destination_entry >	destinations,
		uint64_t	fee,
		size_t	nmix,
		bool	rct,
		rct::RangeProofType	range_proof_type,
		int	bp_version )

Definition at line 883 of file chaingen.cpp.

{
  vector<tx_source_entry> sources;
  vector<tx_destination_entry> destinations_all;
  uint64_t amount = sum_amount(destinations);
 
  if (!fill_tx_sources(sources, events, blk_head, from, amount + fee, nmix))
    throw std::runtime_error("couldn't fill transaction sources");
 
  fill_tx_destinations(from, destinations, fee, sources, destinations_all, false);
 
  return construct_tx_rct(from.get_keys(), sources, destinations_all, get_address(from), std::vector<uint8_t>(), tx, 0, rct, range_proof_type, bp_version);
}

Here is the call graph for this function:

construct_tx_to_key() [3/4]

bool construct_tx_to_key	(	cryptonote::transaction &	tx,
		const cryptonote::account_base &	from,
		const std::vector< cryptonote::tx_destination_entry > &	destinations,
		std::vector< cryptonote::tx_source_entry > &	sources,
		uint64_t	fee,
		bool	rct,
		rct::RangeProofType	range_proof_type,
		int	bp_version )

Definition at line 909 of file chaingen.cpp.

{
  vector<tx_destination_entry> all_destinations;
  fill_tx_destinations(from, destinations, fee, sources, all_destinations, rct);
  return construct_tx_rct(from.get_keys(), sources, all_destinations, get_address(from), std::vector<uint8_t>(), tx, 0, rct, range_proof_type, bp_version);
}

Here is the call graph for this function:

construct_tx_to_key() [4/4]

bool construct_tx_to_key	(	cryptonote::transaction &	tx,
		const cryptonote::account_base &	from,
		const var_addr_t &	to,
		uint64_t	amount,
		std::vector< cryptonote::tx_source_entry > &	sources,
		uint64_t	fee,
		bool	rct,
		rct::RangeProofType	range_proof_type,
		int	bp_version )

Definition at line 899 of file chaingen.cpp.

{
  vector<tx_destination_entry> destinations;
  fill_tx_destinations(from, get_address(to), amount, fee, sources, destinations, rct);
  return construct_tx_rct(from.get_keys(), sources, destinations, get_address(from), std::vector<uint8_t>(), tx, 0, rct, range_proof_type, bp_version);
}

Here is the call graph for this function:

construct_tx_with_fee()

transaction construct_tx_with_fee	(	std::vector< test_event_entry > &	events,
		const block &	blk_head,
		const account_base &	acc_from,
		const var_addr_t &	to,
		uint64_t	amount,
		uint64_t	fee )

Definition at line 931 of file chaingen.cpp.

{
  transaction tx;
  construct_tx_to_key(events, tx, blk_head, acc_from, to, amount, fee, 0);
  events.push_back(tx);
  return tx;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dump_data()

std::string dump_data

(

const cryptonote::transaction &

tx

)

Definition at line 617 of file chaingen.cpp.

{
  ostringstream ss;
  ss << "msg: " << dump_keys(tx.rct_signatures.message.bytes)
     << ", vin: ";
 
  for(auto & in : tx.vin){
    if (typeid(txin_to_key) == in.type()){
      auto tk = boost::get<txin_to_key>(in);
      std::vector<uint64_t> full_off;
      int64_t last = -1;
 
      ss << " i: " << tk.amount << " [";
      for(auto ix : tk.key_offsets){
        ss << ix << ", ";
        if (last == -1){
          last = ix;
          full_off.push_back(ix);
        } else {
          last += ix;
          full_off.push_back((uint64_t)last);
        }
      }
 
      ss << "], full: [";
      for(auto ix : full_off){
        ss << ix << ", ";
      }
      ss << "]; ";
 
    } else if (typeid(txin_gen) == in.type()){
      ss << " h: " << boost::get<txin_gen>(in).height << ", ";
    } else {
      ss << " ?, ";
    }
  }
 
  ss << ", mixring: \n";
  for (const auto & row : tx.rct_signatures.mixRing){
    for(auto cur : row){
      ss << "    (" << dump_keys(cur.dest.bytes) << ", " << dump_keys(cur.mask.bytes) << ")\n ";
    }
    ss << "; ";
  }
 
  return ss.str();
}

Here is the call graph for this function:

Here is the caller graph for this function:

extract_hard_forks()

bool extract_hard_forks	(	const std::vector< test_event_entry > &	events,
		v_hardforks_t &	hard_forks )

Definition at line 966 of file chaingen.cpp.

{
  for(auto & ev : events)
  {
    if (typeid(event_replay_settings) == ev.type())
    {
      const auto & rep_settings = boost::get<event_replay_settings>(ev);
      if (rep_settings.hard_forks)
      {
        const auto & hf = rep_settings.hard_forks.get();
        std::copy(hf.begin(), hf.end(), std::back_inserter(hard_forks));
      }
    }
  }
 
  return !hard_forks.empty();
}

Here is the caller graph for this function:

fill_nonce()

void fill_nonce	(	cryptonote::block &	blk,
		const difficulty_type &	diffic,
		uint64_t	height )

Definition at line 797 of file chaingen.cpp.

{
  blk.nonce = 0;
  while (!miner::find_nonce_for_given_block(blk, diffic, height))
    blk.timestamp++;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fill_output_entries()

bool fill_output_entries	(	std::vector< output_index > &	out_indices,
		size_t	sender_out,
		size_t	nmix,
		size_t &	real_entry_idx,
		std::vector< tx_source_entry::output_entry > &	output_entries )

Definition at line 359 of file chaingen.cpp.

{
  if (out_indices.size() <= nmix)
    return false;
 
  bool sender_out_found = false;
  size_t rest = nmix;
  for (size_t i = 0; i < out_indices.size() && (0 < rest || !sender_out_found); ++i)
  {
    const output_index& oi = out_indices[i];
    if (oi.spent)
      continue;
 
    bool append = false;
    if (i == sender_out)
    {
      append = true;
      sender_out_found = true;
      real_entry_idx = output_entries.size();
    }
    else if (0 < rest)
    {
      --rest;
      append = true;
    }
 
    if (append)
    {
      rct::key comm = oi.commitment();
      const txout_to_key& otk = boost::get<txout_to_key>(oi.out);
      output_entries.push_back(tx_source_entry::output_entry(oi.idx, rct::ctkey({rct::pk2rct(otk.key), comm})));
    }
  }
 
  return 0 == rest && sender_out_found;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fill_tx_destination()

bool fill_tx_destination	(	tx_destination_entry &	de,
		const cryptonote::account_public_address &	to,
		uint64_t	amount )

Definition at line 456 of file chaingen.cpp.

                                                                                                                {
    de.addr = to;
    de.amount = amount;
    return true;
}

Here is the caller graph for this function:

fill_tx_destinations() [1/3]

void fill_tx_destinations	(	const var_addr_t &	from,
		const cryptonote::account_public_address &	to,
		uint64_t	amount,
		uint64_t	fee,
		const std::vector< tx_source_entry > &	sources,
		std::vector< tx_destination_entry > &	destinations,
		bool	always_change )

Definition at line 766 of file chaingen.cpp.

{
  std::vector<tx_destination_entry> destinations_pure;
  fill_tx_destinations(from, to, amount, fee, sources, destinations, destinations_pure, always_change);
}

Here is the call graph for this function:

fill_tx_destinations() [2/3]

void fill_tx_destinations	(	const var_addr_t &	from,
		const cryptonote::account_public_address &	to,
		uint64_t	amount,
		uint64_t	fee,
		const std::vector< tx_source_entry > &	sources,
		std::vector< tx_destination_entry > &	destinations,
		std::vector< tx_destination_entry > &	destinations_pure,
		bool	always_change )

Definition at line 741 of file chaingen.cpp.

{
  destinations.clear();
 
  tx_destination_entry de;
  if (!fill_tx_destination(de, to, amount))
    throw std::runtime_error("couldn't fill transaction destination");
  destinations.push_back(de);
  destinations_pure.push_back(de);
 
  tx_destination_entry de_change;
  uint64_t cache_back = get_inputs_amount(sources) - (amount + fee);
 
  if (cache_back > 0 || always_change) {
    if (!fill_tx_destination(de_change, get_address(from), cache_back <= 0 ? 0 : cache_back))
      throw std::runtime_error("couldn't fill transaction cache back destination");
    destinations.push_back(de_change);
  }
}

Here is the call graph for this function:

fill_tx_destinations() [3/3]

void fill_tx_destinations	(	const var_addr_t &	from,
		const std::vector< tx_destination_entry > &	dests,
		uint64_t	fee,
		const std::vector< tx_source_entry > &	sources,
		std::vector< tx_destination_entry > &	destinations,
		bool	always_change )

Definition at line 720 of file chaingen.cpp.

{
  destinations.clear();
  uint64_t amount = sum_amount(dests);
  std::copy(dests.begin(), dests.end(), std::back_inserter(destinations));
 
  tx_destination_entry de_change;
  uint64_t cache_back = get_inputs_amount(sources) - (amount + fee);
 
  if (cache_back > 0 || always_change) {
    if (!fill_tx_destination(de_change, get_address(from), cache_back <= 0 ? 0 : cache_back))
      throw std::runtime_error("couldn't fill transaction cache back destination");
    destinations.push_back(de_change);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

fill_tx_sources()

bool fill_tx_sources	(	std::vector< tx_source_entry > &	sources,
		const std::vector< test_event_entry > &	events,
		const block &	blk_head,
		const cryptonote::account_base &	from,
		uint64_t	amount,
		size_t	nmix )

Definition at line 396 of file chaingen.cpp.

{
    map_output_idx_t outs;
    map_output_t outs_mine;
 
    std::vector<cryptonote::block> blockchain;
    map_hash2tx_t mtx;
    if (!find_block_chain(events, blockchain, mtx, get_block_hash(blk_head)))
        return false;
 
    if (!init_output_indices(outs, outs_mine, blockchain, mtx, from))
        return false;
 
    if (!init_spent_output_indices(outs, outs_mine, blockchain, mtx, from))
        return false;
 
    // Iterate in reverse is more efficiency
    uint64_t sources_amount = 0;
    bool sources_found = false;
    BOOST_REVERSE_FOREACH(const map_output_t::value_type o, outs_mine)
    {
        for (size_t i = 0; i < o.second.size() && !sources_found; ++i)
        {
            size_t sender_out = o.second[i];
            const output_index& oi = outs[o.first][sender_out];
            if (oi.spent)
                continue;
            if (oi.rct)
                continue;
 
            cryptonote::tx_source_entry ts;
            ts.amount = oi.amount;
            ts.real_output_in_tx_index = oi.out_no;
            ts.real_out_tx_key = get_tx_pub_key_from_extra(*oi.p_tx); // incoming tx public key
            size_t realOutput;
            if (!fill_output_entries(outs[o.first], sender_out, nmix, realOutput, ts.outputs))
              continue;
 
            ts.real_output = realOutput;
            ts.rct = false;
            ts.mask = rct::identity();  // non-rct has identity mask by definition
 
            rct::key comm = rct::zeroCommit(ts.amount);
            for(auto & ot : ts.outputs)
              ot.second.mask = comm;
 
            sources.push_back(ts);
 
            sources_amount += ts.amount;
            sources_found = amount <= sources_amount;
        }
 
        if (sources_found)
            break;
    }
 
    return sources_found;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fill_tx_sources_and_destinations() [1/2]

void fill_tx_sources_and_destinations	(	const std::vector< test_event_entry > &	events,
		const block &	blk_head,
		const cryptonote::account_base &	from,
		const cryptonote::account_base &	to,
		uint64_t	amount,
		uint64_t	fee,
		size_t	nmix,
		std::vector< tx_source_entry > &	sources,
		std::vector< tx_destination_entry > &	destinations )

Definition at line 789 of file chaingen.cpp.

{
  fill_tx_sources_and_destinations(events, blk_head, from, to.get_keys().m_account_address, amount, fee, nmix, sources, destinations);
}

Here is the call graph for this function:

fill_tx_sources_and_destinations() [2/2]

void fill_tx_sources_and_destinations	(	const std::vector< test_event_entry > &	events,
		const block &	blk_head,
		const cryptonote::account_base &	from,
		const cryptonote::account_public_address &	to,
		uint64_t	amount,
		uint64_t	fee,
		size_t	nmix,
		std::vector< tx_source_entry > &	sources,
		std::vector< tx_destination_entry > &	destinations )

Definition at line 775 of file chaingen.cpp.

{
  sources.clear();
  destinations.clear();
 
  if (!fill_tx_sources(sources, events, blk_head, from, amount + fee, nmix))
    throw std::runtime_error("couldn't fill transaction sources");
 
  fill_tx_destinations(from, to, amount, fee, sources, destinations, false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

find_block_chain() [1/2]

bool find_block_chain	(	const std::vector< test_event_entry > &	events,
		std::vector< const cryptonote::block * > &	blockchain,
		map_hash2tx_t &	mtx,
		const crypto::hash &	head )

Definition at line 1105 of file chaingen.cpp.

                                                                                                                                                            {
    std::unordered_map<crypto::hash, const block*> block_index;
    BOOST_FOREACH(const test_event_entry& ev, events)
    {
        if (typeid(block) == ev.type())
        {
            const block* blk = &boost::get<block>(ev);
            block_index[get_block_hash(*blk)] = blk;
        }
        else if (typeid(transaction) == ev.type())
        {
            const transaction& tx = boost::get<transaction>(ev);
            mtx[get_transaction_hash(tx)] = &tx;
        }
    }
 
    bool b_success = false;
    crypto::hash id = head;
    for (auto it = block_index.find(id); block_index.end() != it; it = block_index.find(id))
    {
        blockchain.push_back(it->second);
        id = it->second->prev_id;
        if (null_hash == id)
        {
            b_success = true;
            break;
        }
    }
    reverse(blockchain.begin(), blockchain.end());
    return b_success;
}

Here is the call graph for this function:

find_block_chain() [2/2]

bool find_block_chain	(	const std::vector< test_event_entry > &	events,
		std::vector< cryptonote::block > &	blockchain,
		map_hash2tx_t &	mtx,
		const crypto::hash &	head )

Definition at line 1072 of file chaingen.cpp.

                                                                                                                                                     {
    std::unordered_map<crypto::hash, const block*> block_index;
    BOOST_FOREACH(const test_event_entry& ev, events)
    {
        if (typeid(block) == ev.type())
        {
            const block* blk = &boost::get<block>(ev);
            block_index[get_block_hash(*blk)] = blk;
        }
        else if (typeid(transaction) == ev.type())
        {
            const transaction& tx = boost::get<transaction>(ev);
            mtx[get_transaction_hash(tx)] = &tx;
        }
    }
 
    bool b_success = false;
    crypto::hash id = head;
    for (auto it = block_index.find(id); block_index.end() != it; it = block_index.find(id))
    {
        blockchain.push_back(*it->second);
        id = it->second->prev_id;
        if (null_hash == id)
        {
            b_success = true;
            break;
        }
    }
    reverse(blockchain.begin(), blockchain.end());
 
    return b_success;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_address() [1/5]

cryptonote::account_public_address get_address

(

const cryptonote::account_base &

inp

)

Definition at line 690 of file chaingen.cpp.

{
  return inp.get_keys().m_account_address;
}

get_address() [2/5]

cryptonote::account_public_address get_address

(

const cryptonote::account_keys &

inp

)

Definition at line 685 of file chaingen.cpp.

{
  return inp.m_account_address;
}

get_address() [3/5]

cryptonote::account_public_address get_address

(

const cryptonote::account_public_address &

inp

)

Definition at line 680 of file chaingen.cpp.

{
  return inp;
}

get_address() [4/5]

cryptonote::account_public_address get_address

(

const cryptonote::tx_destination_entry &

inp

)

Definition at line 695 of file chaingen.cpp.

{
  return inp.addr;
}

get_address() [5/5]

cryptonote::account_public_address get_address

(

const var_addr_t &

inp

)

Definition at line 665 of file chaingen.cpp.

{
  if (typeid(cryptonote::account_public_address) == inp.type()){
    return boost::get<cryptonote::account_public_address>(inp);
  } else if(typeid(cryptonote::account_keys) == inp.type()){
    return boost::get<cryptonote::account_keys>(inp).m_account_address;
  } else if (typeid(cryptonote::account_base) == inp.type()){
    return boost::get<cryptonote::account_base>(inp).get_keys().m_account_address;
  } else if (typeid(cryptonote::tx_destination_entry) == inp.type()){
    return boost::get<cryptonote::tx_destination_entry>(inp).addr;
  } else {
    throw std::runtime_error("Unexpected type");
  }
}

Here is the caller graph for this function:

get_balance()

uint64_t get_balance	(	const cryptonote::account_base &	addr,
		const std::vector< cryptonote::block > &	blockchain,
		const map_hash2tx_t &	mtx )

Definition at line 940 of file chaingen.cpp.

                                                                                                                                 {
    uint64_t res = 0;
    std::map<uint64_t, std::vector<output_index> > outs;
    std::map<uint64_t, std::vector<size_t> > outs_mine;
 
    map_hash2tx_t confirmed_txs;
    get_confirmed_txs(blockchain, mtx, confirmed_txs);
 
    if (!init_output_indices(outs, outs_mine, blockchain, confirmed_txs, addr))
        return false;
 
    if (!init_spent_output_indices(outs, outs_mine, blockchain, confirmed_txs, addr))
        return false;
 
    BOOST_FOREACH (const map_output_t::value_type &o, outs_mine) {
        for (size_t i = 0; i < o.second.size(); ++i) {
            if (outs[o.first][o.second[i]].spent)
                continue;
 
            res += outs[o.first][o.second[i]].amount;
        }
    }
 
    return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_confirmed_txs()

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

Definition at line 984 of file chaingen.cpp.

{
  std::unordered_set<crypto::hash> confirmed_hashes;
  BOOST_FOREACH(const block& blk, blockchain)
  {
    BOOST_FOREACH(const crypto::hash& tx_hash, blk.tx_hashes)
    {
      confirmed_hashes.insert(tx_hash);
    }
  }
 
  BOOST_FOREACH(const auto& tx_pair, mtx)
  {
    if (0 != confirmed_hashes.count(tx_pair.first))
    {
      confirmed_txs.insert(tx_pair);
    }
  }
}

Here is the caller graph for this function:

get_head_block()

cryptonote::block get_head_block

(

const std::vector< test_event_entry > &

events

)

Definition at line 1058 of file chaingen.cpp.

{
  for(auto it = events.rbegin(); it != events.rend(); ++it)
  {
    auto &ev = *it;
    if (typeid(block) == ev.type())
    {
      return boost::get<block>(ev);
    }
  }
 
  throw std::runtime_error("No block event");
}

Here is the caller graph for this function:

init_output_indices()

bool init_output_indices	(	map_output_idx_t &	outs,
		std::map< uint64_t, std::vector< size_t > > &	outs_mine,
		const std::vector< cryptonote::block > &	blockchain,
		const map_hash2tx_t &	mtx,
		const cryptonote::account_base &	from )

Definition at line 284 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);
            if (mtx.end() == cit)
                throw std::runtime_error("block contains an unknown tx hash");
 
            vtx.push_back(cit->second);
        }
 
        //vtx.insert(vtx.end(), blk.);
        // TODO: add all other txes
        for (size_t i = 0; i < vtx.size(); i++) {
            const transaction &tx = *vtx[i];
 
            for (size_t j = 0; j < tx.vout.size(); ++j) {
                const tx_out &out = tx.vout[j];
 
                output_index oi(out.target, out.amount, boost::get<txin_gen>(*blk.miner_tx.vin.begin()).height, i, j, &blk, vtx[i]);
                oi.set_rct(tx.version == 4);
                oi.unlock_time = tx.unlock_time;
                oi.is_coin_base = i == 0;
 
                if (2 == out.target.which()) { // out_to_key
                    outs[out.amount].push_back(oi);
                    size_t tx_global_idx = outs[out.amount].size() - 1;
                    outs[out.amount][tx_global_idx].idx = tx_global_idx;
                    // Is out to me?
                    if (is_out_to_acc(from.get_keys(), boost::get<txout_to_key>(out.target), get_tx_pub_key_from_extra(tx), get_additional_tx_pub_keys_from_extra(tx), j)) {
                        outs_mine[out.amount].push_back(tx_global_idx);
                    }
                }
            }
        }
    }
 
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

init_spent_output_indices()

bool init_spent_output_indices	(	map_output_idx_t &	outs,
		map_output_t &	outs_mine,
		const std::vector< cryptonote::block > &	blockchain,
		const map_hash2tx_t &	mtx,
		const cryptonote::account_base &	from )

Definition at line 327 of file chaingen.cpp.

                                                                                                                                                                                            {
 
    BOOST_FOREACH (const map_output_t::value_type &o, outs_mine) {
        for (size_t i = 0; i < o.second.size(); ++i) {
            output_index &oi = outs[o.first][o.second[i]];
 
            // construct key image for this output
            crypto::key_image img;
            keypair in_ephemeral;
            crypto::public_key out_key = boost::get<txout_to_key>(oi.out).key;
            std::unordered_map<crypto::public_key, cryptonote::subaddress_index> subaddresses;
            subaddresses[from.get_keys().m_account_address.m_spend_public_key] = {0,0};
            generate_key_image_helper(from.get_keys(), subaddresses, out_key, get_tx_pub_key_from_extra(*oi.p_tx), get_additional_tx_pub_keys_from_extra(*oi.p_tx), oi.out_no, in_ephemeral, img, hw::get_device(("default")));
 
            // lookup for this key image in the events vector
            BOOST_FOREACH(auto& tx_pair, mtx) {
                const transaction& tx = *tx_pair.second;
                BOOST_FOREACH(const txin_v &in, tx.vin) {
                    if (typeid(txin_to_key) == in.type()) {
                        const txin_to_key &itk = boost::get<txin_to_key>(in);
                        if (itk.k_image == img) {
                            oi.spent = true;
                        }
                    }
                }
            }
        }
    }
 
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

num_blocks()

uint64_t num_blocks

(

const std::vector< test_event_entry > &

events

)

Definition at line 1044 of file chaingen.cpp.

{
  uint64_t res = 0;
  BOOST_FOREACH(const test_event_entry& ev, events)
  {
    if (typeid(block) == ev.type())
    {
      res += 1;
    }
  }
 
  return res;
}

Here is the caller graph for this function:

sum_amount() [1/2]

uint64_t sum_amount

(

const std::vector< cryptonote::tx_source_entry > &

sources

)

Definition at line 710 of file chaingen.cpp.

{
  uint64_t amount = 0;
  for(auto & cur : sources){
    amount += cur.amount;
  }
 
  return amount;
}

sum_amount() [2/2]

uint64_t sum_amount

(

const std::vector< tx_destination_entry > &

destinations

)

Definition at line 700 of file chaingen.cpp.

{
  uint64_t amount = 0;
  for(auto & cur : destinations){
    amount += cur.amount;
  }
 
  return amount;
}

Here is the caller graph for this function:

trim_block_chain() [1/2]

bool trim_block_chain	(	std::vector< const cryptonote::block * > &	blockchain,
		const crypto::hash &	tail )

Definition at line 1024 of file chaingen.cpp.

                                                                                            {
  size_t cut = 0;
  bool found = true;
 
  for(size_t i = 0; i < blockchain.size(); ++i){
    crypto::hash chash = get_block_hash(*blockchain[i]);
    if (chash == tail){
      cut = i;
      found = true;
      break;
    }
  }
 
  if (found && cut > 0){
    blockchain.erase(blockchain.begin(), blockchain.begin() + cut);
  }
 
  return found;
}

Here is the call graph for this function:

trim_block_chain() [2/2]

bool trim_block_chain	(	std::vector< cryptonote::block > &	blockchain,
		const crypto::hash &	tail )

Definition at line 1004 of file chaingen.cpp.

                                                                                     {
  size_t cut = 0;
  bool found = true;
 
  for(size_t i = 0; i < blockchain.size(); ++i){
    crypto::hash chash = get_block_hash(blockchain[i]);
    if (chash == tail){
      cut = i;
      found = true;
      break;
    }
  }
 
  if (found && cut > 0){
    blockchain.erase(blockchain.begin(), blockchain.begin() + cut);
  }
 
  return found;
}

Here is the call graph for this function:

Here is the caller graph for this function: