monero_daemon_model.h

 
#pragma once
 
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/json_parser.hpp>
#include "rapidjson/document.h"
#include "rapidjson/writer.h"
#include "rapidjson/stringbuffer.h"
 
namespace monero {
 
  struct serializable_struct {
 
    std::string serialize() const;
 
    virtual rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const = 0;
  };
 
  enum monero_network_type : uint8_t {
      MAINNET = 0,
      TESTNET,
      STAGENET
  };
 
  struct monero_version : public serializable_struct {
    boost::optional<uint32_t> m_number;
    boost::optional<bool> m_is_release;
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const;
  };
 
  struct monero_rpc_connection : public serializable_struct {
    boost::optional<std::string> m_uri;
    boost::optional<std::string> m_username;
    boost::optional<std::string> m_password;
 
    monero_rpc_connection(const std::string& uri = "", const std::string& username = "", const std::string& password = "") : m_uri(uri), m_username(username), m_password(password) {}
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const;
    static monero_rpc_connection from_property_tree(const boost::property_tree::ptree& node);
  };
 
  // forward declarations
  struct monero_tx;
  struct monero_output;
 
  struct monero_block_header : public serializable_struct {
    boost::optional<std::string> m_hash;
    boost::optional<uint64_t> m_height;
    boost::optional<uint64_t> m_timestamp;
    boost::optional<uint64_t> m_size;
    boost::optional<uint64_t> m_weight;
    boost::optional<uint64_t> m_long_term_weight;
    boost::optional<uint64_t> m_depth;
    boost::optional<uint64_t> m_difficulty;
    boost::optional<uint64_t> m_cumulative_difficulty;
    boost::optional<uint32_t> m_major_version;
    boost::optional<uint32_t> m_minor_version;
    boost::optional<uint32_t> m_nonce;
    boost::optional<std::string> m_miner_tx_hash;
    boost::optional<uint32_t> m_num_txs;
    boost::optional<bool> m_orphan_status;
    boost::optional<std::string> m_prev_hash;
    boost::optional<uint64_t> m_reward;
    boost::optional<std::string> m_pow_hash;
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const;
    std::shared_ptr<monero_block_header> copy(const std::shared_ptr<monero_block_header>& src, const std::shared_ptr<monero_block_header>& tgt) const;
    virtual void merge(const std::shared_ptr<monero_block_header>& self, const std::shared_ptr<monero_block_header>& other);
  };
 
  struct monero_block : public monero_block_header {
    boost::optional<std::string> m_hex;
    boost::optional<std::shared_ptr<monero_tx>> m_miner_tx;
    std::vector<std::shared_ptr<monero_tx>> m_txs;
    std::vector<std::string> m_tx_hashes;
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const;
    std::shared_ptr<monero_block> copy(const std::shared_ptr<monero_block>& src, const std::shared_ptr<monero_block>& tgt) const;
    void merge(const std::shared_ptr<monero_block_header>& self, const std::shared_ptr<monero_block_header>& other);
    void merge(const std::shared_ptr<monero_block>& self, const std::shared_ptr<monero_block>& other);
  };
 
  struct monero_tx : public serializable_struct {
    static const std::string DEFAULT_PAYMENT_ID;  // default payment id "0000000000000000"
    boost::optional<std::shared_ptr<monero_block>> m_block;
    boost::optional<std::string> m_hash;
    boost::optional<uint32_t> m_version;
    boost::optional<bool> m_is_miner_tx;
    boost::optional<std::string> m_payment_id;
    boost::optional<uint64_t> m_fee;
    boost::optional<uint32_t> m_ring_size;
    boost::optional<bool> m_relay;
    boost::optional<bool> m_is_relayed;
    boost::optional<bool> m_is_confirmed;
    boost::optional<bool> m_in_tx_pool;
    boost::optional<uint64_t> m_num_confirmations;
    boost::optional<uint64_t> m_unlock_time;
    boost::optional<uint64_t> m_last_relayed_timestamp;
    boost::optional<uint64_t> m_received_timestamp;
    boost::optional<bool> m_is_double_spend_seen;
    boost::optional<std::string> m_key;
    boost::optional<std::string> m_full_hex;
    boost::optional<std::string> m_pruned_hex;
    boost::optional<std::string> m_prunable_hex;
    boost::optional<std::string> m_prunable_hash;
    boost::optional<uint64_t> m_size;
    boost::optional<uint64_t> m_weight;
    std::vector<std::shared_ptr<monero_output>> m_inputs;
    std::vector<std::shared_ptr<monero_output>> m_outputs;
    std::vector<uint64_t> m_output_indices;
    boost::optional<std::string> m_metadata;
    boost::optional<std::string> m_common_tx_sets;
    std::vector<uint8_t> m_extra;
    boost::optional<std::string> m_rct_signatures;   // TODO: implement
    boost::optional<std::string> m_rct_sig_prunable;  // TODO: implement
    boost::optional<bool> m_is_kept_by_block;
    boost::optional<bool> m_is_failed;
    boost::optional<uint64_t> m_last_failed_height;
    boost::optional<std::string> m_last_failed_hash;
    boost::optional<uint64_t> m_max_used_block_height;
    boost::optional<std::string> m_max_used_block_hash;
    std::vector<std::string> m_signatures;
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const;
    static void from_property_tree(const boost::property_tree::ptree& node, std::shared_ptr<monero_tx> tx);
    std::shared_ptr<monero_tx> copy(const std::shared_ptr<monero_tx>& src, const std::shared_ptr<monero_tx>& tgt) const;
    virtual void merge(const std::shared_ptr<monero_tx>& self, const std::shared_ptr<monero_tx>& other);
    boost::optional<uint64_t> get_height() const;
  };
 
  struct monero_key_image : public serializable_struct {
    boost::optional<std::string> m_hex;
    boost::optional<std::string> m_signature;
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const;
    static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_key_image>& key_image);
    static std::vector<std::shared_ptr<monero_key_image>> deserialize_key_images(const std::string& key_images_json);  // TODO: remove this specialty util used once
    std::shared_ptr<monero_key_image> copy(const std::shared_ptr<monero_key_image>& src, const std::shared_ptr<monero_key_image>& tgt) const;
    void merge(const std::shared_ptr<monero_key_image>& self, const std::shared_ptr<monero_key_image>& other);
  };
 
  struct monero_output : public serializable_struct {
    std::shared_ptr<monero_tx> m_tx;
    boost::optional<std::shared_ptr<monero_key_image>> m_key_image;
    boost::optional<uint64_t> m_amount;
    boost::optional<uint64_t> m_index;
    std::vector<uint64_t> m_ring_output_indices;
    boost::optional<std::string> m_stealth_public_key;
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const;
    static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_output>& output);
    std::shared_ptr<monero_output> copy(const std::shared_ptr<monero_output>& src, const std::shared_ptr<monero_output>& tgt) const;
    virtual void merge(const std::shared_ptr<monero_output>& self, const std::shared_ptr<monero_output>& other);
  };
}