monero_daemon_rpc_model.h

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

namespace monero {

  struct monero_rpc_ban : public monero_ban {
    monero_rpc_ban(const std::shared_ptr<monero_ban> &ban);
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
  };
 
  // ------------------------------ Binary Request ---------------------------------

  struct monero_get_blocks_by_height_request : public monero_rpc_request {
    std::vector<uint64_t> m_heights;
 
    monero_get_blocks_by_height_request(uint64_t num_blocks);
    monero_get_blocks_by_height_request(const std::vector<uint64_t>& heights): m_heights(heights) { m_method = "get_blocks_by_height.bin"; }
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
  };
 
  // ------------------------------ RPC Params ---------------------------------
 
  struct monero_download_update_params : public serializable_struct {
    boost::optional<std::string> m_command;
    boost::optional<std::string> m_path;
 
    monero_download_update_params(const std::string& command = "download", const std::string& path = "");
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
  };
 
  struct monero_submit_tx_params : public serializable_struct {
    boost::optional<std::string> m_tx_hex;
    boost::optional<bool> m_do_not_relay;
    std::vector<std::string> m_tx_hashes;
 
    monero_submit_tx_params(const std::vector<std::string>& tx_hashes): m_tx_hashes(tx_hashes) { }
    monero_submit_tx_params(const std::string& tx_hex, bool do_not_relay): m_tx_hex(tx_hex), m_do_not_relay(do_not_relay) { }
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
  };
 
  struct monero_peer_limits_params : public serializable_struct {
    boost::optional<int> m_in_peers;
    boost::optional<int> m_out_peers;
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
  };
 
  struct monero_get_txs_params : public serializable_struct {
    std::vector<std::string> m_tx_hashes;
    boost::optional<bool> m_decode_as_json;
    boost::optional<bool> m_prune;
 
    monero_get_txs_params(const std::vector<std::string> &tx_hashes, bool prune, bool decode_as_json = true): m_tx_hashes(tx_hashes), m_prune(prune), m_decode_as_json(decode_as_json) { }
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
  };
 
  struct monero_is_key_image_spent_params : public serializable_struct {
    std::vector<std::string> m_key_images;
 
    monero_is_key_image_spent_params(const std::vector<std::string>& key_images): m_key_images(key_images) { }
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
  };
 
  // ------------------------------ JSON-RPC Params ---------------------------------
 
  struct monero_start_mining_params : public serializable_struct {
    boost::optional<std::string> m_miner_address;
    boost::optional<uint64_t> m_num_threads;
    boost::optional<bool> m_is_background;
    boost::optional<bool> m_ignore_battery;
 
    monero_start_mining_params(const boost::optional<std::string>& address, const boost::optional<uint64_t>& num_threads, const boost::optional<bool>& is_background, const boost::optional<bool>& ignore_battery): m_miner_address(address), m_num_threads(num_threads), m_is_background(is_background), m_ignore_battery(ignore_battery) { }
    monero_start_mining_params(const boost::optional<uint64_t>& num_threads, const boost::optional<bool>& is_background, const boost::optional<bool>& ignore_battery): m_num_threads(num_threads), m_is_background(is_background), m_ignore_battery(ignore_battery) { }
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
  };
 
  struct monero_generate_blocks_params : public serializable_struct {
    boost::optional<std::string> m_wallet_address;
    boost::optional<uint64_t> m_num_blocks;
    boost::optional<std::string> m_prev_block_hash;
    boost::optional<uint32_t> m_starting_nonce;
 
    monero_generate_blocks_params(const std::string& wallet_address, uint64_t num_blocks, const boost::optional<std::string>& prev_block_hash, const boost::optional<uint32_t>& starting_nonce): m_wallet_address(wallet_address), m_num_blocks(num_blocks), m_prev_block_hash(prev_block_hash), m_starting_nonce(starting_nonce) { }
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
  };
 
  struct monero_prune_blockchain_params : public serializable_struct {
    boost::optional<bool> m_check;
 
    monero_prune_blockchain_params(bool check = true): m_check(check) { }
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
  };
 
  struct monero_submit_blocks_params : public serializable_struct {
    std::vector<std::string> m_block_blobs;
 
    monero_submit_blocks_params(const std::vector<std::string>& block_blobs): m_block_blobs(block_blobs) { }
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
  };
 
  struct monero_get_block_params : public serializable_struct {
    boost::optional<uint64_t> m_height;
    boost::optional<std::string> m_hash;
    boost::optional<bool> m_fill_pow_hash;
    boost::optional<uint64_t> m_start_height;
    boost::optional<uint64_t> m_end_height;
    boost::optional<std::string> m_wallet_address;
    boost::optional<int> m_reserve_size;
 
    monero_get_block_params(uint64_t height, bool fill_pow_hash = false): m_height(height), m_fill_pow_hash(fill_pow_hash) { }
    monero_get_block_params(const std::string& hash, bool fill_pow_hash = false): m_hash(hash), m_fill_pow_hash(fill_pow_hash) { }
    monero_get_block_params(uint64_t start_height, uint64_t end_height): m_start_height(start_height), m_end_height(end_height) { }
    monero_get_block_params(const std::string& wallet_address, const boost::optional<int>& reserve_size): m_wallet_address(wallet_address), m_reserve_size(reserve_size) { }
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
  };
 
  struct monero_get_block_hash_params : public serializable_struct {
    boost::optional<uint64_t> m_height;
 
    monero_get_block_hash_params(uint64_t height): m_height(height) { }
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
  };
 
  struct monero_get_miner_tx_sum_params : public serializable_struct {
    boost::optional<uint64_t> m_height;
    boost::optional<uint64_t> m_count;
 
    monero_get_miner_tx_sum_params(uint64_t height, uint64_t count): m_height(height), m_count(count) { }
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
  };
 
  struct monero_get_fee_estimate_params : public serializable_struct {
    boost::optional<uint64_t> m_grace_blocks;
 
    monero_get_fee_estimate_params(uint64_t grace_blocks = 0): m_grace_blocks(grace_blocks) { }
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
  };
 
  struct monero_set_bans_params : public serializable_struct {
    std::vector<std::shared_ptr<monero_rpc_ban>> m_bans;
 
    monero_set_bans_params(const std::vector<std::shared_ptr<monero_ban>>& bans);
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
  };
 
  struct monero_get_output_histogram_params : public serializable_struct {
    std::vector<uint64_t> m_amounts;
    boost::optional<int> m_min_count;
    boost::optional<int> m_max_count;
    boost::optional<bool> m_is_unlocked;
    boost::optional<int> m_recent_cutoff;
 
    monero_get_output_histogram_params(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) : m_amounts(amounts), m_min_count(min_count), m_max_count(max_count), m_is_unlocked(is_unlocked), m_recent_cutoff(recent_cutoff) { }
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
  };
 
  struct monero_get_output_distribution_params : public serializable_struct {
    std::vector<uint64_t> m_amounts;
    boost::optional<bool> m_cumulative;
    boost::optional<bool> m_binary;
    boost::optional<uint64_t> m_from_height;
    boost::optional<uint64_t> m_to_height;
 
    monero_get_output_distribution_params(const std::vector<uint64_t>& amounts, const boost::optional<bool>& cumulative, const boost::optional<uint64_t>& from_height, const boost::optional<uint64_t>& to_height) : m_amounts(amounts), m_cumulative(cumulative), m_from_height(from_height), m_to_height(to_height), m_binary(false) { }
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
  };
 
  // ------------------------------ JSON-RPC Response ---------------------------------
 
  struct monero_get_block_result {
    boost::optional<uint64_t> m_count;
    boost::optional<uint64_t> m_height;
    boost::optional<bool> m_untrusted;
 
    static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_get_block_result>& result);
  };
 
  // ------------------------------ RPC Deserialization ---------------------------------
 
  void deserialize_version(const boost::property_tree::ptree& node, monero_version& version);
  void deserialize_block_header(const boost::property_tree::ptree& node, const std::shared_ptr<monero_block_header>& header);
  void deserialize_block_headers(const boost::property_tree::ptree& node, std::vector<std::shared_ptr<monero_block_header>>& headers);
  void deserialize_block(const boost::property_tree::ptree& node, const std::shared_ptr<monero_block>& block, bool is_nested = false);
  void deserialize_blocks(const boost::property_tree::ptree& node, const std::vector<uint64_t>& heights, std::vector<std::shared_ptr<monero_block>>& blocks);
  void deserialize_alt_block_hashes(const boost::property_tree::ptree& node, std::vector<std::string>& block_hashes);
  void deserialize_txs(const boost::property_tree::ptree& node, std::vector<std::shared_ptr<monero_tx>>& txs);
  void deserialize_tx_hashes(const boost::property_tree::ptree& node, std::vector<std::string>& tx_hashes);
  void deserialize_key_image_spent_status(const boost::property_tree::ptree& node, std::vector<monero_key_image_spent_status>& statuses);
  void deserialize_alt_chains(const boost::property_tree::ptree& node, std::vector<std::shared_ptr<monero_alt_chain>>& alt_chains);
  void deserialize_bans(const boost::property_tree::ptree& node, std::vector<std::shared_ptr<monero_ban>>& bans);
  void deserialize_prune_result(const boost::property_tree::ptree& node, const std::shared_ptr<monero_prune_result>& result);
  void deserialize_mining_status(const boost::property_tree::ptree& node, const std::shared_ptr<monero_mining_status>& status);
  void deserialize_generate_blocks_result(const boost::property_tree::ptree& node, const std::shared_ptr<monero_generate_blocks_result>& result);
  void deserialize_miner_tx_sum(const boost::property_tree::ptree& node, const std::shared_ptr<monero_miner_tx_sum>& sum);
  void deserialize_block_template(const boost::property_tree::ptree& node, const std::shared_ptr<monero_block_template>& tmplt);
  void deserialize_peers(const boost::property_tree::ptree& node, std::vector<std::shared_ptr<monero_peer>>& peers);
  void deserialize_submit_tx_result(const boost::property_tree::ptree& node, const std::shared_ptr<monero_submit_tx_result>& result);
  void deserialize_output_distribution_entries(const boost::property_tree::ptree& node, std::vector<std::shared_ptr<monero_output_distribution_entry>>& entries);
  void deserialize_output_histogram_entries(const boost::property_tree::ptree& node, std::vector<std::shared_ptr<monero_output_histogram_entry>>& entries);
  void deserialize_tx_pool_stats(const boost::property_tree::ptree& node, const std::shared_ptr<monero_tx_pool_stats>& stats);
  void deserialize_update_check_result(const boost::property_tree::ptree& node, const std::shared_ptr<monero_daemon_update_check_result>& check);
  void deserialize_update_download_result(const boost::property_tree::ptree& node, const std::shared_ptr<monero_daemon_update_download_result>& check);
  void deserialize_fee_estimate(const boost::property_tree::ptree& node, const std::shared_ptr<monero_fee_estimate>& estimate);
  void deserialize_daemon_info(const boost::property_tree::ptree& node, const std::shared_ptr<monero_daemon_info>& info);
  void deserialize_daemon_sync_info(const boost::property_tree::ptree& node, const std::shared_ptr<monero_daemon_sync_info>& info);
  void deserialize_hard_fork_info(const boost::property_tree::ptree& node, const std::shared_ptr<monero_hard_fork_info>& info);
 
}