monero_daemon.h

 
#pragma once
 
#include "common/monero_rpc_connection.h"
#include "monero_daemon_model.h"

namespace monero {

  class monero_daemon_listener {
  public:
    std::shared_ptr<monero_block_header> m_last_header;

    virtual void on_block_header(const std::shared_ptr<monero_block_header>& header) {
      m_last_header = header;
    }
  };

  class monero_daemon {
  public:

    virtual ~monero_daemon() {}

    virtual void add_listener(monero_daemon_listener &listener) {
      throw std::runtime_error("monero_daemon::add_listener(): not supported");
    }

    virtual void remove_listener(monero_daemon_listener &listener) {
      throw std::runtime_error("monero_daemon::remove_listener(): not supported");
    }

    virtual std::set<monero_daemon_listener*> get_listeners() {
      throw std::runtime_error("monero_daemon::get_listeners(): not supported");
    }

    virtual void remove_listeners() {
      throw std::runtime_error("monero_daemon::remove_listeners(): not supported");
    }

    virtual monero_version get_version() {
      throw std::runtime_error("monero_daemon::get_version(): not supported");
    }

    virtual bool is_trusted() {
      throw std::runtime_error("monero_daemon::is_trusted(): not supported");
    }

    virtual uint64_t get_height() {
      throw std::runtime_error("monero_daemon::get_height(): not supported");
    }

    virtual std::string get_block_hash(uint64_t height) {
      throw std::runtime_error("monero_daemon::get_block_hash(): not supported");
    }

    virtual std::shared_ptr<monero_block_template> get_block_template(const std::string& wallet_address, const boost::optional<int>& reserve_size = boost::none) {
      throw std::runtime_error("monero_daemon::get_block_template(): not supported");
    }

    virtual std::shared_ptr<monero_miner_data> get_miner_data() {
      throw std::runtime_error("monero_daemon::get_miner_data(): not supported");
    }

    virtual std::string calculate_pow(uint32_t major_version, uint64_t height, const std::string& block_blob, const std::string& seed_hash) {
      throw std::runtime_error("monero_daemon::calculate_pow(): not supported");
    }

    virtual std::shared_ptr<monero_add_auxiliary_pow_result> add_auxiliary_pow(const std::string& block_template_blob, const std::vector<std::shared_ptr<monero_auxiliary_pow>>& aux_pow) {
      throw std::runtime_error("monero_daemon::add_auxiliary_pow(): not supported");
    }

    virtual std::shared_ptr<monero_block_header> get_last_block_header() {
      throw std::runtime_error("monero_daemon::get_last_block_header(): not supported");
    }

    virtual std::shared_ptr<monero_block_header> get_block_header_by_hash(const std::string& block_hash) {
      throw std::runtime_error("monero_daemon::get_block_header_by_hash(): not supported");
    }

    virtual std::shared_ptr<monero_block_header> get_block_header_by_height(uint64_t height) {
      throw std::runtime_error("monero_daemon::get_block_header_by_height(): not supported");
    }

    virtual std::vector<std::shared_ptr<monero_block_header>> get_block_headers_by_range(uint64_t start_height, uint64_t end_height) {
      throw std::runtime_error("monero_daemon::get_block_headers_by_range(): not supported");
    }

    virtual std::shared_ptr<monero_block> get_block_by_hash(const std::string& block_hash) {
      throw std::runtime_error("monero_daemon::get_block_by_hash(): not supported");
    }

    virtual std::shared_ptr<monero_get_blocks_by_hash_result> get_blocks_by_hash(const std::vector<std::string>& block_hashes, uint64_t start_height, bool prune, uint64_t max_block_count = 0) {
      throw std::runtime_error("monero_daemon::get_blocks_by_hash(): not supported");
    }

    virtual std::shared_ptr<monero_block> get_block_by_height(uint64_t height) {
      throw std::runtime_error("monero_daemon::get_block_by_height(): not supported");
    }

    virtual std::vector<std::shared_ptr<monero_block>> get_blocks_by_height(const std::vector<uint64_t>& heights) {
      throw std::runtime_error("monero_daemon::get_blocks_by_height(): not supported");
    }

    virtual std::vector<std::shared_ptr<monero_block>> get_blocks_by_range(boost::optional<uint64_t> start_height, boost::optional<uint64_t> end_height) {
      throw std::runtime_error("monero_daemon::get_blocks_by_range(): not supported");
    }

    virtual std::vector<std::shared_ptr<monero_block>> get_blocks_by_range_chunked(boost::optional<uint64_t> start_height, boost::optional<uint64_t> end_height, boost::optional<uint64_t> max_chunk_size) {
      throw std::runtime_error("monero_daemon::get_blocks_by_range_chunked(): not supported");
    }

    virtual std::shared_ptr<monero_get_block_hashes_result> get_block_hashes(const std::vector<std::string>& block_hashes) {
      throw std::runtime_error("monero_daemon::get_block_hashes(): not supported");
    }

    virtual std::shared_ptr<monero_tx> get_tx(const std::string& tx_hash, bool prune = false) {
      std::vector<std::string> hashes;
      hashes.push_back(tx_hash);
      auto txs = get_txs(hashes, prune);
      std::shared_ptr<monero_tx> tx;
 
      if (txs.size() > 0) {
        tx = txs[0];
      }
 
      return tx;
    }

    virtual std::vector<std::shared_ptr<monero_tx>> get_txs(const std::vector<std::string>& tx_hashes, bool prune = false) {
      throw std::runtime_error("monero_daemon::get_txs(): not supported");
    }
 
  
    virtual boost::optional<std::string> get_tx_hex(const std::string& tx_hash, bool prune = false) {
      std::vector<std::string> hashes;
      hashes.push_back(tx_hash);
      auto hexes = get_tx_hexes(hashes, prune);
      boost::optional<std::string> hex;
      if (hexes.size() > 0) {
        hex = hexes[0];
      }
 
      return hex;
    }

    virtual std::vector<std::string> get_tx_hexes(const std::vector<std::string>& tx_hashes, bool prune = false) {
      throw std::runtime_error("monero_daemon::get_tx_hexes(): not supported");
    }

    virtual std::shared_ptr<monero_miner_tx_sum> get_miner_tx_sum(uint64_t height, uint64_t num_blocks) {
      throw std::runtime_error("monero_daemon::get_miner_tx_sum(): not supported");
    }

    virtual std::shared_ptr<monero_fee_estimate> get_fee_estimate(uint64_t grace_blocks = 0) {
      throw std::runtime_error("monero_daemon::get_fee_estimate(): not supported");
    }

    virtual std::shared_ptr<monero_submit_tx_result> submit_tx_hex(const std::string& tx_hex, bool do_not_relay = false) {
      throw std::runtime_error("monero_daemon::submit_tx_hex(): not supported");
    }

    virtual void relay_tx_by_hash(const std::string& tx_hash) {
      std::vector<std::string> tx_hashes;
      tx_hashes.push_back(tx_hash);
      relay_txs_by_hash(tx_hashes);
    }

    virtual void relay_txs_by_hash(const std::vector<std::string>& tx_hashes) {
      throw std::runtime_error("monero_daemon::relay_txs_by_hash(): not supported");
    }

    virtual std::vector<std::shared_ptr<monero_tx>> get_tx_pool() {
      throw std::runtime_error("monero_daemon::get_tx_pool(): not supported");
    }

    virtual std::vector<std::string> get_tx_pool_hashes() {
      throw std::runtime_error("monero_daemon::get_tx_pool_hashes(): not supported");
    }

    virtual std::vector<monero_tx_backlog_entry> get_tx_pool_backlog() {
      throw std::runtime_error("monero_daemon::get_tx_pool_backlog(): not supported");
    }

    virtual std::shared_ptr<monero_tx_pool_stats> get_tx_pool_stats() {
      throw std::runtime_error("monero_daemon::get_tx_pool_stats(): not supported");
    }

    virtual void flush_tx_pool() {
      throw std::runtime_error("monero_daemon::flush_tx_pool(): not supported");
    }

    virtual void flush_tx_pool(const std::vector<std::string> &hashes) {
      throw std::runtime_error("monero_daemon::flush_tx_pool(): not supported");
    }

    virtual void flush_tx_pool(const std::string &hash) {
      throw std::runtime_error("monero_daemon::flush_tx_pool(): not supported");
    }

    virtual monero_key_image_spent_status get_key_image_spent_status(const std::string& key_image) {
      std::vector<std::string> key_images;
      key_images.push_back(key_image);
      auto statuses = get_key_image_spent_statuses(key_images);
      if (statuses.empty()) throw std::runtime_error("Could not get key image spent status");
      return statuses[0];
    }

    virtual std::vector<monero_key_image_spent_status> get_key_image_spent_statuses(const std::vector<std::string>& key_images) {
      throw std::runtime_error("monero_daemon::get_key_image_spent_statuses(): not supported");
    }

    virtual std::vector<uint64_t> get_output_indices(const std::string& tx_hash) {
      throw std::runtime_error("monero_daemon::get_output_indices(): not supported");
    }

    virtual std::vector<std::shared_ptr<monero_output>> get_outputs(const std::vector<monero_output>& outputs) {
      throw std::runtime_error("monero_daemon::get_outputs(): not supported");
    }

    virtual std::vector<std::shared_ptr<monero_output_histogram_entry>> get_output_histogram(const std::vector<uint64_t>& amounts, const boost::optional<int>& min_count, const boost::optional<int>& max_count, const boost::optional<bool>& is_unlocked, const boost::optional<int>& recent_cutoff) {
      throw std::runtime_error("monero_daemon::get_output_histogram(): not supported");
    }

    virtual std::vector<std::shared_ptr<monero_output_distribution_entry>> get_output_distribution(const std::vector<uint64_t>& amounts, const boost::optional<bool>& is_cumulative = boost::none, const boost::optional<uint64_t>& start_height = boost::none, const boost::optional<uint64_t>& end_height = boost::none) {
      throw std::runtime_error("monero_daemon::get_output_distribution(): not supported");
    }

    virtual std::shared_ptr<monero_daemon_info> get_info() {
      throw std::runtime_error("monero_daemon::get_info(): not supported");
    }

    virtual std::shared_ptr<monero_daemon_sync_info> get_sync_info() {
      throw std::runtime_error("monero_daemon::get_sync_info(): not supported");
    }

    virtual std::shared_ptr<monero_daemon_network_stats> get_network_stats() {
      throw std::runtime_error("monero_daemon::get_network_stats(): not supported");
    }

    virtual std::shared_ptr<monero_hard_fork_info> get_hard_fork_info() {
      throw std::runtime_error("monero_daemon::get_hard_fork_info(): not supported");
    }

    virtual std::vector<std::shared_ptr<monero_alt_chain>> get_alt_chains() {
      throw std::runtime_error("monero_daemon::get_alt_chains(): not supported");
    }

    virtual std::vector<std::string> get_alt_block_hashes() {
      throw std::runtime_error("monero_daemon::get_alt_block_hashes(): not supported");
    }

    virtual int get_download_limit() {
      throw std::runtime_error("monero_daemon::get_download_limit(): not supported");
    }

    virtual int set_download_limit(int limit) {
      throw std::runtime_error("monero_daemon::set_download_limit(): not supported");
    }

    virtual int reset_download_limit() {
      throw std::runtime_error("monero_daemon::reset_download_limit(): not supported");
    }

    virtual int get_upload_limit() {
      throw std::runtime_error("monero_daemon::get_upload_limit(): not supported");
    }

    virtual int set_upload_limit(int limit) {
      throw std::runtime_error("monero_daemon::set_upload_limit(): not supported");
    }

    virtual int reset_upload_limit() {
      throw std::runtime_error("monero_daemon::reset_upload_limit(): not supported");
    }

    virtual std::vector<std::shared_ptr<monero_peer>> get_peers() {
      throw std::runtime_error("monero_daemon::get_peers(): not supported");
    }

    virtual std::vector<std::shared_ptr<monero_peer>> get_known_peers() {
      throw std::runtime_error("monero_daemon::get_known_peers(): not supported");
    }

    virtual std::vector<std::shared_ptr<monero_peer>> get_public_peers(bool include_offline = false) {
      throw std::runtime_error("monero_daemon::get_public_peers(): not supported");
    }

    virtual void set_outgoing_peer_limit(int limit) {
      throw std::runtime_error("monero_daemon::set_outgoing_peer_limit(): not supported");
    }

    virtual void set_incoming_peer_limit(int limit) {
      throw std::runtime_error("monero_daemon::set_incoming_peer_limit(): not supported");
    }

    virtual std::vector<std::shared_ptr<monero_ban>> get_peer_bans() {
      throw std::runtime_error("monero_daemon::get_peer_bans(): not supported");
    }

    virtual void set_peer_bans(const std::vector<std::shared_ptr<monero_ban>>& bans) {
      throw std::runtime_error("monero_daemon::set_peer_bans(): not supported");
    }

    virtual void set_peer_ban(const std::shared_ptr<monero_ban>& ban) {
      if (ban == nullptr) throw std::runtime_error("Ban is none");
      std::vector<std::shared_ptr<monero_ban>> bans;
      bans.push_back(ban);
      set_peer_bans(bans);
    }

    virtual std::shared_ptr<monero_ban> get_peer_ban(const std::string& address) {
      throw std::runtime_error("monero_daemon::get_peer_ban(): not supported");
    }

    virtual void start_mining(const std::string &address, boost::optional<uint64_t> num_threads, boost::optional<bool> is_background, boost::optional<bool> ignore_battery) {
      throw std::runtime_error("monero_daemon::start_mining(): not supported");
    }

    virtual void stop_mining() {
      throw std::runtime_error("monero_daemon::stop_mining(): not supported");
    }

    virtual std::shared_ptr<monero_mining_status> get_mining_status() {
      throw std::runtime_error("monero_daemon::get_mining_status(): not supported");
    }

    virtual std::shared_ptr<monero_generate_blocks_result> generate_blocks(const std::string& wallet_address, uint64_t num_blocks, const boost::optional<std::string>& prev_block_hash = boost::none, const boost::optional<uint32_t>& starting_nonce = boost::none) {
      throw std::runtime_error("monero_daemon::generate_blocks(): not supported");
    }

    virtual void submit_block(const std::string& block_blob) {
      std::vector<std::string> block_blobs;
      block_blobs.push_back(block_blob);
      return submit_blocks(block_blobs);
    }

    virtual void submit_blocks(const std::vector<std::string>& block_blobs) {
      throw std::runtime_error("monero_daemon::submit_blocks(): not supported");
    }

    virtual std::shared_ptr<monero_prune_result> prune_blockchain(bool check) {
      throw std::runtime_error("monero_daemon::prune_blockchain(): not supported");
    }

    virtual void save_blockchain() {
      throw std::runtime_error("monero_daemon::save_blockchain(): not supported");
    }

    virtual uint64_t pop_blocks(uint64_t num_blocks) {
      throw std::runtime_error("monero_daemon::pop_blocks(): not supported");
    }

    virtual void flush_cache(bool bad_blocks = false) {
      throw std::runtime_error("monero_daemon::flush_cache(): not supported");
    }

    virtual void set_bootstrap_daemon(const std::string& address, const std::string& username = "", const std::string& password = "", const std::string& proxy = "") {
      throw std::runtime_error("monero_daemon::set_bootstrap_daemon(): not supported");
    }

    virtual void remove_bootstrap_daemon() {
      set_bootstrap_daemon("");
    }

    virtual void set_log_hash_rate(bool is_visible) {
      throw std::runtime_error("monero_daemon::set_log_hash_rate(): not supported");
    }

    virtual void set_log_level(int level) {
      throw std::runtime_error("monero_daemon::set_log_level(): not supported");
    }

    virtual std::string set_log_categories(const std::string& categories = "") {
      throw std::runtime_error("monero_daemon::set_log_categories(): not supported");
    }

    virtual std::shared_ptr<monero_daemon_update_check_result> check_for_update() {
      throw std::runtime_error("monero_daemon::check_for_update(): not supported");
    }

    virtual std::shared_ptr<monero_daemon_update_download_result> download_update(const std::string& path = "") {
      throw std::runtime_error("monero_daemon::download_update(): not supported");
    }

    virtual void stop() {
      throw std::runtime_error("monero_daemon::stop(): not supported");
    }

    virtual std::shared_ptr<monero_block_header> wait_for_next_block_header() {
      throw std::runtime_error("monero_daemon::wait_for_next_block_header(): not supported");
    }
 
  };
}