cryptonote::rpc::DaemonHandler Class Reference

#include <daemon_handler.h>

Inheritance diagram for cryptonote::rpc::DaemonHandler:

Collaboration diagram for cryptonote::rpc::DaemonHandler:

Public Member Functions
	DaemonHandler (cryptonote::core &c, t_p2p &p2p)
	~DaemonHandler ()
void	handle (const GetHeight::Request &req, GetHeight::Response &res)
void	handle (const GetBlocksFast::Request &req, GetBlocksFast::Response &res)
void	handle (const GetHashesFast::Request &req, GetHashesFast::Response &res)
void	handle (const GetTransactions::Request &req, GetTransactions::Response &res)
void	handle (const KeyImagesSpent::Request &req, KeyImagesSpent::Response &res)
void	handle (const GetTxGlobalOutputIndices::Request &req, GetTxGlobalOutputIndices::Response &res)
void	handle (const SendRawTx::Request &req, SendRawTx::Response &res)
void	handle (const SendRawTxHex::Request &req, SendRawTxHex::Response &res)
void	handle (const StartMining::Request &req, StartMining::Response &res)
void	handle (const GetInfo::Request &req, GetInfo::Response &res)
void	handle (const StopMining::Request &req, StopMining::Response &res)
void	handle (const MiningStatus::Request &req, MiningStatus::Response &res)
void	handle (const SaveBC::Request &req, SaveBC::Response &res)
void	handle (const GetBlockHash::Request &req, GetBlockHash::Response &res)
void	handle (const GetBlockTemplate::Request &req, GetBlockTemplate::Response &res)
void	handle (const SubmitBlock::Request &req, SubmitBlock::Response &res)
void	handle (const GetLastBlockHeader::Request &req, GetLastBlockHeader::Response &res)
void	handle (const GetBlockHeaderByHash::Request &req, GetBlockHeaderByHash::Response &res)
void	handle (const GetBlockHeaderByHeight::Request &req, GetBlockHeaderByHeight::Response &res)
void	handle (const GetBlockHeadersByHeight::Request &req, GetBlockHeadersByHeight::Response &res)
void	handle (const GetBlock::Request &req, GetBlock::Response &res)
void	handle (const GetPeerList::Request &req, GetPeerList::Response &res)
void	handle (const SetLogHashRate::Request &req, SetLogHashRate::Response &res)
void	handle (const SetLogLevel::Request &req, SetLogLevel::Response &res)
void	handle (const GetTransactionPool::Request &req, GetTransactionPool::Response &res)
void	handle (const GetConnections::Request &req, GetConnections::Response &res)
void	handle (const GetBlockHeadersRange::Request &req, GetBlockHeadersRange::Response &res)
void	handle (const StopDaemon::Request &req, StopDaemon::Response &res)
void	handle (const StartSaveGraph::Request &req, StartSaveGraph::Response &res)
void	handle (const StopSaveGraph::Request &req, StopSaveGraph::Response &res)
void	handle (const HardForkInfo::Request &req, HardForkInfo::Response &res)
void	handle (const GetBans::Request &req, GetBans::Response &res)
void	handle (const SetBans::Request &req, SetBans::Response &res)
void	handle (const FlushTransactionPool::Request &req, FlushTransactionPool::Response &res)
void	handle (const GetOutputHistogram::Request &req, GetOutputHistogram::Response &res)
void	handle (const GetOutputKeys::Request &req, GetOutputKeys::Response &res)
void	handle (const GetRPCVersion::Request &req, GetRPCVersion::Response &res)
void	handle (const GetFeeEstimate::Request &req, GetFeeEstimate::Response &res)
void	handle (const GetOutputDistribution::Request &req, GetOutputDistribution::Response &res)
std::string	handle (const std::string &request)
Public Member Functions inherited from cryptonote::rpc::RpcHandler
	RpcHandler ()
virtual	~RpcHandler ()

Additional Inherited Members
Static Public Member Functions inherited from cryptonote::rpc::RpcHandler
static boost::optional< output_distribution_data >	get_output_distribution (const std::function< bool(uint64_t, uint64_t, uint64_t, uint64_t &, std::vector< uint64_t > &, uint64_t &)> &f, uint64_t amount, uint64_t from_height, uint64_t to_height, const std::function< crypto::hash(uint64_t)> &get_hash, bool cumulative, uint64_t blockchain_height)

Detailed Description

Definition at line 49 of file daemon_handler.h.

Constructor & Destructor Documentation

DaemonHandler()

cryptonote::rpc::DaemonHandler::DaemonHandler ( cryptonote::core & c, t_p2p & p2p )

inline

Definition at line 53 of file daemon_handler.h.

: m_core(c), m_p2p(p2p) { }

~DaemonHandler()

cryptonote::rpc::DaemonHandler::~DaemonHandler ( )

inline

Definition at line 55 of file daemon_handler.h.

{ }

Member Function Documentation

handle() [1/40]

void cryptonote::rpc::DaemonHandler::handle	(	const FlushTransactionPool::Request &	req,
		FlushTransactionPool::Response &	res )

Definition at line 716 of file daemon_handler.cpp.

  {
    res.status = Message::STATUS_FAILED;
    res.error_details = "RPC method not yet implemented.";
  }

handle() [2/40]

void cryptonote::rpc::DaemonHandler::handle	(	const GetBans::Request &	req,
		GetBans::Response &	res )

Definition at line 704 of file daemon_handler.cpp.

  {
    res.status = Message::STATUS_FAILED;
    res.error_details = "RPC method not yet implemented.";
  }

handle() [3/40]

void cryptonote::rpc::DaemonHandler::handle	(	const GetBlock::Request &	req,
		GetBlock::Response &	res )

Definition at line 624 of file daemon_handler.cpp.

  {
    res.status = Message::STATUS_FAILED;
    res.error_details = "RPC method not yet implemented.";
  }

handle() [4/40]

void cryptonote::rpc::DaemonHandler::handle	(	const GetBlockHash::Request &	req,
		GetBlockHash::Response &	res )

Definition at line 538 of file daemon_handler.cpp.

  {
    if (m_core.get_current_blockchain_height() <= req.height)
    {
      res.hash = crypto::null_hash;
      res.status = Message::STATUS_FAILED;
      res.error_details = "height given is higher than current chain height";
      return;
    }
 
    res.hash = m_core.get_block_id_by_height(req.height);
 
    res.status = Message::STATUS_OK;
  }

handle() [5/40]

void cryptonote::rpc::DaemonHandler::handle	(	const GetBlockHeaderByHash::Request &	req,
		GetBlockHeaderByHash::Response &	res )

Definition at line 579 of file daemon_handler.cpp.

  {
    if (!getBlockHeaderByHash(req.hash, res.header))
    {
      res.status = Message::STATUS_FAILED;
      res.error_details = "Requested block does not exist";
      return;
    }
 
    res.status = Message::STATUS_OK;
  }

handle() [6/40]

void cryptonote::rpc::DaemonHandler::handle	(	const GetBlockHeaderByHeight::Request &	req,
		GetBlockHeaderByHeight::Response &	res )

Definition at line 591 of file daemon_handler.cpp.

  {
    const crypto::hash block_hash = m_core.get_block_id_by_height(req.height);
 
    if (!getBlockHeaderByHash(block_hash, res.header))
    {
      res.status = Message::STATUS_FAILED;
      res.error_details = "Requested block does not exist";
      return;
    }
 
    res.status = Message::STATUS_OK;
  }

handle() [7/40]

void cryptonote::rpc::DaemonHandler::handle	(	const GetBlockHeadersByHeight::Request &	req,
		GetBlockHeadersByHeight::Response &	res )

Definition at line 605 of file daemon_handler.cpp.

  {
    res.headers.resize(req.heights.size());
 
    for (size_t i=0; i < req.heights.size(); i++)
    {
      const crypto::hash block_hash = m_core.get_block_id_by_height(req.heights[i]);
 
      if (!getBlockHeaderByHash(block_hash, res.headers[i]))
      {
        res.status = Message::STATUS_FAILED;
        res.error_details = "A requested block does not exist";
        return;
      }
    }
 
    res.status = Message::STATUS_OK;
  }

handle() [8/40]

void cryptonote::rpc::DaemonHandler::handle	(	const GetBlockHeadersRange::Request &	req,
		GetBlockHeadersRange::Response &	res )

Definition at line 670 of file daemon_handler.cpp.

  {
    res.status = Message::STATUS_FAILED;
    res.error_details = "RPC method not yet implemented.";
  }

handle() [9/40]

void cryptonote::rpc::DaemonHandler::handle	(	const GetBlocksFast::Request &	req,
		GetBlocksFast::Response &	res )

Definition at line 52 of file daemon_handler.cpp.

  {
    std::vector<std::pair<std::pair<blobdata, crypto::hash>, std::vector<std::pair<crypto::hash, blobdata> > > > blocks;
 
    if(!m_core.find_blockchain_supplement(req.start_height, req.block_ids, blocks, res.current_height, res.start_height, req.prune, true, COMMAND_RPC_GET_BLOCKS_FAST_MAX_COUNT))
    {
      res.status = Message::STATUS_FAILED;
      res.error_details = "core::find_blockchain_supplement() returned false";
      return;
    }
 
    res.blocks.resize(blocks.size());
    res.output_indices.resize(blocks.size());
 
    auto it = blocks.begin();
 
    uint64_t block_count = 0;
    while (it != blocks.end())
    {
      cryptonote::rpc::block_with_transactions& bwt = res.blocks[block_count];
 
      if (!parse_and_validate_block_from_blob(it->first.first, bwt.block))
      {
        res.blocks.clear();
        res.output_indices.clear();
        res.status = Message::STATUS_FAILED;
        res.error_details = "failed retrieving a requested block";
        return;
      }
 
      if (it->second.size() != bwt.block.tx_hashes.size())
      {
          res.blocks.clear();
          res.output_indices.clear();
          res.status = Message::STATUS_FAILED;
          res.error_details = "incorrect number of transactions retrieved for block";
          return;
      }
 
      cryptonote::rpc::block_output_indices& indices = res.output_indices[block_count];
 
      // miner tx output indices
      {
        cryptonote::rpc::tx_output_indices tx_indices;
        if (!m_core.get_tx_outputs_gindexs(get_transaction_hash(bwt.block.miner_tx), tx_indices))
        {
          res.status = Message::STATUS_FAILED;
          res.error_details = "core::get_tx_outputs_gindexs() returned false";
          return;
        }
        indices.push_back(std::move(tx_indices));
      }
 
      auto hash_it = bwt.block.tx_hashes.begin();
      bwt.transactions.reserve(it->second.size());
      for (const auto& blob : it->second)
      {
        bwt.transactions.emplace_back();
        if (!parse_and_validate_tx_from_blob(blob.second, bwt.transactions.back()))
        {
          res.blocks.clear();
          res.output_indices.clear();
          res.status = Message::STATUS_FAILED;
          res.error_details = "failed retrieving a requested transaction";
          return;
        }
 
        cryptonote::rpc::tx_output_indices tx_indices;
        if (!m_core.get_tx_outputs_gindexs(*hash_it, tx_indices))
        {
          res.status = Message::STATUS_FAILED;
          res.error_details = "core::get_tx_outputs_gindexs() returned false";
          return;
        }
 
        indices.push_back(std::move(tx_indices));
        ++hash_it;
      }
 
      it++;
      block_count++;
    }
 
    res.status = Message::STATUS_OK;
  }

Here is the call graph for this function:

handle() [10/40]

void cryptonote::rpc::DaemonHandler::handle	(	const GetBlockTemplate::Request &	req,
		GetBlockTemplate::Response &	res )

Definition at line 553 of file daemon_handler.cpp.

  {
    res.status = Message::STATUS_FAILED;
    res.error_details = "RPC method not yet implemented.";
  }

handle() [11/40]

void cryptonote::rpc::DaemonHandler::handle	(	const GetConnections::Request &	req,
		GetConnections::Response &	res )

Definition at line 664 of file daemon_handler.cpp.

  {
    res.status = Message::STATUS_FAILED;
    res.error_details = "RPC method not yet implemented.";
  }

handle() [12/40]

void cryptonote::rpc::DaemonHandler::handle	(	const GetFeeEstimate::Request &	req,
		GetFeeEstimate::Response &	res )

Definition at line 776 of file daemon_handler.cpp.

  {
    res.hard_fork_version = m_core.get_blockchain_storage().get_current_hard_fork_version();
    res.estimated_base_fee = m_core.get_blockchain_storage().get_dynamic_base_fee_estimate(req.num_grace_blocks);
 
    if (res.hard_fork_version < HF_VERSION_PER_BYTE_FEE)
    {
       res.size_scale = 1024; // per KiB fee
       res.fee_mask = 1;
    }
    else
    {
      res.size_scale = 1; // per byte fee
      res.fee_mask = Blockchain::get_fee_quantization_mask();
    }
    res.status = Message::STATUS_OK;
  }

Here is the call graph for this function:

handle() [13/40]

void cryptonote::rpc::DaemonHandler::handle	(	const GetHashesFast::Request &	req,
		GetHashesFast::Response &	res )

Definition at line 138 of file daemon_handler.cpp.

  {
    res.start_height = req.start_height;
 
    auto& chain = m_core.get_blockchain_storage();
 
    if (!chain.find_blockchain_supplement(req.known_hashes, res.hashes, res.start_height, res.current_height, false))
    {
      res.status = Message::STATUS_FAILED;
      res.error_details = "Blockchain::find_blockchain_supplement() returned false";
      return;
    }
 
    res.status = Message::STATUS_OK;
  }

handle() [14/40]

void cryptonote::rpc::DaemonHandler::handle	(	const GetHeight::Request &	req,
		GetHeight::Response &	res )

Definition at line 45 of file daemon_handler.cpp.

  {
    res.height = m_core.get_current_blockchain_height();
 
    res.status = Message::STATUS_OK;
  }

Here is the caller graph for this function:

handle() [15/40]

void cryptonote::rpc::DaemonHandler::handle	(	const GetInfo::Request &	req,
		GetInfo::Response &	res )

Definition at line 448 of file daemon_handler.cpp.

  {
    res.info.height = m_core.get_current_blockchain_height();
 
    res.info.target_height = m_core.get_target_blockchain_height();
 
    if (res.info.height > res.info.target_height)
    {
      res.info.target_height = res.info.height;
    }
 
    auto& chain = m_core.get_blockchain_storage();
 
    res.info.wide_difficulty = chain.get_difficulty_for_next_block();
    res.info.difficulty = (res.info.wide_difficulty & 0xffffffffffffffff).convert_to<uint64_t>();
 
    res.info.target = chain.get_difficulty_target();
 
    res.info.tx_count = chain.get_total_transactions() - res.info.height; //without coinbase
 
    res.info.tx_pool_size = m_core.get_pool_transactions_count();
 
    res.info.alt_blocks_count = chain.get_alternative_blocks_count();
 
    uint64_t total_conn = m_p2p.get_public_connections_count();
    res.info.outgoing_connections_count = m_p2p.get_public_outgoing_connections_count();
    res.info.incoming_connections_count = total_conn - res.info.outgoing_connections_count;
 
    res.info.white_peerlist_size = m_p2p.get_public_white_peers_count();
 
    res.info.grey_peerlist_size = m_p2p.get_public_gray_peers_count();
 
    res.info.mainnet = m_core.get_nettype() == MAINNET;
    res.info.testnet = m_core.get_nettype() == TESTNET;
    res.info.stagenet = m_core.get_nettype() == STAGENET;
    res.info.wide_cumulative_difficulty = m_core.get_blockchain_storage().get_db().get_block_cumulative_difficulty(res.info.height - 1);
    res.info.cumulative_difficulty = (res.info.wide_cumulative_difficulty & 0xffffffffffffffff).convert_to<uint64_t>();
    res.info.block_size_limit = res.info.block_weight_limit = m_core.get_blockchain_storage().get_current_cumulative_block_weight_limit();
    res.info.block_size_median = res.info.block_weight_median = m_core.get_blockchain_storage().get_current_cumulative_block_weight_median();
    res.info.start_time = (uint64_t)m_core.get_start_time();
    res.info.version = ELECTRONEUM_VERSION;
 
    res.status = Message::STATUS_OK;
    res.error_details = "";
  }

handle() [16/40]

void cryptonote::rpc::DaemonHandler::handle	(	const GetLastBlockHeader::Request &	req,
		GetLastBlockHeader::Response &	res )

Definition at line 565 of file daemon_handler.cpp.

  {
    const crypto::hash block_hash = m_core.get_tail_id();
 
    if (!getBlockHeaderByHash(block_hash, res.header))
    {
      res.status = Message::STATUS_FAILED;
      res.error_details = "Requested block does not exist";
      return;
    }
 
    res.status = Message::STATUS_OK;
  }

handle() [17/40]

void cryptonote::rpc::DaemonHandler::handle	(	const GetOutputDistribution::Request &	req,
		GetOutputDistribution::Response &	res )

Definition at line 794 of file daemon_handler.cpp.

  {
    try
    {
      res.distributions.reserve(req.amounts.size());
 
      const uint64_t req_to_height = req.to_height ? req.to_height : (m_core.get_current_blockchain_height() - 1);
      for (std::uint64_t amount : req.amounts)
      {
        auto data = rpc::RpcHandler::get_output_distribution([this](uint64_t amount, uint64_t from, uint64_t to, uint64_t &start_height, std::vector<uint64_t> &distribution, uint64_t &base) { return m_core.get_output_distribution(amount, from, to, start_height, distribution, base); }, amount, req.from_height, req_to_height, [this](uint64_t height) { return m_core.get_blockchain_storage().get_db().get_block_hash_from_height(height); }, req.cumulative, m_core.get_current_blockchain_height());
        if (!data)
        {
          res.distributions.clear();
          res.status = Message::STATUS_FAILED;
          res.error_details = "Failed to get output distribution";
          return;
        }
        res.distributions.push_back(output_distribution{std::move(*data), amount, req.cumulative});
      }
      res.status = Message::STATUS_OK;
    }
    catch (const std::exception& e)
    {
      res.distributions.clear();
      res.status = Message::STATUS_FAILED;
      res.error_details = e.what();
    }
  }

Here is the call graph for this function:

handle() [18/40]

void cryptonote::rpc::DaemonHandler::handle	(	const GetOutputHistogram::Request &	req,
		GetOutputHistogram::Response &	res )

Definition at line 722 of file daemon_handler.cpp.

  {
    std::map<uint64_t, std::tuple<uint64_t, uint64_t, uint64_t> > histogram;
    try
    {
      histogram = m_core.get_blockchain_storage().get_output_histogram(req.amounts, req.unlocked, req.recent_cutoff);
    }
    catch (const std::exception &e)
    {
      res.status = Message::STATUS_FAILED;
      res.error_details = e.what();
      return;
    }
 
    res.histogram.clear();
    res.histogram.reserve(histogram.size());
    for (const auto &i: histogram)
    {
      if (std::get<0>(i.second) >= req.min_count && (std::get<0>(i.second) <= req.max_count || req.max_count == 0))
        res.histogram.emplace_back(output_amount_count{i.first, std::get<0>(i.second), std::get<1>(i.second), std::get<2>(i.second)});
    }
 
    res.status = Message::STATUS_OK;
  }

handle() [19/40]

void cryptonote::rpc::DaemonHandler::handle	(	const GetOutputKeys::Request &	req,
		GetOutputKeys::Response &	res )

Definition at line 747 of file daemon_handler.cpp.

  {
    try
    {
      for (const auto& i : req.outputs)
      {
        crypto::public_key key;
        rct::key mask;
        bool unlocked;
        m_core.get_blockchain_storage().get_output_key_mask_unlocked(i.amount, i.index, key, mask, unlocked);
        res.keys.emplace_back(output_key_mask_unlocked{key, mask, unlocked});
      }
    }
    catch (const std::exception& e)
    {
      res.status = Message::STATUS_FAILED;
      res.error_details = e.what();
      return;
    }
 
    res.status = Message::STATUS_OK;
  }

handle() [20/40]

void cryptonote::rpc::DaemonHandler::handle	(	const GetPeerList::Request &	req,
		GetPeerList::Response &	res )

Definition at line 630 of file daemon_handler.cpp.

  {
    res.status = Message::STATUS_FAILED;
    res.error_details = "RPC method not yet implemented.";
  }

handle() [21/40]

void cryptonote::rpc::DaemonHandler::handle	(	const GetRPCVersion::Request &	req,
		GetRPCVersion::Response &	res )

Definition at line 770 of file daemon_handler.cpp.

  {
    res.version = DAEMON_RPC_VERSION_ZMQ;
    res.status = Message::STATUS_OK;
  }

handle() [22/40]

void cryptonote::rpc::DaemonHandler::handle	(	const GetTransactionPool::Request &	req,
		GetTransactionPool::Response &	res )

Definition at line 656 of file daemon_handler.cpp.

  {
    bool r = m_core.get_pool_for_rpc(res.transactions, res.key_images);
 
    if (!r) res.status = Message::STATUS_FAILED;
    else res.status = Message::STATUS_OK;
  }

handle() [23/40]

void cryptonote::rpc::DaemonHandler::handle	(	const GetTransactions::Request &	req,
		GetTransactions::Response &	res )

Definition at line 154 of file daemon_handler.cpp.

  {
    std::vector<cryptonote::transaction> found_txs_vec;
    std::vector<crypto::hash> missed_vec;
 
    bool r = m_core.get_transactions(req.tx_hashes, found_txs_vec, missed_vec);
 
    // TODO: consider fixing core::get_transactions to not hide exceptions
    if (!r)
    {
      res.status = Message::STATUS_FAILED;
      res.error_details = "core::get_transactions() returned false (exception caught there)";
      return;
    }
 
    size_t num_found = found_txs_vec.size();
 
    std::vector<uint64_t> heights(num_found);
    std::vector<bool> in_pool(num_found, false);
    std::vector<crypto::hash> found_hashes(num_found);
 
    for (size_t i=0; i < num_found; i++)
    {
      found_hashes[i] = get_transaction_hash(found_txs_vec[i]);
      heights[i] = m_core.get_blockchain_storage().get_db().get_tx_block_height(found_hashes[i]);
    }
 
    // if any missing from blockchain, check in tx pool
    if (!missed_vec.empty())
    {
      std::vector<cryptonote::transaction> pool_txs;
 
      m_core.get_pool_transactions(pool_txs);
 
      for (const auto& tx : pool_txs)
      {
        crypto::hash h = get_transaction_hash(tx);
 
        auto itr = std::find(missed_vec.begin(), missed_vec.end(), h);
 
        if (itr != missed_vec.end())
        {
          found_hashes.push_back(h);
          found_txs_vec.push_back(tx);
          heights.push_back(std::numeric_limits<uint64_t>::max());
          in_pool.push_back(true);
          missed_vec.erase(itr);
        }
      }
    }
 
    for (size_t i=0; i < found_hashes.size(); i++)
    {
      cryptonote::rpc::transaction_info info;
      info.height = heights[i];
      info.in_pool = in_pool[i];
      info.transaction = std::move(found_txs_vec[i]);
 
      res.txs.emplace(found_hashes[i], std::move(info));
    }
                                      
    res.missed_hashes = std::move(missed_vec);
    res.status = Message::STATUS_OK;
  }

Here is the call graph for this function:

handle() [24/40]

void cryptonote::rpc::DaemonHandler::handle	(	const GetTxGlobalOutputIndices::Request &	req,
		GetTxGlobalOutputIndices::Response &	res )

Definition at line 251 of file daemon_handler.cpp.

  {
    if (!m_core.get_tx_outputs_gindexs(req.tx_hash, res.output_indices))
    {
      res.status = Message::STATUS_FAILED;
      res.error_details = "core::get_tx_outputs_gindexs() returned false";
      return;
    }
 
    res.status = Message::STATUS_OK;
 
  }

handle() [25/40]

void cryptonote::rpc::DaemonHandler::handle	(	const HardForkInfo::Request &	req,
		HardForkInfo::Response &	res )

Definition at line 694 of file daemon_handler.cpp.

  {
    const Blockchain &blockchain = m_core.get_blockchain_storage();
    uint8_t version = req.version > 0 ? req.version : blockchain.get_ideal_hard_fork_version();
    res.info.version = blockchain.get_current_hard_fork_version();
    res.info.enabled = blockchain.get_hard_fork_voting_info(version, res.info.window, res.info.votes, res.info.threshold, res.info.earliest_height, res.info.voting);
    res.info.state = blockchain.get_hard_fork_state();
    res.status = Message::STATUS_OK;
  }

Here is the call graph for this function:

handle() [26/40]

void cryptonote::rpc::DaemonHandler::handle	(	const KeyImagesSpent::Request &	req,
		KeyImagesSpent::Response &	res )

Definition at line 219 of file daemon_handler.cpp.

  {
    res.spent_status.resize(req.key_images.size(), KeyImagesSpent::STATUS::UNSPENT);
 
    std::vector<bool> chain_spent_status;
    std::vector<bool> pool_spent_status;
 
    m_core.are_key_images_spent(req.key_images, chain_spent_status);
    m_core.are_key_images_spent_in_pool(req.key_images, pool_spent_status);
 
    if ((chain_spent_status.size() != req.key_images.size()) || (pool_spent_status.size() != req.key_images.size()))
    {
      res.status = Message::STATUS_FAILED;
      res.error_details = "tx_pool::have_key_images_as_spent() gave vectors of wrong size(s).";
      return;
    }
 
    for(size_t i=0; i < req.key_images.size(); i++)
    {
      if ( chain_spent_status[i] )
      {
        res.spent_status[i] = KeyImagesSpent::STATUS::SPENT_IN_BLOCKCHAIN;
      }
      else if ( pool_spent_status[i] )
      {
        res.spent_status[i] = KeyImagesSpent::STATUS::SPENT_IN_POOL;
      }
    }
 
    res.status = Message::STATUS_OK;
  }

handle() [27/40]

void cryptonote::rpc::DaemonHandler::handle	(	const MiningStatus::Request &	req,
		MiningStatus::Response &	res )

Definition at line 508 of file daemon_handler.cpp.

  {
    const cryptonote::miner& lMiner = m_core.get_miner();
    res.active = lMiner.is_mining();
    res.is_background_mining_enabled = lMiner.get_is_background_mining_enabled();
    
    if ( lMiner.is_mining() ) {
      res.speed = lMiner.get_speed();
      res.threads_count = lMiner.get_threads_count();
      const account_public_address& lMiningAdr = lMiner.get_mining_address();
      res.address = get_account_address_as_str(m_core.get_nettype(), false, lMiningAdr);
    }
 
    res.status = Message::STATUS_OK;
    res.error_details = "";
  }

Here is the call graph for this function:

handle() [28/40]

void cryptonote::rpc::DaemonHandler::handle	(	const SaveBC::Request &	req,
		SaveBC::Response &	res )

Definition at line 525 of file daemon_handler.cpp.

  {
    if (!m_core.get_blockchain_storage().store_blockchain())
    {
      res.status = Message::STATUS_FAILED;
      res.error_details = "Error storing the blockchain";
    }
    else
    {
      res.status = Message::STATUS_OK;
    }
  }

handle() [29/40]

void cryptonote::rpc::DaemonHandler::handle	(	const SendRawTx::Request &	req,
		SendRawTx::Response &	res )

Definition at line 264 of file daemon_handler.cpp.

  {
    handleTxBlob(cryptonote::tx_to_blob(req.tx), req.relay, res);
  }

Here is the call graph for this function:

handle() [30/40]

void cryptonote::rpc::DaemonHandler::handle	(	const SendRawTxHex::Request &	req,
		SendRawTxHex::Response &	res )

Definition at line 269 of file daemon_handler.cpp.

  {
    std::string tx_blob;
    if(!epee::string_tools::parse_hexstr_to_binbuff(req.tx_as_hex, tx_blob))
    {
      MERROR("[SendRawTxHex]: Failed to parse tx from hexbuff: " << req.tx_as_hex);
      res.status = Message::STATUS_FAILED;
      res.error_details = "Invalid hex";
      return;
    }
    handleTxBlob(tx_blob, req.relay, res);
  }

Here is the call graph for this function:

handle() [31/40]

void cryptonote::rpc::DaemonHandler::handle	(	const SetBans::Request &	req,
		SetBans::Response &	res )

Definition at line 710 of file daemon_handler.cpp.

  {
    res.status = Message::STATUS_FAILED;
    res.error_details = "RPC method not yet implemented.";
  }

handle() [32/40]

void cryptonote::rpc::DaemonHandler::handle	(	const SetLogHashRate::Request &	req,
		SetLogHashRate::Response &	res )

Definition at line 636 of file daemon_handler.cpp.

  {
    res.status = Message::STATUS_FAILED;
    res.error_details = "RPC method not yet implemented.";
  }

handle() [33/40]

void cryptonote::rpc::DaemonHandler::handle	(	const SetLogLevel::Request &	req,
		SetLogLevel::Response &	res )

Definition at line 642 of file daemon_handler.cpp.

  {
    if (req.level < 0 || req.level > 4)
    {
      res.status = Message::STATUS_FAILED;
      res.error_details = "Error: log level not valid";
    }
    else
    {
      res.status = Message::STATUS_OK;
      mlog_set_log_level(req.level);
    }
  }

Here is the call graph for this function:

handle() [34/40]

void cryptonote::rpc::DaemonHandler::handle	(	const StartMining::Request &	req,
		StartMining::Response &	res )

Definition at line 400 of file daemon_handler.cpp.

  {
    cryptonote::address_parse_info info;
    if(!get_account_address_from_str(info, m_core.get_nettype(), req.miner_address))
    {
      res.error_details = "Failed, wrong address";
      LOG_PRINT_L0(res.error_details);
      res.status = Message::STATUS_FAILED;
      return;
    }
    if (info.is_subaddress)
    {
      res.error_details = "Failed, mining to subaddress isn't supported yet";
      LOG_PRINT_L0(res.error_details);
      res.status = Message::STATUS_FAILED;
      return;
    }
 
    unsigned int concurrency_count = boost::thread::hardware_concurrency() * 4;
 
    // if we couldn't detect threads, set it to a ridiculously high number
    if(concurrency_count == 0)
    {
      concurrency_count = 257;
    }
 
    // if there are more threads requested than the hardware supports
    // then we fail and log that.
    if(req.threads_count > concurrency_count)
    {
      res.error_details = "Failed, too many threads relative to CPU cores.";
      LOG_PRINT_L0(res.error_details);
      res.status = Message::STATUS_FAILED;
      return;
    }
 
    if(!m_core.get_miner().start(info.address, static_cast<size_t>(req.threads_count), req.do_background_mining, req.ignore_battery))
    {
      res.error_details = "Failed, mining not started";
      LOG_PRINT_L0(res.error_details);
      res.status = Message::STATUS_FAILED;
      return;
    }
    res.status = Message::STATUS_OK;
    res.error_details = "";
 
  }

Here is the call graph for this function:

handle() [35/40]

void cryptonote::rpc::DaemonHandler::handle	(	const StartSaveGraph::Request &	req,
		StartSaveGraph::Response &	res )

Definition at line 682 of file daemon_handler.cpp.

  {
    res.status = Message::STATUS_FAILED;
    res.error_details = "RPC method not yet implemented.";
  }

handle() [36/40]

std::string cryptonote::rpc::DaemonHandler::handle ( const std::string & request )

virtual

Implements cryptonote::rpc::RpcHandler.

Definition at line 859 of file daemon_handler.cpp.

  {
    MDEBUG("Handling RPC request: " << request);
 
    Message* resp_message = NULL;
 
    try
    {
      FullMessage req_full(request, true);
 
      rapidjson::Value& req_json = req_full.getMessage();
 
      const std::string request_type = req_full.getRequestType();
 
      // create correct Message subclass and call handle() on it
      REQ_RESP_TYPES_MACRO(request_type, GetHeight, req_json, resp_message, handle);
      REQ_RESP_TYPES_MACRO(request_type, GetBlocksFast, req_json, resp_message, handle);
      REQ_RESP_TYPES_MACRO(request_type, GetHashesFast, req_json, resp_message, handle);
      REQ_RESP_TYPES_MACRO(request_type, GetTransactions, req_json, resp_message, handle);
      REQ_RESP_TYPES_MACRO(request_type, KeyImagesSpent, req_json, resp_message, handle);
      REQ_RESP_TYPES_MACRO(request_type, GetTxGlobalOutputIndices, req_json, resp_message, handle);
      REQ_RESP_TYPES_MACRO(request_type, SendRawTx, req_json, resp_message, handle);
      REQ_RESP_TYPES_MACRO(request_type, SendRawTxHex, req_json, resp_message, handle);
      REQ_RESP_TYPES_MACRO(request_type, GetInfo, req_json, resp_message, handle);
      REQ_RESP_TYPES_MACRO(request_type, StartMining, req_json, resp_message, handle);
      REQ_RESP_TYPES_MACRO(request_type, StopMining, req_json, resp_message, handle);
      REQ_RESP_TYPES_MACRO(request_type, MiningStatus, req_json, resp_message, handle);
      REQ_RESP_TYPES_MACRO(request_type, SaveBC, req_json, resp_message, handle);
      REQ_RESP_TYPES_MACRO(request_type, GetBlockHash, req_json, resp_message, handle);
      REQ_RESP_TYPES_MACRO(request_type, GetLastBlockHeader, req_json, resp_message, handle);
      REQ_RESP_TYPES_MACRO(request_type, GetBlockHeaderByHash, req_json, resp_message, handle);
      REQ_RESP_TYPES_MACRO(request_type, GetBlockHeaderByHeight, req_json, resp_message, handle);
      REQ_RESP_TYPES_MACRO(request_type, GetBlockHeadersByHeight, req_json, resp_message, handle);
      REQ_RESP_TYPES_MACRO(request_type, GetPeerList, req_json, resp_message, handle);
      REQ_RESP_TYPES_MACRO(request_type, SetLogLevel, req_json, resp_message, handle);
      REQ_RESP_TYPES_MACRO(request_type, GetTransactionPool, req_json, resp_message, handle);
      REQ_RESP_TYPES_MACRO(request_type, HardForkInfo, req_json, resp_message, handle);
      REQ_RESP_TYPES_MACRO(request_type, GetOutputHistogram, req_json, resp_message, handle);
      REQ_RESP_TYPES_MACRO(request_type, GetOutputKeys, req_json, resp_message, handle);
      REQ_RESP_TYPES_MACRO(request_type, GetRPCVersion, req_json, resp_message, handle);
      REQ_RESP_TYPES_MACRO(request_type, GetFeeEstimate, req_json, resp_message, handle);
      REQ_RESP_TYPES_MACRO(request_type, GetOutputDistribution, req_json, resp_message, handle);
 
      // if none of the request types matches
      if (resp_message == NULL)
      {
        return BAD_REQUEST(request_type, req_full.getID());
      }
 
      FullMessage resp_full = FullMessage::responseMessage(resp_message, req_full.getID());
 
      const std::string response = resp_full.getJson();
      delete resp_message;
      resp_message = NULL;
 
      MDEBUG("Returning RPC response: " << response);
 
      return response;
    }
    catch (const std::exception& e)
    {
      if (resp_message)
      {
        delete resp_message;
      }
 
      return BAD_JSON(e.what());
    }
  }

Here is the call graph for this function:

handle() [37/40]

void cryptonote::rpc::DaemonHandler::handle	(	const StopDaemon::Request &	req,
		StopDaemon::Response &	res )

Definition at line 676 of file daemon_handler.cpp.

  {
    res.status = Message::STATUS_FAILED;
    res.error_details = "RPC method not yet implemented.";
  }

handle() [38/40]

void cryptonote::rpc::DaemonHandler::handle	(	const StopMining::Request &	req,
		StopMining::Response &	res )

Definition at line 494 of file daemon_handler.cpp.

  {
    if(!m_core.get_miner().stop())
    {
      res.error_details = "Failed, mining not stopped";
      LOG_PRINT_L0(res.error_details);
      res.status = Message::STATUS_FAILED;
      return;
    }
 
    res.status = Message::STATUS_OK;
    res.error_details = "";
  }

handle() [39/40]

void cryptonote::rpc::DaemonHandler::handle	(	const StopSaveGraph::Request &	req,
		StopSaveGraph::Response &	res )

Definition at line 688 of file daemon_handler.cpp.

  {
    res.status = Message::STATUS_FAILED;
    res.error_details = "RPC method not yet implemented.";
  }

handle() [40/40]

void cryptonote::rpc::DaemonHandler::handle	(	const SubmitBlock::Request &	req,
		SubmitBlock::Response &	res )

Definition at line 559 of file daemon_handler.cpp.

  {
    res.status = Message::STATUS_FAILED;
    res.error_details = "RPC method not yet implemented.";
  }

---

The documentation for this class was generated from the following files:

• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/rpc/daemon_handler.h
• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/rpc/daemon_handler.cpp