transactions_flow_test.cpp File Reference

#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_io.hpp>
#include <boost/uuid/random_generator.hpp>
#include <unordered_map>
#include "include_base_utils.h"
#include "wallet/wallet2.h"

Include dependency graph for transactions_flow_test.cpp:

Go to the source code of this file.

Macros
#define	FIRST_N_TRANSFERS   10*10

Functions
std::string	generate_random_wallet_name ()
uint64_t	random (const uint64_t max_value)
bool	do_send_etn (tools::wallet2 &w1, tools::wallet2 &w2, size_t mix_in_factor, uint64_t amount_to_transfer, transaction &tx, size_t parts=1)
uint64_t	get_etn_in_first_transfers (const tools::wallet2::transfer_container &incoming_transfers, size_t n_transfers)
bool	transactions_flow_test (std::string &working_folder, std::string path_source_wallet, std::string path_target_wallet, std::string &daemon_addr_a, std::string &daemon_addr_b, uint64_t amount_to_transfer, size_t mix_in_factor, size_t transactions_count, size_t transactions_per_second)

Macro Definition Documentation

FIRST_N_TRANSFERS

#define FIRST_N_TRANSFERS   10*10

Definition at line 113 of file transactions_flow_test.cpp.

Function Documentation

do_send_etn()

bool do_send_etn	(	tools::wallet2 &	w1,
		tools::wallet2 &	w2,
		size_t	mix_in_factor,
		uint64_t	amount_to_transfer,
		transaction &	tx,
		size_t	parts = 1 )

Definition at line 61 of file transactions_flow_test.cpp.

{
  CHECK_AND_ASSERT_MES(parts > 0, false, "parts must be > 0");
 
  std::vector<cryptonote::tx_destination_entry> dsts;
  dsts.reserve(parts);
  uint64_t amount_used = 0;
  uint64_t max_part = amount_to_transfer / parts;
 
  for (size_t i = 0; i < parts; ++i)
  {
    cryptonote::tx_destination_entry de;
    de.addr = w2.get_account().get_keys().m_account_address;
 
    if (i < parts - 1)
      de.amount = random(max_part);
    else
      de.amount = amount_to_transfer - amount_used;
    amount_used += de.amount;
 
    //std::cout << "PARTS (" << amount_to_transfer << ") " << amount_used << " " << de.amount << std::endl;
 
    dsts.push_back(de);
  }
 
  try
  {
    std::vector<tools::wallet2::pending_tx> ptx;
    ptx = w1.create_transactions_2(dsts, mix_in_factor, 0, 0, std::vector<uint8_t>(), 0, {});
    for (auto &p: ptx)
      w1.commit_tx(p);
    return true;
  }
  catch (const std::exception&)
  {
    return false;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

generate_random_wallet_name()

std::string generate_random_wallet_name

(

)

Definition at line 47 of file transactions_flow_test.cpp.

{
  std::stringstream ss;
  ss << boost::uuids::random_generator()();
  return ss.str();
}

Here is the caller graph for this function:

get_etn_in_first_transfers()

uint64_t get_etn_in_first_transfers	(	const tools::wallet2::transfer_container &	incoming_transfers,
		size_t	n_transfers )

Definition at line 100 of file transactions_flow_test.cpp.

{
  uint64_t summ = 0;
  size_t count = 0;
  BOOST_FOREACH(const tools::wallet2::transfer_details& td, incoming_transfers)
  {
    summ += td.m_tx.vout[td.m_internal_output_index].amount;
    if(++count >= n_transfers)
      return summ;
  }
  return summ;
}

Here is the caller graph for this function:

random()

uint64_t random ( const uint64_t max_value )

inline

Definition at line 54 of file transactions_flow_test.cpp.

                                                 {
  return (uint64_t(rand()) ^
          (uint64_t(rand())<<16) ^
          (uint64_t(rand())<<32) ^
          (uint64_t(rand())<<48)) % max_value;
}

Here is the caller graph for this function:

transactions_flow_test()

bool transactions_flow_test	(	std::string &	working_folder,
		std::string	path_source_wallet,
		std::string	path_target_wallet,
		std::string &	daemon_addr_a,
		std::string &	daemon_addr_b,
		uint64_t	amount_to_transfer,
		size_t	mix_in_factor,
		size_t	transactions_count,
		size_t	transactions_per_second )

Definition at line 115 of file transactions_flow_test.cpp.

{
  LOG_PRINT_L0("-----------------------STARTING TRANSACTIONS FLOW TEST-----------------------");
  tools::wallet2 w1, w2;
  if(path_source_wallet.empty())
    path_source_wallet = generate_random_wallet_name();
 
  if(path_target_wallet.empty())
    path_target_wallet = generate_random_wallet_name();
 
 
  try
  {
    w1.generate(working_folder + "/" + path_source_wallet, "");
    w2.generate(working_folder + "/" + path_target_wallet, "");
  }
  catch (const std::exception& e)
  {
    LOG_ERROR("failed to generate wallet: " << e.what());
    return false;
  }
 
  w1.init(daemon_addr_a);
 
  uint64_t blocks_fetched = 0;
  bool received_etn;
  bool ok;
  if(!w1.refresh(true, blocks_fetched, received_etn, ok))
  {
    LOG_ERROR( "failed to refresh source wallet from " << daemon_addr_a );
    return false;
  }
 
  w2.init(daemon_addr_b);
 
  MGINFO_GREEN("Using wallets: " << ENDL
    << "Source:  " << w1.get_account().get_public_address_str(MAINNET) << ENDL << "Path: " << working_folder + "/" + path_source_wallet << ENDL
    << "Target:  " << w2.get_account().get_public_address_str(MAINNET) << ENDL << "Path: " << working_folder + "/" + path_target_wallet);
 
  //lets do some etn
  epee::net_utils::http::http_simple_client http_client;
  COMMAND_RPC_STOP_MINING::request daemon1_req = AUTO_VAL_INIT(daemon1_req);
  COMMAND_RPC_STOP_MINING::response daemon1_rsp = AUTO_VAL_INIT(daemon1_rsp);
  bool r = http_client.set_server(daemon_addr_a, boost::none) && net_utils::invoke_http_json("/stop_mine", daemon1_req, daemon1_rsp, http_client, std::chrono::seconds(10));
  CHECK_AND_ASSERT_MES(r, false, "failed to stop mining");
 
  COMMAND_RPC_START_MINING::request daemon_req = AUTO_VAL_INIT(daemon_req);
  COMMAND_RPC_START_MINING::response daemon_rsp = AUTO_VAL_INIT(daemon_rsp);
  daemon_req.miner_address = w1.get_account().get_public_address_str(MAINNET);
  daemon_req.threads_count = 9;
  r = net_utils::invoke_http_json("/start_mining", daemon_req, daemon_rsp, http_client, std::chrono::seconds(10));
  CHECK_AND_ASSERT_MES(r, false, "failed to start mining getrandom_outs");
  CHECK_AND_ASSERT_MES(daemon_rsp.status == CORE_RPC_STATUS_OK, false, "failed to start mining");
 
  //wait for etn, until balance will have enough etn
  w1.refresh(true, blocks_fetched, received_etn, ok);
  while(w1.unlocked_balance(0, false) < amount_to_transfer)
  {
    misc_utils::sleep_no_w(1000);
    w1.refresh(true, blocks_fetched, received_etn, ok);
  }
 
  //lets make a lot of small outs to ourselves
  //since it is not possible to start from transaction that bigger than 20Kb, we gonna make transactions
  //with 500 outs (about 18kb), and we have to wait appropriate count blocks, mined for test wallet
  while(true)
  {
    tools::wallet2::transfer_container incoming_transfers;
    w1.get_transfers(incoming_transfers);
    if(incoming_transfers.size() > FIRST_N_TRANSFERS && get_etn_in_first_transfers(incoming_transfers, FIRST_N_TRANSFERS) < w1.unlocked_balance(0, false) )
    {
      //lets go!
      size_t count = 0;
      BOOST_FOREACH(tools::wallet2::transfer_details& td, incoming_transfers)
      {
        cryptonote::transaction tx_s;
        bool r = do_send_etn(w1, w1, 0, td.m_tx.vout[td.m_internal_output_index].amount - TEST_FEE, tx_s, 50);
        CHECK_AND_ASSERT_MES(r, false, "Failed to send starter tx " << get_transaction_hash(tx_s));
        MGINFO_GREEN("Starter transaction sent " << get_transaction_hash(tx_s));
        if(++count >= FIRST_N_TRANSFERS)
          break;
      }
      break;
    }else
    {
      misc_utils::sleep_no_w(1000);
      w1.refresh(true, blocks_fetched, received_etn, ok);
    }
  }
  //do actual transfer
  uint64_t transfered_etn = 0;
  uint64_t transfer_size = amount_to_transfer/transactions_count;
  size_t i = 0;
  struct tx_test_entry
  {
    transaction tx;
    size_t m_received_count;
    uint64_t amount_transfered;
  };
  crypto::key_image lst_sent_ki = AUTO_VAL_INIT(lst_sent_ki);
  std::unordered_map<crypto::hash, tx_test_entry> txs;
  for(i = 0; i != transactions_count; i++)
  {
    uint64_t amount_to_tx = (amount_to_transfer - transfered_etn) > transfer_size ? transfer_size: (amount_to_transfer - transfered_etn);
    while(w1.unlocked_balance(0, false) < amount_to_tx + TEST_FEE)
    {
      misc_utils::sleep_no_w(1000);
      LOG_PRINT_L0("not enough ETN, waiting for cashback or mining");
      w1.refresh(true, blocks_fetched, received_etn, ok);
    }
 
    transaction tx;
    /*size_t n_attempts = 0;
    while (!do_send_etn(w1, w2, mix_in_factor, amount_to_tx, tx)) {
        n_attempts++;
        std::cout << "failed to transfer ETN, refresh and try again (attempts=" << n_attempts << ")" << std::endl;
        w1.refresh();
    }*/
 
 
    if(!do_send_etn(w1, w2, mix_in_factor, amount_to_tx, tx))
    {
      LOG_PRINT_L0("failed to transfer ETN, tx: " << get_transaction_hash(tx) << ", refresh and try again" );
      w1.refresh(true, blocks_fetched, received_etn, ok);
      if(!do_send_etn(w1, w2, mix_in_factor, amount_to_tx, tx))
      {
        LOG_PRINT_L0( "failed to transfer ETN, second chance. tx: " << get_transaction_hash(tx) << ", exit" );
        LOCAL_ASSERT(false);
        return false;
      }
    }
    lst_sent_ki = boost::get<txin_to_key>(tx.vin[0]).k_image;
 
    transfered_etn += amount_to_tx;
 
    LOG_PRINT_L0("transferred " << amount_to_tx << ", i=" << i );
    tx_test_entry& ent = txs[get_transaction_hash(tx)] = boost::value_initialized<tx_test_entry>();
    ent.amount_transfered = amount_to_tx;
    ent.tx = tx;
    //if(i % transactions_per_second)
    //  misc_utils::sleep_no_w(1000);
  }
 
 
  LOG_PRINT_L0( "waiting some new blocks...");
  misc_utils::sleep_no_w(DIFFICULTY_BLOCKS_ESTIMATE_TIMESPAN*20*1000);//wait two blocks before sync on another wallet on another daemon
  LOG_PRINT_L0( "refreshing...");
  bool recvd_etn = false;
  while(w2.refresh(true, blocks_fetched, recvd_etn, ok) && ( (blocks_fetched && recvd_etn) || !blocks_fetched  ) )
  {
    misc_utils::sleep_no_w(DIFFICULTY_BLOCKS_ESTIMATE_TIMESPAN*1000);//wait two blocks before sync on another wallet on another daemon
  }
 
  uint64_t etn_2 = w2.balance(0, false);
  if(etn_2 == transfered_etn)
  {
    MGINFO_GREEN("-----------------------FINISHING TRANSACTIONS FLOW TEST OK-----------------------");
    MGINFO_GREEN("transferred " << print_etn(transfered_etn) << " via " << i << " transactions" );
    return true;
  }else
  {
    tools::wallet2::transfer_container tc;
    w2.get_transfers(tc);
    BOOST_FOREACH(tools::wallet2::transfer_details& td, tc)
    {
      auto it = txs.find(td.m_txid);
      CHECK_AND_ASSERT_MES(it != txs.end(), false, "transaction not found in local cache");
      it->second.m_received_count += 1;
    }
 
    BOOST_FOREACH(auto& tx_pair, txs)
    {
      if(tx_pair.second.m_received_count != 1)
      {
        MERROR("Transaction lost: " << get_transaction_hash(tx_pair.second.tx));
      }
 
    }
 
    MERROR("-----------------------FINISHING TRANSACTIONS FLOW TEST FAILED-----------------------" );
    MERROR("income " << print_etn(etn_2) << " via " << i << " transactions, expected ETN = " << print_etn(transfered_etn) );
    LOCAL_ASSERT(false);
    return false;
  }
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function: