11 files changed, 193 insertions, 91 deletions
diff --git a/src/daemon/command_line_args.h b/src/daemon/command_line_args.h
index ee6167b6a..add752029 100644
--- a/src/daemon/command_line_args.h
+++ b/src/daemon/command_line_args.h
@@ -31,20 +31,41 @@
 
 #include "common/command_line.h"
 #include "cryptonote_config.h"
+#include "daemonizer/daemonizer.h"
 
 namespace daemon_args
 {
   std::string const WINDOWS_SERVICE_NAME = "Monero Daemon";
 
-  const command_line::arg_descriptor<std::string> arg_config_file = {
+  const command_line::arg_descriptor<std::string, false, true, 2> arg_config_file = {
     "config-file"
   , "Specify configuration file"
-  , std::string(CRYPTONOTE_NAME ".conf")
+  , (daemonizer::get_default_data_dir() / std::string(CRYPTONOTE_NAME ".conf")).string()
+  , {{ &cryptonote::arg_testnet_on, &cryptonote::arg_stagenet_on }}
+  , [](std::array<bool, 2> testnet_stagenet, bool defaulted, std::string val) {
+      if (testnet_stagenet[0] && defaulted)
+        return (daemonizer::get_default_data_dir() / "testnet" /
+                std::string(CRYPTONOTE_NAME ".conf")).string();
+      else if (testnet_stagenet[1] && defaulted)
+        return (daemonizer::get_default_data_dir() / "stagenet" /
+                std::string(CRYPTONOTE_NAME ".conf")).string();
+      return val;
+    }
   };
-  const command_line::arg_descriptor<std::string> arg_log_file = {
+  const command_line::arg_descriptor<std::string, false, true, 2> arg_log_file = {
     "log-file"
   , "Specify log file"
-  , ""
+  , (daemonizer::get_default_data_dir() / std::string(CRYPTONOTE_NAME ".log")).string()
+  , {{ &cryptonote::arg_testnet_on, &cryptonote::arg_stagenet_on }}
+  , [](std::array<bool, 2> testnet_stagenet, bool defaulted, std::string val) {
+      if (testnet_stagenet[0] && defaulted)
+        return (daemonizer::get_default_data_dir() / "testnet" /
+                std::string(CRYPTONOTE_NAME ".log")).string();
+      else if (testnet_stagenet[1] && defaulted)
+        return (daemonizer::get_default_data_dir() / "stagenet" /
+                std::string(CRYPTONOTE_NAME ".log")).string();
+      return val;
+    }
   };
   const command_line::arg_descriptor<std::size_t> arg_max_log_file_size = {
     "max-log-file-size"
@@ -76,16 +97,18 @@ namespace daemon_args
       , "127.0.0.1"
   };
 
-  const command_line::arg_descriptor<std::string> arg_zmq_rpc_bind_port = {
+  const command_line::arg_descriptor<std::string, false, true, 2> arg_zmq_rpc_bind_port = {
     "zmq-rpc-bind-port"
-      , "Port for ZMQ RPC server to listen on"
-      , std::to_string(config::ZMQ_RPC_DEFAULT_PORT)
-  };
-
-  const command_line::arg_descriptor<std::string> arg_zmq_testnet_rpc_bind_port = {
-    "zmq-testnet-rpc-bind-port"
-      , "Port for testnet ZMQ RPC server to listen on"
-      , std::to_string(config::testnet::ZMQ_RPC_DEFAULT_PORT)
+  , "Port for ZMQ RPC server to listen on"
+  , std::to_string(config::ZMQ_RPC_DEFAULT_PORT)
+  , {{ &cryptonote::arg_testnet_on, &cryptonote::arg_stagenet_on }}
+  , [](std::array<bool, 2> testnet_stagenet, bool defaulted, std::string val) {
+      if (testnet_stagenet[0] && defaulted)
+        return std::to_string(config::testnet::ZMQ_RPC_DEFAULT_PORT);
+      if (testnet_stagenet[1] && defaulted)
+        return std::to_string(config::stagenet::ZMQ_RPC_DEFAULT_PORT);
+      return val;
+    }
   };
 
 }  // namespace daemon_args
diff --git a/src/daemon/command_parser_executor.cpp b/src/daemon/command_parser_executor.cpp
index 3ec74ff79..7a89ebc0c 100644
--- a/src/daemon/command_parser_executor.cpp
+++ b/src/daemon/command_parser_executor.cpp
@@ -268,30 +268,44 @@ bool t_command_parser_executor::start_mining(const std::vector<std::string>& arg
   }
 
   cryptonote::address_parse_info info;
-  bool testnet = false;
-  if(!cryptonote::get_account_address_from_str(info, false, args.front()))
+  cryptonote::network_type nettype = cryptonote::MAINNET;
+  if(!cryptonote::get_account_address_from_str(info, cryptonote::MAINNET, args.front()))
   {
-    if(!cryptonote::get_account_address_from_str(info, true, args.front()))
+    if(!cryptonote::get_account_address_from_str(info, cryptonote::TESTNET, args.front()))
     {
-      bool dnssec_valid;
-      std::string address_str = tools::dns_utils::get_account_address_as_str_from_url(args.front(), dnssec_valid,
-          [](const std::string &url, const std::vector<std::string> &addresses, bool dnssec_valid){return addresses[0];});
-      if(!cryptonote::get_account_address_from_str(info, false, address_str))
+      if(!cryptonote::get_account_address_from_str(info, cryptonote::STAGENET, args.front()))
       {
-        if(!cryptonote::get_account_address_from_str(info, true, address_str))
+        bool dnssec_valid;
+        std::string address_str = tools::dns_utils::get_account_address_as_str_from_url(args.front(), dnssec_valid,
+            [](const std::string &url, const std::vector<std::string> &addresses, bool dnssec_valid){return addresses[0];});
+        if(!cryptonote::get_account_address_from_str(info, cryptonote::MAINNET, address_str))
         {
-          std::cout << "target account address has wrong format" << std::endl;
-          return true;
-        }
-        else
-        {
-          testnet = true;
+          if(!cryptonote::get_account_address_from_str(info, cryptonote::TESTNET, address_str))
+          {
+            if(!cryptonote::get_account_address_from_str(info, cryptonote::STAGENET, address_str))
+            {
+              std::cout << "target account address has wrong format" << std::endl;
+              return true;
+            }
+            else
+            {
+              nettype = cryptonote::STAGENET;
+            }
+          }
+          else
+          {
+            nettype = cryptonote::TESTNET;
+          }
         }
       }
+      else
+      {
+        nettype = cryptonote::STAGENET;
+      }
     }
     else
     {
-      testnet = true;
+      nettype = cryptonote::TESTNET;
     }
   }
   if (info.is_subaddress)
@@ -299,8 +313,8 @@ bool t_command_parser_executor::start_mining(const std::vector<std::string>& arg
     tools::fail_msg_writer() << "subaddress for mining reward is not yet supported!" << std::endl;
     return true;
   }
-  if(testnet)
-    std::cout << "Mining to a testnet address, make sure this is intentional!" << std::endl;
+  if(nettype != cryptonote::MAINNET)
+    std::cout << "Mining to a " << (nettype == cryptonote::TESTNET ? "testnet" : "stagenet") << "address, make sure this is intentional!" << std::endl;
   uint64_t threads_count = 1;
   bool do_background_mining = false;  
   bool ignore_battery = false;  
@@ -325,7 +339,7 @@ bool t_command_parser_executor::start_mining(const std::vector<std::string>& arg
     threads_count = (ok && 0 < threads_count) ? threads_count : 1;
   }
 
-  m_executor.start_mining(info.address, threads_count, testnet, do_background_mining, ignore_battery);
+  m_executor.start_mining(info.address, threads_count, nettype, do_background_mining, ignore_battery);
 
   return true;
 }
@@ -428,6 +442,23 @@ bool t_command_parser_executor::out_peers(const std::vector<std::string>& args)
 	return m_executor.out_peers(limit);
 }
 
+bool t_command_parser_executor::in_peers(const std::vector<std::string>& args)
+{
+	if (args.empty()) return false;
+
+	unsigned int limit;
+	try {
+		limit = std::stoi(args[0]);
+	}
+
+	catch(const std::exception& ex) {
+		_erro("stoi exception");
+		return false;
+	}
+
+	return m_executor.in_peers(limit);
+}
+
 bool t_command_parser_executor::start_save_graph(const std::vector<std::string>& args)
 {
 	if (!args.empty()) return false;
diff --git a/src/daemon/command_parser_executor.h b/src/daemon/command_parser_executor.h
index 37e900b8f..2c09a4748 100644
--- a/src/daemon/command_parser_executor.h
+++ b/src/daemon/command_parser_executor.h
@@ -108,7 +108,9 @@ public:
   bool set_limit_down(const std::vector<std::string>& args);
 
   bool out_peers(const std::vector<std::string>& args);
-  
+
+  bool in_peers(const std::vector<std::string>& args);
+
   bool start_save_graph(const std::vector<std::string>& args);
   
   bool stop_save_graph(const std::vector<std::string>& args);
diff --git a/src/daemon/command_server.cpp b/src/daemon/command_server.cpp
index 1f8981fa2..a50dbea69 100644
--- a/src/daemon/command_server.cpp
+++ b/src/daemon/command_server.cpp
@@ -197,6 +197,12 @@ t_command_server::t_command_server(
     , "Set the <max_number> of out peers."
     );
     m_command_lookup.set_handler(
+      "in_peers"
+    , std::bind(&t_command_parser_executor::in_peers, &m_parser, p::_1)
+    , "in_peers <max_number>"
+    , "Set the <max_number> of in peers."
+    );
+    m_command_lookup.set_handler(
       "start_save_graph"
     , std::bind(&t_command_parser_executor::start_save_graph, &m_parser, p::_1)
     , "Start saving data for dr monero."
diff --git a/src/daemon/core.h b/src/daemon/core.h
index f00dffccc..475f418d6 100644
--- a/src/daemon/core.h
+++ b/src/daemon/core.h
@@ -69,10 +69,12 @@ public:
   std::string get_config_subdir() const
   {
     bool testnet = command_line::get_arg(m_vm_HACK, cryptonote::arg_testnet_on);
-    auto p2p_bind_arg = testnet ? nodetool::arg_testnet_p2p_bind_port : nodetool::arg_p2p_bind_port;
-    std::string port = command_line::get_arg(m_vm_HACK, p2p_bind_arg);
-    if ((!testnet && port != std::to_string(::config::P2P_DEFAULT_PORT))
-        || (testnet && port != std::to_string(::config::testnet::P2P_DEFAULT_PORT))) {
+    bool stagenet = command_line::get_arg(m_vm_HACK, cryptonote::arg_stagenet_on);
+    bool mainnet = !testnet && !stagenet;
+    std::string port = command_line::get_arg(m_vm_HACK, nodetool::arg_p2p_bind_port);
+    if ((mainnet && port != std::to_string(::config::P2P_DEFAULT_PORT))
+        || (testnet && port != std::to_string(::config::testnet::P2P_DEFAULT_PORT))
+        || (stagenet && port != std::to_string(::config::stagenet::P2P_DEFAULT_PORT))) {
       return port;
     }
     return std::string();
diff --git a/src/daemon/daemon.cpp b/src/daemon/daemon.cpp
index 2d662b7d3..48671f190 100644
--- a/src/daemon/daemon.cpp
+++ b/src/daemon/daemon.cpp
@@ -68,7 +68,7 @@ public:
       boost::program_options::variables_map const & vm
     )
     : core{vm}
-    , protocol{vm, core}
+    , protocol{vm, core, command_line::get_arg(vm, cryptonote::arg_offline)}
     , p2p{vm, protocol}
   {
     // Handle circular dependencies
@@ -76,15 +76,16 @@ public:
     core.set_protocol(protocol.get());
 
     const auto testnet = command_line::get_arg(vm, cryptonote::arg_testnet_on);
+    const auto stagenet = command_line::get_arg(vm, cryptonote::arg_stagenet_on);
     const auto restricted = command_line::get_arg(vm, cryptonote::core_rpc_server::arg_restricted_rpc);
-    const auto main_rpc_port = command_line::get_arg(vm, testnet ? cryptonote::core_rpc_server::arg_testnet_rpc_bind_port : cryptonote::core_rpc_server::arg_rpc_bind_port);
-    rpcs.emplace_back(new t_rpc{vm, core, p2p, restricted, testnet, main_rpc_port, "core"});
+    const auto main_rpc_port = command_line::get_arg(vm, cryptonote::core_rpc_server::arg_rpc_bind_port);
+    rpcs.emplace_back(new t_rpc{vm, core, p2p, restricted, testnet ? cryptonote::TESTNET : stagenet ? cryptonote::STAGENET : cryptonote::MAINNET, main_rpc_port, "core"});
 
-    auto restricted_rpc_port_arg = testnet ? cryptonote::core_rpc_server::arg_testnet_rpc_restricted_bind_port : cryptonote::core_rpc_server::arg_rpc_restricted_bind_port;
+    auto restricted_rpc_port_arg = cryptonote::core_rpc_server::arg_rpc_restricted_bind_port;
     if(!command_line::is_arg_defaulted(vm, restricted_rpc_port_arg))
     {
       auto restricted_rpc_port = command_line::get_arg(vm, restricted_rpc_port_arg);
-      rpcs.emplace_back(new t_rpc{vm, core, p2p, true, testnet, restricted_rpc_port, "restricted"});
+      rpcs.emplace_back(new t_rpc{vm, core, p2p, true, testnet ? cryptonote::TESTNET : stagenet ? cryptonote::STAGENET : cryptonote::MAINNET, restricted_rpc_port, "restricted"});
     }
   }
 };
@@ -101,15 +102,7 @@ t_daemon::t_daemon(
   )
   : mp_internals{new t_internals{vm}}
 {
-  bool testnet = command_line::get_arg(vm, cryptonote::arg_testnet_on);
-  if (testnet)
-  {
-    zmq_rpc_bind_port = command_line::get_arg(vm, daemon_args::arg_zmq_testnet_rpc_bind_port);
-  }
-  else
-  {
-    zmq_rpc_bind_port = command_line::get_arg(vm, daemon_args::arg_zmq_rpc_bind_port);
-  }
+  zmq_rpc_bind_port = command_line::get_arg(vm, daemon_args::arg_zmq_rpc_bind_port);
   zmq_rpc_bind_address = command_line::get_arg(vm, daemon_args::arg_zmq_rpc_bind_ip);
 }
 
diff --git a/src/daemon/main.cpp b/src/daemon/main.cpp
index f4d8fad5e..50384b2a6 100644
--- a/src/daemon/main.cpp
+++ b/src/daemon/main.cpp
@@ -73,26 +73,20 @@ int main(int argc, char const * argv[])
     po::options_description core_settings("Settings");
     po::positional_options_description positional_options;
     {
-      bf::path default_data_dir = daemonizer::get_default_data_dir();
-      bf::path default_testnet_data_dir = {default_data_dir / "testnet"};
-
       // Misc Options
 
       command_line::add_arg(visible_options, command_line::arg_help);
       command_line::add_arg(visible_options, command_line::arg_version);
       command_line::add_arg(visible_options, daemon_args::arg_os_version);
-      bf::path default_conf = default_data_dir / std::string(CRYPTONOTE_NAME ".conf");
-      command_line::add_arg(visible_options, daemon_args::arg_config_file, default_conf.string());
+      command_line::add_arg(visible_options, daemon_args::arg_config_file);
 
       // Settings
-      bf::path default_log = default_data_dir / std::string(CRYPTONOTE_NAME ".log");
-      command_line::add_arg(core_settings, daemon_args::arg_log_file, default_log.string());
+      command_line::add_arg(core_settings, daemon_args::arg_log_file);
       command_line::add_arg(core_settings, daemon_args::arg_log_level);
       command_line::add_arg(core_settings, daemon_args::arg_max_log_file_size);
       command_line::add_arg(core_settings, daemon_args::arg_max_concurrency);
       command_line::add_arg(core_settings, daemon_args::arg_zmq_rpc_bind_ip);
       command_line::add_arg(core_settings, daemon_args::arg_zmq_rpc_bind_port);
-      command_line::add_arg(core_settings, daemon_args::arg_zmq_testnet_rpc_bind_port);
 
       daemonizer::init_options(hidden_options, visible_options);
       daemonize::t_executor::init_options(core_settings);
@@ -144,6 +138,14 @@ int main(int argc, char const * argv[])
       return 0;
     }
 
+    const bool testnet = command_line::get_arg(vm, cryptonote::arg_testnet_on);
+    const bool stagenet = command_line::get_arg(vm, cryptonote::arg_stagenet_on);
+    if (testnet && stagenet)
+    {
+      std::cerr << "Can't specify more than one of --tesnet and --stagenet" << ENDL;
+      return 1;
+    }
+
     std::string db_type = command_line::get_arg(vm, cryptonote::arg_db_type);
 
     // verify that blockchaindb type is valid
@@ -154,10 +156,6 @@ int main(int argc, char const * argv[])
       return 0;
     }
 
-    bool testnet_mode = command_line::get_arg(vm, cryptonote::arg_testnet_on);
-
-    auto data_dir_arg = testnet_mode ? cryptonote::arg_testnet_data_dir : cryptonote::arg_data_dir;
-
     // data_dir
     //   default: e.g. ~/.bitmonero/ or ~/.bitmonero/testnet
     //   if data-dir argument given:
@@ -166,7 +164,7 @@ int main(int argc, char const * argv[])
 
     // Create data dir if it doesn't exist
     boost::filesystem::path data_dir = boost::filesystem::absolute(
-        command_line::get_arg(vm, data_dir_arg));
+        command_line::get_arg(vm, cryptonote::arg_data_dir));
 
     // FIXME: not sure on windows implementation default, needs further review
     //bf::path relative_path_base = daemonizer::get_relative_path_base(vm);
@@ -226,10 +224,6 @@ int main(int argc, char const * argv[])
         const cryptonote::rpc_args::descriptors arg{};
         auto rpc_ip_str = command_line::get_arg(vm, arg.rpc_bind_ip);
         auto rpc_port_str = command_line::get_arg(vm, cryptonote::core_rpc_server::arg_rpc_bind_port);
-        if (testnet_mode)
-        {
-          rpc_port_str = command_line::get_arg(vm, cryptonote::core_rpc_server::arg_testnet_rpc_bind_port);
-        }
 
         uint32_t rpc_ip;
         uint16_t rpc_port;
@@ -287,7 +281,7 @@ int main(int argc, char const * argv[])
 
     MINFO("Moving from main() into the daemonize now.");
 
-    return daemonizer::daemonize(argc, argv, daemonize::t_executor{}, vm);
+    return daemonizer::daemonize(argc, argv, daemonize::t_executor{}, vm) ? 0 : 1;
   }
   catch (std::exception const & ex)
   {
diff --git a/src/daemon/protocol.h b/src/daemon/protocol.h
index a251ae47c..fd1d1b638 100644
--- a/src/daemon/protocol.h
+++ b/src/daemon/protocol.h
@@ -46,9 +46,9 @@ private:
 public:
   t_protocol(
       boost::program_options::variables_map const & vm
-    , t_core & core
+    , t_core & core, bool offline = false
     )
-    : m_protocol{core.get(), nullptr}
+    : m_protocol{core.get(), nullptr, offline}
   {
     MGINFO("Initializing cryptonote protocol...");
     if (!m_protocol.init(vm))
diff --git a/src/daemon/rpc.h b/src/daemon/rpc.h
index c1c2329ac..9621b0d01 100644
--- a/src/daemon/rpc.h
+++ b/src/daemon/rpc.h
@@ -54,34 +54,34 @@ public:
     , t_core & core
     , t_p2p & p2p
     , const bool restricted
-    , const bool testnet
+    , const cryptonote::network_type nettype
     , const std::string & port
     , const std::string & description
     )
     : m_server{core.get(), p2p.get()}, m_description{description}
   {
-    MGINFO("Initializing " << m_description << " rpc server...");
+    MGINFO("Initializing " << m_description << " RPC server...");
 
-    if (!m_server.init(vm, restricted, testnet, port))
+    if (!m_server.init(vm, restricted, nettype, port))
     {
-      throw std::runtime_error("Failed to initialize " + m_description + " rpc server.");
+      throw std::runtime_error("Failed to initialize " + m_description + " RPC server.");
     }
-    MGINFO(m_description << " rpc server initialized OK on port: " << m_server.get_binded_port());
+    MGINFO(m_description << " RPC server initialized OK on port: " << m_server.get_binded_port());
   }
 
   void run()
   {
-    MGINFO("Starting " << m_description << " rpc server...");
+    MGINFO("Starting " << m_description << " RPC server...");
     if (!m_server.run(2, false))
     {
-      throw std::runtime_error("Failed to start " + m_description + " rpc server.");
+      throw std::runtime_error("Failed to start " + m_description + " RPC server.");
     }
-    MGINFO(m_description << " rpc server started ok");
+    MGINFO(m_description << " RPC server started ok");
   }
 
   void stop()
   {
-    MGINFO("Stopping " << m_description << " rpc server...");
+    MGINFO("Stopping " << m_description << " RPC server...");
     m_server.send_stop_signal();
     m_server.timed_wait_server_stop(5000);
   }
@@ -93,11 +93,11 @@ public:
 
   ~t_rpc()
   {
-    MGINFO("Deinitializing " << m_description << " rpc server...");
+    MGINFO("Deinitializing " << m_description << " RPC server...");
     try {
       m_server.deinit();
     } catch (...) {
-      MERROR("Failed to deinitialize " << m_description << " rpc server...");
+      MERROR("Failed to deinitialize " << m_description << " RPC server...");
     }
   }
 };
diff --git a/src/daemon/rpc_command_executor.cpp b/src/daemon/rpc_command_executor.cpp
index 2da4f3e6e..73b8d1a18 100644
--- a/src/daemon/rpc_command_executor.cpp
+++ b/src/daemon/rpc_command_executor.cpp
@@ -353,15 +353,18 @@ static std::string get_fork_extra_info(uint64_t t, uint64_t now, uint64_t block_
   return "";
 }
 
-static float get_sync_percentage(const cryptonote::COMMAND_RPC_GET_INFO::response &ires)
+static float get_sync_percentage(uint64_t height, uint64_t target_height)
 {
-  uint64_t height = ires.height;
-  uint64_t target_height = ires.target_height ? ires.target_height < ires.height ? ires.height : ires.target_height : ires.height;
+  target_height = target_height ? target_height < height ? height : target_height : height;
   float pc = 100.0f * height / target_height;
   if (height < target_height && pc > 99.9f)
     return 99.9f; // to avoid 100% when not fully synced
   return pc;
 }
+static float get_sync_percentage(const cryptonote::COMMAND_RPC_GET_INFO::response &ires)
+{
+  return get_sync_percentage(ires.height, ires.target_height);
+}
 
 bool t_rpc_command_executor::show_status() {
   cryptonote::COMMAND_RPC_GET_INFO::request ireq;
@@ -421,12 +424,26 @@ bool t_rpc_command_executor::show_status() {
 
   std::time_t uptime = std::time(nullptr) - ires.start_time;
   uint64_t net_height = ires.target_height > ires.height ? ires.target_height : ires.height;
+  std::string bootstrap_msg;
+  if (ires.was_bootstrap_ever_used)
+  {
+    bootstrap_msg = ", bootstrapping from " + ires.bootstrap_daemon_address;
+    if (ires.untrusted)
+    {
+      bootstrap_msg += (boost::format(", local height: %llu (%.1f%%)") % ires.height_without_bootstrap % get_sync_percentage(ires.height_without_bootstrap, net_height)).str();
+    }
+    else
+    {
+      bootstrap_msg += " was used before";
+    }
+  }
 
-  tools::success_msg_writer() << boost::format("Height: %llu/%llu (%.1f%%) on %s, %s, net hash %s, v%u%s, %s, %u(out)+%u(in) connections, uptime %ud %uh %um %us")
+  tools::success_msg_writer() << boost::format("Height: %llu/%llu (%.1f%%) on %s%s, %s, net hash %s, v%u%s, %s, %u(out)+%u(in) connections, uptime %ud %uh %um %us")
     % (unsigned long long)ires.height
     % (unsigned long long)net_height
     % get_sync_percentage(ires)
-    % (ires.testnet ? "testnet" : "mainnet")
+    % (ires.testnet ? "testnet" : ires.stagenet ? "stagenet" : "mainnet")
+    % bootstrap_msg
     % (!has_mining_info ? "mining info unavailable" : mining_busy ? "syncing" : mres.active ? ( ( mres.is_background_mining_enabled ? "smart " : "" ) + std::string("mining at ") + get_mining_speed(mres.speed) ) : "not mining")
     % get_mining_speed(ires.difficulty / ires.target)
     % (unsigned)hfres.version
@@ -1019,10 +1036,10 @@ bool t_rpc_command_executor::print_transaction_pool_stats() {
   return true;
 }
 
-bool t_rpc_command_executor::start_mining(cryptonote::account_public_address address, uint64_t num_threads, bool testnet, bool do_background_mining, bool ignore_battery) {
+bool t_rpc_command_executor::start_mining(cryptonote::account_public_address address, uint64_t num_threads, cryptonote::network_type nettype, bool do_background_mining, bool ignore_battery) {
   cryptonote::COMMAND_RPC_START_MINING::request req;
   cryptonote::COMMAND_RPC_START_MINING::response res;
-  req.miner_address = cryptonote::get_account_address_as_str(testnet, false, address);
+  req.miner_address = cryptonote::get_account_address_as_str(nettype, false, address);
   req.threads_count = num_threads;
   req.do_background_mining = do_background_mining;
   req.ignore_battery = ignore_battery;
@@ -1262,7 +1279,7 @@ bool t_rpc_command_executor::out_peers(uint64_t limit)
 
 	if (m_is_rpc)
 	{
-		if (!m_rpc_client->json_rpc_request(req, res, "out_peers", fail_message.c_str()))
+		if (!m_rpc_client->rpc_request(req, res, "/out_peers", fail_message.c_str()))
 		{
 			return true;
 		}
@@ -1281,6 +1298,38 @@ bool t_rpc_command_executor::out_peers(uint64_t limit)
 	return true;
 }
 
+bool t_rpc_command_executor::in_peers(uint64_t limit)
+{
+	cryptonote::COMMAND_RPC_IN_PEERS::request req;
+	cryptonote::COMMAND_RPC_IN_PEERS::response res;
+
+	epee::json_rpc::error error_resp;
+
+	req.in_peers = limit;
+
+	std::string fail_message = "Unsuccessful";
+
+	if (m_is_rpc)
+	{
+		if (!m_rpc_client->rpc_request(req, res, "/in_peers", fail_message.c_str()))
+		{
+			return true;
+		}
+	}
+	else
+	{
+		if (!m_rpc_server->on_in_peers(req, res) || res.status != CORE_RPC_STATUS_OK)
+		{
+			tools::fail_msg_writer() << make_error(fail_message, res.status);
+			return true;
+		}
+	}
+
+	std::cout << "Max number of in peers set to " << limit << std::endl;
+
+	return true;
+}
+
 bool t_rpc_command_executor::start_save_graph()
 {
 	cryptonote::COMMAND_RPC_START_SAVE_GRAPH::request req;
diff --git a/src/daemon/rpc_command_executor.h b/src/daemon/rpc_command_executor.h
index f0781180a..46168c93b 100644
--- a/src/daemon/rpc_command_executor.h
+++ b/src/daemon/rpc_command_executor.h
@@ -105,7 +105,7 @@ public:
 
   bool print_transaction_pool_stats();
 
-  bool start_mining(cryptonote::account_public_address address, uint64_t num_threads, bool testnet, bool do_background_mining = false, bool ignore_battery = false);
+  bool start_mining(cryptonote::account_public_address address, uint64_t num_threads, cryptonote::network_type nettype, bool do_background_mining = false, bool ignore_battery = false);
 
   bool stop_mining();
 
@@ -122,7 +122,9 @@ public:
   bool set_limit(int64_t limit_down, int64_t limit_up);
 
   bool out_peers(uint64_t limit);
-  
+
+  bool in_peers(uint64_t limit);
+
   bool start_save_graph();
   
   bool stop_save_graph();