json rpc for wallet and bugfix

1 files changed, 501 insertions, 164 deletions

diff --git a/src/simplewallet/simplewallet.cpp b/src/simplewallet/simplewallet.cpp
index 2ba031325..a8aa7dc00 100644
--- a/src/simplewallet/simplewallet.cpp
+++ b/src/simplewallet/simplewallet.cpp
@@ -15,6 +15,7 @@
 #include "cryptonote_core/cryptonote_format_utils.h"
 #include "storages/http_abstract_invoke.h"
 #include "rpc/core_rpc_server_commands_defs.h"
+#include "wallet/wallet_rpc_server.h"
 #include "version.h"
 
 #if defined(WIN32)
@@ -37,27 +38,109 @@ namespace
   const command_line::arg_descriptor<std::string> arg_daemon_address = {"daemon-address", "Use daemon instance at <host>:<port>", ""};
   const command_line::arg_descriptor<std::string> arg_daemon_host = {"daemon-host", "Use daemon instance at host <arg> instead of localhost", ""};
   const command_line::arg_descriptor<std::string> arg_password = {"password", "Wallet password", "", true};
-  const command_line::arg_descriptor<int> arg_daemon_port = {"daemon-port", "Use daemon instance at port <arg> instead of 8080", 0};
+  const command_line::arg_descriptor<int> arg_daemon_port = {"daemon-port", "Use daemon instance at port <arg> instead of 8081", 0};
   const command_line::arg_descriptor<uint32_t> arg_log_level = {"set_log", "", 0, true};
 
   const command_line::arg_descriptor< std::vector<std::string> > arg_command = {"command", ""};
 
-  void print_success_msg(const std::string& msg, bool color = false)
+  inline std::string interpret_rpc_response(bool ok, const std::string& status)
   {
-    LOG_PRINT_L4(msg);
-    if (color) epee::log_space::set_console_color(epee::log_space::console_color_green, false);
-    std::cout << msg;
-    if (color) epee::log_space::reset_console_color();
-    std::cout << std::endl;
+    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
+    {
+      err = "possible lost connection to daemon";
+    }
+    return err;
+  }
+
+  class message_writer
+  {
+  public:
+    message_writer(epee::log_space::console_colors color = epee::log_space::console_color_default, bool bright = false,
+      std::string&& prefix = std::string(), int log_level = LOG_LEVEL_2)
+      : m_flush(true)
+      , m_color(color)
+      , m_bright(bright)
+      , m_log_level(log_level)
+    {
+      m_oss << prefix;
+    }
+
+    message_writer(message_writer&& rhs)
+      : m_flush(std::move(rhs.m_flush))
+#if defined(_MSC_VER)
+      , m_oss(std::move(rhs.m_oss))
+#else
+      // GCC bug: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=54316
+      , m_oss(rhs.m_oss.str(), ios_base::out | ios_base::ate) 
+#endif
+      , m_color(std::move(rhs.m_color))
+      , m_log_level(std::move(rhs.m_log_level))
+    {
+      rhs.m_flush = false;
+    }
+
+    template<typename T>
+    message_writer& operator<<(const T& val)
+    {
+      m_oss << val;
+      return *this;
+    }
+
+    ~message_writer()
+    {
+      if (m_flush)
+      {
+        m_flush = false;
+
+        LOG_PRINT(m_oss.str(), m_log_level)
+
+        if (epee::log_space::console_color_default == m_color)
+        {
+          std::cout << m_oss.str();
+        }
+        else
+        {
+          epee::log_space::set_console_color(m_color, m_bright);
+          std::cout << m_oss.str();
+          epee::log_space::reset_console_color();
+        }
+        std::cout << std::endl;
+      }
+    }
+
+  private:
+    message_writer(message_writer& rhs);
+    message_writer& operator=(message_writer& rhs);
+    message_writer& operator=(message_writer&& rhs);
+
+  private:
+    bool m_flush;
+    std::stringstream m_oss;
+    epee::log_space::console_colors m_color;
+    bool m_bright;
+    int m_log_level;
+  };
+
+  message_writer success_msg_writer(bool color = false)
+  {
+    return message_writer(color ? epee::log_space::console_color_green : epee::log_space::console_color_default, false, std::string(), LOG_LEVEL_2);
   }
 
-  void print_fail_msg(const std::string& msg)
+  message_writer fail_msg_writer()
   {
-    LOG_PRINT_L1("Error:" << msg);
-    epee::log_space::set_console_color(epee::log_space::console_color_red, true);
-    std::cout << "Error: " << msg;
-    epee::log_space::reset_console_color();
-    std::cout << std::endl;
+    return message_writer(epee::log_space::console_color_red, true, "Error: ", LOG_LEVEL_0);
   }
 }
 
@@ -75,21 +158,22 @@ std::string simple_wallet::get_commands_str()
 
 bool simple_wallet::help(const std::vector<std::string> &args/* = std::vector<std::string>()*/)
 {
-  std::cout << get_commands_str();
+  success_msg_writer() << get_commands_str();
   return true;
 }
 
 simple_wallet::simple_wallet()
   : m_daemon_port(0)
+  , m_refresh_progress_reporter(*this)
 {
-  m_cmd_binder.set_handler("start_mining", boost::bind(&simple_wallet::start_mining, this, _1), "Start mining in daemon, start_mining <threads_count>");
+  m_cmd_binder.set_handler("start_mining", boost::bind(&simple_wallet::start_mining, this, _1), "start_mining <threads_count> - Start mining in daemon");
   m_cmd_binder.set_handler("stop_mining", boost::bind(&simple_wallet::stop_mining, this, _1), "Stop mining in daemon");
   m_cmd_binder.set_handler("refresh", boost::bind(&simple_wallet::refresh, this, _1), "Resynchronize transactions and balance");
-  m_cmd_binder.set_handler("show_balance", boost::bind(&simple_wallet::show_balance, this, _1), "Show current wallet balance");
-  m_cmd_binder.set_handler("show_incoming_transfers", boost::bind(&simple_wallet::show_incoming_transfers, this, _1), "Show incoming transfers");
-  m_cmd_binder.set_handler("show_bc_height", boost::bind(&simple_wallet::show_blockchain_height, this, _1), "Show blockchain height");
-  m_cmd_binder.set_handler("transfer", boost::bind(&simple_wallet::transfer, this, _1), "transfer <mixin_count> {<addr> <amount>} Transfer <amount> to <address>. <mixin_count> is the number of transactions yours is indistinguishable from (from 0 to maximum available)");
-  m_cmd_binder.set_handler("set_log", boost::bind(&simple_wallet::set_log, this, _1), "Change current log detalization level, <level> is a number 0-4");
+  m_cmd_binder.set_handler("balance", boost::bind(&simple_wallet::show_balance, this, _1), "Show current wallet balance");
+  m_cmd_binder.set_handler("incoming_transfers", boost::bind(&simple_wallet::show_incoming_transfers, this, _1), "incoming_transfers [available|unavailable] - Show incoming transfers - all of them or filter them by availability");
+  m_cmd_binder.set_handler("bc_height", boost::bind(&simple_wallet::show_blockchain_height, this, _1), "Show blockchain height");
+  m_cmd_binder.set_handler("transfer", boost::bind(&simple_wallet::transfer, this, _1), "transfer <mixin_count> <addr_1> <amount_1> [<addr_2> <amount_2> ... <addr_N> <amount_N>] - Transfer <amount_1>,... <amount_N> to <address_1>,... <address_N>, respectively. <mixin_count> is the number of transactions yours is indistinguishable from (from 0 to maximum available)");
+  m_cmd_binder.set_handler("set_log", boost::bind(&simple_wallet::set_log, this, _1), "set_log <level> - Change current log detalization level, <level> is a number 0-4");
   m_cmd_binder.set_handler("address", boost::bind(&simple_wallet::print_address, this, _1), "Show current wallet public address");
   m_cmd_binder.set_handler("save", boost::bind(&simple_wallet::save, this, _1), "Save wallet synchronized data");
   m_cmd_binder.set_handler("help", boost::bind(&simple_wallet::help, this, _1), "Show this help");
@@ -99,18 +183,18 @@ bool simple_wallet::set_log(const std::vector<std::string> &args)
 {
   if(args.size() != 1) 
   {
-    std::cout << "use: set_log <log_level_number_0-4>" << ENDL;
+    fail_msg_writer() << "use: set_log <log_level_number_0-4>";
     return true;
   }
   uint16_t l = 0;
   if(!string_tools::get_xtype_from_string(l, args[0]))
   {
-    std::cout << "wrong number format, use: set_log <log_level_number_0-4>" << ENDL;
+    fail_msg_writer() << "wrong number format, use: set_log <log_level_number_0-4>";
     return true;
   }
   if(LOG_LEVEL_4 < l)
   {
-    std::cout << "wrong number range, use: set_log <log_level_number_0-4>" << ENDL;
+    fail_msg_writer() << "wrong number range, use: set_log <log_level_number_0-4>";
     return true;
   }
 
@@ -122,19 +206,27 @@ bool simple_wallet::init(const boost::program_options::variables_map& vm)
 {
   handle_command_line(vm);
 
-  CHECK_AND_ASSERT_MES(m_daemon_address.empty() || (m_daemon_host.empty() && !m_daemon_port), false, "you can't specify daemon host or port several times");
+  if (!m_daemon_address.empty() && !m_daemon_host.empty() && 0 != m_daemon_port)
+  {
+    fail_msg_writer() << "you can't specify daemon host or port several times";
+    return false;
+  }
 
   size_t c = 0; 
   if(!m_generate_new.empty()) ++c;
   if(!m_wallet_file.empty()) ++c;
-  CHECK_AND_ASSERT_MES(c == 1, false, "you must specify --wallet-file or --generate-new-wallet params");
+  if (1 != c)
+  {
+    fail_msg_writer() << "you must specify --wallet-file or --generate-new-wallet params";
+    return false;
+  }
 
   if (m_daemon_host.empty())
     m_daemon_host = "localhost";
   if (!m_daemon_port)
     m_daemon_port = RPC_DEFAULT_PORT;
   if (m_daemon_address.empty())
-    m_daemon_address = string("http://") + m_daemon_host + ":" + lexical_cast<string>(m_daemon_port);
+    m_daemon_address = std::string("http://") + m_daemon_host + ":" + std::to_string(m_daemon_port);
 
   tools::password_container pwd_container;
   if (command_line::has_arg(vm, arg_password))
@@ -144,7 +236,11 @@ bool simple_wallet::init(const boost::program_options::variables_map& vm)
   else
   {
     bool r = pwd_container.read_password();
-    CHECK_AND_ASSERT_MES(r, false, "failed to read wallet password");
+    if (!r)
+    {
+      fail_msg_writer() << "failed to read wallet password";
+      return false;
+    }
   }
 
   if (!m_generate_new.empty())
@@ -169,25 +265,22 @@ bool simple_wallet::deinit()
   return close_wallet();
 }
 //----------------------------------------------------------------------------------------------------
-bool simple_wallet::handle_command_line(const boost::program_options::variables_map& vm)
+void simple_wallet::handle_command_line(const boost::program_options::variables_map& vm)
 {
   m_wallet_file    = command_line::get_arg(vm, arg_wallet_file);
   m_generate_new   = command_line::get_arg(vm, arg_generate_new_wallet);
   m_daemon_address = command_line::get_arg(vm, arg_daemon_address);
   m_daemon_host    = command_line::get_arg(vm, arg_daemon_host);
   m_daemon_port    = command_line::get_arg(vm, arg_daemon_port);
-
-  return true;
 }
 //----------------------------------------------------------------------------------------------------
 bool simple_wallet::try_connect_to_daemon()
 {
   if (!m_wallet->check_connection())
   {
-    std::string msg = "wallet failed to connect to daemon (" + m_daemon_address + "). " +
-      "Daemon either is not started or passed wrong port. " +
+    fail_msg_writer() << "wallet failed to connect to daemon (" << m_daemon_address << "). " <<
+      "Daemon either is not started or passed wrong port. " <<
       "Please, make sure that daemon is running or restart the wallet with correct daemon address.";
-    print_fail_msg(msg);
     return false;
   }
   return true;
@@ -196,29 +289,31 @@ bool simple_wallet::try_connect_to_daemon()
 bool simple_wallet::new_wallet(const string &wallet_file, const std::string& password)
 {
   m_wallet_file = wallet_file;
-  if(boost::filesystem::exists(wallet_file))
-  {
-    std::cout << "wallet creation failed, file " << wallet_file << " already exists" << std::endl;
-    return false;
-  }
 
   m_wallet.reset(new tools::wallet2());
-  bool r = m_wallet->generate(wallet_file, password);
-  if(!r)
+  m_wallet->callback(this);
+  try
+  {
+    m_wallet->generate(wallet_file, password);
+    message_writer(epee::log_space::console_color_white, true) << "Generated new wallet: " << m_wallet->get_account().get_public_address_str();
+  }
+  catch (const std::exception& e)
+  {
+    fail_msg_writer() << "failed to generate new wallet: " << e.what();
     return false;
+  }
 
-  cout << "Generated new wallet" << ENDL;
-  print_address(std::vector<std::string>());
-  r = m_wallet->init(m_daemon_address);
-  CHECK_AND_ASSERT_MES(r, false, "failed to init wallet");
-  std::cout << "**********************************************************************" << ENDL 
-    << "Your wallet has been generated. " << ENDL 
-    << "To start synchronizing with the daemon use \"refresh\" command." << ENDL
-    << "Use \"help\" command to see the list of available commands." << ENDL
-    << "Always use \"exit\" command when closing simplewallet to save "
-    << "current session's state. Otherwise, you will possibly need to synchronize " << ENDL 
-    << "your wallet again. Your wallet key is NOT under risk anyway." << ENDL 
-    << "**********************************************************************" << ENDL;
+  m_wallet->init(m_daemon_address);
+
+  success_msg_writer() <<
+    "**********************************************************************\n" <<
+    "Your wallet has been generated.\n" <<
+    "To start synchronizing with the daemon use \"refresh\" command.\n" <<
+    "Use \"help\" command to see the list of available commands.\n" <<
+    "Always use \"exit\" command when closing simplewallet to save\n" <<
+    "current session's state. Otherwise, you will possibly need to synchronize \n" <<
+    "your wallet again. Your wallet key is NOT under risk anyway.\n" <<
+    "**********************************************************************";
   return true;
 }
 //----------------------------------------------------------------------------------------------------
@@ -226,35 +321,63 @@ bool simple_wallet::open_wallet(const string &wallet_file, const std::string& pa
 {
   m_wallet_file = wallet_file;
   m_wallet.reset(new tools::wallet2());
+  m_wallet->callback(this);
 
-  bool r = m_wallet->load(m_wallet_file, password);
-  CHECK_AND_ASSERT_MES(r, false, "failed to load wallet " + m_wallet_file);
-  r = m_wallet->init(m_daemon_address);
-  CHECK_AND_ASSERT_MES(r, false, "failed to init wallet");
+  try
+  {
+    m_wallet->load(m_wallet_file, password);
+    message_writer(epee::log_space::console_color_white, true) << "Opened wallet: " << m_wallet->get_account().get_public_address_str();
+  }
+  catch (const std::exception& e)
+  {
+    fail_msg_writer() << "failed to load wallet: " << e.what();
+    return false;
+  }
+
+  m_wallet->init(m_daemon_address);
 
   refresh(std::vector<std::string>());
-  std::cout << "**********************************************************************" << ENDL 
-    << "Use \"help\" command to see the list of available commands." << ENDL 
-    << "**********************************************************************" << ENDL ;
+  success_msg_writer() <<
+    "**********************************************************************\n" <<
+    "Use \"help\" command to see the list of available commands.\n" <<
+    "**********************************************************************";
   return true;
 }
 //----------------------------------------------------------------------------------------------------
 bool simple_wallet::close_wallet()
 {
   bool r = m_wallet->deinit();
-  CHECK_AND_ASSERT_MES(r, false, "failed to deinit wallet");
-  r = m_wallet->store();
-  CHECK_AND_ASSERT_MES(r, false, "failed to store wallet " + m_wallet_file);
+  if (!r)
+  {
+    fail_msg_writer() << "failed to deinit wallet";
+    return false;
+  }
+
+  try
+  {
+    m_wallet->store();
+  }
+  catch (const std::exception& e)
+  {
+    fail_msg_writer() << e.what();
+    return false;
+  }
+
   return true;
 }
 //----------------------------------------------------------------------------------------------------
 bool simple_wallet::save(const std::vector<std::string> &args)
 {
-  bool r = m_wallet->store();
-  if (r)
-    print_success_msg("Wallet data saved");
-  else
-    print_fail_msg("failed to store wallet " + m_wallet_file);
+  try
+  {
+    m_wallet->store();
+    success_msg_writer() << "Wallet data saved";
+  }
+  catch (const std::exception& e)
+  {
+    fail_msg_writer() << e.what();
+  }
+
   return true;
 }
 //----------------------------------------------------------------------------------------------------
@@ -276,24 +399,24 @@ bool simple_wallet::start_mining(const std::vector<std::string>& args)
     bool ok = string_tools::get_xtype_from_string(num, args[0]);
     if(!ok || 0 == num)
     {
-      print_fail_msg("wrong number of mining threads: \"" + args[0] + "\"");
+      fail_msg_writer() << "wrong number of mining threads: \"" << args[0] << "\"";
       return true;
     }
     req.threads_count = num;
   }
   else
   {
-    print_fail_msg("wrong number of arguments, expected the number of mining threads");
+    fail_msg_writer() << "wrong number of arguments, expected the number of mining threads";
     return true;
   }
 
   COMMAND_RPC_START_MINING::response res;
   bool r = net_utils::invoke_http_json_remote_command2(m_daemon_address + "/start_mining", req, res, m_http_client);
-  std::string err = tools::interpret_rpc_response(r, res.status);
+  std::string err = interpret_rpc_response(r, res.status);
   if (err.empty())
-    print_success_msg("Mining started in daemon");
+    success_msg_writer() << "Mining started in daemon";
   else
-    print_fail_msg("mining has NOT been started: " + err);
+    fail_msg_writer() << "mining has NOT been started: " << err;
   return true;
 }
 //----------------------------------------------------------------------------------------------------
@@ -305,82 +428,158 @@ bool simple_wallet::stop_mining(const std::vector<std::string>& args)
   COMMAND_RPC_STOP_MINING::request req;
   COMMAND_RPC_STOP_MINING::response res;
   bool r = net_utils::invoke_http_json_remote_command2(m_daemon_address + "/stop_mining", req, res, m_http_client);
-  std::string err = tools::interpret_rpc_response(r, res.status);
+  std::string err = interpret_rpc_response(r, res.status);
   if (err.empty())
-    print_success_msg("Mining stopped in daemon");
+    success_msg_writer() << "Mining stopped in daemon";
   else
-    print_fail_msg("mining has NOT been stopped: " + err);
+    fail_msg_writer() << "mining has NOT been stopped: " << err;
   return true;
 }
 //----------------------------------------------------------------------------------------------------
+void simple_wallet::on_new_block(uint64_t height, const cryptonote::block& block)
+{
+  m_refresh_progress_reporter.update(height, false);
+}
+//----------------------------------------------------------------------------------------------------
+void simple_wallet::on_money_received(uint64_t height, const cryptonote::transaction& tx, size_t out_index)
+{
+  message_writer(epee::log_space::console_color_green, false) <<
+    "Height " << height <<
+    ", transaction " << get_transaction_hash(tx) <<
+    ", received " << print_money(tx.vout[out_index].amount);
+  m_refresh_progress_reporter.update(height, true);
+}
+//----------------------------------------------------------------------------------------------------
+void simple_wallet::on_money_spent(uint64_t height, const cryptonote::transaction& in_tx, size_t out_index, const cryptonote::transaction& spend_tx)
+{
+  message_writer(epee::log_space::console_color_magenta, false) <<
+    "Height " << height <<
+    ", transaction " << get_transaction_hash(spend_tx) <<
+    ", spent " << print_money(in_tx.vout[out_index].amount);
+  m_refresh_progress_reporter.update(height, true);
+}
+//----------------------------------------------------------------------------------------------------
 bool simple_wallet::refresh(const std::vector<std::string>& args)
 {
   if (!try_connect_to_daemon())
     return true;
 
-  std::cout << "Starting refresh..." << endl;
-  std::atomic<bool> refresh_is_done(false);
-  std::thread th([&]()
-  {
-    epee::misc_utils::sleep_no_w(1000);
-    while(!refresh_is_done)
-    {
-      std::string err;
-      uint64_t bc_height = get_daemon_blockchain_height(err);
-      if (err.empty())
-        cout << "Height " << m_wallet->get_blockchain_current_height() << " of " << bc_height << endl;
-      epee::misc_utils::sleep_no_w(1000);
-    }
-  });
-  uint64_t initial_height = m_wallet->get_blockchain_current_height();
+  message_writer() << "Starting refresh...";
   uint64_t fetched_blocks = 0;
-  bool money_received = false;
-  tools::wallet2::fail_details fd;
-  bool ok = m_wallet->refresh(fetched_blocks, money_received, fd);
-  refresh_is_done = true;
-  th.join();
-  if (ok)
+  bool ok = false;
+  std::ostringstream ss;
+  try
   {
-    std::stringstream ss;
-    ss << "Refresh done, blocks received: " << fetched_blocks;
-    print_success_msg(ss.str(), true);
-
+    m_wallet->refresh(fetched_blocks);
+    ok = true;
+    // Clear line "Height xxx of xxx"
+    std::cout << "\r                                                                \r";
+    success_msg_writer(true) << "Refresh done, blocks received: " << fetched_blocks;
     show_balance();
   }
-  else
+  catch (const tools::error::daemon_busy&)
+  {
+    ss << "daemon is busy. Please try later";
+  }
+  catch (const tools::error::no_connection_to_daemon&)
+  {
+    ss << "no connection to daemon. Please, make sure daemon is running";
+  }
+  catch (const tools::error::wallet_rpc_error& e)
+  {
+    LOG_ERROR("Unknown RPC error: " << e.to_string());
+    ss << "RPC error \"" << e.what() << '"';
+  }
+  catch (const tools::error::refresh_error& e)
+  {
+    LOG_ERROR("refresh error: " << e.to_string());
+    ss << e.what();
+  }
+  catch (const tools::error::wallet_internal_error& e)
   {
-    fetched_blocks = m_wallet->get_blockchain_current_height() - initial_height;
-    std::stringstream ss;
-    ss << "refresh failed: " << fd.what() << ". Blocks received: " << fetched_blocks;
-    print_fail_msg(ss.str());
+    LOG_ERROR("internal error: " << e.to_string());
+    ss << "internal error: " << e.what();
   }
+  catch (const std::exception& e)
+  {
+    LOG_ERROR("unexpected error: " << e.what());
+    ss << "unexpected error: " << e.what();
+  }
+  catch (...)
+  {
+    LOG_ERROR("Unknown error");
+    ss << "unknown error";
+  }
+
+  if (!ok)
+  {
+    fail_msg_writer() << "refresh failed: " << ss.str() << ". Blocks received: " << fetched_blocks;
+  }
+
   return true;
 }
 //----------------------------------------------------------------------------------------------------
 bool simple_wallet::show_balance(const std::vector<std::string>& args/* = std::vector<std::string>()*/)
 {
-  std::stringstream ss;
-  ss << "balance: " << print_money(m_wallet->balance()) << ", unlocked balance: " << print_money(m_wallet->unlocked_balance());
-  print_success_msg(ss.str());
+  success_msg_writer() << "balance: " << print_money(m_wallet->balance()) << ", unlocked balance: " << print_money(m_wallet->unlocked_balance());
   return true;
 }
 //----------------------------------------------------------------------------------------------------
 bool simple_wallet::show_incoming_transfers(const std::vector<std::string>& args)
 {
-  std::cout << "        amount       \tspent\tglobal index\t                              tx id" << std::endl;
-  bool ok = m_wallet->enum_incoming_transfers([](const cryptonote::transaction& tx, uint64_t global_out_index, uint64_t amount, bool spent) {
-    epee::log_space::set_console_color(spent ? epee::log_space::console_color_magenta : epee::log_space::console_color_green, true);
-    std::cout << std::setw(21) << print_money(amount) << '\t'
-      << std::setw(3) << (spent ? 'T' : 'F') << "  \t"
-      << std::setw(12) << global_out_index << '\t'
-      << get_transaction_hash(tx)
-      << '\n';
-  });
-  epee::log_space::reset_console_color();
-  if (ok)
-    std::cout.flush();
-  else
-    print_fail_msg("No incoming transfers");
+  bool filter = false;
+  bool available = false;
+  if (!args.empty())
+  {
+    if (args[0] == "available")
+    {
+      filter = true;
+      available = true;
+    }
+    else if (args[0] == "unavailable")
+    {
+      filter = true;
+      available = false;
+    }
+  }
+
+  tools::wallet2::transfer_container transfers;
+  m_wallet->get_transfers(transfers);
+
+  bool transfers_found = false;
+  for (const auto& td : transfers)
+  {
+    if (!filter || available != td.m_spent)
+    {
+      if (!transfers_found)
+      {
+        message_writer() << "        amount       \tspent\tglobal index\t                              tx id";
+        transfers_found = true;
+      }
+      message_writer(td.m_spent ? epee::log_space::console_color_magenta : epee::log_space::console_color_green, false) <<
+        std::setw(21) << print_money(td.amount()) << '\t' <<
+        std::setw(3) << (td.m_spent ? 'T' : 'F') << "  \t" <<
+        std::setw(12) << td.m_global_output_index << '\t' <<
+        get_transaction_hash(td.m_tx);
+    }
+  }
+
+  if (!transfers_found)
+  {
+    if (!filter)
+    {
+      success_msg_writer() << "No incoming transfers";
+    }
+    else if (available)
+    {
+      success_msg_writer() << "No incoming available transfers";
+    }
+    else
+    {
+      success_msg_writer() << "No incoming unavailable transfers";
+    }
+  }
+
   return true;
 }
 //----------------------------------------------------------------------------------------------------
@@ -389,7 +588,7 @@ uint64_t simple_wallet::get_daemon_blockchain_height(std::string& err)
   COMMAND_RPC_GET_HEIGHT::request req;
   COMMAND_RPC_GET_HEIGHT::response res = boost::value_initialized<COMMAND_RPC_GET_HEIGHT::response>();
   bool r = net_utils::invoke_http_json_remote_command2(m_daemon_address + "/getheight", req, res, m_http_client);
-  err = tools::interpret_rpc_response(r, res.status);
+  err = interpret_rpc_response(r, res.status);
   return res.height;
 }
 //----------------------------------------------------------------------------------------------------
@@ -401,9 +600,9 @@ bool simple_wallet::show_blockchain_height(const std::vector<std::string>& args)
   std::string err;
   uint64_t bc_height = get_daemon_blockchain_height(err);
   if (err.empty())
-    print_success_msg(boost::lexical_cast<std::string>(bc_height));
+    success_msg_writer() << bc_height;
   else
-    print_fail_msg("failed to get blockchain height: " + err);
+    fail_msg_writer() << "failed to get blockchain height: " << err;
   return true;
 }
 //----------------------------------------------------------------------------------------------------
@@ -415,65 +614,132 @@ bool simple_wallet::transfer(const std::vector<std::string> &args_)
   std::vector<std::string> local_args = args_;
   if(local_args.size() < 3)
   {
-    print_fail_msg("wrong number of arguments, expected at least 3, got " + boost::lexical_cast<std::string>(local_args.size()));
+    fail_msg_writer() << "wrong number of arguments, expected at least 3, got " << local_args.size();
     return true;
   }
 
   size_t fake_outs_count;
   if(!string_tools::get_xtype_from_string(fake_outs_count, local_args[0]))
   {
-    print_fail_msg("mixin_count should be non-negative integer, got " + local_args[0]);
+    fail_msg_writer() << "mixin_count should be non-negative integer, got " << local_args[0];
     return true;
   }
-  local_args.erase(local_args.begin());
 
   vector<cryptonote::tx_destination_entry> dsts;
-  uint64_t summary_amount = 0;
-  for (size_t i = 0; i < local_args.size(); i += 2) 
+  for (size_t i = 1; i < local_args.size(); i += 2) 
   {
     cryptonote::tx_destination_entry de;
     if(!get_account_address_from_str(de.addr, local_args[i]))
     {
-      print_fail_msg("wrong address: " + local_args[i]);
+      fail_msg_writer() << "wrong address: " << local_args[i];
       return true;
     }
 
     if (local_args.size() <= i + 1)
     {
-      print_fail_msg("amount for the last address " + local_args[i] + " is not specified");
+      fail_msg_writer() << "amount for the last address " << local_args[i] << " is not specified";
       return true;
     }
 
     bool ok = cryptonote::parse_amount(de.amount, local_args[i + 1]);
     if(!ok || 0 == de.amount)
     {
-      print_fail_msg("amount is wrong: " + local_args[i] + " " + local_args[i + 1]);
+      fail_msg_writer() << "amount is wrong: " << local_args[i] << ' ' << local_args[i + 1] <<
+        ", expected number from 0 to " << print_money(std::numeric_limits<uint64_t>::max());
       return true;
     }
 
-    summary_amount += de.amount;
     dsts.push_back(de);
   }
 
-  if(summary_amount > m_wallet->unlocked_balance())
+  try
   {
-    print_fail_msg("not enough money to transfer " + print_money(summary_amount) + ", available (unlocked) only " + print_money(m_wallet->unlocked_balance()));
-    return true;
+    cryptonote::transaction tx;
+    m_wallet->transfer(dsts, fake_outs_count, 0, DEFAULT_FEE, tx);
+    success_msg_writer(true) << "Money successfully sent, transaction " << get_transaction_hash(tx);
+  }
+  catch (const tools::error::daemon_busy&)
+  {
+    fail_msg_writer() << "daemon is busy. Please try later";
+  }
+  catch (const tools::error::no_connection_to_daemon&)
+  {
+    fail_msg_writer() << "no connection to daemon. Please, make sure daemon is running.";
+  }
+  catch (const tools::error::wallet_rpc_error& e)
+  {
+    LOG_ERROR("Unknown RPC error: " << e.to_string());
+    fail_msg_writer() << "RPC error \"" << e.what() << '"';
+  }
+  catch (const tools::error::get_random_outs_error&)
+  {
+    fail_msg_writer() << "failed to get random outputs to mix";
+  }
+  catch (const tools::error::not_enough_money& e)
+  {
+    fail_msg_writer() << "not enough money to transfer, available only " << print_money(e.available()) <<
+      ", transaction amount " << print_money(e.tx_amount() + e.fee()) << " = " << print_money(e.tx_amount()) <<
+      " + " << print_money(e.fee()) << " (fee)";
+  }
+  catch (const tools::error::not_enough_outs_to_mix& e)
+  {
+    auto writer = fail_msg_writer();
+    writer << "not enough outputs for specified mixin_count = " << e.mixin_count() << ":";
+    for (const cryptonote::COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::outs_for_amount& outs_for_amount : e.scanty_outs())
+    {
+      writer << "\noutput amount = " << print_money(outs_for_amount.amount) << ", fount outputs to mix = " << outs_for_amount.outs.size();
+    }
+  }
+  catch (const tools::error::tx_not_constructed&)
+  {
+    fail_msg_writer() << "transaction was not constructed";
+  }
+  catch (const tools::error::tx_rejected& e)
+  {
+    fail_msg_writer() << "transaction " << get_transaction_hash(e.tx()) << " was rejected by daemon with status \"" << e.status() << '"';
+  }
+  catch (const tools::error::tx_sum_overflow& e)
+  {
+    fail_msg_writer() << e.what();
+  }
+  catch (const tools::error::tx_too_big& e)
+  {
+    cryptonote::transaction tx = e.tx();
+    fail_msg_writer() << "transaction " << get_transaction_hash(e.tx()) << " is too big. Transaction size: " <<
+      get_object_blobsize(e.tx()) << " bytes, transaction size limit: " << e.tx_size_limit() << " bytes";
+  }
+  catch (const tools::error::zero_destination&)
+  {
+    fail_msg_writer() << "one of destinations is zero";
+  }
+  catch (const tools::error::transfer_error& e)
+  {
+    LOG_ERROR("unknown transfer error: " << e.to_string());
+    fail_msg_writer() << "unknown transfer error: " << e.what();
+  }
+  catch (const tools::error::wallet_internal_error& e)
+  {
+    LOG_ERROR("internal error: " << e.to_string());
+    fail_msg_writer() << "internal error: " << e.what();
+  }
+  catch (const std::exception& e)
+  {
+    LOG_ERROR("unexpected error: " << e.what());
+    fail_msg_writer() << "unexpected error: " << e.what();
+  }
+  catch (...)
+  {
+    LOG_ERROR("Unknown error");
+    fail_msg_writer() << "unknown error";
   }
 
-  cryptonote::transaction tx;
-  tools::wallet2::fail_details tfd;
-  bool ok = m_wallet->transfer(dsts, fake_outs_count, 0, DEFAULT_FEE, tx, tfd);
-  if (ok)
-    print_success_msg("Money successfully sent", true);
-  else
-    print_fail_msg("failed to transfer money: " + tfd.what());
   return true;
 }
 //----------------------------------------------------------------------------------------------------
 bool simple_wallet::run()
 {
-  return m_cmd_binder.run_handling("[wallet]# ", "");
+  std::string addr_start = m_wallet->get_account().get_public_address_str().substr(0, 6);
+  return m_cmd_binder.run_handling("[wallet " + addr_start + "]: ", "");
 }
 //----------------------------------------------------------------------------------------------------
 void simple_wallet::stop()
@@ -482,9 +748,9 @@ void simple_wallet::stop()
   m_wallet->stop();
 }
 //----------------------------------------------------------------------------------------------------
-bool simple_wallet::print_address(const std::vector<std::string> &args)
+bool simple_wallet::print_address(const std::vector<std::string> &args/* = std::vector<std::string>()*/)
 {
-  print_success_msg(m_wallet->get_account().get_public_address_str());
+  success_msg_writer() << m_wallet->get_account().get_public_address_str();
   return true;
 }
 //----------------------------------------------------------------------------------------------------
@@ -495,7 +761,6 @@ bool simple_wallet::process_command(const std::vector<std::string> &args)
 //----------------------------------------------------------------------------------------------------
 int main(int argc, char* argv[])
 {
-
 #ifdef WIN32
   _CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
 #endif
@@ -517,6 +782,7 @@ int main(int argc, char* argv[])
   command_line::add_arg(desc_params, arg_daemon_port);
   command_line::add_arg(desc_params, arg_command);
   command_line::add_arg(desc_params, arg_log_level);
+  tools::wallet_rpc_server::init_options(desc_params);
 
   po::positional_options_description positional_options;
   positional_options.add(arg_command.name, -1);
@@ -531,13 +797,13 @@ int main(int argc, char* argv[])
 
     if (command_line::get_arg(vm, command_line::arg_help))
     {
-      std::cout << "Usage: simplewallet [--wallet-file=<file>|--generate-new-wallet=<file>] [--daemon-address=<host>:<port>] [<COMMAND>]\n";
-      std::cout << desc_all << '\n' << w.get_commands_str() << std::endl;
+      success_msg_writer() << "Usage: simplewallet [--wallet-file=<file>|--generate-new-wallet=<file>] [--daemon-address=<host>:<port>] [<COMMAND>]";
+      success_msg_writer() << desc_all << '\n' << w.get_commands_str();
       return false;
     }
     else if (command_line::get_arg(vm, command_line::arg_version))
     {
-      std::cout << CRYPTONOTE_NAME << " wallet v" << PROJECT_VERSION_LONG << ENDL;
+      success_msg_writer() << CRYPTONOTE_NAME << " wallet v" << PROJECT_VERSION_LONG;
       return false;
     }
 
@@ -551,33 +817,104 @@ int main(int argc, char* argv[])
 
   //set up logging options
   log_space::get_set_log_detalisation_level(true, LOG_LEVEL_2);
-  log_space::log_singletone::add_logger(LOGGER_CONSOLE, NULL, NULL, LOG_LEVEL_0);
+  //log_space::log_singletone::add_logger(LOGGER_CONSOLE, NULL, NULL, LOG_LEVEL_0);
   log_space::log_singletone::add_logger(LOGGER_FILE,
     log_space::log_singletone::get_default_log_file().c_str(),
     log_space::log_singletone::get_default_log_folder().c_str(), LOG_LEVEL_4);
 
-  LOG_PRINT_L0(CRYPTONOTE_NAME << " wallet v" << PROJECT_VERSION_LONG);
+  message_writer(epee::log_space::console_color_white, true) << CRYPTONOTE_NAME << " wallet v" << PROJECT_VERSION_LONG;
 
   if(command_line::has_arg(vm, arg_log_level))
   {
     LOG_PRINT_L0("Setting log level = " << command_line::get_arg(vm, arg_log_level));
     log_space::get_set_log_detalisation_level(true, command_line::get_arg(vm, arg_log_level));
   }
+  
+  if(command_line::has_arg(vm, tools::wallet_rpc_server::arg_rpc_bind_port))
+  {
+    log_space::log_singletone::add_logger(LOGGER_CONSOLE, NULL, NULL, LOG_LEVEL_2);
+    //runs wallet with rpc interface 
+    if(!command_line::has_arg(vm, arg_wallet_file) )
+    {
+      LOG_ERROR("Wallet file not set.");
+      return 1;
+    }
+    if(!command_line::has_arg(vm, arg_daemon_address) )
+    {
+      LOG_ERROR("Daemon address not set.");
+      return 1;
+    }
+    if(!command_line::has_arg(vm, arg_password) )
+    {
+      LOG_ERROR("Wallet password not set.");
+      return 1;
+    }
 
-  r = w.init(vm);
-  CHECK_AND_ASSERT_MES(r, 1, "Failed to initialize wallet");
-
-  std::vector<std::string> command = command_line::get_arg(vm, arg_command);
-  if (!command.empty())
-    w.process_command(command);
+    std::string wallet_file     = command_line::get_arg(vm, arg_wallet_file);    
+    std::string wallet_password = command_line::get_arg(vm, arg_password);
+    std::string daemon_address  = command_line::get_arg(vm, arg_daemon_address);
+    std::string daemon_host = command_line::get_arg(vm, arg_daemon_host);
+    int daemon_port = command_line::get_arg(vm, arg_daemon_port);
+    if (daemon_host.empty())
+      daemon_host = "localhost";
+    if (!daemon_port)
+      daemon_port = RPC_DEFAULT_PORT;
+    if (daemon_address.empty())
+      daemon_address = std::string("http://") + daemon_host + ":" + std::to_string(daemon_port);
+
+    tools::wallet2 wal;
+    try
+    {
+      LOG_PRINT_L0("Loading wallet...");
+      wal.load(wallet_file, wallet_password);
+      wal.init(daemon_address);
+      wal.refresh();
+      LOG_PRINT_GREEN("Loaded ok", LOG_LEVEL_0);
+    }
+    catch (const std::exception& e)
+    {
+      LOG_ERROR("Wallet initialize failed: " << e.what());
+      return 1;
+    }
+    tools::wallet_rpc_server wrpc(wal);
+    bool r = wrpc.init(vm);
+    CHECK_AND_ASSERT_MES(r, 1, "Failed to initialize wallet rpc server");
+
+    tools::signal_handler::install([&wrpc, &wal] {
+      wrpc.send_stop_signal();
+      wal.store();
+    });
+    LOG_PRINT_L0("Starting wallet rpc server");
+    wrpc.run();
+    LOG_PRINT_L0("Stopped wallet rpc server");
+    try
+    {
+      LOG_PRINT_L0("Storing wallet...");
+      wal.store();
+      LOG_PRINT_GREEN("Stored ok", LOG_LEVEL_0);
+    }
+    catch (const std::exception& e)
+    {
+      LOG_ERROR("Failed to store wallet: " << e.what());
+      return 1;
+    }
+  }else
+  {
+    //runs wallet with console interface 
+    r = w.init(vm);
+    CHECK_AND_ASSERT_MES(r, 1, "Failed to initialize wallet");
 
-  tools::signal_handler::install([&w] {
-    w.stop();
-  });
-  w.run();
+    std::vector<std::string> command = command_line::get_arg(vm, arg_command);
+    if (!command.empty())
+      w.process_command(command);
 
-  w.deinit();
+    tools::signal_handler::install([&w] {
+      w.stop();
+    });
+    w.run();
 
+    w.deinit();
+  }
   return 1;
   //CATCH_ENTRY_L0("main", 1);
 }