Merge pull request #294

693a8bf rpc_command_executor: fix mining in testnet mode (moneromooo-monero)
d09be11 core_rpc_server: add a getter for the testnet flag (moneromooo-monero)
754f863 core_rpc_server: log some error messages to the console (moneromooo-monero)
4f0e8cf daemon: remove obsolete daemon_commands_handler.h (moneromooo-monero)
bac366e core_rpc_server: reenable print_pl (moneromooo-monero)
39a9508 net_peerlist: fix grayt/white naming mismatch (moneromooo-monero)
8069b3b blockchain_db: add a few const (moneromooo-monero)
0932476 wallet: add consts where appropriate (moneromooo-monero)

src/blockchain_db/berkeleydb/db_bdb.cpp

@@ -502,7 +502,7 @@ void BlockchainBDB::remove_spent_key(const crypto::key_image& k_image)
       throw1(DB_ERROR("Error adding removal of key image to db transaction"));
 }
 
-blobdata BlockchainBDB::output_to_blob(const tx_out& output)
+blobdata BlockchainBDB::output_to_blob(const tx_out& output) const
 {
   LOG_PRINT_L3("BlockchainBDB::" << __func__);
   blobdata b;

src/blockchain_db/berkeleydb/db_bdb.h

@@ -232,7 +232,7 @@ private:
    *
    * @return the resultant blob
    */
-  blobdata output_to_blob(const tx_out& output);
+  blobdata output_to_blob(const tx_out& output) const;
 
   /**
    * @brief convert a tx output blob to a tx output

src/blockchain_db/blockchain_db.cpp

@@ -129,7 +129,7 @@ void BlockchainDB::pop_block(block& blk, std::vector<transaction>& txs)
   }
 }
 
-bool BlockchainDB::is_open()
+bool BlockchainDB::is_open() const
 {
   return m_open;
 }

src/blockchain_db/blockchain_db.h

@@ -330,7 +330,7 @@ public:
   virtual void open(const std::string& filename, const int db_flags = 0) = 0;
 
   // returns true of the db is open/ready, else false
-  bool is_open();
+  bool is_open() const;
 
   // close and sync the db
   virtual void close() = 0;

src/blockchain_db/lmdb/db_lmdb.cpp

@@ -212,7 +212,7 @@ void mdb_txn_safe::abort()
   }
 }
 
-uint64_t mdb_txn_safe::num_active_tx()
+uint64_t mdb_txn_safe::num_active_tx() const
 {
   return num_active_txns;
 }
@@ -273,7 +273,7 @@ void BlockchainLMDB::do_resize()
   mdb_txn_safe::allow_new_txns();
 }
 
-bool BlockchainLMDB::need_resize()
+bool BlockchainLMDB::need_resize() const
 {
   MDB_envinfo mei;
 
@@ -668,7 +668,7 @@ void BlockchainLMDB::remove_spent_key(const crypto::key_image& k_image)
       throw1(DB_ERROR("Error adding removal of key image to db transaction"));
 }
 
-blobdata BlockchainLMDB::output_to_blob(const tx_out& output)
+blobdata BlockchainLMDB::output_to_blob(const tx_out& output) const
 {
   LOG_PRINT_L3("BlockchainLMDB::" << __func__);
   blobdata b;

src/blockchain_db/lmdb/db_lmdb.h

@@ -59,7 +59,7 @@ struct mdb_txn_safe
     return &m_txn;
   }
 
-  uint64_t num_active_tx();
+  uint64_t num_active_tx() const;
 
   static void prevent_new_txns();
   static void wait_no_active_txns();
@@ -201,7 +201,7 @@ public:
 private:
   void do_resize();
 
-  bool need_resize();
+  bool need_resize() const;
 
   virtual void add_block( const block& blk
                 , const size_t& block_size
@@ -236,7 +236,7 @@ private:
    *
    * @return the resultant blob
    */
-  blobdata output_to_blob(const tx_out& output);
+  blobdata output_to_blob(const tx_out& output) const;
 
   /**
    * @brief convert a tx output blob to a tx output

src/daemon/CMakeLists.txt

@@ -42,7 +42,6 @@ set(daemon_private_headers
   command_server.h
   core.h
   daemon.h
-  daemon_commands_handler.h
   executor.h
   p2p.h
   protocol.h

src/daemon/daemon_commands_handler.h

@@ -1,529 +0,0 @@
-// Copyright (c) 2014-2015, The Monero Project
-// 
-// All rights reserved.
-// 
-// Redistribution and use in source and binary forms, with or without modification, are
-// permitted provided that the following conditions are met:
-// 
-// 1. Redistributions of source code must retain the above copyright notice, this list of
-//    conditions and the following disclaimer.
-// 
-// 2. Redistributions in binary form must reproduce the above copyright notice, this list
-//    of conditions and the following disclaimer in the documentation and/or other
-//    materials provided with the distribution.
-// 
-// 3. Neither the name of the copyright holder nor the names of its contributors may be
-//    used to endorse or promote products derived from this software without specific
-//    prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
-// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
-// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
-// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// 
-// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
-
-
-/* This isn't a header file, may want to refactor this... */
-#pragma once
-
-#include <boost/lexical_cast.hpp>
-
-#include "console_handler.h"
-#include "p2p/net_node.h"
-#include "cryptonote_protocol/cryptonote_protocol_handler.h"
-#include "common/util.h"
-#include "crypto/hash.h"
-#include "version.h"
-#include "../../contrib/otshell_utils/utils.hpp"
-
-//#include "net/net_helper.h"
-//#include "../p2p/p2p_protocol_defs.h"
-//#include "../p2p/net_peerlist_boost_serialization.h"
-//#include "net/local_ip.h"
-//#include "crypto/crypto.h"
-//#include "storages/levin_abstract_invoke2.h"
-
-class daemon_cmmands_handler
-{
-  nodetool::node_server<cryptonote::t_cryptonote_protocol_handler<cryptonote::core> >& m_srv;
-public:
-  daemon_cmmands_handler(nodetool::node_server<cryptonote::t_cryptonote_protocol_handler<cryptonote::core> >& srv):m_srv(srv)
-  {
-    m_cmd_binder.set_handler("help", boost::bind(&daemon_cmmands_handler::help, this, _1), "Show this help");
-    m_cmd_binder.set_handler("print_pl", boost::bind(&daemon_cmmands_handler::print_pl, this, _1), "Print peer list");
-    m_cmd_binder.set_handler("print_cn", boost::bind(&daemon_cmmands_handler::print_cn, this, _1), "Print connections");
-    m_cmd_binder.set_handler("print_bc", boost::bind(&daemon_cmmands_handler::print_bc, this, _1), "Print blockchain info in a given blocks range, print_bc <begin_height> [<end_height>]");
-    //m_cmd_binder.set_handler("print_bci", boost::bind(&daemon_cmmands_handler::print_bci, this, _1));
-    //m_cmd_binder.set_handler("print_bc_outs", boost::bind(&daemon_cmmands_handler::print_bc_outs, this, _1));
-    m_cmd_binder.set_handler("print_block", boost::bind(&daemon_cmmands_handler::print_block, this, _1), "Print block, print_block <block_hash> | <block_height>");
-    m_cmd_binder.set_handler("print_tx", boost::bind(&daemon_cmmands_handler::print_tx, this, _1), "Print transaction, print_tx <transaction_hash>");
-    m_cmd_binder.set_handler("start_mining", boost::bind(&daemon_cmmands_handler::start_mining, this, _1), "Start mining for specified address, start_mining <addr> [threads=1]");
-    m_cmd_binder.set_handler("stop_mining", boost::bind(&daemon_cmmands_handler::stop_mining, this, _1), "Stop mining");
-    m_cmd_binder.set_handler("print_pool", boost::bind(&daemon_cmmands_handler::print_pool, this, _1), "Print transaction pool (long format)");
-    m_cmd_binder.set_handler("print_pool_sh", boost::bind(&daemon_cmmands_handler::print_pool_sh, this, _1), "Print transaction pool (short format)");
-    m_cmd_binder.set_handler("show_hr", boost::bind(&daemon_cmmands_handler::show_hr, this, _1), "Start showing hash rate");
-    m_cmd_binder.set_handler("hide_hr", boost::bind(&daemon_cmmands_handler::hide_hr, this, _1), "Stop showing hash rate");
-    m_cmd_binder.set_handler("save", boost::bind(&daemon_cmmands_handler::save, this, _1), "Save blockchain");
-    m_cmd_binder.set_handler("set_log", boost::bind(&daemon_cmmands_handler::set_log, this, _1), "set_log <level> - Change current log detalization level, <level> is a number 0-4");
-    m_cmd_binder.set_handler("diff", boost::bind(&daemon_cmmands_handler::diff, this, _1), "Show difficulty");
-    m_cmd_binder.set_handler("out_peers", boost::bind(&daemon_cmmands_handler::out_peers_limit, this, _1), "Set max limit of out peers");
-    m_cmd_binder.set_handler("limit_up", boost::bind(&daemon_cmmands_handler::limit_up, this, _1), "Set upload limit [kB/s]");
-    m_cmd_binder.set_handler("limit_down", boost::bind(&daemon_cmmands_handler::limit_down, this, _1), "Set download limit [kB/s]");
-    m_cmd_binder.set_handler("limit", boost::bind(&daemon_cmmands_handler::limit, this, _1), "Set download and upload limit [kB/s]");
-    m_cmd_binder.set_handler("fast_exit", boost::bind(&daemon_cmmands_handler::fast_exit, this, _1), "Exit");
-    m_cmd_binder.set_handler("test_drop_download", boost::bind(&daemon_cmmands_handler::test_drop_download, this, _1), "For network testing, drop downloaded blocks instead checking/adding them to blockchain. Can fake-download blocks very fast.");
-    m_cmd_binder.set_handler("start_save_graph", boost::bind(&daemon_cmmands_handler::start_save_graph, this, _1), "");
-    m_cmd_binder.set_handler("stop_save_graph", boost::bind(&daemon_cmmands_handler::stop_save_graph, this, _1), "");
-  }
-
-  bool start_handling()
-  {
-    m_cmd_binder.start_handling(&m_srv, "", "");
-    return true;
-  }
-
-  void stop_handling()
-  {
-    m_cmd_binder.stop_handling();
-  }
-
-private:
-  epee::srv_console_handlers_binder<nodetool::node_server<cryptonote::t_cryptonote_protocol_handler<cryptonote::core> > > m_cmd_binder;
-
-
-  //--------------------------------------------------------------------------------
-  std::string get_commands_str()
-  {
-    std::stringstream ss;
-    ss << CRYPTONOTE_NAME << " v" << MONERO_VERSION_FULL << ENDL;
-    ss << "Commands: " << ENDL;
-    std::string usage = m_cmd_binder.get_usage();
-    boost::replace_all(usage, "\n", "\n  ");
-    usage.insert(0, "  ");
-    ss << usage << ENDL;
-    return ss.str();
-  }
-  //--------------------------------------------------------------------------------
-  bool help(const std::vector<std::string>& args)
-  {
-    std::cout << get_commands_str() << ENDL;
-    return true;
-  }
-  //--------------------------------------------------------------------------------
-  bool print_pl(const std::vector<std::string>& args)
-  {
-    m_srv.log_peerlist();
-    return true;
-  }
-  //--------------------------------------------------------------------------------
-  bool save(const std::vector<std::string>& args)
-  {
-    m_srv.get_payload_object().get_core().get_blockchain_storage().store_blockchain();
-    return true;
-  }
-  //--------------------------------------------------------------------------------
-  bool limit_up(const std::vector<std::string>& args)
-  {
-      if(args.size()!=1) {
-          std::cout << "Usage: limit_up <speed>" << ENDL;
-          return false;
-      }
-      
-	  int limit;
-	  try {
-		  limit = std::stoi(args[0]);
-	  }
-	  catch(std::invalid_argument& ex) {
-		  return false;
-	  }
-
-      if (limit==-1) {
-          limit=128;
-          //this->islimitup=false;
-      }
-
-      limit *= 1024;
-
-
-      //nodetool::epee::net_utils::connection<epee::levin::async_protocol_handler<nodetool::p2p_connection_context> >::set_rate_up_limit( limit );
-      epee::net_utils::connection_basic::set_rate_up_limit( limit );
-      std::cout << "Set limit-up to " << limit/1024 << " kB/s" << std::endl;
-
-      return true;
-  }
-  
-  //--------------------------------------------------------------------------------  
-  bool limit_down(const std::vector<std::string>& args)
-  {
-
-      if(args.size()!=1) {
-          std::cout << "Usage: limit_down <speed>" << ENDL;
-          return true;
-      }
-
-	  int limit;
-	  try {
-		  limit = std::stoi(args[0]);
-	  }
-	  
-	  catch(std::invalid_argument& ex) {
-		  return false;
-	  }
-
-      if (limit==-1) {
-          limit=128;
-          //this->islimitup=false;
-      }
-
-      limit *= 1024;
-
-
-      //nodetool::epee::net_utils::connection<epee::levin::async_protocol_handler<nodetool::p2p_connection_context> >::set_rate_up_limit( limit );
-      epee::net_utils::connection_basic::set_rate_down_limit( limit );
-      std::cout << "Set limit-down to " << limit/1024 << " kB/s" << std::endl;
-
-      return true;
-  }
-  
-//--------------------------------------------------------------------------------  
-  bool limit(const std::vector<std::string>& args)
-  {
-      if(args.size()!=1) {
-          std::cout << "Usage: limit_down <speed>" << ENDL;
-          return true;
-      }
-
-	  int limit;
-	  try {
-		  limit = std::stoi(args[0]);
-	  }
-	  catch(std::invalid_argument& ex) {
-		  return false;
-	  }
-
-      if (limit==-1) {
-          limit=128;
-          //this->islimitup=false;
-      }
-
-      limit *= 1024;
-
-
-      //nodetool::epee::net_utils::connection<epee::levin::async_protocol_handler<nodetool::p2p_connection_context> >::set_rate_up_limit( limit );
-      epee::net_utils::connection_basic::set_rate_down_limit( limit );
-      epee::net_utils::connection_basic::set_rate_up_limit( limit );
-      std::cout << "Set limit-down to " << limit/1024 << " kB/s" << std::endl;
-      std::cout << "Set limit-up to " << limit/1024 << " kB/s" << std::endl;
-
-      return true;
-  }
- //--------------------------------------------------------------------------------
- bool out_peers_limit(const std::vector<std::string>& args) {
-	  if(args.size()!=1) {		
-		  std::cout << "Usage: limit_down <speed>" << ENDL;
-          return true;
-      }
-    
-      int limit;
-	  try {
-		  limit = std::stoi(args[0]);
-	  }
-	  
-	  catch(std::invalid_argument& ex) {
-		  return false;
-	  }
-    
-	  LOG_PRINT_RED_L0("connections_count:  " << limit);
-	  m_srv.m_config.m_net_config.connections_count = limit;
-	  return true;
- }
- //--------------------------------------------------------------------------------
-  bool show_hr(const std::vector<std::string>& args)
-  {
-	if(!m_srv.get_payload_object().get_core().get_miner().is_mining()) 
-	{
-	  std::cout << "Mining is not started. You need start mining before you can see hash rate." << ENDL;
-	} else 
-	{
-	  m_srv.get_payload_object().get_core().get_miner().do_print_hashrate(true);
-	}
-    return true;
-  }
-  //--------------------------------------------------------------------------------
-  bool hide_hr(const std::vector<std::string>& args)
-  {
-    m_srv.get_payload_object().get_core().get_miner().do_print_hashrate(false);
-    return true;
-  }
-  //--------------------------------------------------------------------------------
-  bool diff(const std::vector<std::string>& args)
-  {
-	  cryptonote::difficulty_type difficulty = m_srv.get_payload_object().get_core().get_blockchain_storage().get_difficulty_for_next_block();
-	  uint64_t height = m_srv.get_payload_object().get_core().get_blockchain_storage().get_current_blockchain_height();
-
-	  LOG_PRINT_GREEN("BH: " << height << ", DIFF: " << difficulty 
-		  << ", HR: " << (int) difficulty / 60L << " H/s", LOG_LEVEL_0);
-
-	  return true;
-  } 
-  //--------------------------------------------------------------------------------
-  bool print_bc_outs(const std::vector<std::string>& args)
-  {
-    if(args.size() != 1)
-    {
-      std::cout << "need file path as parameter" << ENDL;
-      return true;
-    }
-    m_srv.get_payload_object().get_core().print_blockchain_outs(args[0]);
-    return true;
-  }
-  //--------------------------------------------------------------------------------
-  bool print_cn(const std::vector<std::string>& args)
-  {
-     m_srv.get_payload_object().log_connections();
-     return true;
-  }
-  //--------------------------------------------------------------------------------
-  bool print_bc(const std::vector<std::string>& args)
-  {
-    if(!args.size())
-    {
-      std::cout << "need block index parameter" << ENDL;
-      return false;
-    }
-    uint64_t start_index = 0;
-    uint64_t end_index = 0;
-    uint64_t end_block_parametr = m_srv.get_payload_object().get_core().get_current_blockchain_height();
-    if(!string_tools::get_xtype_from_string(start_index, args[0]))
-    {
-      std::cout << "wrong starter block index parameter" << ENDL;
-      return false;
-    }
-    if(args.size() >1 && !string_tools::get_xtype_from_string(end_index, args[1]))
-    {
-      std::cout << "wrong end block index parameter" << ENDL;
-      return false;
-    }
-    if (end_index == 0)
-    {
-      end_index = end_block_parametr;
-    }
-    if (end_index > end_block_parametr)
-    {
-      std::cout << "end block index parameter shouldn't be greater than " << end_block_parametr << ENDL;
-      return false;
-    }
-    if (end_index <= start_index)
-    {
-      std::cout << "end block index should be greater than starter block index" << ENDL;
-      return false;
-    }
-
-    m_srv.get_payload_object().get_core().print_blockchain(start_index, end_index);
-    return true;
-  }
-  //--------------------------------------------------------------------------------
-  bool print_bci(const std::vector<std::string>& args)
-  {
-    m_srv.get_payload_object().get_core().print_blockchain_index();
-    return true;
-  }
-
-  bool set_log(const std::vector<std::string>& args)
-  {
-    if(args.size() != 1)
-    {
-      std::cout << "use: set_log <log_level_number_0-4>" << ENDL;
-      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;
-      return true;
-    }
-
-    if(LOG_LEVEL_4 < l)
-    {
-      std::cout << "wrong number range, use: set_log <log_level_number_0-4>" << ENDL;
-      return true;
-    }
-
-		// TODO what the hell causes compilation warning in following code line
-PUSH_WARNINGS
-DISABLE_GCC_WARNING(maybe-uninitialized)
-    log_space::log_singletone::get_set_log_detalisation_level(true, l);
-    int otshell_utils_log_level = 100 - (l * 25);
-    gCurrentLogger.setDebugLevel(otshell_utils_log_level);
-POP_WARNINGS
-
-    return true;
-  }
-
-  //--------------------------------------------------------------------------------
-  template <typename T>
-  static bool print_as_json(T& obj)
-  {
-    std::cout << cryptonote::obj_to_json_str(obj) << ENDL;
-    return true;
-  }
-  //--------------------------------------------------------------------------------
-  bool print_block_by_height(uint64_t height)
-  {
-    std::list<cryptonote::block> blocks;
-    m_srv.get_payload_object().get_core().get_blocks(height, 1, blocks);
-
-    if (1 == blocks.size())
-    {
-      cryptonote::block& block = blocks.front();
-      std::cout << "block_id: " << get_block_hash(block) << ENDL;
-      print_as_json(block);
-    }
-    else
-    {
-      uint64_t current_height;
-      crypto::hash top_id;
-      m_srv.get_payload_object().get_core().get_blockchain_top(current_height, top_id);
-      std::cout << "block wasn't found. Current block chain height: " << current_height << ", requested: " << height << std::endl;
-      return false;
-    }
-
-    return true;
-  }
-  //--------------------------------------------------------------------------------
-  bool print_block_by_hash(const std::string& arg)
-  {
-    crypto::hash block_hash;
-    if (!parse_hash256(arg, block_hash))
-    {
-      return false;
-    }
-
-    std::list<crypto::hash> block_ids;
-    block_ids.push_back(block_hash);
-    std::list<cryptonote::block> blocks;
-    std::list<crypto::hash> missed_ids;
-    m_srv.get_payload_object().get_core().get_blocks(block_ids, blocks, missed_ids);
-
-    if (1 == blocks.size())
-    {
-      cryptonote::block block = blocks.front();
-      print_as_json(block);
-    }
-    else
-    {
-      std::cout << "block wasn't found: " << arg << std::endl;
-      return false;
-    }
-
-    return true;
-  }
-  //--------------------------------------------------------------------------------
-  bool print_block(const std::vector<std::string>& args)
-  {
-    if (args.empty())
-    {
-      std::cout << "expected: print_block (<block_hash> | <block_height>)" << std::endl;
-      return true;
-    }
-
-    const std::string& arg = args.front();
-    try
-    {
-      uint64_t height = boost::lexical_cast<uint64_t>(arg);
-      print_block_by_height(height);
-    }
-    catch (boost::bad_lexical_cast&)
-    {
-      print_block_by_hash(arg);
-    }
-
-    return true;
-  }
-  //--------------------------------------------------------------------------------
-  bool print_tx(const std::vector<std::string>& args)
-  {
-    if (args.empty())
-    {
-      std::cout << "expected: print_tx <transaction hash>" << std::endl;
-      return true;
-    }
-
-    const std::string& str_hash = args.front();
-    crypto::hash tx_hash;
-    if (!parse_hash256(str_hash, tx_hash))
-    {
-      return true;
-    }
-
-    std::vector<crypto::hash> tx_ids;
-    tx_ids.push_back(tx_hash);
-    std::list<cryptonote::transaction> txs;
-    std::list<crypto::hash> missed_ids;
-    m_srv.get_payload_object().get_core().get_transactions(tx_ids, txs, missed_ids);
-
-    if (1 == txs.size())
-    {
-      cryptonote::transaction tx = txs.front();
-      print_as_json(tx);
-    }
-    else
-    {
-      std::cout << "transaction wasn't found: <" << str_hash << '>' << std::endl;
-    }
-
-    return true;
-  }
-  //--------------------------------------------------------------------------------
-  bool print_pool(const std::vector<std::string>& args)
-  {
-    LOG_PRINT_L0("Pool state: " << ENDL << m_srv.get_payload_object().get_core().print_pool(false));
-    return true;
-  }
-  //--------------------------------------------------------------------------------
-  bool print_pool_sh(const std::vector<std::string>& args)
-  {
-    LOG_PRINT_L0("Pool state: " << ENDL << m_srv.get_payload_object().get_core().print_pool(true));
-    return true;
-  }  //--------------------------------------------------------------------------------
-  bool start_mining(const std::vector<std::string>& args)
-  {
-    if(!args.size())
-    {
-      std::cout << "Please, specify wallet address to mine for: start_mining <addr> [threads=1]" << std::endl;
-      return true;
-    }
-
-    cryptonote::account_public_address adr;
-    if(!cryptonote::get_account_address_from_str(adr, args.front()))
-    {
-      std::cout << "target account address has wrong format" << std::endl;
-      return true;
-    }
-    size_t threads_count = 1;
-    if(args.size() > 1)
-    {
-      bool ok = string_tools::get_xtype_from_string(threads_count, args[1]);
-      threads_count = (ok && 0 < threads_count) ? threads_count : 1;
-    }
-
-    boost::thread::attributes attrs;
-    attrs.set_stack_size(THREAD_STACK_SIZE);
-
-    m_srv.get_payload_object().get_core().get_miner().start(adr, threads_count, attrs);
-    return true;
-  }
-  //--------------------------------------------------------------------------------
-  bool stop_mining(const std::vector<std::string>& args)
-  {
-    m_srv.get_payload_object().get_core().get_miner().stop();
-    return true;
-  }
-};

src/daemon/rpc_command_executor.cpp

@@ -621,11 +621,10 @@ bool t_rpc_command_executor::print_transaction_pool_short() {
   return true;
 }
 
-// TODO: update this for testnet
 bool t_rpc_command_executor::start_mining(cryptonote::account_public_address address, uint64_t num_threads) {
   cryptonote::COMMAND_RPC_START_MINING::request req;
   cryptonote::COMMAND_RPC_START_MINING::response res;
-  req.miner_address = cryptonote::get_account_address_as_str(false, address);
+  req.miner_address = cryptonote::get_account_address_as_str(m_rpc_server->is_testnet(), address);
   req.threads_count = num_threads;
 
   std::string fail_message = "Mining did not start";

src/p2p/net_peerlist.h

@@ -204,7 +204,7 @@ namespace nodetool
     return true;
   }
   //--------------------------------------------------------------------------------------------------
-  inline void peerlist_manager::trim_white_peerlist()
+  inline void peerlist_manager::trim_gray_peerlist()
   {
     while(m_peers_gray.size() > P2P_LOCAL_GRAY_PEERLIST_LIMIT)
     {
@@ -213,7 +213,7 @@ namespace nodetool
     }
   }
   //--------------------------------------------------------------------------------------------------
-  inline void peerlist_manager::trim_gray_peerlist()
+  inline void peerlist_manager::trim_white_peerlist()
   {
     while(m_peers_white.size() > P2P_LOCAL_WHITE_PEERLIST_LIMIT)
     {

src/rpc/core_rpc_server.cpp

@@ -291,6 +291,7 @@ namespace cryptonote
     if(!get_account_address_from_str(adr, m_testnet, req.miner_address))
     {
       res.status = "Failed, wrong address";
+      LOG_PRINT_L0(res.status);
       return true;
     }
 
@@ -300,6 +301,7 @@ namespace cryptonote
     if(!m_core.get_miner().start(adr, static_cast<size_t>(req.threads_count), attrs))
     {
       res.status = "Failed, mining not started";
+      LOG_PRINT_L0(res.status);
       return true;
     }
     res.status = CORE_RPC_STATUS_OK;
@@ -311,6 +313,7 @@ namespace cryptonote
     if(!m_core.get_miner().stop())
     {
       res.status = "Failed, mining not stopped";
+      LOG_PRINT_L0(res.status);
       return true;
     }
     res.status = CORE_RPC_STATUS_OK;
@@ -349,10 +352,10 @@ namespace cryptonote
   //------------------------------------------------------------------------------------------------------------------------------
   bool core_rpc_server::on_get_peer_list(const COMMAND_RPC_GET_PEER_LIST::request& req, COMMAND_RPC_GET_PEER_LIST::response& res)
   {
-    /*
     std::list<nodetool::peerlist_entry> white_list;
     std::list<nodetool::peerlist_entry> gray_list;
-    m_p2p.get_peerlist(white_list, gray_list);
+    m_p2p.get_peerlist_manager().get_peerlist_full(white_list, gray_list);
+
 
     for (auto & entry : white_list)
     {
@@ -364,7 +367,6 @@ namespace cryptonote
       res.gray_list.emplace_back(entry.id, entry.adr.ip, entry.adr.port, entry.last_seen);
     }
 
-    */
     res.status = CORE_RPC_STATUS_OK;
     return true;
   }

src/rpc/core_rpc_server.h

@@ -67,6 +67,7 @@ namespace cryptonote
     bool init(
         const boost::program_options::variables_map& vm
       );
+    bool is_testnet() const { return m_testnet; }
 
     CHAIN_HTTP_TO_MAP2(connection_context); //forward http requests to uri map
 

src/wallet/wallet2.cpp

@@ -89,7 +89,7 @@ void wallet2::init(const std::string& daemon_address, uint64_t upper_transaction
   m_daemon_address = daemon_address;
 }
 //----------------------------------------------------------------------------------------------------
-bool wallet2::is_deterministic()
+bool wallet2::is_deterministic() const
 {
   crypto::secret_key second;
   keccak((uint8_t *)&get_account().get_keys().m_spend_secret_key, sizeof(crypto::secret_key), (uint8_t *)&second, sizeof(crypto::secret_key));
@@ -98,7 +98,7 @@ bool wallet2::is_deterministic()
   return keys_deterministic;
 }
 //----------------------------------------------------------------------------------------------------
-bool wallet2::get_seed(std::string& electrum_words)
+bool wallet2::get_seed(std::string& electrum_words) const
 {
   bool keys_deterministic = is_deterministic();
   if (!keys_deterministic)
@@ -119,7 +119,7 @@ bool wallet2::get_seed(std::string& electrum_words)
 /*!
  * \brief Gets the seed language
  */
-const std::string wallet2::get_seed_language()
+const std::string &wallet2::get_seed_language() const
 {
   return seed_language;
 }
@@ -287,7 +287,7 @@ void wallet2::process_new_blockchain_entry(const cryptonote::block& b, cryptonot
     m_callback->on_new_block(height, b);
 }
 //----------------------------------------------------------------------------------------------------
-void wallet2::get_short_chain_history(std::list<crypto::hash>& ids)
+void wallet2::get_short_chain_history(std::list<crypto::hash>& ids) const
 {
   size_t i = 0;
   size_t current_multiplier = 1;
@@ -580,7 +580,7 @@ void wallet2::load_keys(const std::string& keys_file_name, const std::string& pa
  * can be used prior to rewriting wallet keys file, to ensure user has entered the correct password
  *
  */
-bool wallet2::verify_password(const std::string& password)
+bool wallet2::verify_password(const std::string& password) const
 {
   const std::string keys_file_name = m_keys_file;
   wallet2::keys_file_data keys_file_data;
@@ -765,7 +765,7 @@ void wallet2::load(const std::string& wallet_, const std::string& password)
   m_local_bc_height = m_blockchain.size();
 }
 //----------------------------------------------------------------------------------------------------
-void wallet2::check_genesis(const crypto::hash& genesis_hash) {
+void wallet2::check_genesis(const crypto::hash& genesis_hash) const {
   std::string what("Genesis block missmatch. You probably use wallet without testnet flag with blockchain from test network or vice versa");
 
   THROW_WALLET_EXCEPTION_IF(genesis_hash != m_blockchain[0], error::wallet_internal_error, what);
@@ -777,17 +777,17 @@ void wallet2::store()
   THROW_WALLET_EXCEPTION_IF(!r, error::file_save_error, m_wallet_file);
 }
 //----------------------------------------------------------------------------------------------------
-uint64_t wallet2::unlocked_balance()
+uint64_t wallet2::unlocked_balance() const
 {
   uint64_t amount = 0;
-  BOOST_FOREACH(transfer_details& td, m_transfers)
+  BOOST_FOREACH(const transfer_details& td, m_transfers)
     if(!td.m_spent && is_transfer_unlocked(td))
       amount += td.amount();
 
   return amount;
 }
 //----------------------------------------------------------------------------------------------------
-uint64_t wallet2::balance()
+uint64_t wallet2::balance() const
 {
   uint64_t amount = 0;
   BOOST_FOREACH(auto& td, m_transfers)

src/wallet/wallet2.h

@@ -157,8 +157,9 @@ namespace tools
     /*!
      * \brief verifies given password is correct for default wallet keys file
      */
-    bool verify_password(const std::string& password);
+    bool verify_password(const std::string& password) const;
     cryptonote::account_base& get_account(){return m_account;}
+    const cryptonote::account_base& get_account()const{return m_account;}
 
     // upper_transaction_size_limit as defined below is set to 
     // approximately 125% of the fixed minimum allowable penalty
@@ -176,12 +177,12 @@ namespace tools
     /*!
      * \brief Checks if deterministic wallet
      */
-    bool is_deterministic();
+    bool is_deterministic() const;
-    bool get_seed(std::string& electrum_words);
+    bool get_seed(std::string& electrum_words) const;
     /*!
      * \brief Gets the seed language
      */
-    const std::string get_seed_language();
+    const std::string &get_seed_language() const;
     /*!
      * \brief Sets the seed language
      */
@@ -195,11 +196,11 @@ namespace tools
     void refresh(uint64_t start_height, size_t & blocks_fetched, bool& received_money);
     bool refresh(size_t & blocks_fetched, bool& received_money, bool& ok);
 
-    bool testnet() { return m_testnet; }
+    bool testnet() const { return m_testnet; }
     bool restricted() const { return m_restricted; }
 
-    uint64_t balance();
+    uint64_t balance() const;
-    uint64_t unlocked_balance();
+    uint64_t unlocked_balance() const;
     template<typename T>
     void transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, size_t fake_outputs_count, uint64_t unlock_time, uint64_t fee, const std::vector<uint8_t>& extra, T destination_split_strategy, const tx_dust_policy& dust_policy);
     template<typename T>
@@ -267,7 +268,7 @@ namespace tools
     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);
+    void get_short_chain_history(std::list<crypto::hash>& ids) const;
     bool is_tx_spendtime_unlocked(uint64_t unlock_time) const;
     bool is_transfer_unlocked(const transfer_details& td) const;
     bool clear();
@@ -277,7 +278,7 @@ namespace tools
     void process_unconfirmed(const cryptonote::transaction& tx);
     void add_unconfirmed_tx(const cryptonote::transaction& tx, uint64_t change_amount);
     void generate_genesis(cryptonote::block& b);
-    void check_genesis(const crypto::hash& genesis_hash); //throws
+    void check_genesis(const crypto::hash& genesis_hash) const; //throws
 
     cryptonote::account_base m_account;
     std::string m_daemon_address;