core: add consts where appropriate

6 files changed, 82 insertions, 79 deletions

diff --git a/src/cryptonote_core/blockchain.cpp b/src/cryptonote_core/blockchain.cpp
index dfaae85b9..7673aa1f1 100644
--- a/src/cryptonote_core/blockchain.cpp
+++ b/src/cryptonote_core/blockchain.cpp
@@ -1632,7 +1632,7 @@ bool Blockchain::get_transactions(const t_ids_container& txs_ids, t_tx_container
     return true;
 }
 //------------------------------------------------------------------
-void Blockchain::print_blockchain(uint64_t start_index, uint64_t end_index)
+void Blockchain::print_blockchain(uint64_t start_index, uint64_t end_index) const
 {
     LOG_PRINT_L3("Blockchain::" << __func__);
     std::stringstream ss;
@@ -1652,7 +1652,7 @@ void Blockchain::print_blockchain(uint64_t start_index, uint64_t end_index)
     LOG_PRINT_L0("Blockchain printed with log level 1");
 }
 //------------------------------------------------------------------
-void Blockchain::print_blockchain_index()
+void Blockchain::print_blockchain_index() const
 {
     LOG_PRINT_L3("Blockchain::" << __func__);
     std::stringstream ss;
@@ -1670,7 +1670,7 @@ void Blockchain::print_blockchain_index()
 }
 //------------------------------------------------------------------
 //TODO: remove this function and references to it
-void Blockchain::print_blockchain_outs(const std::string& file)
+void Blockchain::print_blockchain_outs(const std::string& file) const
 {
     LOG_PRINT_L3("Blockchain::" << __func__);
     return;
diff --git a/src/cryptonote_core/blockchain.h b/src/cryptonote_core/blockchain.h
index 967745c46..6a73faf4a 100644
--- a/src/cryptonote_core/blockchain.h
+++ b/src/cryptonote_core/blockchain.h
@@ -145,9 +145,9 @@ namespace cryptonote
     bool get_transactions(const t_ids_container& txs_ids, t_tx_container& txs, t_missed_container& missed_txs) const;
 
     //debug functions
-    void print_blockchain(uint64_t start_index, uint64_t end_index);
-    void print_blockchain_index();
-    void print_blockchain_outs(const std::string& file);
+    void print_blockchain(uint64_t start_index, uint64_t end_index) const;
+    void print_blockchain_index() const;
+    void print_blockchain_outs(const std::string& file) const;
 
     void check_against_checkpoints(const checkpoints& points, bool enforce);
     void set_enforce_dns_checkpoints(bool enforce);
diff --git a/src/cryptonote_core/blockchain_storage.cpp b/src/cryptonote_core/blockchain_storage.cpp
index ee4263687..4a4d348ba 100644
--- a/src/cryptonote_core/blockchain_storage.cpp
+++ b/src/cryptonote_core/blockchain_storage.cpp
@@ -1178,7 +1178,7 @@ double blockchain_storage::get_avg_block_size( size_t count) const
 		return average;
 }
 //------------------------------------------------------------------
-void blockchain_storage::print_blockchain(uint64_t start_index, uint64_t end_index)
+void blockchain_storage::print_blockchain(uint64_t start_index, uint64_t end_index) const
 {
   std::stringstream ss;
   CRITICAL_REGION_LOCAL(m_blockchain_lock);
@@ -1198,7 +1198,7 @@ void blockchain_storage::print_blockchain(uint64_t start_index, uint64_t end_ind
   LOG_PRINT_L0("Blockchain printed with log level 1");
 }
 //------------------------------------------------------------------
-void blockchain_storage::print_blockchain_index()
+void blockchain_storage::print_blockchain_index() const
 {
   std::stringstream ss;
   CRITICAL_REGION_LOCAL(m_blockchain_lock);
@@ -1208,7 +1208,7 @@ void blockchain_storage::print_blockchain_index()
   LOG_PRINT_L0("Current blockchain index:" << ENDL << ss.str());
 }
 //------------------------------------------------------------------
-void blockchain_storage::print_blockchain_outs(const std::string& file)
+void blockchain_storage::print_blockchain_outs(const std::string& file) const
 {
   std::stringstream ss;
   CRITICAL_REGION_LOCAL(m_blockchain_lock);
diff --git a/src/cryptonote_core/blockchain_storage.h b/src/cryptonote_core/blockchain_storage.h
index aeeef31b6..2a4cfcd49 100644
--- a/src/cryptonote_core/blockchain_storage.h
+++ b/src/cryptonote_core/blockchain_storage.h
@@ -173,9 +173,9 @@ namespace cryptonote
       return true;
     }
     //debug functions
-    void print_blockchain(uint64_t start_index, uint64_t end_index);
-    void print_blockchain_index();
-    void print_blockchain_outs(const std::string& file);
+    void print_blockchain(uint64_t start_index, uint64_t end_index) const;
+    void print_blockchain_index() const;
+    void print_blockchain_outs(const std::string& file) const;
     void check_against_checkpoints(const checkpoints& points, bool enforce);
     bool update_checkpoints(const std::string& file_path, bool check_dns);
     void set_enforce_dns_checkpoints(bool enforce_checkpoints);
diff --git a/src/cryptonote_core/cryptonote_core.cpp b/src/cryptonote_core/cryptonote_core.cpp
index 0769dbb69..4ade50cde 100644
--- a/src/cryptonote_core/cryptonote_core.cpp
+++ b/src/cryptonote_core/cryptonote_core.cpp
@@ -168,37 +168,37 @@ namespace cryptonote
     return true;
   }
   //-----------------------------------------------------------------------------------------------
-  uint64_t core::get_current_blockchain_height()
+  uint64_t core::get_current_blockchain_height() const
   {
     return m_blockchain_storage.get_current_blockchain_height();
   }
   //-----------------------------------------------------------------------------------------------
-  bool core::get_blockchain_top(uint64_t& height, crypto::hash& top_id)
+  bool core::get_blockchain_top(uint64_t& height, crypto::hash& top_id) const
   {
     top_id = m_blockchain_storage.get_tail_id(height);
     return true;
   }
   //-----------------------------------------------------------------------------------------------
-  bool core::get_blocks(uint64_t start_offset, size_t count, std::list<block>& blocks, std::list<transaction>& txs)
+  bool core::get_blocks(uint64_t start_offset, size_t count, std::list<block>& blocks, std::list<transaction>& txs) const
   {
     return m_blockchain_storage.get_blocks(start_offset, count, blocks, txs);
   }
   //-----------------------------------------------------------------------------------------------
-  bool core::get_blocks(uint64_t start_offset, size_t count, std::list<block>& blocks)
+  bool core::get_blocks(uint64_t start_offset, size_t count, std::list<block>& blocks) const
   {
     return m_blockchain_storage.get_blocks(start_offset, count, blocks);
   }  //-----------------------------------------------------------------------------------------------
-  bool core::get_transactions(const std::vector<crypto::hash>& txs_ids, std::list<transaction>& txs, std::list<crypto::hash>& missed_txs)
+  bool core::get_transactions(const std::vector<crypto::hash>& txs_ids, std::list<transaction>& txs, std::list<crypto::hash>& missed_txs) const
   {
     return m_blockchain_storage.get_transactions(txs_ids, txs, missed_txs);
   }
   //-----------------------------------------------------------------------------------------------
-  bool core::get_alternative_blocks(std::list<block>& blocks)
+  bool core::get_alternative_blocks(std::list<block>& blocks) const
   {
     return m_blockchain_storage.get_alternative_blocks(blocks);
   }
   //-----------------------------------------------------------------------------------------------
-  size_t core::get_alternative_blocks_count()
+  size_t core::get_alternative_blocks_count() const
   {
     return m_blockchain_storage.get_alternative_blocks_count();
   }
@@ -385,12 +385,12 @@ namespace cryptonote
 	  m_test_drop_download_height = height;
   }
   //-----------------------------------------------------------------------------------------------
-  bool core::get_test_drop_download()
+  bool core::get_test_drop_download() const
   {
 	  return m_test_drop_download;
   }
   //-----------------------------------------------------------------------------------------------
-  bool core::get_test_drop_download_height()
+  bool core::get_test_drop_download_height() const
   {
 	  if (m_test_drop_download_height == 0)
 		return true;
@@ -451,7 +451,7 @@ namespace cryptonote
     return r;
   }
   //-----------------------------------------------------------------------------------------------
-  bool core::get_stat_info(core_stat_info& st_inf)
+  bool core::get_stat_info(core_stat_info& st_inf) const
   {
     st_inf.mining_speed = m_miner.get_speed();
     st_inf.alternative_blocks = m_blockchain_storage.get_alternative_blocks_count();
@@ -462,7 +462,7 @@ namespace cryptonote
   }
 
   //-----------------------------------------------------------------------------------------------
-  bool core::check_tx_semantic(const transaction& tx, bool keeped_by_block)
+  bool core::check_tx_semantic(const transaction& tx, bool keeped_by_block) const
   {
     if(!tx.vin.size())
     {
@@ -515,12 +515,12 @@ namespace cryptonote
     return true;
   }
   //-----------------------------------------------------------------------------------------------
-  bool core::is_key_image_spent(const crypto::key_image &key_image)
+  bool core::is_key_image_spent(const crypto::key_image &key_image) const
   {
     return m_blockchain_storage.have_tx_keyimg_as_spent(key_image);
   }
   //-----------------------------------------------------------------------------------------------
-  bool core::are_key_images_spent(const std::vector<crypto::key_image>& key_im, std::vector<bool> &spent)
+  bool core::are_key_images_spent(const std::vector<crypto::key_image>& key_im, std::vector<bool> &spent) const
   {
     spent.clear();
     BOOST_FOREACH(auto& ki, key_im)
@@ -530,7 +530,7 @@ namespace cryptonote
     return true;
   }
   //-----------------------------------------------------------------------------------------------
-  bool core::check_tx_inputs_keyimages_diff(const transaction& tx)
+  bool core::check_tx_inputs_keyimages_diff(const transaction& tx) const
   {
     std::unordered_set<crypto::key_image> ki;
     BOOST_FOREACH(const auto& in, tx.vin)
@@ -551,7 +551,7 @@ namespace cryptonote
     return add_new_tx(tx, tx_hash, tx_prefix_hash, bl.size(), tvc, keeped_by_block);
   }
   //-----------------------------------------------------------------------------------------------
-  size_t core::get_blockchain_total_transactions()
+  size_t core::get_blockchain_total_transactions() const
   {
     return m_blockchain_storage.get_total_transactions();
   }
@@ -583,22 +583,22 @@ namespace cryptonote
     return m_blockchain_storage.create_block_template(b, adr, diffic, height, ex_nonce);
   }
   //-----------------------------------------------------------------------------------------------
-  bool core::find_blockchain_supplement(const std::list<crypto::hash>& qblock_ids, NOTIFY_RESPONSE_CHAIN_ENTRY::request& resp)
+  bool core::find_blockchain_supplement(const std::list<crypto::hash>& qblock_ids, NOTIFY_RESPONSE_CHAIN_ENTRY::request& resp) const
   {
     return m_blockchain_storage.find_blockchain_supplement(qblock_ids, resp);
   }
   //-----------------------------------------------------------------------------------------------
-  bool core::find_blockchain_supplement(const uint64_t req_start_block, const std::list<crypto::hash>& qblock_ids, std::list<std::pair<block, std::list<transaction> > >& blocks, uint64_t& total_height, uint64_t& start_height, size_t max_count)
+  bool core::find_blockchain_supplement(const uint64_t req_start_block, const std::list<crypto::hash>& qblock_ids, std::list<std::pair<block, std::list<transaction> > >& blocks, uint64_t& total_height, uint64_t& start_height, size_t max_count) const
   {
     return m_blockchain_storage.find_blockchain_supplement(req_start_block, qblock_ids, blocks, total_height, start_height, max_count);
   }
   //-----------------------------------------------------------------------------------------------
-  void core::print_blockchain(uint64_t start_index, uint64_t end_index)
+  void core::print_blockchain(uint64_t start_index, uint64_t end_index) const
   {
     m_blockchain_storage.print_blockchain(start_index, end_index);
   }
   //-----------------------------------------------------------------------------------------------
-  void core::print_blockchain_index()
+  void core::print_blockchain_index() const
   {
     m_blockchain_storage.print_blockchain_index();
   }
@@ -608,12 +608,12 @@ namespace cryptonote
     m_blockchain_storage.print_blockchain_outs(file);
   }
   //-----------------------------------------------------------------------------------------------
-  bool core::get_random_outs_for_amounts(const COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::request& req, COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::response& res)
+  bool core::get_random_outs_for_amounts(const COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::request& req, COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::response& res) const
   {
     return m_blockchain_storage.get_random_outs_for_amounts(req, res);
   }
   //-----------------------------------------------------------------------------------------------
-  bool core::get_tx_outputs_gindexs(const crypto::hash& tx_id, std::vector<uint64_t>& indexs)
+  bool core::get_tx_outputs_gindexs(const crypto::hash& tx_id, std::vector<uint64_t>& indexs) const
   {
     return m_blockchain_storage.get_tx_outputs_gindexs(tx_id, indexs);
   }
@@ -728,7 +728,7 @@ namespace cryptonote
   //-----------------------------------------------------------------------------------------------
   // Used by the RPC server to check the size of an incoming
   // block_blob
-  bool core::check_incoming_block_size(const blobdata& block_blob)
+  bool core::check_incoming_block_size(const blobdata& block_blob) const
   {
     if(block_blob.size() > get_max_block_size())
     {
@@ -738,32 +738,32 @@ namespace cryptonote
     return true;
   }
   //-----------------------------------------------------------------------------------------------
-  crypto::hash core::get_tail_id()
+  crypto::hash core::get_tail_id() const
   {
     return m_blockchain_storage.get_tail_id();
   }
   //-----------------------------------------------------------------------------------------------
-  size_t core::get_pool_transactions_count()
+  size_t core::get_pool_transactions_count() const
   {
     return m_mempool.get_transactions_count();
   }
   //-----------------------------------------------------------------------------------------------
-  bool core::have_block(const crypto::hash& id)
+  bool core::have_block(const crypto::hash& id) const
   {
     return m_blockchain_storage.have_block(id);
   }
   //-----------------------------------------------------------------------------------------------
-  bool core::parse_tx_from_blob(transaction& tx, crypto::hash& tx_hash, crypto::hash& tx_prefix_hash, const blobdata& blob)
+  bool core::parse_tx_from_blob(transaction& tx, crypto::hash& tx_hash, crypto::hash& tx_prefix_hash, const blobdata& blob) const
   {
     return parse_and_validate_tx_from_blob(blob, tx, tx_hash, tx_prefix_hash);
   }
   //-----------------------------------------------------------------------------------------------
-    bool core::check_tx_syntax(const transaction& tx)
+  bool core::check_tx_syntax(const transaction& tx) const
   {
     return true;
   }
   //-----------------------------------------------------------------------------------------------
-  bool core::get_pool_transactions(std::list<transaction>& txs)
+  bool core::get_pool_transactions(std::list<transaction>& txs) const
   {
     m_mempool.get_transactions(txs);
     return true;
@@ -774,7 +774,7 @@ namespace cryptonote
     return m_mempool.get_transactions_and_spent_keys_info(tx_infos, key_image_infos);
   }
   //-----------------------------------------------------------------------------------------------
-  bool core::get_short_chain_history(std::list<crypto::hash>& ids)
+  bool core::get_short_chain_history(std::list<crypto::hash>& ids) const
   {
     return m_blockchain_storage.get_short_chain_history(ids);
   }
@@ -784,12 +784,12 @@ namespace cryptonote
     return m_blockchain_storage.handle_get_objects(arg, rsp);
   }
   //-----------------------------------------------------------------------------------------------
-  crypto::hash core::get_block_id_by_height(uint64_t height)
+  crypto::hash core::get_block_id_by_height(uint64_t height) const
   {
     return m_blockchain_storage.get_block_id_by_height(height);
   }
   //-----------------------------------------------------------------------------------------------
-  bool core::get_block_by_hash(const crypto::hash &h, block &blk)
+  bool core::get_block_by_hash(const crypto::hash &h, block &blk) const
   {
     return m_blockchain_storage.get_block_by_hash(h, blk);
   }
@@ -798,7 +798,7 @@ namespace cryptonote
   //  m_blockchain_storage.get_all_known_block_ids(main, alt, invalid);
   //}
   //-----------------------------------------------------------------------------------------------
-  std::string core::print_pool(bool short_format)
+  std::string core::print_pool(bool short_format) const
   {
     return m_mempool.print_pool(short_format);
   }
diff --git a/src/cryptonote_core/cryptonote_core.h b/src/cryptonote_core/cryptonote_core.h
index 8e134e080..634340a3f 100644
--- a/src/cryptonote_core/cryptonote_core.h
+++ b/src/cryptonote_core/cryptonote_core.h
@@ -69,7 +69,7 @@ namespace cryptonote
      bool prepare_handle_incoming_blocks(const std::list<block_complete_entry>  &blocks);
      bool cleanup_handle_incoming_blocks(bool force_sync = false);
      	     	
-     bool check_incoming_block_size(const blobdata& block_blob);
+     bool check_incoming_block_size(const blobdata& block_blob) const;
      i_cryptonote_protocol* get_protocol(){return m_pprotocol;}
 
      //-------------------- i_miner_handler -----------------------
@@ -78,6 +78,7 @@ namespace cryptonote
 
 
      miner& get_miner(){return m_miner;}
+     const miner& get_miner()const{return m_miner;}
      static void init_options(boost::program_options::options_description& desc);
      bool init(const boost::program_options::variables_map& vm);
      bool set_genesis_block(const block& b);
@@ -86,55 +87,57 @@ namespace cryptonote
      static bool get_fast_exit();
      void test_drop_download();
      void test_drop_download_height(uint64_t height);
-     bool get_test_drop_download();
-     bool get_test_drop_download_height();
-     uint64_t get_current_blockchain_height();
-     bool get_blockchain_top(uint64_t& heeight, crypto::hash& top_id);
-     bool get_blocks(uint64_t start_offset, size_t count, std::list<block>& blocks, std::list<transaction>& txs);
-     bool get_blocks(uint64_t start_offset, size_t count, std::list<block>& blocks);
+     bool get_test_drop_download() const;
+     bool get_test_drop_download_height() const;
+     uint64_t get_current_blockchain_height() const;
+     bool get_blockchain_top(uint64_t& heeight, crypto::hash& top_id) const;
+     bool get_blocks(uint64_t start_offset, size_t count, std::list<block>& blocks, std::list<transaction>& txs) const;
+     bool get_blocks(uint64_t start_offset, size_t count, std::list<block>& blocks) const;
      template<class t_ids_container, class t_blocks_container, class t_missed_container>
-     bool get_blocks(const t_ids_container& block_ids, t_blocks_container& blocks, t_missed_container& missed_bs)
+     bool get_blocks(const t_ids_container& block_ids, t_blocks_container& blocks, t_missed_container& missed_bs) const
      {
        return m_blockchain_storage.get_blocks(block_ids, blocks, missed_bs);
      }
-     crypto::hash get_block_id_by_height(uint64_t height);
-     bool get_transactions(const std::vector<crypto::hash>& txs_ids, std::list<transaction>& txs, std::list<crypto::hash>& missed_txs);
-     bool get_block_by_hash(const crypto::hash &h, block &blk);
+     crypto::hash get_block_id_by_height(uint64_t height) const;
+     bool get_transactions(const std::vector<crypto::hash>& txs_ids, std::list<transaction>& txs, std::list<crypto::hash>& missed_txs) const;
+     bool get_block_by_hash(const crypto::hash &h, block &blk) const;
      //void get_all_known_block_ids(std::list<crypto::hash> &main, std::list<crypto::hash> &alt, std::list<crypto::hash> &invalid);
 
-     bool get_alternative_blocks(std::list<block>& blocks);
-     size_t get_alternative_blocks_count();
+     bool get_alternative_blocks(std::list<block>& blocks) const;
+     size_t get_alternative_blocks_count() const;
 
      void set_cryptonote_protocol(i_cryptonote_protocol* pprotocol);
      void set_checkpoints(checkpoints&& chk_pts);
      void set_checkpoints_file_path(const std::string& path);
      void set_enforce_dns_checkpoints(bool enforce_dns);
 
-     bool get_pool_transactions(std::list<transaction>& txs);
+     bool get_pool_transactions(std::list<transaction>& txs) const;
      bool get_pool_transactions_and_spent_keys_info(std::vector<tx_info>& tx_infos, std::vector<spent_key_image_info>& key_image_infos) const;
-     size_t get_pool_transactions_count();
-     size_t get_blockchain_total_transactions();
+     size_t get_pool_transactions_count() const;
+     size_t get_blockchain_total_transactions() const;
      //bool get_outs(uint64_t amount, std::list<crypto::public_key>& pkeys);
-     bool have_block(const crypto::hash& id);
-     bool get_short_chain_history(std::list<crypto::hash>& ids);
-     bool find_blockchain_supplement(const std::list<crypto::hash>& qblock_ids, NOTIFY_RESPONSE_CHAIN_ENTRY::request& resp);
-     bool find_blockchain_supplement(const uint64_t req_start_block, const std::list<crypto::hash>& qblock_ids, std::list<std::pair<block, std::list<transaction> > >& blocks, uint64_t& total_height, uint64_t& start_height, size_t max_count);
-     bool get_stat_info(core_stat_info& st_inf);
+     bool have_block(const crypto::hash& id) const;
+     bool get_short_chain_history(std::list<crypto::hash>& ids) const;
+     bool find_blockchain_supplement(const std::list<crypto::hash>& qblock_ids, NOTIFY_RESPONSE_CHAIN_ENTRY::request& resp) const;
+     bool find_blockchain_supplement(const uint64_t req_start_block, const std::list<crypto::hash>& qblock_ids, std::list<std::pair<block, std::list<transaction> > >& blocks, uint64_t& total_height, uint64_t& start_height, size_t max_count) const;
+     bool get_stat_info(core_stat_info& st_inf) const;
      //bool get_backward_blocks_sizes(uint64_t from_height, std::vector<size_t>& sizes, size_t count);
-     bool get_tx_outputs_gindexs(const crypto::hash& tx_id, std::vector<uint64_t>& indexs);
-     crypto::hash get_tail_id();
-     bool get_random_outs_for_amounts(const COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::request& req, COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::response& res);
+     bool get_tx_outputs_gindexs(const crypto::hash& tx_id, std::vector<uint64_t>& indexs) const;
+     crypto::hash get_tail_id() const;
+     bool get_random_outs_for_amounts(const COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::request& req, COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::response& res) const;
      void pause_mine();
      void resume_mine();
 #if BLOCKCHAIN_DB == DB_LMDB
      Blockchain& get_blockchain_storage(){return m_blockchain_storage;}
+     const Blockchain& get_blockchain_storage()const{return m_blockchain_storage;}
 #else
      blockchain_storage& get_blockchain_storage(){return m_blockchain_storage;}
+     const blockchain_storage& get_blockchain_storage()const{return m_blockchain_storage;}
 #endif
      //debug functions
-     void print_blockchain(uint64_t start_index, uint64_t end_index);
-     void print_blockchain_index();
-     std::string print_pool(bool short_format);
+     void print_blockchain(uint64_t start_index, uint64_t end_index) const;
+     void print_blockchain_index() const;
+     std::string print_pool(bool short_format) const;
      void print_blockchain_outs(const std::string& file);
      void on_synchronized();
 
@@ -145,27 +148,27 @@ namespace cryptonote
 
      void stop();
 
-     bool is_key_image_spent(const crypto::key_image& key_im);
-     bool are_key_images_spent(const std::vector<crypto::key_image>& key_im, std::vector<bool> &spent);
+     bool is_key_image_spent(const crypto::key_image& key_im) const;
+     bool are_key_images_spent(const std::vector<crypto::key_image>& key_im, std::vector<bool> &spent) const;
 
    private:
      bool add_new_tx(const transaction& tx, const crypto::hash& tx_hash, const crypto::hash& tx_prefix_hash, size_t blob_size, tx_verification_context& tvc, bool keeped_by_block);
      bool add_new_tx(const transaction& tx, tx_verification_context& tvc, bool keeped_by_block);
      bool add_new_block(const block& b, block_verification_context& bvc);
      bool load_state_data();
-     bool parse_tx_from_blob(transaction& tx, crypto::hash& tx_hash, crypto::hash& tx_prefix_hash, const blobdata& blob);
+     bool parse_tx_from_blob(transaction& tx, crypto::hash& tx_hash, crypto::hash& tx_prefix_hash, const blobdata& blob) const;
 
-     bool check_tx_syntax(const transaction& tx);
+     bool check_tx_syntax(const transaction& tx) const;
      //check correct values, amounts and all lightweight checks not related with database
-     bool check_tx_semantic(const transaction& tx, bool keeped_by_block);
+     bool check_tx_semantic(const transaction& tx, bool keeped_by_block) const;
      //check if tx already in memory pool or in main blockchain
 
-     bool check_tx_ring_signature(const txin_to_key& tx, const crypto::hash& tx_prefix_hash, const std::vector<crypto::signature>& sig);
-     bool is_tx_spendtime_unlocked(uint64_t unlock_time);
+     bool check_tx_ring_signature(const txin_to_key& tx, const crypto::hash& tx_prefix_hash, const std::vector<crypto::signature>& sig) const;
+     bool is_tx_spendtime_unlocked(uint64_t unlock_time) const;
      bool update_miner_block_template();
      bool handle_command_line(const boost::program_options::variables_map& vm);
      bool on_update_blocktemplate_interval();
-     bool check_tx_inputs_keyimages_diff(const transaction& tx);
+     bool check_tx_inputs_keyimages_diff(const transaction& tx) const;
      void graceful_exit();
      bool check_fork_time();
      static std::atomic<bool> m_fast_exit;