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"

using namespace std;

namespace monero {

  struct serializable_struct {

    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 {
    string m_uri;
    boost::optional<string> m_username;
    boost::optional<string> m_password;
    monero_rpc_connection(const string& uri = "", const boost::optional<string>& username = boost::none, const boost::optional<string>& password = boost::none) : m_uri(uri), m_username(username), m_password(password) {}
  };

  // forward declarations
  struct monero_tx;
  struct monero_output;

  struct monero_block_header : public serializable_struct {
    boost::optional<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<string> m_miner_tx_hash;
    boost::optional<uint32_t> m_num_txs;
    boost::optional<bool> m_orphan_status;
    boost::optional<string> m_prev_hash;
    boost::optional<uint64_t> m_reward;
    boost::optional<string> m_pow_hash;

    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const;
    virtual void merge(const shared_ptr<monero_block_header>& self, const shared_ptr<monero_block_header>& other);
  };

  struct monero_block : public monero_block_header {
    boost::optional<string> m_hex;
    boost::optional<shared_ptr<monero_tx>> m_miner_tx;
    vector<shared_ptr<monero_tx>> m_txs;
    vector<string> m_tx_hashes;

    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const;
    void merge(const shared_ptr<monero_block_header>& self, const shared_ptr<monero_block_header>& other);
    void merge(const shared_ptr<monero_block>& self, const shared_ptr<monero_block>& other);
  };

  struct monero_tx : public serializable_struct {
    static const string DEFAULT_PAYMENT_ID;  // default payment id "0000000000000000"
    boost::optional<shared_ptr<monero_block>> m_block;
    boost::optional<string> m_hash;
    boost::optional<uint32_t> m_version;
    boost::optional<bool> m_is_miner_tx;
    boost::optional<string> m_payment_id;
    boost::optional<uint64_t> m_fee;
    boost::optional<uint32_t> m_ring_size;
    boost::optional<bool> m_do_not_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<string> m_key;
    boost::optional<string> m_full_hex;
    boost::optional<string> m_pruned_hex;
    boost::optional<string> m_prunable_hex;
    boost::optional<string> m_prunable_hash;
    boost::optional<uint64_t> m_size;
    boost::optional<uint64_t> m_weight;
    vector<shared_ptr<monero_output>> m_inputs;
    vector<shared_ptr<monero_output>> m_outputs;
    vector<uint32_t> m_output_indices;
    boost::optional<string> m_metadata;
    boost::optional<string> m_common_tx_sets;
    vector<uint8_t> m_extra;
    boost::optional<string> m_rct_signatures;   // TODO: implement
    boost::optional<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<string> m_last_failed_hash;
    boost::optional<uint64_t> m_max_used_block_height;
    boost::optional<string> m_max_used_block_hash;
    vector<string> m_signatures;

    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const;
    static void from_property_tree(const boost::property_tree::ptree& node, shared_ptr<monero_tx> tx);
    shared_ptr<monero_tx> copy(const shared_ptr<monero_tx>& src, const shared_ptr<monero_tx>& tgt) const;
    virtual void merge(const shared_ptr<monero_tx>& self, const shared_ptr<monero_tx>& other);
    boost::optional<uint64_t> get_height() const;
  };

  struct monero_key_image : public serializable_struct {
    boost::optional<string> m_hex;
    boost::optional<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 shared_ptr<monero_key_image>& key_image);
    static vector<shared_ptr<monero_key_image>> deserialize_key_images(const string& key_images_json);  // TODO: remove this specialty util used once
    shared_ptr<monero_key_image> copy(const shared_ptr<monero_key_image>& src, const shared_ptr<monero_key_image>& tgt) const;
    void merge(const shared_ptr<monero_key_image>& self, const shared_ptr<monero_key_image>& other);
  };

  struct monero_output : public serializable_struct {
    shared_ptr<monero_tx> m_tx;
    boost::optional<shared_ptr<monero_key_image>> m_key_image;
    boost::optional<uint64_t> m_amount;
    boost::optional<uint64_t> m_index;
    vector<uint64_t> m_ring_output_indices;
    boost::optional<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 shared_ptr<monero_output>& output);
    shared_ptr<monero_output> copy(const shared_ptr<monero_output>& src, const shared_ptr<monero_output>& tgt) const;
    virtual void merge(const shared_ptr<monero_output>& self, const shared_ptr<monero_output>& other);
  };
}