json rpc for wallet and bugfix

7 files changed, 1160 insertions, 354 deletions

diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp
index 7b898755a..572affb2f 100644
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@@ -25,25 +25,25 @@ using namespace cryptonote;
 namespace tools
 {
 //----------------------------------------------------------------------------------------------------
-bool wallet2::init(const std::string& daemon_address, uint64_t upper_transaction_size_limit)
+void wallet2::init(const std::string& daemon_address, uint64_t upper_transaction_size_limit)
 {
   m_upper_transaction_size_limit = upper_transaction_size_limit;
   m_daemon_address = daemon_address;
-  return true;
 }
 //----------------------------------------------------------------------------------------------------
-bool wallet2::process_new_transaction(cryptonote::transaction& tx, uint64_t height, fail_details& fd)
+void wallet2::process_new_transaction(const cryptonote::transaction& tx, uint64_t height)
 {
+  process_unconfirmed(tx);
   std::vector<size_t> outs;
   uint64_t tx_money_got_in_outs = 0;
   crypto::public_key tx_pub_key = null_pkey;
   bool r = parse_and_validate_tx_extra(tx, tx_pub_key);
-  fd.reason = fail_details::error_to_parse_tx_extra;
-  CHECK_AND_ASSERT_MES(r && tx_pub_key != null_pkey, false, "process_new_transaction failed.");
+  CHECK_AND_THROW_WALLET_EX(!r, error::tx_extra_parse_error, tx);
+
   r = lookup_acc_outs(m_account.get_keys(), tx, tx_pub_key, outs, tx_money_got_in_outs);
-  fd.reason = fail_details::error_invalid_tx;
-  CHECK_AND_ASSERT_MES(r, false, "call lookup_acc_outs failed");
-  if(outs.size() && tx_money_got_in_outs)
+  CHECK_AND_THROW_WALLET_EX(!r, error::acc_outs_lookup_error, tx, tx_pub_key, m_account.get_keys());
+
+  if(!outs.empty() && tx_money_got_in_outs)
   {
     //good news - got money! take care about it
     //usually we have only one transfer for user in transaction
@@ -51,25 +51,18 @@ bool wallet2::process_new_transaction(cryptonote::transaction& tx, uint64_t heig
     cryptonote::COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES::response res = AUTO_VAL_INIT(res);
     req.txid = get_transaction_hash(tx);
     bool r = net_utils::invoke_http_bin_remote_command2(m_daemon_address + "/get_o_indexes.bin", req, res, m_http_client, WALLET_RCP_CONNECTION_TIMEOUT);
-    if (!r)                                      fd.reason = fail_details::error_not_connected;
-    else if (CORE_RPC_STATUS_BUSY == res.status) fd.reason = fail_details::error_daemon_is_busy;
-    else if (CORE_RPC_STATUS_OK != res.status)   fd.reason = fail_details::error_internal_error;
-    else                                         fd.reason = fail_details::error_ok;
-    if (fail_details::error_ok != fd.reason)
-    {
-      // in case of split while lookup_acc_outs, transaction could be lost (especially if it is coinbase tx)
-      LOG_PRINT_L0("failed to invoke get_o_indexes.bin: " << interpret_rpc_response(r, res.status));
-      return false;
-    }
-
-    fd.reason = fail_details::error_internal_error;
-    CHECK_AND_ASSERT_MES(res.o_indexes.size() == tx.vout.size(), false, "internal error: transactions outputs size=" << tx.vout.size()
-      << " not match with COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES response size=" << res.o_indexes.size());
+    CHECK_AND_THROW_WALLET_EX(!r, error::no_connection_to_daemon, "get_o_indexes.bin");
+    CHECK_AND_THROW_WALLET_EX(res.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "get_o_indexes.bin");
+    CHECK_AND_THROW_WALLET_EX(res.status != CORE_RPC_STATUS_OK, error::get_out_indices_error, res.status);
+    CHECK_AND_THROW_WALLET_EX(res.o_indexes.size() != tx.vout.size(), error::wallet_internal_error,
+      "transactions outputs size=" + std::to_string(tx.vout.size()) +
+      " not match with COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES response size=" + std::to_string(res.o_indexes.size()));
 
     BOOST_FOREACH(size_t o, outs)
     {
-      fd.reason = fail_details::error_invalid_tx;
-      CHECK_AND_ASSERT_MES(o < tx.vout.size(), false, "wrong out in transaction: internal index=" << o << ", total_outs" << tx.vout.size());
+      CHECK_AND_THROW_WALLET_EX(tx.vout.size() <= o, error::wallet_internal_error, "wrong out in transaction: internal index=" +
+        std::to_string(o) + ", total_outs=" + std::to_string(tx.vout.size()));
+
       m_transfers.push_back(boost::value_initialized<transfer_details>());
       transfer_details& td = m_transfers.back();
       td.m_block_height = height;
@@ -79,12 +72,13 @@ bool wallet2::process_new_transaction(cryptonote::transaction& tx, uint64_t heig
       td.m_spent = false;
       cryptonote::keypair in_ephemeral;
       cryptonote::generate_key_image_helper(m_account.get_keys(), tx_pub_key, o, in_ephemeral, td.m_key_image);
-      fd.reason = fail_details::error_internal_error;
-      CHECK_AND_ASSERT_MES(in_ephemeral.pub == boost::get<cryptonote::txout_to_key>(tx.vout[o].target).key,
-        false, "internal error: at key_image generating ephemeral public key not matched with output_key");
+      CHECK_AND_THROW_WALLET_EX(in_ephemeral.pub != boost::get<cryptonote::txout_to_key>(tx.vout[o].target).key,
+        error::wallet_internal_error, "key_image generated ephemeral public key not matched with output_key");
+
       m_key_images[td.m_key_image] = m_transfers.size()-1;
-      LOG_PRINT_COLOR("Received money: " << print_money(td.amount()) << ", with tx: " << get_transaction_hash(tx),
-        LOG_LEVEL_0, epee::log_space::console_color_green);
+      LOG_PRINT_L0("Received money: " << print_money(td.amount()) << ", with tx: " << get_transaction_hash(tx));
+      if (0 != m_callback)
+        m_callback->on_money_received(height, td.m_tx, td.m_internal_output_index);
     }
   }
   // check all outputs for spending (compare key images)
@@ -95,36 +89,42 @@ bool wallet2::process_new_transaction(cryptonote::transaction& tx, uint64_t heig
     auto it = m_key_images.find(boost::get<cryptonote::txin_to_key>(in).k_image);
     if(it != m_key_images.end())
     {
-      LOG_PRINT_COLOR("Spent money: " << print_money(boost::get<cryptonote::txin_to_key>(in).amount) << ", with tx: " << get_transaction_hash(tx),
-        LOG_LEVEL_0, epee::log_space::console_color_magenta);
-      m_transfers[it->second].m_spent = true;
+      LOG_PRINT_L0("Spent money: " << print_money(boost::get<cryptonote::txin_to_key>(in).amount) << ", with tx: " << get_transaction_hash(tx));
+      transfer_details& td = m_transfers[it->second];
+      td.m_spent = true;
+      if (0 != m_callback)
+        m_callback->on_money_spent(height, td.m_tx, td.m_internal_output_index, tx);
     }
   }
-  return true;
 }
 //----------------------------------------------------------------------------------------------------
-bool wallet2::process_new_blockchain_entry(cryptonote::block& b, cryptonote::block_complete_entry& bche, crypto::hash& bl_id, uint64_t height, fail_details& fd)
+void wallet2::process_unconfirmed(const cryptonote::transaction& tx)
+{
+  auto unconf_it = m_unconfirmed_txs.find(get_transaction_hash(tx));
+  if(unconf_it != m_unconfirmed_txs.end())
+    m_unconfirmed_txs.erase(unconf_it);
+}
+//----------------------------------------------------------------------------------------------------
+void wallet2::process_new_blockchain_entry(const cryptonote::block& b, cryptonote::block_complete_entry& bche, crypto::hash& bl_id, uint64_t height)
 {
   //handle transactions from new block
-  fd.reason = fail_details::error_internal_error;
-  CHECK_AND_ASSERT_MES(height == m_blockchain.size(), false, "internal error: current_index=" << height << ", m_blockchain.size()=" << m_blockchain.size());
+  CHECK_AND_THROW_WALLET_EX(height != m_blockchain.size(), error::wallet_internal_error,
+    "current_index=" + std::to_string(height) + ", m_blockchain.size()=" + std::to_string(m_blockchain.size()));
+
   //optimization: seeking only for blocks that are not older then the wallet creation time plus 1 day. 1 day is for possible user incorrect time setup
   if(b.timestamp + 60*60*24 > m_account.get_createtime())
   {
     TIME_MEASURE_START(miner_tx_handle_time);
-    bool r = process_new_transaction(b.miner_tx, height, fd);
+    process_new_transaction(b.miner_tx, height);
     TIME_MEASURE_FINISH(miner_tx_handle_time);
-    CHECK_AND_NO_ASSERT_MES(r, false, "failed to process transaction");
 
     TIME_MEASURE_START(txs_handle_time);
     BOOST_FOREACH(auto& txblob, bche.txs)
     {
       cryptonote::transaction tx;
-      r = parse_and_validate_tx_from_blob(txblob, tx);
-      fd.reason = fail_details::error_to_parse_tx;
-      CHECK_AND_ASSERT_MES(r, false, "failed to parse and validate transaction from blob");
-      r = process_new_transaction(tx, height, fd);
-      CHECK_AND_ASSERT_MES(r, false, "failed to process transaction");
+      bool r = parse_and_validate_tx_from_blob(txblob, tx);
+      CHECK_AND_THROW_WALLET_EX(!r, error::tx_parse_error, txblob);
+      process_new_transaction(tx, height);
     }
     TIME_MEASURE_FINISH(txs_handle_time);
     LOG_PRINT_L2("Processed block: " << bl_id << ", height " << height << ", " <<  miner_tx_handle_time + txs_handle_time << "(" << miner_tx_handle_time << "/" << txs_handle_time <<")ms");
@@ -134,16 +134,18 @@ bool wallet2::process_new_blockchain_entry(cryptonote::block& b, cryptonote::blo
   }
   m_blockchain.push_back(bl_id);
   ++m_local_bc_height;
-  return true;
+
+  if (0 != m_callback)
+    m_callback->on_new_block(height, b);
 }
 //----------------------------------------------------------------------------------------------------
-bool wallet2::get_short_chain_history(std::list<crypto::hash>& ids)
+void wallet2::get_short_chain_history(std::list<crypto::hash>& ids)
 {
   size_t i = 0;
   size_t current_multiplier = 1;
   size_t sz = m_blockchain.size();
   if(!sz)
-    return true;
+    return;
   size_t current_back_offset = 1;
   bool genesis_included = false;
   while(current_back_offset < sz)
@@ -162,77 +164,68 @@ bool wallet2::get_short_chain_history(std::list<crypto::hash>& ids)
   }
   if(!genesis_included)
     ids.push_back(m_blockchain[0]);
-
-  return true;
 }
 //----------------------------------------------------------------------------------------------------
-bool wallet2::pull_blocks(size_t& blocks_added, fail_details& fd)
+void wallet2::pull_blocks(size_t& blocks_added)
 {
   blocks_added = 0;
   cryptonote::COMMAND_RPC_GET_BLOCKS_FAST::request req = AUTO_VAL_INIT(req);
   cryptonote::COMMAND_RPC_GET_BLOCKS_FAST::response res = AUTO_VAL_INIT(res);
   get_short_chain_history(req.block_ids);
   bool r = net_utils::invoke_http_bin_remote_command2(m_daemon_address + "/getblocks.bin", req, res, m_http_client, WALLET_RCP_CONNECTION_TIMEOUT);
-  if (!r)                                      fd.reason = fail_details::error_not_connected;
-  else if (CORE_RPC_STATUS_BUSY == res.status) fd.reason = fail_details::error_daemon_is_busy;
-  else if (CORE_RPC_STATUS_OK != res.status)   fd.reason = fail_details::error_internal_error;
-  else                                         fd.reason = fail_details::error_ok;
-  if (fail_details::error_ok != fd.reason)
-  {
-    LOG_PRINT_L0("failed to get blocks: " << interpret_rpc_response(r, res.status));
-    return false;
-  }
-
-  //find split position, if split happened
-
-  fd.reason = fail_details::error_internal_error;
-  CHECK_AND_ASSERT_MES(res.start_height < m_blockchain.size(), false, "wrong daemon response: m_start_height="
-    << res.start_height << " not less than local blockchain size=" << m_blockchain.size());
+  CHECK_AND_THROW_WALLET_EX(!r, error::no_connection_to_daemon, "getblocks.bin");
+  CHECK_AND_THROW_WALLET_EX(res.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "getblocks.bin");
+  CHECK_AND_THROW_WALLET_EX(res.status != CORE_RPC_STATUS_OK, error::get_blocks_error, res.status);
+  CHECK_AND_THROW_WALLET_EX(m_blockchain.size() <= res.start_height, error::wallet_internal_error,
+    "wrong daemon response: m_start_height=" + std::to_string(res.start_height) +
+    " not less than local blockchain size=" + std::to_string(m_blockchain.size()));
 
   size_t current_index = res.start_height;
   BOOST_FOREACH(auto& bl_entry, res.blocks)
   {
     cryptonote::block bl;
     r = cryptonote::parse_and_validate_block_from_blob(bl_entry.block, bl);
-    fd.reason = fail_details::error_to_parse_block;
-    CHECK_AND_ASSERT_MES(r, false, "failed to parse/validate block");
+    CHECK_AND_THROW_WALLET_EX(!r, error::block_parse_error, bl_entry.block);
+
     crypto::hash bl_id = get_block_hash(bl);
     if(current_index >= m_blockchain.size())
     {
-      r = process_new_blockchain_entry(bl, bl_entry, bl_id, current_index, fd);
-      if(!r) return false;
+      process_new_blockchain_entry(bl, bl_entry, bl_id, current_index);
       ++blocks_added;
-    }else
+    }
+    else if(bl_id != m_blockchain[current_index])
     {
-      if(bl_id != m_blockchain[current_index])
-      {
-        //split detected here !!!
-        fd.reason = fail_details::error_internal_error;
-        CHECK_AND_ASSERT_MES(current_index != res.start_height, false, "wrong daemon response: first block in response " << string_tools::pod_to_hex(bl_id)
-          << "\nnot match with local block id " << string_tools::pod_to_hex(m_blockchain[current_index]));
-        detach_blockchain(current_index);
-        r = process_new_blockchain_entry(bl, bl_entry, bl_id, current_index, fd);
-        if(!r) return false;
-      }
+      //split detected here !!!
+      CHECK_AND_THROW_WALLET_EX(current_index == res.start_height, error::wallet_internal_error,
+        "wrong daemon response: split starts from the first block in response " + string_tools::pod_to_hex(bl_id) + 
+        " (height " + std::to_string(res.start_height) + "), local block id at this height: " +
+        string_tools::pod_to_hex(m_blockchain[current_index]));
+
+      detach_blockchain(current_index);
+      process_new_blockchain_entry(bl, bl_entry, bl_id, current_index);
     }
+    else
+    {
+      LOG_PRINT_L2("Block is already in blockchain: " << string_tools::pod_to_hex(bl_id));
+    }
+
     ++current_index;
   }
-  return true;
 }
 //----------------------------------------------------------------------------------------------------
-bool wallet2::refresh(fail_details& fd)
+void wallet2::refresh()
 {
   size_t blocks_fetched = 0;
-  return refresh(blocks_fetched, fd);
+  refresh(blocks_fetched);
 }
 //----------------------------------------------------------------------------------------------------
-bool wallet2::refresh(size_t & blocks_fetched, fail_details& fd)
+void wallet2::refresh(size_t & blocks_fetched)
 {
   bool received_money = false;
-  return refresh(blocks_fetched, received_money, fd);
+  refresh(blocks_fetched, received_money);
 }
 //----------------------------------------------------------------------------------------------------
-bool wallet2::refresh(size_t & blocks_fetched, bool& received_money, fail_details& fd)
+void wallet2::refresh(size_t & blocks_fetched, bool& received_money)
 {
   received_money = false;
   blocks_fetched = 0;
@@ -242,33 +235,49 @@ bool wallet2::refresh(size_t & blocks_fetched, bool& received_money, fail_detail
 
   while(m_run.load(std::memory_order_relaxed))
   {
-    bool res = pull_blocks(added_blocks, fd);
-    if(!res)
+    try
+    {
+      pull_blocks(added_blocks);
+      blocks_fetched += added_blocks;
+      if(!added_blocks)
+        break;
+    }
+    catch (const std::exception&)
     {
+      blocks_fetched += added_blocks;
       if(try_count < 3)
       {
         LOG_PRINT_L1("Another try pull_blocks (try_count=" << try_count << ")...");
         ++try_count;
-        continue;
-      }else
+      }
+      else
       {
-        LOG_PRINT_L1("pull_blocks failed, try_count=" << try_count);
-        return false;
+        LOG_ERROR("pull_blocks failed, try_count=" << try_count);
+        throw;
       }
     }
-    blocks_fetched+=added_blocks;
-
-    if(!added_blocks)
-      break;
   }
   if(last_tx_hash_id != (m_transfers.size() ? get_transaction_hash(m_transfers.back().m_tx) : null_hash))
     received_money = true;
 
   LOG_PRINT_L1("Refresh done, blocks received: " << blocks_fetched << ", balance: " << print_money(balance()) << ", unlocked: " << print_money(unlocked_balance()));
-  return true;
 }
 //----------------------------------------------------------------------------------------------------
-bool wallet2::detach_blockchain(uint64_t height)
+bool wallet2::refresh(size_t & blocks_fetched, bool& received_money, bool& ok)
+{
+  try
+  {
+    refresh(blocks_fetched, received_money);
+    ok = true;
+  }
+  catch (...)
+  {
+    ok = false;
+  }
+  return ok;
+}
+//----------------------------------------------------------------------------------------------------
+void wallet2::detach_blockchain(uint64_t height)
 {
   LOG_PRINT_L0("Detaching blockchain on height " << height);
   size_t transfers_detached = 0;
@@ -279,7 +288,7 @@ bool wallet2::detach_blockchain(uint64_t height)
   for(size_t i = i_start; i!= m_transfers.size();i++)
   {
     auto it_ki = m_key_images.find(m_transfers[i].m_key_image);
-    CHECK_AND_ASSERT_MES(it_ki != m_key_images.end(), false, "key image not found");
+    CHECK_AND_THROW_WALLET_EX(it_ki == m_key_images.end(), error::wallet_internal_error, "key image not found");
     m_key_images.erase(it_ki);
     ++transfers_detached;
   }
@@ -290,8 +299,6 @@ bool wallet2::detach_blockchain(uint64_t height)
   m_local_bc_height -= blocks_detached;
 
   LOG_PRINT_L0("Detached blockchain on height " << height << ", transfers detached " << transfers_detached << ", blocks detached " << blocks_detached);
-
-  return true;
 }
 //----------------------------------------------------------------------------------------------------
 bool wallet2::deinit()
@@ -343,13 +350,14 @@ namespace
   }
 }
 //----------------------------------------------------------------------------------------------------
-bool wallet2::load_keys(const std::string& keys_file_name, const std::string& password)
+void wallet2::load_keys(const std::string& keys_file_name, const std::string& password)
 {
   wallet2::keys_file_data keys_file_data;
   std::string buf;
   bool r = epee::file_io_utils::load_file_to_string(keys_file_name, buf);
-  r &= ::serialization::parse_binary(buf, keys_file_data);
-  CHECK_AND_ASSERT_MES(r, false, "failed to load wallet keys file: " << keys_file_name);
+  CHECK_AND_THROW_WALLET_EX(!r, error::file_read_error, keys_file_name);
+  r = ::serialization::parse_binary(buf, keys_file_data);
+  CHECK_AND_THROW_WALLET_EX(!r, error::wallet_internal_error, "internal error: failed to deserialize \"" + keys_file_name + '\"');
 
   crypto::chacha8_key key;
   crypto::generate_chacha8_key(password, key);
@@ -361,34 +369,28 @@ bool wallet2::load_keys(const std::string& keys_file_name, const std::string& pa
   r = epee::serialization::load_t_from_binary(m_account, account_data);
   r = r && verify_keys(keys.m_view_secret_key,  keys.m_account_address.m_view_public_key);
   r = r && verify_keys(keys.m_spend_secret_key, keys.m_account_address.m_spend_public_key);
-  if (!r)
-  {
-    LOG_ERROR("invalid password");
-    return false;
-  }
-
-  return true;
+  CHECK_AND_THROW_WALLET_EX(!r, error::invalid_password);
 }
 //----------------------------------------------------------------------------------------------------
-bool wallet2::generate(const std::string& wallet_, const std::string& password)
+void wallet2::generate(const std::string& wallet_, const std::string& password)
 {
   clear();
   prepare_file_names(wallet_);
-  boost::system::error_code e;
-  if(boost::filesystem::exists(m_wallet_file, e) || boost::filesystem::exists(m_keys_file, e))
-  {
-    LOG_PRINT_RED_L0("failed to generate wallet, file already exist or wrong path: " << wallet_);
-    return false;
-  }
+
+  boost::system::error_code ignored_ec;
+  CHECK_AND_THROW_WALLET_EX(boost::filesystem::exists(m_wallet_file, ignored_ec), error::file_exists, m_wallet_file);
+  CHECK_AND_THROW_WALLET_EX(boost::filesystem::exists(m_keys_file,   ignored_ec), error::file_exists, m_keys_file);
 
   m_account.generate();
   m_account_public_address = m_account.get_keys().m_account_address;
 
   bool r = store_keys(m_keys_file, password);
-  CHECK_AND_ASSERT_MES(r, false, "Failed to store wallet key files!");
+  CHECK_AND_THROW_WALLET_EX(!r, error::file_save_error, m_keys_file);
+
   r = file_io_utils::save_string_to_file(m_wallet_file + ".address.txt", m_account.get_public_address_str());
   if(!r) LOG_PRINT_RED_L0("String with address text not saved");
-  return store();
+
+  store();
 }
 //----------------------------------------------------------------------------------------------------
 bool wallet2::prepare_file_names(const std::string& file_path)
@@ -418,51 +420,46 @@ bool wallet2::check_connection()
   return m_http_client.connect(u.host, std::to_string(u.port), WALLET_RCP_CONNECTION_TIMEOUT);
 }
 //----------------------------------------------------------------------------------------------------
-bool wallet2::load(const std::string& wallet_, const std::string& password)
+void wallet2::load(const std::string& wallet_, const std::string& password)
 {
   clear();
   prepare_file_names(wallet_);
-  boost::system::error_code e;
-  if(!boost::filesystem::exists(m_keys_file, e) || e)
-  {
-    LOG_PRINT_L0("file not found: " << m_keys_file);
-    return false;
-  }
 
-  bool r = load_keys(m_keys_file, password);
-  if (!r)
-    return false;
+  boost::system::error_code e;
+  bool exists = boost::filesystem::exists(m_keys_file, e);
+  CHECK_AND_THROW_WALLET_EX(e || !exists, error::file_not_found, m_keys_file);
 
+  load_keys(m_keys_file, password);
   LOG_PRINT_L0("Loaded wallet keys file, with public address: " << m_account.get_public_address_str());
+
   //keys loaded ok!
   //try to load wallet file. but even if we failed, it is not big problem
   if(!boost::filesystem::exists(m_wallet_file, e) || e)
   {
     LOG_PRINT_L0("file not found: " << m_wallet_file << ", starting with empty blockchain");
     m_account_public_address = m_account.get_keys().m_account_address;
-    return true;
+    return;
   }
-  r = tools::unserialize_obj_from_file(*this, m_wallet_file);
-  CHECK_AND_ASSERT_MES(r, false, "failed to load wallet from file " << m_wallet_file);
-  CHECK_AND_ASSERT_MES(m_account_public_address.m_spend_public_key == m_account.get_keys().m_account_address.m_spend_public_key &&
-                       m_account_public_address.m_view_public_key == m_account.get_keys().m_account_address.m_view_public_key,
-                       false, "addresses of wallet keys file and wallet data file are mismatched");
-  if(!m_blockchain.size())
+  bool r = tools::unserialize_obj_from_file(*this, m_wallet_file);
+  CHECK_AND_THROW_WALLET_EX(!r, error::file_read_error, m_wallet_file);
+  CHECK_AND_THROW_WALLET_EX(
+    m_account_public_address.m_spend_public_key != m_account.get_keys().m_account_address.m_spend_public_key ||
+    m_account_public_address.m_view_public_key  != m_account.get_keys().m_account_address.m_view_public_key,
+    error::wallet_files_doesnt_correspond, m_keys_file, m_wallet_file);
+
+  if(m_blockchain.empty())
   {
     cryptonote::block b;
     cryptonote::generate_genesis_block(b);
     m_blockchain.push_back(get_block_hash(b));
   }
   m_local_bc_height = m_blockchain.size();
-
-  return true;
 }
 //----------------------------------------------------------------------------------------------------
-bool wallet2::store()
+void wallet2::store()
 {
   bool r = tools::serialize_obj_to_file(*this, m_wallet_file);
-  CHECK_AND_ASSERT_MES(r, false, "failed to save wallet to file " << m_wallet_file);
-  return r;
+  CHECK_AND_THROW_WALLET_EX(!r, error::file_save_error, m_wallet_file);
 }
 //----------------------------------------------------------------------------------------------------
 uint64_t wallet2::unlocked_balance()
@@ -482,13 +479,16 @@ uint64_t wallet2::balance()
     if(!td.m_spent)
       amount += td.amount();
 
+
+  BOOST_FOREACH(auto& utx, m_unconfirmed_txs)
+    amount+= utx.second.m_change;
+
   return amount;
 }
 //----------------------------------------------------------------------------------------------------
-bool wallet2::get_transfers(wallet2::transfer_container& incoming_transfers)
+void wallet2::get_transfers(wallet2::transfer_container& incoming_transfers) const
 {
   incoming_transfers = m_transfers;
-  return true;
 }
 //----------------------------------------------------------------------------------------------------
 bool wallet2::is_transfer_unlocked(const transfer_details& td) const
@@ -581,22 +581,25 @@ uint64_t wallet2::select_transfers(uint64_t needed_money, bool add_dust, uint64_
   return found_money;
 }
 //----------------------------------------------------------------------------------------------------
-bool wallet2::transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, size_t fake_outputs_count,
-  uint64_t unlock_time, uint64_t fee, cryptonote::transaction& tx)
+void wallet2::add_unconfirmed_tx(const cryptonote::transaction& tx, uint64_t change_amount)
 {
-  return transfer(dsts, fake_outputs_count, unlock_time, fee, detail::digit_split_strategy, tx_dust_policy(fee), tx);
+  unconfirmed_transfer_details& utd = m_unconfirmed_txs[cryptonote::get_transaction_hash(tx)];
+  utd.m_change = change_amount;
+  utd.m_sent_time = time(NULL);
+  utd.m_tx = tx;
 }
 //----------------------------------------------------------------------------------------------------
-bool wallet2::transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, size_t fake_outputs_count, uint64_t unlock_time, uint64_t fee, cryptonote::transaction& tx, fail_details& tfd)
+void wallet2::transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, size_t fake_outputs_count,
+                       uint64_t unlock_time, uint64_t fee, cryptonote::transaction& tx)
 {
-  return transfer(dsts, fake_outputs_count, unlock_time, fee, detail::digit_split_strategy, tx_dust_policy(fee), tx, tfd);
+  transfer(dsts, fake_outputs_count, unlock_time, fee, detail::digit_split_strategy, tx_dust_policy(fee), tx);
 }
 //----------------------------------------------------------------------------------------------------
-bool wallet2::transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, size_t fake_outputs_count,
+void wallet2::transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, size_t fake_outputs_count,
                        uint64_t unlock_time, uint64_t fee)
 {
   cryptonote::transaction tx;
-  return transfer(dsts, fake_outputs_count, unlock_time, fee, tx);
+  transfer(dsts, fake_outputs_count, unlock_time, fee, tx);
 }
 //----------------------------------------------------------------------------------------------------
 }
diff --git a/src/wallet/wallet2.h b/src/wallet/wallet2.h
index f26f8022e..74de1b6d9 100644
--- a/src/wallet/wallet2.h
+++ b/src/wallet/wallet2.h
@@ -8,6 +8,7 @@
 #include <boost/serialization/list.hpp>
 #include <boost/serialization/vector.hpp>
 #include <atomic>
+
 #include "include_base_utils.h"
 #include "cryptonote_core/account.h"
 #include "cryptonote_core/account_boost_serialization.h"
@@ -20,38 +21,40 @@
 #include "crypto/chacha8.h"
 #include "crypto/hash.h"
 
+#include "wallet_errors.h"
+
 #define DEFAULT_TX_SPENDABLE_AGE                               10
 #define WALLET_RCP_CONNECTION_TIMEOUT                          200000
 
 namespace tools
 {
-  inline std::string interpret_rpc_response(bool ok, const std::string& status)
+  class i_wallet2_callback
   {
-    std::string err;
-    if (ok)
-    {
-      if (status == CORE_RPC_STATUS_BUSY)
-      {
-        err = "daemon is busy. Please try later";
-      }
-      else if (status != CORE_RPC_STATUS_OK)
-      {
-        err = status;
-      }
-    }
-    else
+  public:
+    virtual void on_new_block(uint64_t height, const cryptonote::block& block) {}
+    virtual void on_money_received(uint64_t height, const cryptonote::transaction& tx, size_t out_index) {}
+    virtual void on_money_spent(uint64_t height, const cryptonote::transaction& in_tx, size_t out_index, const cryptonote::transaction& spend_tx) {}
+  };
+
+  struct tx_dust_policy
+  {
+    uint64_t dust_threshold;
+    bool add_to_fee;
+    cryptonote::account_public_address addr_for_dust;
+
+    tx_dust_policy(uint64_t a_dust_threshold = 0, bool an_add_to_fee = true, cryptonote::account_public_address an_addr_for_dust = cryptonote::account_public_address())
+      : dust_threshold(a_dust_threshold)
+      , add_to_fee(an_add_to_fee)
+      , addr_for_dust(an_addr_for_dust)
     {
-      err = "possible lost connection to daemon";
     }
-    return err;
-  }
-
+  };
 
   class wallet2
   {
-    wallet2(const wallet2&) : m_run(true) {};
+    wallet2(const wallet2&) : m_run(true), m_callback(0) {};
   public:
-    wallet2() : m_run(true) {};
+    wallet2() : m_run(true), m_callback(0) {};
     struct transfer_details
     {
       uint64_t m_block_height;
@@ -63,22 +66,16 @@ namespace tools
 
       uint64_t amount() const { return m_tx.vout[m_internal_output_index].amount; }
     };
-    typedef std::vector<transfer_details> transfer_container;
 
-    struct tx_dust_policy
+    struct unconfirmed_transfer_details
     {
-      uint64_t dust_threshold;
-      bool add_to_fee;
-      cryptonote::account_public_address addr_for_dust;
-
-      tx_dust_policy(uint64_t a_dust_threshold = 0, bool an_add_to_fee = true, cryptonote::account_public_address an_addr_for_dust = cryptonote::account_public_address())
-        : dust_threshold(a_dust_threshold)
-        , add_to_fee(an_add_to_fee)
-        , addr_for_dust(an_addr_for_dust)
-      {
-      }
+      cryptonote::transaction m_tx;
+      uint64_t m_change;
+      time_t m_sent_time; 
     };
 
+    typedef std::vector<transfer_details> transfer_container;
+
     struct keys_file_data
     {
       crypto::chacha8_iv iv;
@@ -90,77 +87,34 @@ namespace tools
       END_SERIALIZE()
     };
 
-    struct fail_details
-    {
-      enum fail_reason
-      {
-        error_ok = 0,
-        error_not_connected,
-        error_daemon_is_busy,
-        error_rejected_by_daemon,
-        error_too_big_transaction,
-        error_not_enough_money,
-        error_too_big_mixin,
-        error_to_parse_block,
-        error_to_parse_tx,
-        error_to_parse_tx_extra,
-        error_invalid_tx,
-        error_internal_error
-      };
-      fail_reason reason;
-      uint64_t tx_blob_size;
-      uint64_t max_expected_tx_blob_size;
-
-      std::string what() const
-      {
-        switch (reason)
-        {
-        case error_ok:                  return "OK";
-        case error_not_connected:       return "not connected";
-        case error_daemon_is_busy:      return "daemon is busy. Please try later";
-        case error_rejected_by_daemon:  return "rejected by daemon";
-        case error_too_big_transaction: return "transaction size is too big";
-        case error_not_enough_money:    return "not enough money";
-        case error_too_big_mixin:       return "not enough outputs for specified mixin_count";
-        case error_to_parse_block:      return "failed to parse/validate block";
-        case error_to_parse_tx:         return "failed to parse/validate tx";
-        case error_to_parse_tx_extra:   return "failed to parse/validate tx extra";
-        case error_invalid_tx:          return "wrong tx";
-        case error_internal_error:      return "internal error";
-        default:                        return "unknown error";
-        }
-      }
-    };
-
-    bool generate(const std::string& wallet, const std::string& password);
-    bool load(const std::string& wallet, const std::string& password);
-    bool store();
+    void generate(const std::string& wallet, const std::string& password);
+    void load(const std::string& wallet, const std::string& password);
+    void store();
     cryptonote::account_base& get_account(){return m_account;}
 
-    bool init(const std::string& daemon_address = "http://localhost:8080", uint64_t upper_transaction_size_limit = CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE*2 - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE);
-
-    bool refresh(fail_details& fd);
-    bool refresh(size_t & blocks_fetched, fail_details& fd);
-    bool refresh(size_t & blocks_fetched, bool& received_money, fail_details& fd);
+    void init(const std::string& daemon_address = "http://localhost:8080", uint64_t upper_transaction_size_limit = CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE*2 - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE);
     bool deinit();
 
     void stop() { m_run.store(false, std::memory_order_relaxed); }
 
+    i_wallet2_callback* callback() const { return m_callback; }
+    void callback(i_wallet2_callback* callback) { m_callback = callback; }
+
+    void refresh();
+    void refresh(size_t & blocks_fetched);
+    void refresh(size_t & blocks_fetched, bool& received_money);
+    bool refresh(size_t & blocks_fetched, bool& received_money, bool& ok);
+
     uint64_t balance();
     uint64_t unlocked_balance();
     template<typename T>
-    bool enum_incoming_transfers(const T& handler) const;
-    template<typename T>
-    bool transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, size_t fake_outputs_count, uint64_t unlock_time, uint64_t fee, T destination_split_strategy, const tx_dust_policy& dust_policy);
+    void transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, size_t fake_outputs_count, uint64_t unlock_time, uint64_t fee, T destination_split_strategy, const tx_dust_policy& dust_policy);
     template<typename T>
-    bool transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, size_t fake_outputs_count, uint64_t unlock_time, uint64_t fee, T destination_split_strategy, const tx_dust_policy& dust_policy, cryptonote::transaction &tx, fail_details& tfd);
-    template<typename T>
-    bool transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, size_t fake_outputs_count, uint64_t unlock_time, uint64_t fee, T destination_split_strategy, const tx_dust_policy& dust_policy, cryptonote::transaction &tx);
-    bool transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, size_t fake_outputs_count, uint64_t unlock_time, uint64_t fee);
-    bool transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, size_t fake_outputs_count, uint64_t unlock_time, uint64_t fee, cryptonote::transaction& tx);
-    bool transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, size_t fake_outputs_count, uint64_t unlock_time, uint64_t fee, cryptonote::transaction& tx, fail_details& tfd);
+    void transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, size_t fake_outputs_count, uint64_t unlock_time, uint64_t fee, T destination_split_strategy, const tx_dust_policy& dust_policy, cryptonote::transaction &tx);
+    void transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, size_t fake_outputs_count, uint64_t unlock_time, uint64_t fee);
+    void transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, size_t fake_outputs_count, uint64_t unlock_time, uint64_t fee, cryptonote::transaction& tx);
     bool check_connection();
-    bool get_transfers(wallet2::transfer_container& incoming_transfers);
+    void get_transfers(wallet2::transfer_container& incoming_transfers) const;
     uint64_t get_blockchain_current_height() const { return m_local_bc_height; }
     template <class t_archive>
     inline void serialize(t_archive &a, const unsigned int ver)
@@ -171,21 +125,26 @@ namespace tools
       a & m_transfers;
       a & m_account_public_address;
       a & m_key_images;
+      if(ver < 6)
+        return;
+      a & m_unconfirmed_txs;
     }
 
   private:
     bool store_keys(const std::string& keys_file_name, const std::string& password);
-    bool load_keys(const std::string& keys_file_name, const std::string& password);
-    bool process_new_transaction(cryptonote::transaction& tx, uint64_t height, fail_details& fd);
-    bool process_new_blockchain_entry(cryptonote::block& b, cryptonote::block_complete_entry& bche, crypto::hash& bl_id, uint64_t height, fail_details& fd);
-    bool detach_blockchain(uint64_t height);
-    bool get_short_chain_history(std::list<crypto::hash>& ids);
+    void load_keys(const std::string& keys_file_name, const std::string& password);
+    void process_new_transaction(const cryptonote::transaction& tx, uint64_t height);
+    void process_new_blockchain_entry(const cryptonote::block& b, cryptonote::block_complete_entry& bche, crypto::hash& bl_id, uint64_t height);
+    void detach_blockchain(uint64_t height);
+    void get_short_chain_history(std::list<crypto::hash>& ids);
     bool is_tx_spendtime_unlocked(uint64_t unlock_time) const;
     bool is_transfer_unlocked(const transfer_details& td) const;
     bool clear();
-    bool pull_blocks(size_t& blocks_added, fail_details& fd);
+    void pull_blocks(size_t& blocks_added);
     uint64_t select_transfers(uint64_t needed_money, bool add_dust, uint64_t dust, std::list<transfer_container::iterator>& selected_transfers);
     bool prepare_file_names(const std::string& file_path);
+    void process_unconfirmed(const cryptonote::transaction& tx);
+    void add_unconfirmed_tx(const cryptonote::transaction& tx, uint64_t change_amount);
 
     cryptonote::account_base m_account;
     std::string m_daemon_address;
@@ -194,6 +153,7 @@ namespace tools
     epee::net_utils::http::http_simple_client m_http_client;
     std::vector<crypto::hash> m_blockchain;
     std::atomic<uint64_t> m_local_bc_height; //temporary workaround 
+    std::unordered_map<crypto::hash, unconfirmed_transfer_details> m_unconfirmed_txs;
 
     transfer_container m_transfers;
     std::unordered_map<crypto::key_image, size_t> m_key_images;
@@ -201,9 +161,11 @@ namespace tools
     uint64_t m_upper_transaction_size_limit; //TODO: auto-calc this value or request from daemon, now use some fixed value
 
     std::atomic<bool> m_run;
+
+    i_wallet2_callback* m_callback;
   };
 }
-BOOST_CLASS_VERSION(tools::wallet2, 5)
+BOOST_CLASS_VERSION(tools::wallet2, 6)
 
 namespace boost
 {
@@ -219,6 +181,16 @@ namespace boost
       a & x.m_spent;
       a & x.m_key_image;
     }
+
+    template <class Archive>
+    inline void serialize(Archive &a, tools::wallet2::unconfirmed_transfer_details &x, const boost::serialization::version_type ver)
+    {
+      a & x.m_change;
+      a & x.m_sent_time;
+      a & x.m_tx;
+    }
+
+
   }
 }
 
@@ -288,62 +260,31 @@ namespace tools
   }
   //----------------------------------------------------------------------------------------------------
   template<typename T>
-  bool wallet2::enum_incoming_transfers(const T& handler) const
-  {
-    if(!m_transfers.empty())
-    {
-      BOOST_FOREACH(const transfer_details& td, m_transfers)
-      {
-        handler(td.m_tx, td.m_global_output_index, td.amount(), td.m_spent);
-      }
-      return true;
-    }
-    else
-    {
-      return false;
-    }
-  }
-  //----------------------------------------------------------------------------------------------------
-  template<typename T>
-  bool wallet2::transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, size_t fake_outputs_count,
+  void wallet2::transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, size_t fake_outputs_count,
     uint64_t unlock_time, uint64_t fee, T destination_split_strategy, const tx_dust_policy& dust_policy)
   {
     cryptonote::transaction tx;
-    return transfer(dsts, fake_outputs_count, unlock_time, fee, destination_split_strategy, dust_policy, tx);
+    transfer(dsts, fake_outputs_count, unlock_time, fee, destination_split_strategy, dust_policy, tx);
   }
 
   template<typename T>
-  bool wallet2::transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, size_t fake_outputs_count,
+  void wallet2::transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, size_t fake_outputs_count,
     uint64_t unlock_time, uint64_t fee, T destination_split_strategy, const tx_dust_policy& dust_policy, cryptonote::transaction &tx)
   {
-    fail_details stub = AUTO_VAL_INIT(stub);
-    return transfer(dsts, fake_outputs_count, unlock_time, fee, destination_split_strategy, dust_policy, tx, stub);
-  }
-
-  template<typename T>
-  bool wallet2::transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, size_t fake_outputs_count,
-    uint64_t unlock_time, uint64_t fee, T destination_split_strategy, const tx_dust_policy& dust_policy, cryptonote::transaction &tx, fail_details& tfd)
-  {
     using namespace cryptonote;
 
     uint64_t needed_money = fee;
     BOOST_FOREACH(auto& dt, dsts)
     {
-      CHECK_AND_ASSERT_MES(dt.amount > 0, false, "Wrong destination amount value: " << dt.amount);
+      CHECK_AND_THROW_WALLET_EX(0 == dt.amount, error::zero_destination);
       needed_money += dt.amount;
+      CHECK_AND_THROW_WALLET_EX(needed_money < dt.amount, error::tx_sum_overflow, dsts, fee);
     }
 
     std::list<transfer_container::iterator> selected_transfers;
     uint64_t found_money = select_transfers(needed_money, 0 == fake_outputs_count, dust_policy.dust_threshold, selected_transfers);
+    CHECK_AND_THROW_WALLET_EX(found_money < needed_money, error::not_enough_money, found_money, needed_money - fee, fee);
 
-    if(found_money < needed_money)
-    {
-      LOG_ERROR("not enough money, available only " << print_money(found_money) << ", transaction amount " <<
-        print_money(needed_money) << " = " << print_money(needed_money - fee) << " + " << print_money(fee) << " (fee)");
-      tfd.reason = fail_details::error_not_enough_money;
-      return false;
-    }
-    //typedef COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::outs_for_amount outs_for_amount;
     typedef COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::out_entry out_entry;
     typedef cryptonote::tx_source_entry::output_entry tx_output_entry;
 
@@ -354,41 +295,30 @@ namespace tools
       req.outs_count = fake_outputs_count + 1;// add one to make possible (if need) to skip real output key
       BOOST_FOREACH(transfer_container::iterator it, selected_transfers)
       {
-        CHECK_AND_ASSERT_MES(it->m_tx.vout.size() > it->m_internal_output_index, false, "internal error: m_internal_output_index = "
-          << it->m_internal_output_index << " more than " << it->m_tx.vout.size());
+        CHECK_AND_THROW_WALLET_EX(it->m_tx.vout.size() <= it->m_internal_output_index, error::wallet_internal_error,
+          "m_internal_output_index = " + std::to_string(it->m_internal_output_index) +
+          " is greater or equal to outputs count = " + std::to_string(it->m_tx.vout.size()));
         req.amounts.push_back(it->amount());
       }
 
       bool r = net_utils::invoke_http_bin_remote_command2(m_daemon_address + "/getrandom_outs.bin", req, daemon_resp, m_http_client, 200000);
-      if (!r)                                              tfd.reason = fail_details::error_not_connected;
-      else if (CORE_RPC_STATUS_BUSY == daemon_resp.status) tfd.reason = fail_details::error_daemon_is_busy;
-      else if (CORE_RPC_STATUS_OK != daemon_resp.status)   tfd.reason = fail_details::error_internal_error;
-      else                                                 tfd.reason = fail_details::error_ok;
-      if (fail_details::error_ok != tfd.reason)
-      {
-        LOG_PRINT_L0("failed to invoke getrandom_outs.bin: " << interpret_rpc_response(r, daemon_resp.status));
-        return false;
-      }
-
-      tfd.reason = fail_details::error_internal_error;
-      CHECK_AND_ASSERT_MES(daemon_resp.outs.size() == selected_transfers.size(), false,
-        "internal error: daemon returned wrong response for getrandom_outs.bin, wrong amounts count = "
-        << daemon_resp.outs.size() << ", expected " << selected_transfers.size());
-
-      tfd.reason = fail_details::error_ok;
+      CHECK_AND_THROW_WALLET_EX(!r, error::no_connection_to_daemon, "getrandom_outs.bin");
+      CHECK_AND_THROW_WALLET_EX(daemon_resp.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "getrandom_outs.bin");
+      CHECK_AND_THROW_WALLET_EX(daemon_resp.status != CORE_RPC_STATUS_OK, error::get_random_outs_error, daemon_resp.status);
+      CHECK_AND_THROW_WALLET_EX(daemon_resp.outs.size() != selected_transfers.size(), error::wallet_internal_error,
+        "daemon returned wrong response for getrandom_outs.bin, wrong amounts count = " +
+        std::to_string(daemon_resp.outs.size()) + ", expected " +  std::to_string(selected_transfers.size()));
+
+      std::vector<COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::outs_for_amount> scanty_outs;
       BOOST_FOREACH(COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::outs_for_amount& amount_outs, daemon_resp.outs)
       {
-        if (amount_outs.outs.size() != fake_outputs_count)
+        if (amount_outs.outs.size() < fake_outputs_count)
         {
-          tfd.reason = fail_details::error_too_big_mixin;
-          LOG_PRINT_L0("not enough outputs to mix output " << print_money(amount_outs.amount) << ", requested " <<
-            fake_outputs_count << ", found " << amount_outs.outs.size());
+          scanty_outs.push_back(amount_outs);
         }
       }
-      if (fail_details::error_ok != tfd.reason)
-        return false;
+      CHECK_AND_THROW_WALLET_EX(!scanty_outs.empty(), error::not_enough_outs_to_mix, scanty_outs, fake_outputs_count);
     }
-    tfd.reason = fail_details::error_ok;
  
     //prepare inputs
     size_t i = 0;
@@ -443,60 +373,36 @@ namespace tools
     uint64_t dust = 0;
     std::vector<cryptonote::tx_destination_entry> splitted_dsts;
     destination_split_strategy(dsts, change_dts, dust_policy.dust_threshold, splitted_dsts, dust);
-    CHECK_AND_ASSERT_MES(dust <= dust_policy.dust_threshold, false, "internal error: invalid dust value");
+    CHECK_AND_THROW_WALLET_EX(dust_policy.dust_threshold < dust, error::wallet_internal_error, "invalid dust value: dust = " +
+      std::to_string(dust) + ", dust_threshold = " + std::to_string(dust_policy.dust_threshold));
     if (0 != dust && !dust_policy.add_to_fee)
     {
       splitted_dsts.push_back(cryptonote::tx_destination_entry(dust, dust_policy.addr_for_dust));
     }
 
-    tfd.reason = fail_details::error_internal_error;
     bool r = cryptonote::construct_tx(m_account.get_keys(), sources, splitted_dsts, tx, unlock_time);
-    CHECK_AND_ASSERT_MES(r, false, "Transaction construction failed");
+    CHECK_AND_THROW_WALLET_EX(!r, error::tx_not_constructed, sources, splitted_dsts, unlock_time);
+    CHECK_AND_THROW_WALLET_EX(m_upper_transaction_size_limit <= get_object_blobsize(tx), error::tx_too_big, tx, m_upper_transaction_size_limit);
 
-    //check transaction size
-    if(get_object_blobsize(tx) >= m_upper_transaction_size_limit)
+    std::string key_images;
+    bool all_are_txin_to_key = std::all_of(tx.vin.begin(), tx.vin.end(), [&](const txin_v& s_e) -> bool
     {
-      LOG_PRINT_L0("Transaction size is too big: " << get_object_blobsize(tx)  << ", expected size < " << m_upper_transaction_size_limit);
-      tfd.reason = fail_details::error_too_big_transaction;
-      tfd.tx_blob_size = get_object_blobsize(tx);
-      tfd.max_expected_tx_blob_size = m_upper_transaction_size_limit;
-      return false;
-    }
+      CHECKED_GET_SPECIFIC_VARIANT(s_e, const txin_to_key, in, false);
+      key_images += boost::to_string(in.k_image) + " ";
+      return true;
+    });
+    CHECK_AND_THROW_WALLET_EX(!all_are_txin_to_key, error::unexpected_txin_type, tx);
 
     COMMAND_RPC_SEND_RAW_TX::request req;
     req.tx_as_hex = epee::string_tools::buff_to_hex_nodelimer(tx_to_blob(tx));
     COMMAND_RPC_SEND_RAW_TX::response daemon_send_resp;
     r = net_utils::invoke_http_json_remote_command2(m_daemon_address + "/sendrawtransaction", req, daemon_send_resp, m_http_client, 200000);
-    if (!r)
-    {
-      tfd.reason = fail_details::error_not_connected;
-      LOG_PRINT_L0("failed to send transaction: " << interpret_rpc_response(r, daemon_send_resp.status));
-      return false;
-    }
-    else if (CORE_RPC_STATUS_BUSY == daemon_send_resp.status)
-    {
-      tfd.reason = fail_details::error_daemon_is_busy;
-      LOG_PRINT_L0("failed to send transaction: " << interpret_rpc_response(r, daemon_send_resp.status));
-      return false;
-    }
-    else if (CORE_RPC_STATUS_OK != daemon_send_resp.status)
-    {
-      tfd.reason = fail_details::error_rejected_by_daemon;
-      LOG_ERROR("daemon failed to accept generated transaction, id: " << get_transaction_hash(tx));
-      return false;
-    }
-    else
-    {
-      tfd.reason = fail_details::error_ok;
-    }
+    CHECK_AND_THROW_WALLET_EX(!r, error::no_connection_to_daemon, "sendrawtransaction");
+    CHECK_AND_THROW_WALLET_EX(daemon_send_resp.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "sendrawtransaction");
+    CHECK_AND_THROW_WALLET_EX(daemon_send_resp.status != CORE_RPC_STATUS_OK, error::tx_rejected, tx, daemon_send_resp.status);
+
+    add_unconfirmed_tx(tx, change_dts.amount);
 
-    std::string key_images;
-    std::for_each(tx.vin.begin(), tx.vin.end(), [&](const txin_v& s_e) -> bool
-    {
-      CHECKED_GET_SPECIFIC_VARIANT(s_e, const txin_to_key, in, false);
-      key_images += boost::to_string(in.k_image) + " ";
-      return true;
-    });
     LOG_PRINT_L2("transaction " << get_transaction_hash(tx) << " generated ok and sent to daemon, key_images: [" << key_images << "]");
 
     BOOST_FOREACH(transfer_container::iterator it, selected_transfers)
@@ -507,8 +413,5 @@ namespace tools
                   << "Balance: " << print_money(balance()) << ENDL
                   << "Unlocked: " << print_money(unlocked_balance()) << ENDL
                   << "Please, wait for confirmation for your balance to be unlocked.");
-
-    tfd.reason = fail_details::error_ok;
-    return true;
   }
 }
diff --git a/src/wallet/wallet_errors.h b/src/wallet/wallet_errors.h
new file mode 100644
index 000000000..b517d64f9
--- /dev/null
+++ b/src/wallet/wallet_errors.h
@@ -0,0 +1,611 @@
+// Copyright (c) 2012-2013 The Cryptonote developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#pragma once
+
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "cryptonote_core/cryptonote_format_utils.h"
+#include "rpc/core_rpc_server_commands_defs.h"
+#include "include_base_utils.h"
+
+
+namespace tools
+{
+  namespace error
+  {
+    // std::exception
+    //   std::runtime_error
+    //     wallet_runtime_error *
+    //       wallet_internal_error
+    //         unexpected_txin_type
+    //   std::logic_error
+    //     wallet_logic_error *
+    //       file_exists
+    //       file_not_found
+    //       file_read_error
+    //       file_save_error
+    //       invalid_password
+    //       refresh_error *
+    //         acc_outs_lookup_error
+    //         block_parse_error
+    //         get_blocks_error
+    //         get_out_indexes_error
+    //         tx_extra_parse_error
+    //         tx_parse_error
+    //       transfer_error *
+    //         get_random_outs_general_error
+    //         not_enough_money
+    //         not_enough_outs_to_mix
+    //         tx_not_constructed
+    //         tx_rejected
+    //         tx_sum_overflow
+    //         tx_too_big
+    //         zero_destination
+    //       wallet_rpc_error *
+    //         daemon_busy
+    //         no_connection_to_daemon
+    //       wallet_files_doesnt_correspond
+    //
+    // * - class with protected ctor
+
+    //----------------------------------------------------------------------------------------------------
+    template<typename Base>
+    struct wallet_error_base : public Base
+    {
+      const std::string& location() const { return m_loc; }
+
+      std::string to_string() const
+      {
+        std::ostringstream ss;
+        ss << m_loc << ':' << typeid(*this).name() << ": " << Base::what();
+        return ss.str();
+      }
+
+    protected:
+      wallet_error_base(std::string&& loc, const std::string& message)
+        : Base(message)
+        , m_loc(loc)
+      {
+      }
+
+    private:
+      std::string m_loc;
+    };
+    //----------------------------------------------------------------------------------------------------
+    const char* const failed_rpc_request_messages[] = {
+      "failed to get blocks",
+      "failed to get out indices",
+      "failed to get random outs"
+    };
+    enum failed_rpc_request_message_indices
+    {
+      get_blocks_error_message_index,
+      get_out_indices_error_message_index,
+      get_random_outs_error_message_index
+    };
+
+    template<typename Base, int msg_index>
+    struct failed_rpc_request : public Base
+    {
+      explicit failed_rpc_request(std::string&& loc, const std::string& status)
+        : Base(std::move(loc), failed_rpc_request_messages[msg_index])
+        , m_status(status)
+      {
+      }
+
+      const std::string& status() const { return m_status; }
+
+      std::string to_string() const
+      {
+        std::ostringstream ss;
+        ss << Base::to_string() << ", status = " << status();
+        return ss.str();
+      }
+
+    private:
+      std::string m_status;
+    };
+    //----------------------------------------------------------------------------------------------------
+    typedef wallet_error_base<std::logic_error> wallet_logic_error;
+    typedef wallet_error_base<std::runtime_error> wallet_runtime_error;
+    //----------------------------------------------------------------------------------------------------
+    struct wallet_internal_error : public wallet_runtime_error
+    {
+      explicit wallet_internal_error(std::string&& loc, const std::string& message)
+        : wallet_runtime_error(std::move(loc), message)
+      {
+      }
+    };
+    //----------------------------------------------------------------------------------------------------
+    struct unexpected_txin_type : public wallet_internal_error
+    {
+      explicit unexpected_txin_type(std::string&& loc, const cryptonote::transaction& tx)
+        : wallet_internal_error(std::move(loc), "one of tx inputs has unexpected type")
+        , m_tx(tx)
+      {
+      }
+
+      const cryptonote::transaction& tx() const { return m_tx; }
+
+      std::string to_string() const
+      {
+        std::ostringstream ss;
+        cryptonote::transaction tx = m_tx;
+        ss << wallet_internal_error::to_string() << ", tx:\n" << cryptonote::obj_to_json_str(tx);
+        return ss.str();
+      }
+
+    private:
+      cryptonote::transaction m_tx;
+    };
+    //----------------------------------------------------------------------------------------------------
+    const char* const file_error_messages[] = {
+      "file already exists",
+      "file not found",
+      "failed to read file",
+      "failed to save file"
+    };
+    enum file_error_message_indices
+    {
+      file_exists_message_index,
+      file_not_found_message_index,
+      file_read_error_message_index,
+      file_save_error_message_index
+    };
+
+    template<int msg_index>
+    struct file_error_base : public wallet_logic_error
+    {
+      explicit file_error_base(std::string&& loc, const std::string& file)
+        : wallet_logic_error(std::move(loc), std::string(file_error_messages[msg_index]) +  " \"" + file + '\"')
+        , m_file(file)
+      {
+      }
+
+      const std::string& file() const { return m_file; }
+
+      std::string to_string() const { return wallet_logic_error::to_string(); }
+
+    private:
+      std::string m_file;
+    };
+    //----------------------------------------------------------------------------------------------------
+    typedef file_error_base<file_exists_message_index> file_exists;
+    typedef file_error_base<file_not_found_message_index>  file_not_found;
+    typedef file_error_base<file_not_found_message_index>  file_not_found;
+    typedef file_error_base<file_read_error_message_index> file_read_error;
+    typedef file_error_base<file_save_error_message_index> file_save_error;
+    //----------------------------------------------------------------------------------------------------
+    struct invalid_password : public wallet_logic_error
+    {
+      explicit invalid_password(std::string&& loc)
+        : wallet_logic_error(std::move(loc), "invalid password")
+      {
+      }
+
+      std::string to_string() const { return wallet_logic_error::to_string(); }
+    };
+    //----------------------------------------------------------------------------------------------------
+    struct refresh_error : public wallet_logic_error
+    {
+    protected:
+      refresh_error(std::string&& loc, const std::string& message)
+        : wallet_logic_error(std::move(loc), message)
+      {
+      }
+    };
+    //----------------------------------------------------------------------------------------------------
+    struct acc_outs_lookup_error : public refresh_error
+    {
+      explicit acc_outs_lookup_error(std::string&& loc, const cryptonote::transaction& tx,
+        const crypto::public_key& tx_pub_key, const cryptonote::account_keys& acc_keys)
+        : refresh_error(std::move(loc), "account outs lookup error")
+        , m_tx(tx)
+        , m_tx_pub_key(tx_pub_key)
+        , m_acc_keys(acc_keys)
+      {
+      }
+
+      const cryptonote::transaction& tx() const { return m_tx; }
+      const crypto::public_key& tx_pub_key() const { return m_tx_pub_key; }
+      const cryptonote::account_keys& acc_keys() const { return m_acc_keys; }
+
+      std::string to_string() const
+      {
+        std::ostringstream ss;
+        cryptonote::transaction tx = m_tx;
+        ss << refresh_error::to_string() << ", tx: " << cryptonote::obj_to_json_str(tx);
+        return ss.str();
+      }
+
+    private:
+      const cryptonote::transaction m_tx;
+      const crypto::public_key m_tx_pub_key;
+      const cryptonote::account_keys m_acc_keys;
+    };
+    //----------------------------------------------------------------------------------------------------
+    struct block_parse_error : public refresh_error
+    {
+      explicit block_parse_error(std::string&& loc, const cryptonote::blobdata& block_data)
+        : refresh_error(std::move(loc), "block parse error")
+        , m_block_blob(block_data)
+      {
+      }
+
+      const cryptonote::blobdata& block_blob() const { return m_block_blob; }
+
+      std::string to_string() const { return refresh_error::to_string(); }
+
+    private:
+      cryptonote::blobdata m_block_blob;
+    };
+    //----------------------------------------------------------------------------------------------------
+    typedef failed_rpc_request<refresh_error, get_blocks_error_message_index> get_blocks_error;
+    //----------------------------------------------------------------------------------------------------
+    typedef failed_rpc_request<refresh_error, get_out_indices_error_message_index> get_out_indices_error;
+    //----------------------------------------------------------------------------------------------------
+    struct tx_extra_parse_error : public refresh_error
+    {
+      explicit tx_extra_parse_error(std::string&& loc, const cryptonote::transaction& tx)
+        : refresh_error(std::move(loc), "transaction extra parse error")
+        , m_tx(tx)
+      {
+      }
+
+      const cryptonote::transaction& tx() const { return m_tx; }
+
+      std::string to_string() const
+      {
+        std::ostringstream ss;
+        cryptonote::transaction tx = m_tx;
+        ss << refresh_error::to_string() << ", tx: " << cryptonote::obj_to_json_str(tx);
+        return ss.str();
+      }
+
+    private:
+      const cryptonote::transaction m_tx;
+    };
+    //----------------------------------------------------------------------------------------------------
+    struct tx_parse_error : public refresh_error
+    {
+      explicit tx_parse_error(std::string&& loc, const cryptonote::blobdata& tx_blob)
+        : refresh_error(std::move(loc), "transaction parse error")
+        , m_tx_blob(tx_blob)
+      {
+      }
+
+      const cryptonote::blobdata& tx_blob() const { return m_tx_blob; }
+
+      std::string to_string() const { return refresh_error::to_string(); }
+
+    private:
+      cryptonote::blobdata m_tx_blob;
+    };
+    //----------------------------------------------------------------------------------------------------
+    struct transfer_error : public wallet_logic_error
+    {
+    protected:
+      transfer_error(std::string&& loc, const std::string& message)
+        : wallet_logic_error(std::move(loc), message)
+      {
+      }
+    };
+    //----------------------------------------------------------------------------------------------------
+    typedef failed_rpc_request<transfer_error, get_random_outs_error_message_index> get_random_outs_error;
+    //----------------------------------------------------------------------------------------------------
+    struct not_enough_money : public transfer_error
+    {
+      not_enough_money(std::string&& loc, uint64_t availbable, uint64_t tx_amount, uint64_t fee)
+        : transfer_error(std::move(loc), "not enough money")
+        , m_available(availbable)
+        , m_tx_amount(tx_amount)
+        , m_fee(fee)
+      {
+      }
+
+      uint64_t available() const { return m_available; }
+      uint64_t tx_amount() const { return m_tx_amount; }
+      uint64_t fee() const { return m_fee; }
+
+      std::string to_string() const
+      {
+        std::ostringstream ss;
+        ss << transfer_error::to_string() <<
+          ", available = " << cryptonote::print_money(m_available) <<
+          ", tx_amount = " << cryptonote::print_money(m_tx_amount) <<
+          ", fee = " << cryptonote::print_money(m_fee);
+        return ss.str();
+      }
+
+    private:
+      uint64_t m_available;
+      uint64_t m_tx_amount;
+      uint64_t m_fee;
+    };
+    //----------------------------------------------------------------------------------------------------
+    struct not_enough_outs_to_mix : public transfer_error
+    {
+      typedef std::vector<cryptonote::COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::outs_for_amount> scanty_outs_t;
+
+      explicit not_enough_outs_to_mix(std::string&& loc, const scanty_outs_t& scanty_outs, size_t mixin_count)
+        : transfer_error(std::move(loc), "not enough outputs to mix")
+        , m_scanty_outs(scanty_outs)
+        , m_mixin_count(mixin_count)
+      {
+      }
+
+      const scanty_outs_t& scanty_outs() const { return m_scanty_outs; }
+      size_t mixin_count() const { return m_mixin_count; }
+
+      std::string to_string() const
+      {
+        std::ostringstream ss;
+        ss << transfer_error::to_string() << ", mixin_count = " << m_mixin_count << ", scanty_outs:";
+        for (const auto& outs_for_amount : m_scanty_outs)
+        {
+          ss << '\n' << cryptonote::print_money(outs_for_amount.amount) << " - " << outs_for_amount.outs.size();
+        }
+        return ss.str();
+      }
+
+    private:
+      scanty_outs_t m_scanty_outs;
+      size_t m_mixin_count;
+    };
+    //----------------------------------------------------------------------------------------------------
+    struct tx_not_constructed : public transfer_error
+    {
+      typedef std::vector<cryptonote::tx_source_entry> sources_t;
+      typedef std::vector<cryptonote::tx_destination_entry> destinations_t;
+
+      explicit tx_not_constructed(std::string&& loc, const sources_t& sources, const destinations_t& destinations, uint64_t unlock_time)
+        : transfer_error(std::move(loc), "transaction was not constructed")
+        , m_sources(sources)
+        , m_destinations(destinations)
+        , m_unlock_time(unlock_time)
+      {
+      }
+
+      const sources_t& sources() const { return m_sources; }
+      const destinations_t& destinations() const { return m_destinations; }
+      uint64_t unlock_time() const { return m_unlock_time; }
+
+      std::string to_string() const
+      {
+        std::ostringstream ss;
+        ss << transfer_error::to_string();
+        ss << "\nSources:";
+        for (size_t i = 0; i < m_sources.size(); ++i)
+        {
+          const cryptonote::tx_source_entry& src = m_sources[i];
+          ss << "\n  source " << i << ":";
+          ss << "\n    amount: " << cryptonote::print_money(src.amount);
+          // It's not good, if logs will contain such much data
+          //ss << "\n    real_output: " << src.real_output;
+          //ss << "\n    real_output_in_tx_index: " << src.real_output_in_tx_index;
+          //ss << "\n    real_out_tx_key: " << epee::string_tools::pod_to_hex(src.real_out_tx_key);
+          //ss << "\n    outputs:";
+          //for (size_t j = 0; j < src.outputs.size(); ++j)
+          //{
+          //  const cryptonote::tx_source_entry::output_entry& out = src.outputs[j];
+          //  ss << "\n      " << j << ": " << out.first << ", " << epee::string_tools::pod_to_hex(out.second);
+          //}
+        }
+
+        ss << "\nDestinations:";
+        for (size_t i = 0; i < m_destinations.size(); ++i)
+        {
+          const cryptonote::tx_destination_entry& dst = m_destinations[i];
+          ss << "\n  " << i << ": " << cryptonote::get_account_address_as_str(dst.addr) << " " <<
+            cryptonote::print_money(dst.amount);
+        }
+
+        ss << "\nunlock_time: " << m_unlock_time;
+
+        return ss.str();
+      }
+
+    private:
+      sources_t m_sources;
+      destinations_t m_destinations;
+      uint64_t m_unlock_time;
+    };
+    //----------------------------------------------------------------------------------------------------
+    struct tx_rejected : public transfer_error
+    {
+      explicit tx_rejected(std::string&& loc, const cryptonote::transaction& tx, const std::string& status)
+        : transfer_error(std::move(loc), "transaction was rejected by daemon")
+        , m_tx(tx)
+        , m_status(status)
+      {
+      }
+
+      const cryptonote::transaction& tx() const { return m_tx; }
+      const std::string& status() const { return m_status; }
+
+      std::string to_string() const
+      {
+        std::ostringstream ss;
+        ss << transfer_error::to_string() << ", status = " << m_status << ", tx:\n";
+        cryptonote::transaction tx = m_tx;
+        ss << cryptonote::obj_to_json_str(tx);
+        return ss.str();
+      }
+
+    private:
+      cryptonote::transaction m_tx;
+      std::string m_status;
+    };
+    //----------------------------------------------------------------------------------------------------
+    struct tx_sum_overflow : public transfer_error
+    {
+      tx_sum_overflow(std::string&& loc, const std::vector<cryptonote::tx_destination_entry>& destinations, uint64_t fee)
+        : transfer_error(std::move(loc), "transaction sum + fee exceeds " + cryptonote::print_money(std::numeric_limits<uint64_t>::max()))
+        , m_destinations(destinations)
+        , m_fee(fee)
+      {
+      }
+
+      const std::vector<cryptonote::tx_destination_entry>& destinations() const { return m_destinations; }
+      uint64_t fee() const { return m_fee; }
+
+      std::string to_string() const
+      {
+        std::ostringstream ss;
+        ss << transfer_error::to_string() <<
+          ", fee = " << cryptonote::print_money(m_fee) <<
+          ", destinations:";
+        for (const auto& dst : m_destinations)
+        {
+          ss << '\n' << cryptonote::print_money(dst.amount) << " -> " << cryptonote::get_account_address_as_str(dst.addr);
+        }
+        return ss.str();
+      }
+
+    private:
+      std::vector<cryptonote::tx_destination_entry> m_destinations;
+      uint64_t m_fee;
+    };
+    //----------------------------------------------------------------------------------------------------
+    struct tx_too_big : public transfer_error
+    {
+      explicit tx_too_big(std::string&& loc, const cryptonote::transaction& tx, uint64_t tx_size_limit)
+        : transfer_error(std::move(loc), "transaction is too big")
+        , m_tx(tx)
+        , m_tx_size_limit(tx_size_limit)
+      {
+      }
+
+      const cryptonote::transaction& tx() const { return m_tx; }
+      uint64_t tx_size_limit() const { return m_tx_size_limit; }
+
+      std::string to_string() const
+      {
+        std::ostringstream ss;
+        cryptonote::transaction tx = m_tx;
+        ss << transfer_error::to_string() <<
+          ", tx_size_limit = " << m_tx_size_limit <<
+          ", tx size = " << get_object_blobsize(m_tx) <<
+          ", tx:\n" << cryptonote::obj_to_json_str(tx);
+        return ss.str();
+      }
+
+    private:
+      cryptonote::transaction m_tx;
+      uint64_t m_tx_size_limit;
+    };
+    //----------------------------------------------------------------------------------------------------
+    struct zero_destination : public transfer_error
+    {
+      explicit zero_destination(std::string&& loc)
+        : transfer_error(std::move(loc), "destination amount is zero")
+      {
+      }
+    };
+    //----------------------------------------------------------------------------------------------------
+    struct wallet_rpc_error : public wallet_logic_error
+    {
+      const std::string& request() const { return m_request; }
+
+      std::string to_string() const
+      {
+        std::ostringstream ss;
+        ss << wallet_logic_error::to_string() << ", request = " << m_request;
+        return ss.str();
+      }
+
+    protected:
+      wallet_rpc_error(std::string&& loc, const std::string& message, const std::string& request)
+        : wallet_logic_error(std::move(loc), message)
+        , m_request(request)
+      {
+      }
+
+    private:
+      std::string m_request;
+    };
+    //----------------------------------------------------------------------------------------------------
+    struct daemon_busy : public wallet_rpc_error
+    {
+      explicit daemon_busy(std::string&& loc, const std::string& request)
+        : wallet_rpc_error(std::move(loc), "daemon is busy", request)
+      {
+      }
+    };
+    //----------------------------------------------------------------------------------------------------
+    struct no_connection_to_daemon : public wallet_rpc_error
+    {
+      explicit no_connection_to_daemon(std::string&& loc, const std::string& request)
+        : wallet_rpc_error(std::move(loc), "no connection to daemon", request)
+      {
+      }
+    };
+    //----------------------------------------------------------------------------------------------------
+    struct wallet_files_doesnt_correspond : public wallet_logic_error
+    {
+      explicit wallet_files_doesnt_correspond(std::string&& loc, const std::string& keys_file, const std::string& wallet_file)
+        : wallet_logic_error(std::move(loc), "file " + wallet_file + " does not correspond to " + keys_file)
+      {
+      }
+
+      const std::string& keys_file() const { return m_keys_file; }
+      const std::string& wallet_file() const { return m_wallet_file; }
+
+      std::string to_string() const { return wallet_logic_error::to_string(); }
+
+    private:
+      std::string m_keys_file;
+      std::string m_wallet_file;
+    };
+    //----------------------------------------------------------------------------------------------------
+
+#if !defined(_MSC_VER)
+
+    template<typename TException, typename... TArgs>
+    void throw_wallet_ex(std::string&& loc, const TArgs&... args)
+    {
+      TException e(std::move(loc), args...);
+      LOG_PRINT_L0(e.to_string());
+      throw e;
+    }
+
+#else
+    #include <boost/preprocessor/repetition/enum_binary_params.hpp>
+    #include <boost/preprocessor/repetition/enum_params.hpp>
+    #include <boost/preprocessor/repetition/repeat_from_to.hpp>
+
+    template<typename TException>
+    void throw_wallet_ex(std::string&& loc)
+    {
+      TException e(std::move(loc));
+      LOG_PRINT_L0(e.to_string());
+      throw e;
+    }
+
+#define GEN_throw_wallet_ex(z, n, data)                                                       \
+    template<typename TException, BOOST_PP_ENUM_PARAMS(n, typename TArg)>                     \
+    void throw_wallet_ex(std::string&& loc, BOOST_PP_ENUM_BINARY_PARAMS(n, const TArg, &arg)) \
+    {                                                                                         \
+      TException e(std::move(loc), BOOST_PP_ENUM_PARAMS(n, arg));                             \
+      LOG_PRINT_L0(e.to_string());                                                            \
+      throw e;                                                                                \
+    }
+
+    BOOST_PP_REPEAT_FROM_TO(1, 6, GEN_throw_wallet_ex, ~)
+#endif
+  }
+}
+
+#define STRINGIZE_DETAIL(x) #x
+#define STRINGIZE(x) STRINGIZE_DETAIL(x)
+
+#define CHECK_AND_THROW_WALLET_EX(cond, err_type, ...)                                                      \
+  if (cond)                                                                                                 \
+  {                                                                                                         \
+    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
+    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
+  }
diff --git a/src/wallet/wallet_rpc_server.cpp b/src/wallet/wallet_rpc_server.cpp
new file mode 100644
index 000000000..a89cc4e72
--- /dev/null
+++ b/src/wallet/wallet_rpc_server.cpp
@@ -0,0 +1,132 @@
+// Copyright (c) 2012-2013 The Cryptonote developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+
+#include "include_base_utils.h"
+using namespace epee;
+
+#include "wallet_rpc_server.h"
+#include "common/command_line.h"
+#include "cryptonote_core/cryptonote_format_utils.h"
+#include "cryptonote_core/account.h"
+#include "misc_language.h"
+#include "crypto/hash.h"
+
+namespace tools
+{
+  //-----------------------------------------------------------------------------------
+  const command_line::arg_descriptor<std::string> wallet_rpc_server::arg_rpc_bind_port = {"rpc-bind-port", "Starts wallet as rpc server for wallet operations, sets bind port for server", "", true};
+  const command_line::arg_descriptor<std::string> wallet_rpc_server::arg_rpc_bind_ip = {"rpc-bind-ip", "Specify ip to bind rpc server", "127.0.0.1"};
+
+  void wallet_rpc_server::init_options(boost::program_options::options_description& desc)
+  {
+    command_line::add_arg(desc, arg_rpc_bind_ip);
+    command_line::add_arg(desc, arg_rpc_bind_port);
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
+  wallet_rpc_server::wallet_rpc_server(wallet2& w):m_wallet(w)
+  {}
+  //------------------------------------------------------------------------------------------------------------------------------
+  bool wallet_rpc_server::run()
+  {
+    m_net_server.add_idle_handler([this](){
+      m_wallet.refresh();
+      return true;
+    }, 20000);
+
+    //DO NOT START THIS SERVER IN MORE THEN 1 THREADS WITHOUT REFACTORING
+    return epee::http_server_impl_base<wallet_rpc_server, connection_context>::run(1, true);
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
+  bool wallet_rpc_server::handle_command_line(const boost::program_options::variables_map& vm)
+  {
+    m_bind_ip = command_line::get_arg(vm, arg_rpc_bind_ip);
+    m_port = command_line::get_arg(vm, arg_rpc_bind_port);
+    return true;
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
+  bool wallet_rpc_server::init(const boost::program_options::variables_map& vm)
+  {
+    m_net_server.set_threads_prefix("RPC");
+    bool r = handle_command_line(vm);
+    CHECK_AND_ASSERT_MES(r, false, "Failed to process command line in core_rpc_server");
+    return epee::http_server_impl_base<wallet_rpc_server, connection_context>::init(m_port, m_bind_ip);
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
+  bool wallet_rpc_server::on_getbalance(const wallet_rpc::COMMAND_RPC_GET_BALANCE::request& req, wallet_rpc::COMMAND_RPC_GET_BALANCE::response& res, epee::json_rpc::error& er, connection_context& cntx)
+  {
+    try
+    {
+      res.balance = m_wallet.balance();
+      res.unlocked_balance = m_wallet.unlocked_balance();
+    }
+    catch (std::exception& e)
+    {
+      er.code = WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR;
+      er.message = e.what();
+      return false;
+    }
+    return true;
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
+  bool wallet_rpc_server::on_transfer(const wallet_rpc::COMMAND_RPC_TRANSFER::request& req, wallet_rpc::COMMAND_RPC_TRANSFER::response& res, epee::json_rpc::error& er, connection_context& cntx)
+  {
+
+    std::vector<cryptonote::tx_destination_entry> dsts;
+    for (auto it = req.destinations.begin(); it != req.destinations.end(); it++) 
+    {
+      cryptonote::tx_destination_entry de;
+      if(!get_account_address_from_str(de.addr, it->address))
+      {
+        er.code = WALLET_RPC_ERROR_CODE_WRONG_ADDRESS;
+        er.message = std::string("WALLET_RPC_ERROR_CODE_WRONG_ADDRESS: ") + it->address;
+        return false;
+      }
+      de.amount = it->amount;
+      dsts.push_back(de);
+    }
+    try
+    {
+      cryptonote::transaction tx;
+      m_wallet.transfer(dsts, req.mixin, req.unlock_time, req.fee, tx);
+      res.tx_hash = boost::lexical_cast<std::string>(cryptonote::get_transaction_hash(tx));
+      return true;
+    }
+    catch (const tools::error::daemon_busy& e)
+    {
+      er.code = WALLET_RPC_ERROR_CODE_DAEMON_IS_BUSY;
+      er.message = e.what();
+      return false; 
+    }
+    catch (const std::exception& e)
+    {
+      er.code = WALLET_RPC_ERROR_CODE_GENERIC_TRANSFER_ERROR;
+      er.message = e.what();
+      return false; 
+    }
+    catch (...)
+    {
+      er.code = WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR;
+      er.message = "WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR";
+      return false; 
+    }
+    return true;
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
+  bool wallet_rpc_server::on_store(const wallet_rpc::COMMAND_RPC_STORE::request& req, wallet_rpc::COMMAND_RPC_STORE::response& res, epee::json_rpc::error& er, connection_context& cntx)
+  {
+    try
+    {
+      m_wallet.store();
+    }
+    catch (std::exception& e)
+    {
+      er.code = WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR;
+      er.message = e.what();
+      return false;
+    }
+    return true;
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
+}
\ No newline at end of file
diff --git a/src/wallet/wallet_rpc_server.h b/src/wallet/wallet_rpc_server.h
new file mode 100644
index 000000000..418f055d9
--- /dev/null
+++ b/src/wallet/wallet_rpc_server.h
@@ -0,0 +1,55 @@
+// Copyright (c) 2012-2013 The Cryptonote developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#pragma  once 
+
+#include <boost/program_options/options_description.hpp>
+#include <boost/program_options/variables_map.hpp>
+#include "net/http_server_impl_base.h"
+#include "wallet_rpc_server_commans_defs.h"
+#include "wallet2.h"
+#include "common/command_line.h"
+namespace tools
+{
+  /************************************************************************/
+  /*                                                                      */
+  /************************************************************************/
+  class wallet_rpc_server: public epee::http_server_impl_base<wallet_rpc_server>
+  {
+  public:
+    typedef epee::net_utils::connection_context_base connection_context;
+
+    wallet_rpc_server(wallet2& cr);
+
+    const static command_line::arg_descriptor<std::string> arg_rpc_bind_port;
+    const static command_line::arg_descriptor<std::string> arg_rpc_bind_ip;
+
+
+    static void init_options(boost::program_options::options_description& desc);
+    bool init(const boost::program_options::variables_map& vm);
+    bool run();
+  private:
+
+    CHAIN_HTTP_TO_MAP2(connection_context); //forward http requests to uri map
+
+    BEGIN_URI_MAP2()
+      BEGIN_JSON_RPC_MAP("/json_rpc")
+        MAP_JON_RPC_WE("getbalance",  on_getbalance, wallet_rpc::COMMAND_RPC_GET_BALANCE)
+        MAP_JON_RPC_WE("transfer",    on_transfer,   wallet_rpc::COMMAND_RPC_TRANSFER)
+        MAP_JON_RPC_WE("store",       on_store,      wallet_rpc::COMMAND_RPC_STORE)
+      END_JSON_RPC_MAP()
+    END_URI_MAP2()
+
+      //json_rpc
+      bool on_getbalance(const wallet_rpc::COMMAND_RPC_GET_BALANCE::request& req, wallet_rpc::COMMAND_RPC_GET_BALANCE::response& res, epee::json_rpc::error& er, connection_context& cntx);
+      bool on_transfer(const wallet_rpc::COMMAND_RPC_TRANSFER::request& req, wallet_rpc::COMMAND_RPC_TRANSFER::response& res, epee::json_rpc::error& er, connection_context& cntx);
+      bool on_store(const wallet_rpc::COMMAND_RPC_STORE::request& req, wallet_rpc::COMMAND_RPC_STORE::response& res, epee::json_rpc::error& er, connection_context& cntx);
+
+      bool handle_command_line(const boost::program_options::variables_map& vm);
+
+      wallet2& m_wallet;
+      std::string m_port;
+      std::string m_bind_ip;
+  };
+}
diff --git a/src/wallet/wallet_rpc_server_commans_defs.h b/src/wallet/wallet_rpc_server_commans_defs.h
new file mode 100644
index 000000000..a94ce36b0
--- /dev/null
+++ b/src/wallet/wallet_rpc_server_commans_defs.h
@@ -0,0 +1,91 @@
+// Copyright (c) 2012-2013 The Cryptonote developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#pragma once
+#include "cryptonote_protocol/cryptonote_protocol_defs.h"
+#include "cryptonote_core/cryptonote_basic.h"
+#include "crypto/hash.h"
+#include "wallet_rpc_server_error_codes.h"
+namespace tools
+{
+namespace wallet_rpc
+{
+#define WALLET_RPC_STATUS_OK      "OK"
+#define WALLET_RPC_STATUS_BUSY    "BUSY"
+
+  struct COMMAND_RPC_GET_BALANCE
+  {
+    struct request
+    {
+      BEGIN_KV_SERIALIZE_MAP()
+      END_KV_SERIALIZE_MAP()
+    };
+
+    struct response
+    {
+      uint64_t 	 balance;
+      uint64_t 	 unlocked_balance;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(balance)
+        KV_SERIALIZE(unlocked_balance)
+      END_KV_SERIALIZE_MAP()
+    };
+  };
+
+  struct trnsfer_destination
+  {
+    uint64_t amount;
+    std::string address;
+    BEGIN_KV_SERIALIZE_MAP()
+      KV_SERIALIZE(amount)
+      KV_SERIALIZE(address)
+    END_KV_SERIALIZE_MAP()
+  };
+
+  struct COMMAND_RPC_TRANSFER
+  {
+    struct request
+    {
+      std::list<trnsfer_destination> destinations;
+      uint64_t fee;
+      uint64_t mixin;
+      uint64_t unlock_time;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(destinations)
+        KV_SERIALIZE(fee)
+        KV_SERIALIZE(mixin)
+        KV_SERIALIZE(unlock_time)
+      END_KV_SERIALIZE_MAP()
+    };
+
+    struct response
+    {
+      std::string tx_hash;
+
+      BEGIN_KV_SERIALIZE_MAP()
+        KV_SERIALIZE(tx_hash)
+      END_KV_SERIALIZE_MAP()
+    };
+  };
+
+  struct COMMAND_RPC_STORE
+  {
+    struct request
+    {
+      BEGIN_KV_SERIALIZE_MAP()
+      END_KV_SERIALIZE_MAP()
+    };
+
+    struct response
+    {
+      BEGIN_KV_SERIALIZE_MAP()
+      END_KV_SERIALIZE_MAP()
+    };
+  };
+
+}
+}
+
diff --git a/src/wallet/wallet_rpc_server_error_codes.h b/src/wallet/wallet_rpc_server_error_codes.h
new file mode 100644
index 000000000..415abf406
--- /dev/null
+++ b/src/wallet/wallet_rpc_server_error_codes.h
@@ -0,0 +1,11 @@
+// Copyright (c) 2012-2013 The Cryptonote developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#pragma  once 
+
+
+#define WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR           -1
+#define WALLET_RPC_ERROR_CODE_WRONG_ADDRESS           -2
+#define WALLET_RPC_ERROR_CODE_DAEMON_IS_BUSY          -3
+#define WALLET_RPC_ERROR_CODE_GENERIC_TRANSFER_ERROR  -4