gen_trezor_base Class Reference

#include <trezor_tests.h>

Inheritance diagram for gen_trezor_base:

Collaboration diagram for gen_trezor_base:

Public Member Functions
	gen_trezor_base ()
	gen_trezor_base (const gen_trezor_base &other)
virtual	~gen_trezor_base ()
virtual void	setup_args (const std::string &trezor_path, bool heavy_tests=false)
virtual bool	generate (std::vector< test_event_entry > &events)
virtual void	load (std::vector< test_event_entry > &events)
virtual void	fix_hf (std::vector< test_event_entry > &events)
virtual void	update_trackers (std::vector< test_event_entry > &events)
virtual void	fork (gen_trezor_base &other)
virtual void	clear ()
virtual void	add_shared_events (std::vector< test_event_entry > &events)
virtual void	test_setup (std::vector< test_event_entry > &events)
virtual void	add_transactions_to_events (std::vector< test_event_entry > &events, test_generator &generator, const std::vector< cryptonote::transaction > &txs)
virtual void	test_trezor_tx (std::vector< test_event_entry > &events, std::vector< tools::wallet2::pending_tx > &ptxs, std::vector< cryptonote::address_parse_info > &dsts_info, test_generator &generator, std::vector< tools::wallet2 * > wallets, bool is_sweep=false)
virtual void	test_get_tx (std::vector< test_event_entry > &events, std::vector< tools::wallet2 * > wallets, const std::vector< tools::wallet2::pending_tx > &ptxs, const std::vector< std::string > &aux_tx_info)
virtual void	mine_and_test (std::vector< test_event_entry > &events)
virtual void	rewind_blocks (std::vector< test_event_entry > &events, size_t rewind_n, uint8_t hf)
virtual void	set_hard_fork (uint8_t hf)
crypto::hash	head_hash () const
cryptonote::block	head_block () const
bool	heavy_tests () const
void	rct_config (rct::RCTConfig rct_config)
uint8_t	cur_hf () const
cryptonote::network_type	nettype () const
std::shared_ptr< mock_daemon >	daemon () const
void	daemon (std::shared_ptr< mock_daemon > daemon)
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 > &)

Static Public Attributes
static const uint64_t	m_ts_start = 1397862000
static const uint64_t	m_wallet_ts = m_ts_start - 60*60*24*4
static const std::string	m_device_name = "Trezor:udp"
static const std::string	m_master_seed_str = "14821d0bc5659b24cafbc889dc4fc60785ee08b65d71c525f81eeaba4f3a570f"
static const std::string	m_device_seed = "permit universe parent weapon amused modify essay borrow tobacco budget walnut lunch consider gallery ride amazing frog forget treat market chapter velvet useless topple"
static const std::string	m_alice_spend_private = m_master_seed_str
static const std::string	m_alice_view_private = "a6ccd4ac344a295d1387f8d18c81bdd394f1845de84188e204514ef9370fd403"

Protected Member Functions
virtual void	setup_trezor ()
virtual void	init_fields ()
virtual void	update_client_settings ()
virtual bool	verify_tx_key (const ::crypto::secret_key &tx_priv, const ::crypto::public_key &tx_pub, const subaddresses_t &subs)
template<class Archive>
void	serialize (Archive &ar, const unsigned int)

Protected Attributes
test_generator	m_generator
block_tracker	m_bt
cryptonote::network_type	m_network_type
std::shared_ptr< mock_daemon >	m_daemon
uint8_t	m_top_hard_fork
v_hardforks_t	m_hard_forks
cryptonote::block	m_head
std::vector< test_event_entry >	m_events
std::string	m_trezor_path
bool	m_heavy_tests
bool	m_test_get_tx_key
rct::RCTConfig	m_rct_config
bool	m_live_refresh_enabled
cryptonote::account_base	m_miner_account
cryptonote::account_base	m_bob_account
cryptonote::account_base	m_alice_account
cryptonote::account_base	m_eve_account
hw::trezor::device_trezor *	m_trezor
std::unique_ptr< tools::wallet2 >	m_wl_alice
std::unique_ptr< tools::wallet2 >	m_wl_bob
std::unique_ptr< tools::wallet2 >	m_wl_eve

Friends
class	tsx_builder
class	boost::serialization::access

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 46 of file trezor_tests.h.

Constructor & Destructor Documentation

gen_trezor_base() [1/2]

gen_trezor_base::gen_trezor_base

(

)

Definition at line 608 of file trezor_tests.cpp.

                                {
  m_rct_config = {rct::RangeProofPaddedBulletproof, 1};
  m_test_get_tx_key = true;
  m_network_type = cryptonote::TESTNET;
}

Here is the caller graph for this function:

gen_trezor_base() [2/2]

gen_trezor_base::gen_trezor_base

(

const gen_trezor_base &

other

)

Definition at line 614 of file trezor_tests.cpp.

                                                            :
    m_generator(other.m_generator), m_bt(other.m_bt), m_miner_account(other.m_miner_account),
    m_bob_account(other.m_bob_account), m_alice_account(other.m_alice_account), m_eve_account(other.m_eve_account),
    m_hard_forks(other.m_hard_forks), m_trezor(other.m_trezor), m_rct_config(other.m_rct_config), m_top_hard_fork(other.m_top_hard_fork),
    m_heavy_tests(other.m_heavy_tests), m_test_get_tx_key(other.m_test_get_tx_key), m_live_refresh_enabled(other.m_live_refresh_enabled),
    m_network_type(other.m_network_type), m_daemon(other.m_daemon)
{
 
}

Here is the call graph for this function:

~gen_trezor_base()

virtual gen_trezor_base::~gen_trezor_base ( )

inlinevirtual

Definition at line 53 of file trezor_tests.h.

{};

Member Function Documentation

add_shared_events()

void gen_trezor_base::add_shared_events ( std::vector< test_event_entry > & events )

virtual

Definition at line 672 of file trezor_tests.cpp.

{
  events.reserve(m_events.size());
  for(const test_event_entry & c : m_events){
    events.push_back(c);
  }
}

Here is the caller graph for this function:

add_transactions_to_events()

void gen_trezor_base::add_transactions_to_events ( std::vector< test_event_entry > & events, test_generator & generator, const std::vector< cryptonote::transaction > & txs )

virtual

Definition at line 984 of file trezor_tests.cpp.

{
  // If current test requires higher hard-fork, move it up
  const auto current_hf = m_hard_forks.back().first;
  const uint8_t tx_hf = m_top_hard_fork;
  CHECK_AND_ASSERT_THROW_MES(tx_hf <= current_hf, "Too late for HF change: " << (int)tx_hf << " current: " << (int)current_hf);
  CHECK_AND_ASSERT_THROW_MES(m_rct_config.bp_version < 2 || tx_hf >= 10, "HF too low for BPv2: " << (int)tx_hf);
 
  std::list<cryptonote::transaction> tx_list;
  for(const auto & tx : txs)
  {
    events.push_back(tx);
    tx_list.push_back(tx);
  }
 
  MAKE_NEXT_BLOCK_TX_LIST_HF(events, blk_new, m_head, m_miner_account, tx_list, tx_hf);
  MDEBUG("New tsx: " << (num_blocks(events) - 1) << " at block: " << get_block_hash(blk_new));
 
  m_head = blk_new;
}

Here is the call graph for this function:

Here is the caller graph for this function:

clear()

void gen_trezor_base::clear ( )

virtual

Definition at line 663 of file trezor_tests.cpp.

{
  m_generator = test_generator();
  m_bt = block_tracker();
  m_events.clear();
  m_hard_forks.clear();
  m_trezor = nullptr;
}

cur_hf()

uint8_t gen_trezor_base::cur_hf ( ) const

inline

Definition at line 95 of file trezor_tests.h.

{ return m_hard_forks.size() > 0 ? m_hard_forks.back().first : 0; }

daemon() [1/2]

std::shared_ptr< mock_daemon > gen_trezor_base::daemon ( ) const

inline

Definition at line 97 of file trezor_tests.h.

{ return m_daemon; }

Here is the caller graph for this function:

daemon() [2/2]

void gen_trezor_base::daemon ( std::shared_ptr< mock_daemon > daemon )

inline

Definition at line 98 of file trezor_tests.h.

{ m_daemon = std::move(daemon); }

Here is the call graph for this function:

fix_hf()

void gen_trezor_base::fix_hf ( std::vector< test_event_entry > & events )

virtual

Definition at line 929 of file trezor_tests.cpp.

{
  // If current test requires higher hard-fork, move it up
  const auto current_hf = m_hard_forks.back().first;
 
  if (current_hf > m_top_hard_fork)
  {
    throw std::runtime_error("Generated chain hardfork is higher than desired maximum");
  }
 
  if (m_rct_config.bp_version == 2 && m_top_hard_fork < 10)
  {
    throw std::runtime_error("Desired maximum is too low for BPv2");
  }
 
  if (current_hf < m_top_hard_fork)
  {
    auto hardfork_height = num_blocks(events);
    ADD_HARDFORK(m_hard_forks, m_top_hard_fork, hardfork_height);
    add_top_hfork(events, m_hard_forks);
    MDEBUG("Hardfork added at height: " << hardfork_height << ", from " << (int)current_hf << " to " << (int)m_top_hard_fork);
 
    if (current_hf < 10)
    { // buffer blocks, add 10 to apply v10 rules
      rewind_blocks(events, 10, m_top_hard_fork);
    }
  }
}

Here is the call graph for this function:

fork()

void gen_trezor_base::fork ( gen_trezor_base & other )

virtual

Definition at line 640 of file trezor_tests.cpp.

{
  other.m_generator = m_generator;
  other.m_bt = m_bt;
  other.m_network_type = m_network_type;
  other.m_daemon = m_daemon;
  other.m_events = m_events;
  other.m_head = m_head;
  other.m_hard_forks = m_hard_forks;
  other.m_top_hard_fork = m_top_hard_fork;
  other.m_trezor_path = m_trezor_path;
  other.m_heavy_tests = m_heavy_tests;
  other.m_rct_config = m_rct_config;
  other.m_test_get_tx_key = m_test_get_tx_key;
  other.m_live_refresh_enabled = m_live_refresh_enabled;
 
  other.m_miner_account = m_miner_account;
  other.m_bob_account = m_bob_account;
  other.m_alice_account = m_alice_account;
  other.m_eve_account = m_eve_account;
  other.m_trezor = m_trezor;
}

Here is the call graph for this function:

generate()

bool gen_trezor_base::generate ( std::vector< test_event_entry > & events )

virtual

Reimplemented in gen_trezor_1utxo, gen_trezor_1utxo_paymentid_long, gen_trezor_1utxo_paymentid_short, gen_trezor_1utxo_paymentid_short_integrated, gen_trezor_2utxo_sub_acc_to_1norm_2sub, gen_trezor_4utxo, gen_trezor_4utxo_acc1, gen_trezor_4utxo_to_1norm_2sub, gen_trezor_4utxo_to_2sub, gen_trezor_4utxo_to_7outs, gen_trezor_4utxo_to_sub, gen_trezor_ki_sync, gen_trezor_ki_sync_with_refresh, gen_trezor_ki_sync_without_refresh, gen_trezor_live_refresh, gen_trezor_many_utxo, and wallet_api_tests.

Definition at line 700 of file trezor_tests.cpp.

{
  init_fields();
  setup_trezor();
 
  m_live_refresh_enabled = false;
  update_client_settings();
 
  m_alice_account.create_from_device(*m_trezor);
  m_alice_account.set_createtime(m_wallet_ts);
 
  // Events, custom genesis so it matches wallet genesis
  auto & generator = m_generator;  // macro shortcut
 
  cryptonote::block blk_gen;
  std::vector<size_t> block_weights;
  generate_genesis_block(blk_gen, get_config(m_network_type).GENESIS_TX, get_config(m_network_type).GENESIS_NONCE);
  events.push_back(blk_gen);
  generator.add_block(blk_gen, 0, block_weights, 0);
 
  // First event has to be the genesis block
  m_bob_account.generate();
  m_eve_account.generate();
  m_bob_account.set_createtime(m_wallet_ts);
  m_eve_account.set_createtime(m_wallet_ts);
  cryptonote::account_base * accounts[] = {TREZOR_ACCOUNT_ORDERING};
  for(cryptonote::account_base * ac : accounts){
    events.push_back(*ac);
  }
 
  // Another block with predefined timestamp.
  // Carefully set reward and already generated coins so it passes miner_tx check.
  cryptonote::block blk_0;
  {
    std::list<cryptonote::transaction> tx_list;
    const crypto::hash prev_id = get_block_hash(blk_gen);
    const uint64_t already_generated_coins = generator.get_already_generated_coins(prev_id);
    block_weights.clear();
    generator.get_last_n_block_weights(block_weights, prev_id, CRYPTONOTE_REWARD_BLOCKS_WINDOW);
    generator.construct_block(blk_0, 1, prev_id, m_miner_account, m_ts_start, already_generated_coins, block_weights, tx_list);
  }
 
  events.push_back(blk_0);
  MDEBUG("Gen+1 block has time: " << blk_0.timestamp << " blid: " << get_block_hash(blk_0));
 
  // Generate some spendable funds on the Miner account
  REWIND_BLOCKS_N(events, blk_3, blk_0, m_miner_account, 40);
 
  // Rewind so the miners funds are unlocked for initial transactions.
  REWIND_BLOCKS(events, blk_3r, blk_3, m_miner_account);
 
  // Non-rct transactions Miner -> Bob
  MAKE_TX_LIST_START(events, txs_blk_4, m_miner_account, m_alice_account, MK_COINS(10), blk_3);
  MAKE_TX_LIST(events, txs_blk_4, m_miner_account, m_alice_account, MK_COINS(7), blk_3);
  MAKE_TX_LIST(events, txs_blk_4, m_miner_account, m_alice_account, MK_COINS(7), blk_3);
  MAKE_TX_LIST(events, txs_blk_4, m_miner_account, m_alice_account, MK_COINS(14), blk_3);
  MAKE_TX_LIST(events, txs_blk_4, m_miner_account, m_alice_account, MK_COINS(20), blk_3);
  MAKE_TX_LIST(events, txs_blk_4, m_miner_account, m_alice_account, MK_COINS(2), blk_3);
  MAKE_TX_LIST(events, txs_blk_4, m_miner_account, m_alice_account, MK_COINS(2), blk_3);
  MAKE_TX_LIST(events, txs_blk_4, m_miner_account, m_alice_account, MK_COINS(5), blk_3);
  MAKE_NEXT_BLOCK_TX_LIST(events, blk_4, blk_3r, m_miner_account, txs_blk_4);
  REWIND_BLOCKS(events, blk_4r, blk_4, m_miner_account);  // rewind to unlock
 
  // Hard fork to bulletproofs version, v9.
  const uint8_t CUR_HF = 9;
  auto hardfork_height = num_blocks(events);  // next block is v9
  ADD_HARDFORK(m_hard_forks, CUR_HF, hardfork_height);
  add_hforks(events, m_hard_forks);
  MDEBUG("Hardfork height: " << hardfork_height << " at block: " << get_block_hash(blk_4r));
 
  // RCT transactions, wallets have to be used, wallet init
  m_wl_alice.reset(new tools::wallet2(m_network_type, 1, true));
  m_wl_bob.reset(new tools::wallet2(m_network_type, 1, true));
  wallet_accessor_test::set_account(m_wl_alice.get(), m_alice_account);
  wallet_accessor_test::set_account(m_wl_bob.get(), m_bob_account);
 
  auto addr_alice_sub_0_1 = m_wl_alice->get_subaddress({0, 1});
  auto addr_alice_sub_0_2 = m_wl_alice->get_subaddress({0, 2});
  auto addr_alice_sub_0_3 = m_wl_alice->get_subaddress({0, 3});
  auto addr_alice_sub_0_4 = m_wl_alice->get_subaddress({0, 4});
  auto addr_alice_sub_0_5 = m_wl_alice->get_subaddress({0, 5});
  auto addr_alice_sub_1_0 = m_wl_alice->get_subaddress({1, 0});
  auto addr_alice_sub_1_1 = m_wl_alice->get_subaddress({1, 1});
  auto addr_alice_sub_1_2 = m_wl_alice->get_subaddress({1, 2});
 
  // Miner -> Bob, RCT funds
  MAKE_TX_LIST_START_RCT(events, txs_blk_5, m_miner_account, m_alice_account, MK_COINS(50), 10, blk_4);
 
  const size_t target_rct = m_heavy_tests ? 105 : 15;
  for(size_t i = 0; i < target_rct; ++i)
  {
    MAKE_TX_MIX_LIST_RCT(events, txs_blk_5, m_miner_account, m_alice_account, MK_COINS(1) >> 2, 10, blk_4);
  }
 
  // Sub-address destinations
  MAKE_TX_MIX_DEST_LIST_RCT(events, txs_blk_5, m_miner_account, build_dsts(addr_alice_sub_0_1, true, MK_COINS(1) >> 1), 10, blk_4);
  MAKE_TX_MIX_DEST_LIST_RCT(events, txs_blk_5, m_miner_account, build_dsts(addr_alice_sub_0_2, true, MK_COINS(1) >> 1), 10, blk_4);
  MAKE_TX_MIX_DEST_LIST_RCT(events, txs_blk_5, m_miner_account, build_dsts(addr_alice_sub_0_3, true, MK_COINS(1) >> 1), 10, blk_4);
  MAKE_TX_MIX_DEST_LIST_RCT(events, txs_blk_5, m_miner_account, build_dsts(addr_alice_sub_0_4, true, MK_COINS(1) >> 1), 10, blk_4);
 
  // Sub-address destinations + multi out to force use of additional keys
  MAKE_TX_MIX_DEST_LIST_RCT(events, txs_blk_5, m_miner_account, build_dsts({{addr_alice_sub_0_1, true, MK_COINS(1) >> 1}, {addr_alice_sub_0_2, true, MK_COINS(1) >> 1}}), 10, blk_4);
  MAKE_TX_MIX_DEST_LIST_RCT(events, txs_blk_5, m_miner_account, build_dsts({{addr_alice_sub_0_1, true, MK_COINS(1) >> 1}, {addr_alice_sub_0_2, true, MK_COINS(1) >> 1}, {addr_alice_sub_0_3, true, MK_COINS(1) >> 1}}), 10, blk_4);
  MAKE_TX_MIX_DEST_LIST_RCT(events, txs_blk_5, m_miner_account, build_dsts({{m_miner_account, false, MK_COINS(1) >> 1}, {addr_alice_sub_0_2, true, MK_COINS(1) >> 1}, {addr_alice_sub_0_3, true, MK_COINS(1) >> 1}}), 10, blk_4);
  MAKE_TX_MIX_DEST_LIST_RCT(events, txs_blk_5, m_miner_account, build_dsts({{m_miner_account, false, MK_COINS(1) >> 1}, {addr_alice_sub_0_2, true, MK_COINS(1) >> 1}, {addr_alice_sub_0_3, true, MK_COINS(1) >> 1}}), 10, blk_4);
 
  // Transfer to other accounts
  MAKE_TX_MIX_DEST_LIST_RCT(events, txs_blk_5, m_miner_account, build_dsts(addr_alice_sub_1_0, true, MK_COINS(1) >> 1), 10, blk_4);
  MAKE_TX_MIX_DEST_LIST_RCT(events, txs_blk_5, m_miner_account, build_dsts(addr_alice_sub_1_1, true, MK_COINS(1) >> 1), 10, blk_4);
  MAKE_TX_MIX_DEST_LIST_RCT(events, txs_blk_5, m_miner_account, build_dsts({{addr_alice_sub_1_0, true, MK_COINS(1) >> 1}, {addr_alice_sub_1_1, true, MK_COINS(1) >> 1}, {addr_alice_sub_0_3, true, MK_COINS(1) >> 1}}), 10, blk_4);
  MAKE_TX_MIX_DEST_LIST_RCT(events, txs_blk_5, m_miner_account, build_dsts({{addr_alice_sub_1_1, true, MK_COINS(1) >> 1}, {addr_alice_sub_1_1, true, MK_COINS(1) >> 1}, {addr_alice_sub_0_2, true, MK_COINS(1) >> 1}}), 10, blk_4);
  MAKE_TX_MIX_DEST_LIST_RCT(events, txs_blk_5, m_miner_account, build_dsts({{addr_alice_sub_1_2, true, MK_COINS(1) >> 1}, {addr_alice_sub_1_1, true, MK_COINS(1) >> 1}, {addr_alice_sub_0_5, true, MK_COINS(1) >> 1}}), 10, blk_4);
 
  // Simple RCT transactions
  MAKE_TX_MIX_LIST_RCT(events, txs_blk_5, m_miner_account, m_alice_account, MK_COINS(7), 10, blk_4);
  MAKE_TX_MIX_LIST_RCT(events, txs_blk_5, m_miner_account, m_alice_account, MK_COINS(10), 10, blk_4);
  MAKE_TX_MIX_LIST_RCT(events, txs_blk_5, m_miner_account, m_alice_account, MK_COINS(30), 10, blk_4);
  MAKE_TX_MIX_LIST_RCT(events, txs_blk_5, m_miner_account, m_alice_account, MK_COINS(40), 10, blk_4);
  MAKE_NEXT_BLOCK_TX_LIST_HF(events, blk_5, blk_4r, m_miner_account, txs_blk_5, CUR_HF);
 
  // Simple transaction check
  bool resx = rct::verRctSemanticsSimple(txs_blk_5.begin()->rct_signatures);
  bool resy = rct::verRctNonSemanticsSimple(txs_blk_5.begin()->rct_signatures);
  CHECK_AND_ASSERT_THROW_MES(resx, "Tsx5[0] semantics failed");
  CHECK_AND_ASSERT_THROW_MES(resy, "Tsx5[0] non-semantics failed");
 
  REWIND_BLOCKS_HF(events, blk_5r, blk_5, m_miner_account, CUR_HF);  // rewind to unlock
 
  // RCT transactions, wallets have to be used
  wallet_tools::process_transactions(m_wl_alice.get(), events, blk_5r, m_bt);
  wallet_tools::process_transactions(m_wl_bob.get(), events, blk_5r, m_bt);
 
  // Send Alice -> Bob, manually constructed. Simple TX test, precondition.
  cryptonote::transaction tx_1;
  std::vector<size_t> selected_transfers;
  std::vector<tx_source_entry> sources;
  bool res = wallet_tools::fill_tx_sources(m_wl_alice.get(), sources, TREZOR_TEST_MIXIN, boost::none, MK_COINS(2), m_bt, selected_transfers, num_blocks(events) - 1, 0, 1);
  CHECK_AND_ASSERT_THROW_MES(res, "TX Fill sources failed");
 
  construct_tx_to_key(tx_1, m_wl_alice.get(), m_bob_account, MK_COINS(1), sources, TREZOR_TEST_FEE, true, rct::RangeProofPaddedBulletproof, 1);
  events.push_back(tx_1);
  MAKE_NEXT_BLOCK_TX1_HF(events, blk_6, blk_5r, m_miner_account, tx_1, CUR_HF);
  MDEBUG("Post 1st tsx: " << (num_blocks(events) - 1) << " at block: " << get_block_hash(blk_6));
 
  // Simple transaction check
  resx = rct::verRctSemanticsSimple(tx_1.rct_signatures);
  resy = rct::verRctNonSemanticsSimple(tx_1.rct_signatures);
  CHECK_AND_ASSERT_THROW_MES(resx, "tx_1 semantics failed");
  CHECK_AND_ASSERT_THROW_MES(resy, "tx_1 non-semantics failed");
 
  REWIND_BLOCKS_N_HF(events, blk_6r, blk_6, m_miner_account, 10, CUR_HF);
  wallet_tools::process_transactions(m_wl_alice.get(), events, blk_6, m_bt);
  wallet_tools::process_transactions(m_wl_bob.get(), events, blk_6, m_bt);
  MDEBUG("Available funds on Alice: " << get_available_funds(m_wl_alice.get()));
  MDEBUG("Available funds on Bob: " << get_available_funds(m_wl_bob.get()));
 
  m_head = blk_6r;
  m_events = events;
  return true;
}

Here is the call graph for this function:

head_block()

cryptonote::block gen_trezor_base::head_block ( ) const

inline

Definition at line 92 of file trezor_tests.h.

{ return m_head; }

Here is the caller graph for this function:

head_hash()

crypto::hash gen_trezor_base::head_hash ( ) const

inline

Definition at line 91 of file trezor_tests.h.

{ return get_block_hash(m_head); }

Here is the call graph for this function:

Here is the caller graph for this function:

heavy_tests()

bool gen_trezor_base::heavy_tests ( ) const

inline

Definition at line 93 of file trezor_tests.h.

{ return m_heavy_tests; }

Here is the caller graph for this function:

init_fields()

void gen_trezor_base::init_fields ( )

protectedvirtual

Definition at line 680 of file trezor_tests.cpp.

{
  m_miner_account.generate();
  DEFAULT_HARDFORKS(m_hard_forks);
 
  crypto::secret_key master_seed{};
  CHECK_AND_ASSERT_THROW_MES(epee::string_tools::hex_to_pod(m_master_seed_str, master_seed), "Hexdecode fails");
 
  m_alice_account.generate(master_seed, true);
  m_alice_account.set_createtime(m_wallet_ts);
}

Here is the call graph for this function:

Here is the caller graph for this function:

load()

void gen_trezor_base::load ( std::vector< test_event_entry > & events )

virtual

Definition at line 861 of file trezor_tests.cpp.

{
  init_fields();
  m_events = events;
 
  unsigned acc_idx = 0;
  cryptonote::account_base * accounts[] = {TREZOR_ACCOUNT_ORDERING};
  unsigned accounts_num = (sizeof(accounts) / sizeof(accounts[0]));
 
  for(auto & ev : events)
  {
    if (typeid(cryptonote::block) == ev.type())
    {
      m_head = boost::get<cryptonote::block>(ev);
    }
    else if (typeid(cryptonote::account_base) == ev.type())  // accounts
    {
      const auto & acc = boost::get<cryptonote::account_base>(ev);
      if (acc_idx < accounts_num)
      {
        *accounts[acc_idx++] = acc;
      }
    }
    else if (typeid(event_replay_settings) == ev.type())  // hard forks
    {
      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(m_hard_forks));
      }
    }
  }
 
  // Setup wallets, synchronize blocks
  m_bob_account.set_createtime(m_wallet_ts);
  m_eve_account.set_createtime(m_wallet_ts);
 
  setup_trezor();
  update_client_settings();
  m_alice_account.create_from_device(*m_trezor);
  m_alice_account.set_createtime(m_wallet_ts);
 
  m_wl_alice.reset(new tools::wallet2(m_network_type, 1, true));
  m_wl_bob.reset(new tools::wallet2(m_network_type, 1, true));
  m_wl_eve.reset(new tools::wallet2(m_network_type, 1, true));
  wallet_accessor_test::set_account(m_wl_alice.get(), m_alice_account);
  wallet_accessor_test::set_account(m_wl_bob.get(), m_bob_account);
  wallet_accessor_test::set_account(m_wl_eve.get(), m_eve_account);
 
  wallet_tools::process_transactions(m_wl_alice.get(), events, m_head, m_bt);
  wallet_tools::process_transactions(m_wl_bob.get(), events, m_head, m_bt);
  MDEBUG("Available funds on Alice: " << get_available_funds(m_wl_alice.get()));
  MDEBUG("Available funds on Bob: " << get_available_funds(m_wl_bob.get()));
}

Here is the call graph for this function:

mine_and_test()

void gen_trezor_base::mine_and_test ( std::vector< test_event_entry > & events )

virtual

Definition at line 1231 of file trezor_tests.cpp.

{
  cryptonote::core * core = daemon()->core();
  const uint64_t height_before_mining = daemon()->get_height();
 
  const auto miner_address = cryptonote::get_account_address_as_str(FAKECHAIN, false, get_address(m_miner_account));
  daemon()->mine_blocks(1, miner_address);
 
  const uint64_t cur_height = daemon()->get_height();
  CHECK_AND_ASSERT_THROW_MES(height_before_mining < cur_height, "Mining fail");
 
  const crypto::hash top_hash = core->get_blockchain_storage().get_block_id_by_height(height_before_mining);
  cryptonote::block top_block{};
  CHECK_AND_ASSERT_THROW_MES(core->get_blockchain_storage().get_block_by_hash(top_hash, top_block), "Block fetch fail");
  CHECK_AND_ASSERT_THROW_MES(!top_block.tx_hashes.empty(), "Mined block is empty");
 
  std::vector<cryptonote::transaction> txs_found;
  std::vector<crypto::hash> txs_missed;
  bool r = core->get_blockchain_storage().get_transactions(top_block.tx_hashes, txs_found, txs_missed);
  CHECK_AND_ASSERT_THROW_MES(r, "Transaction lookup fail");
  CHECK_AND_ASSERT_THROW_MES(!txs_found.empty(), "Transaction lookup fail");
 
  // Transaction is not expanded, but mining verified it.
  events.push_back(txs_found[0]);
  events.push_back(top_block);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nettype()

cryptonote::network_type gen_trezor_base::nettype ( ) const

inline

Definition at line 96 of file trezor_tests.h.

{ return m_network_type; }

Here is the caller graph for this function:

rct_config()

void gen_trezor_base::rct_config ( rct::RCTConfig rct_config )

inline

Definition at line 94 of file trezor_tests.h.

{ m_rct_config = rct_config; }

Here is the call graph for this function:

Here is the caller graph for this function:

rewind_blocks()

void gen_trezor_base::rewind_blocks ( std::vector< test_event_entry > & events, size_t rewind_n, uint8_t hf )

virtual

Definition at line 917 of file trezor_tests.cpp.

{
  auto & generator = m_generator;  // macro shortcut
  REWIND_BLOCKS_N_HF(events, blk_new, m_head, m_miner_account, rewind_n, hf);
  m_head = blk_new;
  m_events = events;
  MDEBUG("Blocks rewound: " << rewind_n << ", #blocks: " << num_blocks(events) << ", #events: " << events.size());
 
  wallet_tools::process_transactions(m_wl_alice.get(), events, m_head, m_bt);
  wallet_tools::process_transactions(m_wl_bob.get(), events, m_head, m_bt);
}

Here is the call graph for this function:

Here is the caller graph for this function:

serialize()

template<class Archive>

void gen_trezor_base::serialize ( Archive & ar, const unsigned int  )

inlineprotected

Definition at line 143 of file trezor_tests.h.

  {
    ar & m_generator;
    ar & m_network_type;
  }

set_hard_fork()

void gen_trezor_base::set_hard_fork ( uint8_t hf )

virtual

Definition at line 1258 of file trezor_tests.cpp.

{
  m_top_hard_fork = hf;
  if (hf < 9){
    throw std::runtime_error("Minimal supported Hardfork is 9");
  } else if (hf == 9){
    rct_config({rct::RangeProofPaddedBulletproof, 1});
  } else {
    rct_config({rct::RangeProofPaddedBulletproof, 2});
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

setup_args()

void gen_trezor_base::setup_args ( const std::string & trezor_path, bool heavy_tests = false )

virtual

Definition at line 624 of file trezor_tests.cpp.

{
  m_trezor_path = trezor_path.empty() ? m_device_name : std::string("Trezor:") + trezor_path;
  m_heavy_tests = heavy_tests;
}

Here is the call graph for this function:

Here is the caller graph for this function:

setup_trezor()

void gen_trezor_base::setup_trezor ( )

protectedvirtual

Definition at line 630 of file trezor_tests.cpp.

{
  hw::device &hwdev = hw::get_device(m_trezor_path);
  auto trezor = dynamic_cast<device_trezor_test *>(&hwdev);
  CHECK_AND_ASSERT_THROW_MES(trezor, "Dynamic cast failed");
 
  trezor->setup_for_tests(m_trezor_path, m_device_seed, m_network_type);
  m_trezor = trezor;
}

Here is the call graph for this function:

Here is the caller graph for this function:

test_get_tx()

void gen_trezor_base::test_get_tx ( std::vector< test_event_entry > & events, std::vector< tools::wallet2 * > wallets, const std::vector< tools::wallet2::pending_tx > & ptxs, const std::vector< std::string > & aux_tx_info )

virtual

Definition at line 1175 of file trezor_tests.cpp.

{
  if (!m_test_get_tx_key)
  {
    return;
  }
 
  auto dev_cold = dynamic_cast<::hw::device_cold*>(m_trezor);
  CHECK_AND_ASSERT_THROW_MES(dev_cold, "Device does not implement cold signing interface");
 
  if (!dev_cold->is_get_tx_key_supported())
  {
    MERROR("Get TX key is not supported by the connected Trezor");
    return;
  }
 
  subaddresses_t all_subs;
  for(tools::wallet2 * wlt : wallets)
  {
    wlt->expand_subaddresses({10, 20});
 
    const subaddresses_t & cur_sub = wallet_accessor_test::get_subaddresses(wlt);
    all_subs.insert(cur_sub.begin(), cur_sub.end());
  }
 
  for(size_t txid = 0; txid < ptxs.size(); ++txid)
  {
    const auto &c_ptx = ptxs[txid];
    const auto &c_tx = c_ptx.tx;
    const ::crypto::hash tx_prefix_hash = cryptonote::get_transaction_prefix_hash(c_tx);
 
    auto tx_pub = cryptonote::get_tx_pub_key_from_extra(c_tx.extra);
    auto additional_pub_keys = cryptonote::get_additional_tx_pub_keys_from_extra(c_tx.extra);
 
    hw::device_cold:: tx_key_data_t tx_key_data;
    std::vector<::crypto::secret_key> tx_keys;
 
    dev_cold->load_tx_key_data(tx_key_data, aux_tx_info[txid]);
    CHECK_AND_ASSERT_THROW_MES(std::string(tx_prefix_hash.data, 32) == tx_key_data.tx_prefix_hash, "TX prefix mismatch");
 
    dev_cold->get_tx_key(tx_keys, tx_key_data, m_alice_account.get_keys().m_view_secret_key);
    CHECK_AND_ASSERT_THROW_MES(!tx_keys.empty(), "Empty TX keys");
    CHECK_AND_ASSERT_THROW_MES(verify_tx_key(tx_keys[0], tx_pub, all_subs), "Tx pub mismatch");
    CHECK_AND_ASSERT_THROW_MES(additional_pub_keys.size() == tx_keys.size() - 1, "Invalid additional keys count");
 
    for(size_t i = 0; i < additional_pub_keys.size(); ++i)
    {
      CHECK_AND_ASSERT_THROW_MES(verify_tx_key(tx_keys[i + 1], additional_pub_keys[i], all_subs), "Tx pub mismatch");
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

test_setup()

void gen_trezor_base::test_setup ( std::vector< test_event_entry > & events )

virtual

Definition at line 963 of file trezor_tests.cpp.

{
  add_shared_events(events);
 
  setup_trezor();
  update_client_settings();
 
  m_alice_account.create_from_device(*m_trezor);
  m_alice_account.set_createtime(m_wallet_ts);
 
  m_wl_alice.reset(new tools::wallet2(m_network_type, 1, true));
  m_wl_bob.reset(new tools::wallet2(m_network_type, 1, true));
  m_wl_eve.reset(new tools::wallet2(m_network_type, 1, true));
  wallet_accessor_test::set_account(m_wl_alice.get(), m_alice_account);
  wallet_accessor_test::set_account(m_wl_bob.get(), m_bob_account);
  wallet_accessor_test::set_account(m_wl_eve.get(), m_eve_account);
  wallet_tools::process_transactions(m_wl_alice.get(), events, m_head, m_bt);
  wallet_tools::process_transactions(m_wl_bob.get(), events, m_head, m_bt);
  wallet_tools::process_transactions(m_wl_eve.get(), events, m_head, m_bt);
}

Here is the call graph for this function:

Here is the caller graph for this function:

test_trezor_tx()

void gen_trezor_base::test_trezor_tx ( std::vector< test_event_entry > & events, std::vector< tools::wallet2::pending_tx > & ptxs, std::vector< cryptonote::address_parse_info > & dsts_info, test_generator & generator, std::vector< tools::wallet2 * > wallets, bool is_sweep = false )

virtual

Definition at line 1008 of file trezor_tests.cpp.

{
  // Construct pending transaction for signature in the Trezor.
  const uint64_t height_pre = num_blocks(events) - 1;
  cryptonote::block head_block = get_head_block(events);
  const crypto::hash head_hash = get_block_hash(head_block);
 
  tools::wallet2::unsigned_tx_set txs;
  std::vector<cryptonote::transaction> tx_list;
 
  for(auto &ptx : ptxs) {
    txs.txes.push_back(get_construction_data_with_decrypted_short_payment_id(ptx, *m_trezor));
  }
  txs.transfers = std::make_pair(0, wallet_accessor_test::get_transfers(m_wl_alice.get()));
 
  auto dev_cold = dynamic_cast<::hw::device_cold*>(m_trezor);
  CHECK_AND_ASSERT_THROW_MES(dev_cold, "Device does not implement cold signing interface");
 
  tools::wallet2::signed_tx_set exported_txs;
  hw::tx_aux_data aux_data;
  hw::wallet_shim wallet_shim;
  setup_shim(&wallet_shim);
  aux_data.tx_recipients = dsts_info;
  aux_data.bp_version = m_rct_config.bp_version;
  dev_cold->tx_sign(&wallet_shim, txs, exported_txs, aux_data);
 
  MDEBUG("Signed tx data from hw: " << exported_txs.ptx.size() << " transactions");
  CHECK_AND_ASSERT_THROW_MES(exported_txs.ptx.size() == ptxs.size(), "Invalid transaction sizes");
 
  for (size_t i = 0; i < exported_txs.ptx.size(); ++i){
    auto &c_ptx = exported_txs.ptx[i];
    c_ptx.tx.rct_signatures.mixRing = ptxs[i].tx.rct_signatures.mixRing;
    expand_tsx(c_ptx.tx);
 
    // Simple TX tests, more complex are performed in the core.
    MTRACE(cryptonote::obj_to_json_str(c_ptx.tx));
    bool resx = rct::verRctSemanticsSimple(c_ptx.tx.rct_signatures);
    bool resy = rct::verRctNonSemanticsSimple(c_ptx.tx.rct_signatures);
    CHECK_AND_ASSERT_THROW_MES(resx, "Trezor tx_1 semantics failed");
    CHECK_AND_ASSERT_THROW_MES(resy, "Trezor tx_1 Nonsemantics failed");
 
    tx_list.push_back(c_ptx.tx);
    MDEBUG("Transaction: " << dump_data(c_ptx.tx));
  }
 
  add_transactions_to_events(events, generator, tx_list);
 
  // TX receive test
  uint64_t sum_in = 0;
  uint64_t sum_out = 0;
 
  for(size_t txid = 0; txid < exported_txs.ptx.size(); ++txid) {
    auto &c_ptx = exported_txs.ptx[txid];
    auto &c_tx = c_ptx.tx;
    const crypto::hash txhash = cryptonote::get_transaction_hash(c_tx);
    const size_t num_outs = c_tx.vout.size();
    size_t num_received = 0;
    uint64_t cur_sum_in = 0;
    uint64_t cur_sum_out = 0;
    uint64_t cur_sum_out_recv = 0;
    std::unordered_set<size_t> recv_out_idx;
    std::string exp_payment_id = get_payment_id(c_ptx.construction_data.extra);
    std::string enc_payment_id = get_payment_id(c_tx.extra);
    size_t num_payment_id_checks_done = 0;
 
    CHECK_AND_ASSERT_THROW_MES(exp_payment_id.empty() || exp_payment_id.size() == 8 || exp_payment_id.size() == 32, "Required payment ID invalid");
    CHECK_AND_ASSERT_THROW_MES((exp_payment_id.size() == 32) == (enc_payment_id.size() == 32), "Required and built payment ID size mismatch");
    CHECK_AND_ASSERT_THROW_MES(exp_payment_id.size() <= enc_payment_id.size(), "Required and built payment ID size mismatch");
 
    for(auto &src : c_ptx.construction_data.sources){
      cur_sum_in += src.amount;
    }
 
    for(auto &dst : c_ptx.construction_data.splitted_dsts){
      cur_sum_out += dst.amount;
    }
 
    CHECK_AND_ASSERT_THROW_MES(c_tx.rct_signatures.txnFee + cur_sum_out == cur_sum_in, "Tx Input Output amount mismatch");
 
    for (size_t widx = 0; widx < wallets.size(); ++widx) {
      const bool sender = widx == 0;
      tools::wallet2 *wl = wallets[widx];
 
      wallet_tools::process_transactions(wl, events, m_head, m_bt, boost::make_optional(head_hash));
 
      tools::wallet2::transfer_container m_trans;
      tools::wallet2::transfer_container m_trans_txid;
      wl->get_transfers(m_trans);
 
      std::copy_if(m_trans.begin(), m_trans.end(), std::back_inserter(m_trans_txid), [&txhash](const tools::wallet2::transfer_details& item) {
        return item.m_txid == txhash;
      });
 
      // Testing if the transaction output has been received
      num_received += m_trans_txid.size();
      for (auto & ctran : m_trans_txid){
        cur_sum_out_recv += ctran.amount();
        recv_out_idx.insert(ctran.m_internal_output_index);
        CHECK_AND_ASSERT_THROW_MES(!ctran.m_spent, "Txout is spent");
        CHECK_AND_ASSERT_THROW_MES(!sender || ctran.m_key_image_known, "Key Image unknown for recipient");  // sender is Trezor, does not need to have KI
      }
 
      // Sender output payment (contains change and stuff)
      if (sender) {
        std::list<std::pair<crypto::hash, tools::wallet2::confirmed_transfer_details>> confirmed_transfers;  // txid -> tdetail
        std::list<std::pair<crypto::hash, tools::wallet2::confirmed_transfer_details>> confirmed_transfers_txid;  // txid -> tdetail
        wl->get_payments_out(confirmed_transfers, height_pre);
 
        std::copy_if(confirmed_transfers.begin(), confirmed_transfers.end(), std::back_inserter(confirmed_transfers_txid), [&txhash](const std::pair<crypto::hash, tools::wallet2::confirmed_transfer_details>& item) {
          return item.first == txhash;
        });
 
        CHECK_AND_ASSERT_THROW_MES(confirmed_transfers_txid.size() == 1, "Sender does not have outgoing transfer for the transaction");
      }
 
      // Received payment from the block
      std::list<std::pair<crypto::hash, tools::wallet2::payment_details>> payments; // payment id -> [payment details] multimap
      std::list<std::pair<crypto::hash, tools::wallet2::payment_details>> payments_txid; // payment id -> [payment details] multimap
      wl->get_payments(payments, height_pre);
 
      std::copy_if(payments.begin(), payments.end(), std::back_inserter(payments_txid), [&txhash](const std::pair<crypto::hash, tools::wallet2::payment_details>& item) {
        return item.second.m_tx_hash == txhash;
      });
 
      for(auto &paydet : payments_txid){
        CHECK_AND_ASSERT_THROW_MES(exp_payment_id.empty() || (memcmp(exp_payment_id.data(), paydet.first.data, exp_payment_id.size()) == 0), "Payment ID mismatch");
        num_payment_id_checks_done += 1;
      }
    }
 
    CHECK_AND_ASSERT_THROW_MES(c_tx.rct_signatures.txnFee + cur_sum_out_recv == cur_sum_in, "Tx Input Output amount mismatch");
    CHECK_AND_ASSERT_THROW_MES(exp_payment_id.empty() || num_payment_id_checks_done > 0, "No Payment ID checks");
 
    if(!is_sweep){
      CHECK_AND_ASSERT_THROW_MES(num_received == num_outs, "Number of received outputs do not match number of outgoing");
      CHECK_AND_ASSERT_THROW_MES(recv_out_idx.size() == num_outs, "Num of outs received do not match");
    } else {
      CHECK_AND_ASSERT_THROW_MES(num_received + 1 >= num_outs, "Number of received outputs do not match number of outgoing");
      CHECK_AND_ASSERT_THROW_MES(recv_out_idx.size() + 1 >= num_outs, "Num of outs received do not match");  // can have dummy out
    }
 
    sum_in += cur_sum_in;
    sum_out += cur_sum_out + c_tx.rct_signatures.txnFee;
  }
 
  CHECK_AND_ASSERT_THROW_MES(sum_in == sum_out, "Tx amount mismatch");
 
  // Test get_tx_key feature for stored private tx keys
  test_get_tx(events, wallets, exported_txs.ptx, aux_data.tx_device_aux);
}

Here is the call graph for this function:

update_client_settings()

void gen_trezor_base::update_client_settings ( )

protectedvirtual

Definition at line 692 of file trezor_tests.cpp.

{
  auto dev_trezor = dynamic_cast<::hw::trezor::device_trezor*>(m_trezor);
  CHECK_AND_ASSERT_THROW_MES(dev_trezor, "Could not cast to device_trezor");
 
  dev_trezor->set_live_refresh_enabled(m_live_refresh_enabled);
}

Here is the caller graph for this function:

update_trackers()

void gen_trezor_base::update_trackers ( std::vector< test_event_entry > & events )

virtual

Definition at line 958 of file trezor_tests.cpp.

{
  wallet_tools::process_transactions(nullptr, events, m_head, m_bt);
}

Here is the call graph for this function:

verify_tx_key()

bool gen_trezor_base::verify_tx_key ( const ::crypto::secret_key & tx_priv, const ::crypto::public_key & tx_pub, const subaddresses_t & subs )

protectedvirtual

Definition at line 1159 of file trezor_tests.cpp.

{
  ::crypto::public_key tx_pub_c;
  ::crypto::secret_key_to_public_key(tx_priv, tx_pub_c);
  if (tx_pub == tx_pub_c)
    return true;
 
  for(const auto & elem : subs)
  {
    tx_pub_c = rct::rct2pk(rct::scalarmultKey(rct::pk2rct(elem.first), rct::sk2rct(tx_priv)));
    if (tx_pub == tx_pub_c)
      return true;
  }
  return false;
}

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 140 of file trezor_tests.h.

tsx_builder

friend class tsx_builder

friend

Definition at line 49 of file trezor_tests.h.

Member Data Documentation

m_alice_account

cryptonote::account_base gen_trezor_base::m_alice_account

protected

Definition at line 133 of file trezor_tests.h.

m_alice_spend_private

const std::string gen_trezor_base::m_alice_spend_private = m_master_seed_str

static

Definition at line 106 of file trezor_tests.h.

m_alice_view_private

const std::string gen_trezor_base::m_alice_view_private = "a6ccd4ac344a295d1387f8d18c81bdd394f1845de84188e204514ef9370fd403"

static

Definition at line 107 of file trezor_tests.h.

m_bob_account

cryptonote::account_base gen_trezor_base::m_bob_account

protected

Definition at line 132 of file trezor_tests.h.

m_bt

block_tracker gen_trezor_base::m_bt

protected

Definition at line 116 of file trezor_tests.h.

m_daemon

std::shared_ptr<mock_daemon> gen_trezor_base::m_daemon

protected

Definition at line 118 of file trezor_tests.h.

m_device_name

const std::string gen_trezor_base::m_device_name = "Trezor:udp"

static

Definition at line 103 of file trezor_tests.h.

m_device_seed

const std::string gen_trezor_base::m_device_seed = "permit universe parent weapon amused modify essay borrow tobacco budget walnut lunch consider gallery ride amazing frog forget treat market chapter velvet useless topple"

static

Definition at line 105 of file trezor_tests.h.

m_eve_account

cryptonote::account_base gen_trezor_base::m_eve_account

protected

Definition at line 134 of file trezor_tests.h.

m_events

std::vector<test_event_entry> gen_trezor_base::m_events

protected

Definition at line 123 of file trezor_tests.h.

m_generator

test_generator gen_trezor_base::m_generator

protected

Definition at line 115 of file trezor_tests.h.

m_hard_forks

v_hardforks_t gen_trezor_base::m_hard_forks

protected

Definition at line 121 of file trezor_tests.h.

m_head

cryptonote::block gen_trezor_base::m_head

protected

Definition at line 122 of file trezor_tests.h.

m_heavy_tests

bool gen_trezor_base::m_heavy_tests

protected

Definition at line 126 of file trezor_tests.h.

m_live_refresh_enabled

bool gen_trezor_base::m_live_refresh_enabled

protected

Definition at line 129 of file trezor_tests.h.

m_master_seed_str

const std::string gen_trezor_base::m_master_seed_str = "14821d0bc5659b24cafbc889dc4fc60785ee08b65d71c525f81eeaba4f3a570f"

static

Definition at line 104 of file trezor_tests.h.

m_miner_account

cryptonote::account_base gen_trezor_base::m_miner_account

protected

Definition at line 131 of file trezor_tests.h.

m_network_type

cryptonote::network_type gen_trezor_base::m_network_type

protected

Definition at line 117 of file trezor_tests.h.

m_rct_config

rct::RCTConfig gen_trezor_base::m_rct_config

protected

Definition at line 128 of file trezor_tests.h.

m_test_get_tx_key

bool gen_trezor_base::m_test_get_tx_key

protected

Definition at line 127 of file trezor_tests.h.

m_top_hard_fork

uint8_t gen_trezor_base::m_top_hard_fork

protected

Definition at line 120 of file trezor_tests.h.

m_trezor

hw::trezor::device_trezor* gen_trezor_base::m_trezor

protected

Definition at line 135 of file trezor_tests.h.

m_trezor_path

std::string gen_trezor_base::m_trezor_path

protected

Definition at line 125 of file trezor_tests.h.

m_ts_start

const uint64_t gen_trezor_base::m_ts_start = 1397862000

static

Definition at line 101 of file trezor_tests.h.

m_wallet_ts

const uint64_t gen_trezor_base::m_wallet_ts = m_ts_start - 60*60*24*4

static

Definition at line 102 of file trezor_tests.h.

m_wl_alice

std::unique_ptr<tools::wallet2> gen_trezor_base::m_wl_alice

protected

Definition at line 136 of file trezor_tests.h.

m_wl_bob

std::unique_ptr<tools::wallet2> gen_trezor_base::m_wl_bob

protected

Definition at line 137 of file trezor_tests.h.

m_wl_eve

std::unique_ptr<tools::wallet2> gen_trezor_base::m_wl_eve

protected

Definition at line 138 of file trezor_tests.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/trezor/trezor_tests.h
• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/tests/trezor/trezor_tests.cpp