monero_wallet_model.h

 
#pragma once
 
#include "common/monero_rpc_connection.h"
#include "daemon/monero_daemon_model.h"
 
using namespace monero;

namespace monero {

  struct monero_wallet_config : public serializable_struct {
    boost::optional<std::string> m_path;
    boost::optional<std::string> m_password;
    boost::optional<monero_network_type> m_network_type;
    std::shared_ptr<monero_rpc_connection> m_server;
    boost::optional<bool> m_is_trusted_daemon;
    boost::optional<std::string> m_seed;
    boost::optional<std::string> m_seed_offset;
    boost::optional<std::string> m_primary_address;
    boost::optional<std::string> m_private_view_key;
    boost::optional<std::string> m_private_spend_key;
    boost::optional<uint64_t> m_restore_height;
    boost::optional<std::string> m_language;
    boost::optional<bool> m_save_current;
    boost::optional<uint64_t> m_account_lookahead;
    boost::optional<uint64_t> m_subaddress_lookahead;
    boost::optional<bool> m_is_multisig;
    boost::optional<bool> m_regtest;
 
    monero_wallet_config() {}
    monero_wallet_config(const monero_wallet_config& config);
    monero_wallet_config copy() const;
    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_wallet_config>& config);
    static std::shared_ptr<monero_wallet_config> deserialize(const std::string& config_json);
  };

  struct monero_sync_result : public serializable_struct {
    uint64_t m_num_blocks_fetched;
    bool m_received_money;
    monero_sync_result() {}
    monero_sync_result(const uint64_t num_blocks_fetched, const bool received_money) : m_num_blocks_fetched(num_blocks_fetched), m_received_money(received_money) {}
 
    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_sync_result>& result);
    static std::shared_ptr<monero_sync_result> deserialize(const std::string& json);
  };

  struct monero_subaddress : public serializable_struct {
    boost::optional<uint32_t> m_account_index;
    boost::optional<uint32_t> m_index;
    boost::optional<std::string> m_address;
    boost::optional<std::string> m_label;
    boost::optional<uint64_t> m_balance;
    boost::optional<uint64_t> m_unlocked_balance;
    boost::optional<uint64_t> m_num_unspent_outputs;
    boost::optional<bool> m_is_used;
    boost::optional<uint64_t> m_num_blocks_to_unlock;
 
    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_subaddress>& subaddress);
    static std::shared_ptr<monero_subaddress> deserialize(const std::string& json);
  };

  struct monero_account : public serializable_struct {
    boost::optional<uint32_t> m_index;
    boost::optional<std::string> m_primary_address;
    boost::optional<uint64_t> m_balance;
    boost::optional<uint64_t> m_unlocked_balance;
    boost::optional<std::string> m_tag;
    std::vector<monero_subaddress> m_subaddresses;
 
    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_account>& account);
    static std::shared_ptr<monero_account> deserialize(const std::string& json);
  };

  struct monero_destination : public serializable_struct {
    boost::optional<std::string> m_address;
    boost::optional<uint64_t> m_amount;
 
    monero_destination(boost::optional<std::string> address = boost::none, boost::optional<uint64_t> amount = boost::none) : m_address(address), m_amount(amount) {}
    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_destination>& destination);
    static std::shared_ptr<monero_destination> deserialize(const std::string& json);
    std::shared_ptr<monero_destination> copy(const std::shared_ptr<monero_destination>& src, const std::shared_ptr<monero_destination>& tgt) const;
  };
 
  // forward declarations
  struct monero_tx_config;
  struct monero_tx_wallet;
  struct monero_tx_query;
  struct monero_tx_set;

  struct monero_transfer : public serializable_struct {
    std::shared_ptr<monero_tx_wallet> m_tx;
    boost::optional<uint64_t> m_amount;
    boost::optional<uint32_t> m_account_index;
 
    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_transfer>& transfer);
    virtual boost::optional<bool> is_incoming() const = 0;  // derived class must implement
    std::shared_ptr<monero_transfer> copy(const std::shared_ptr<monero_transfer>& src, const std::shared_ptr<monero_transfer>& tgt) const;
    boost::optional<bool> is_outgoing() const {
            if (is_incoming() == boost::none) return boost::none;
      return !(*is_incoming());
    }
    void merge(const std::shared_ptr<monero_transfer>& self, const std::shared_ptr<monero_transfer>& other);
  };

  struct monero_incoming_transfer : public monero_transfer {
    boost::optional<uint32_t> m_subaddress_index;
    boost::optional<std::string> m_address;
    boost::optional<uint64_t> m_num_suggested_confirmations;
 
    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_incoming_transfer>& transfer);
    static std::shared_ptr<monero_incoming_transfer> deserialize(const std::string& json);
    std::shared_ptr<monero_incoming_transfer> copy(const std::shared_ptr<monero_transfer>& src, const std::shared_ptr<monero_transfer>& tgt) const;
    std::shared_ptr<monero_incoming_transfer> copy(const std::shared_ptr<monero_incoming_transfer>& src, const std::shared_ptr<monero_incoming_transfer>& tgt) const;
    boost::optional<bool> is_incoming() const;
    void merge(const std::shared_ptr<monero_transfer>& self, const std::shared_ptr<monero_transfer>& other);
    void merge(const std::shared_ptr<monero_incoming_transfer>& self, const std::shared_ptr<monero_incoming_transfer>& other);
  };

  struct monero_outgoing_transfer : public monero_transfer {
    std::vector<uint32_t> m_subaddress_indices;
    std::vector<std::string> m_addresses;
    std::vector<std::shared_ptr<monero_destination>> m_destinations;
 
    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_outgoing_transfer>& transfer);
    static std::shared_ptr<monero_outgoing_transfer> deserialize(const std::string& json);
    std::shared_ptr<monero_outgoing_transfer> copy(const std::shared_ptr<monero_transfer>& src, const std::shared_ptr<monero_transfer>& tgt) const;
    std::shared_ptr<monero_outgoing_transfer> copy(const std::shared_ptr<monero_outgoing_transfer>& src, const std::shared_ptr<monero_outgoing_transfer>& tgt) const;
    boost::optional<bool> is_incoming() const;
    void merge(const std::shared_ptr<monero_transfer>& self, const std::shared_ptr<monero_transfer>& other);
    void merge(const std::shared_ptr<monero_outgoing_transfer>& self, const std::shared_ptr<monero_outgoing_transfer>& other);
  };

  struct monero_transfer_query : public monero_transfer {
    boost::optional<bool> m_is_incoming;
    boost::optional<std::string> m_address;
    std::vector<std::string> m_addresses;
    boost::optional<uint32_t> m_subaddress_index;
    std::vector<uint32_t> m_subaddress_indices;
    std::vector<std::shared_ptr<monero_destination>> m_destinations;
    boost::optional<bool> m_has_destinations;
    std::shared_ptr<monero_tx_query> m_tx_query;
 
    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_transfer_query>& transfer_query);
    static std::shared_ptr<monero_transfer_query> deserialize(const std::string& json);
    static std::shared_ptr<monero_transfer_query> deserialize_from_block(const std::string& transfer_query_json);
    static bool is_contextual(const monero_transfer_query& query);
    std::shared_ptr<monero_transfer_query> copy(const std::shared_ptr<monero_transfer>& src, const std::shared_ptr<monero_transfer>& tgt) const;
    std::shared_ptr<monero_transfer_query> copy(const std::shared_ptr<monero_transfer_query>& src, const std::shared_ptr<monero_transfer_query>& tgt) const;
    boost::optional<bool> is_incoming() const;
    bool meets_criteria(monero_transfer* transfer, bool query_parent = true) const;
  };

  struct monero_output_wallet : public monero_output {
    boost::optional<uint32_t> m_account_index;
    boost::optional<uint32_t> m_subaddress_index;
    boost::optional<bool> m_is_spent;
    boost::optional<bool> m_is_frozen;
 
    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_wallet>& output_wallet);
    static std::shared_ptr<monero_output_wallet> deserialize(const std::string& json);
    std::shared_ptr<monero_output_wallet> copy(const std::shared_ptr<monero_output>& src, const std::shared_ptr<monero_output>& tgt) const;
    std::shared_ptr<monero_output_wallet> copy(const std::shared_ptr<monero_output_wallet>& src, const std::shared_ptr<monero_output_wallet>& tgt) const;
    void merge(const std::shared_ptr<monero_output>& self, const std::shared_ptr<monero_output>& other);
    void merge(const std::shared_ptr<monero_output_wallet>& self, const std::shared_ptr<monero_output_wallet>& other);
  };

  struct monero_output_query : public monero_output_wallet {
    std::vector<uint32_t> m_subaddress_indices;
    boost::optional<uint64_t> m_min_amount;
    boost::optional<uint64_t> m_max_amount;
    std::shared_ptr<monero_tx_query> m_tx_query;
 
    //boost::property_tree::ptree to_property_tree() const;
    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_query>& output_query);
    static std::shared_ptr<monero_output_query> deserialize(const std::string& json);
    static std::shared_ptr<monero_output_query> deserialize_from_block(const std::string& output_query_json);
    static bool is_contextual(const monero_output_query& query);
    std::shared_ptr<monero_output_query> copy(const std::shared_ptr<monero_output>& src, const std::shared_ptr<monero_output>& tgt) const;
    std::shared_ptr<monero_output_query> copy(const std::shared_ptr<monero_output_wallet>& src, const std::shared_ptr<monero_output_wallet>& tgt) const; // TODO: necessary to override all super classes?
    std::shared_ptr<monero_output_query> copy(const std::shared_ptr<monero_output_query>& src, const std::shared_ptr<monero_output_query>& tgt) const;
    bool meets_criteria(monero_output_wallet* output, bool query_parent = true) const;
  };

  struct monero_tx_wallet : public monero_tx {
    std::shared_ptr<monero_tx_set> m_tx_set;
    boost::optional<bool> m_is_incoming;
    boost::optional<bool> m_is_outgoing;
    std::vector<std::shared_ptr<monero_incoming_transfer>> m_incoming_transfers;
    std::shared_ptr<monero_outgoing_transfer> m_outgoing_transfer;
    boost::optional<std::string> m_note;
    boost::optional<uint64_t> m_input_sum;
    boost::optional<uint64_t> m_output_sum;
    boost::optional<std::string> m_change_address;
    boost::optional<uint64_t> m_change_amount;
    boost::optional<uint32_t> m_num_dummy_outputs;
    boost::optional<std::string> m_extra_hex;
 
    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_tx_wallet>& tx_wallet);
    static std::shared_ptr<monero_tx_wallet> deserialize(const std::string& json);
    std::shared_ptr<monero_tx_wallet> copy(const std::shared_ptr<monero_tx>& src, const std::shared_ptr<monero_tx>& tgt) const;
    std::shared_ptr<monero_tx_wallet> copy(const std::shared_ptr<monero_tx_wallet>& src, const std::shared_ptr<monero_tx_wallet>& tgt) const;
    void merge(const std::shared_ptr<monero_tx>& self, const std::shared_ptr<monero_tx>& other);
    void merge(const std::shared_ptr<monero_tx_wallet>& self, const std::shared_ptr<monero_tx_wallet>& other);
    uint64_t get_incoming_amount() const;
    uint64_t get_outgoing_amount() const;
    std::vector<std::shared_ptr<monero_transfer>> get_transfers() const;
    std::vector<std::shared_ptr<monero_transfer>> get_transfers(const monero_transfer_query& query) const;
    std::vector<std::shared_ptr<monero_transfer>> filter_transfers(const monero_transfer_query& query);
    std::vector<std::shared_ptr<monero_output_wallet>> get_inputs_wallet() const;
    std::vector<std::shared_ptr<monero_output_wallet>> get_inputs_wallet(const monero_output_query& query) const;
    std::vector<std::shared_ptr<monero_output_wallet>> filter_inputs_wallet(const monero_output_query& query);
    std::vector<std::shared_ptr<monero_output_wallet>> get_outputs_wallet() const;
    std::vector<std::shared_ptr<monero_output_wallet>> get_outputs_wallet(const monero_output_query& query) const;
    std::vector<std::shared_ptr<monero_output_wallet>> filter_outputs_wallet(const monero_output_query& query);
  };

  struct monero_tx_query : public monero_tx_wallet {
    std::vector<std::string> m_hashes;
    boost::optional<bool> m_has_payment_id;
    std::vector<std::string> m_payment_ids;
    boost::optional<uint64_t> m_height;
    boost::optional<uint64_t> m_min_height;
    boost::optional<uint64_t> m_max_height;
    boost::optional<uint64_t> m_include_outputs;
    std::shared_ptr<monero_transfer_query> m_transfer_query;
    std::shared_ptr<monero_output_query> m_input_query;
    std::shared_ptr<monero_output_query> m_output_query;
 
    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_tx_query>& tx_query);
    static std::shared_ptr<monero_tx_query> deserialize(const std::string& json);
    static std::shared_ptr<monero_tx_query> deserialize_from_block(const std::string& tx_query_json);

    static std::shared_ptr<monero_tx_query> decontextualize(std::shared_ptr<monero_tx_query> query);
    std::shared_ptr<monero_tx_query> copy(const std::shared_ptr<monero_tx>& src, const std::shared_ptr<monero_tx>& tgt) const;
    std::shared_ptr<monero_tx_query> copy(const std::shared_ptr<monero_tx_wallet>& src, const std::shared_ptr<monero_tx_wallet>& tgt) const; // TODO: necessary to override all super classes?
    std::shared_ptr<monero_tx_query> copy(const std::shared_ptr<monero_tx_query>& src, const std::shared_ptr<monero_tx_query>& tgt) const;
    bool meets_criteria(monero_tx_wallet* tx, bool query_children = true) const;
  };

  struct monero_tx_set : public serializable_struct {
    std::vector<std::shared_ptr<monero_tx_wallet>> m_txs;
    boost::optional<std::string> m_signed_tx_hex;
    boost::optional<std::string> m_unsigned_tx_hex;
    boost::optional<std::string> m_multisig_tx_hex;
 
    //boost::property_tree::ptree to_property_tree() const;
 
    static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_tx_set>& set);
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const;
    static std::shared_ptr<monero_tx_set> deserialize(const std::string& tx_set_json);
  };

  struct monero_integrated_address : public serializable_struct {
    std::string m_standard_address;
    std::string m_payment_id;
    std::string m_integrated_address;
 
    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_integrated_address>& subaddress);
    static std::shared_ptr<monero_integrated_address> deserialize(const std::string& json);
  };

  enum monero_tx_priority : uint8_t {
    DEFAULT = 0,
    UNIMPORTANT,
    NORMAL,
    ELEVATED
  };

  struct monero_tx_config : public serializable_struct {
    boost::optional<std::string> m_address;
    boost::optional<uint64_t> m_amount;
    std::vector<std::shared_ptr<monero_destination>> m_destinations;
    std::vector<uint32_t> m_subtract_fee_from;
    boost::optional<std::string> m_payment_id;
    boost::optional<monero_tx_priority> m_priority;
    boost::optional<uint32_t> m_ring_size;
    boost::optional<uint64_t> m_fee;
    boost::optional<uint32_t> m_account_index;
    std::vector<uint32_t> m_subaddress_indices;
    boost::optional<bool> m_can_split;
    boost::optional<bool> m_relay;
    boost::optional<std::string> m_note;
    boost::optional<std::string> m_recipient_name;
    boost::optional<uint64_t> m_below_amount;
    boost::optional<bool> m_sweep_each_subaddress;
    boost::optional<std::string> m_key_image;
 
    monero_tx_config() {}
    monero_tx_config(const monero_tx_config& config);
    monero_tx_config copy() const;
    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_tx_config>& config);
    static std::shared_ptr<monero_tx_config> deserialize(const std::string& config_json);
    std::vector<std::shared_ptr<monero_destination>> get_normalized_destinations() const;
  };

  struct monero_key_image_export_result : public serializable_struct {
    boost::optional<uint64_t> m_offset;
    std::vector<std::shared_ptr<monero_key_image>> m_key_images;
 
    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_export_result>& result);
    static std::shared_ptr<monero_key_image_export_result> deserialize(const std::string& result_json);
  };

  struct monero_key_image_import_result : public serializable_struct {
    boost::optional<uint64_t> m_height;
    boost::optional<uint64_t> m_spent_amount;
    boost::optional<uint64_t> m_unspent_amount;
 
    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_import_result>& result);
    static std::shared_ptr<monero_key_image_import_result> deserialize(const std::string& json);
  };

  enum monero_message_signature_type : uint8_t {
    SIGN_WITH_SPEND_KEY = 0,
    SIGN_WITH_VIEW_KEY
  };

  struct monero_message_signature_result : public serializable_struct {
    bool m_is_good;
    uint32_t m_version;
    bool m_is_old;
    monero_message_signature_type m_signature_type;
 
    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_message_signature_result> result);
    static std::shared_ptr<monero_message_signature_result> deserialize(const std::string& json);
  };

  struct monero_check : public serializable_struct {
    bool m_is_good;
 
    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_check>& check);
    static std::shared_ptr<monero_check> deserialize(const std::string& json);
  };

  struct monero_check_tx : public monero_check {
    boost::optional<bool> m_in_tx_pool;
    boost::optional<uint64_t> m_num_confirmations;
    boost::optional<uint64_t> m_received_amount;
 
    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_check_tx>& check);
    static std::shared_ptr<monero_check_tx> deserialize(const std::string& json);
  };

  struct monero_check_reserve : public monero_check  {
    boost::optional<uint64_t> m_total_amount;
    boost::optional<uint64_t> m_unconfirmed_spent_amount;
 
    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_check_reserve>& check);
    static std::shared_ptr<monero_check_reserve> deserialize(const std::string& json);
  };

  struct monero_multisig_info : public serializable_struct {
    bool m_is_multisig;
    bool m_is_ready;
    uint32_t m_threshold;
    uint32_t m_num_participants;
 
    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_multisig_info>& info);
    static std::shared_ptr<monero_multisig_info> deserialize(const std::string& json);
  };

  struct monero_multisig_init_result : public serializable_struct {
    boost::optional<std::string> m_address;
    boost::optional<std::string> m_multisig_hex;
 
    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_multisig_init_result>& res);
    static std::shared_ptr<monero_multisig_init_result> deserialize(const std::string& json);
  };

  struct monero_multisig_sign_result : public serializable_struct {
    boost::optional<std::string> m_signed_multisig_tx_hex;
    std::vector<std::string> m_tx_hashes;
 
    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_multisig_sign_result>& res);
    static std::shared_ptr<monero_multisig_sign_result> deserialize(const std::string& json);
  };

  struct monero_address_book_entry : public serializable_struct {
    boost::optional<uint64_t> m_index;  // TODO: not boost::optional
    boost::optional<std::string> m_address;
    boost::optional<std::string> m_description;
    boost::optional<std::string> m_payment_id;
 
    monero_address_book_entry() {}
    monero_address_book_entry(uint64_t index, const std::string& address, const std::string& description) : m_index(index), m_address(address), m_description(description) {}
    monero_address_book_entry(uint64_t index, const std::string& address, const std::string& description, const std::string& payment_id) : m_index(index), m_address(address), m_description(description), m_payment_id(payment_id) {}
 
    static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_address_book_entry>& entry);
    static std::shared_ptr<monero_address_book_entry> deserialize(const std::string& json);
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const;
  };

  enum monero_address_type : uint8_t {
    PRIMARY_ADDRESS = 0,
    INTEGRATED_ADDRESS,
    SUBADDRESS
  };

  struct monero_tx_height_comparator {
    bool operator()(const std::shared_ptr<monero_tx>& tx1, const std::shared_ptr<monero_tx>& tx2) const;
  };

  struct monero_incoming_transfer_comparator {
    bool operator()(const std::shared_ptr<monero_incoming_transfer>& t1, const std::shared_ptr<monero_incoming_transfer>& t2) const;
    bool operator()(const monero_incoming_transfer& t1, const monero_incoming_transfer& t2) const;
  };

  struct monero_output_comparator {
    bool operator()(const monero_output_wallet& o1, const monero_output_wallet& o2) const;
  };

  struct monero_decoded_address : public serializable_struct {
    std::string m_address;
    monero_address_type m_address_type;
    monero_network_type m_network_type;
 
    monero_decoded_address(): m_address_type(monero_address_type::PRIMARY_ADDRESS), m_network_type(monero_network_type::MAINNET) {}
    monero_decoded_address(const std::string& address, monero_address_type address_type, monero_network_type network_type);
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
    static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_decoded_address>& address);
    static std::shared_ptr<monero_decoded_address> deserialize(const std::string& json);
  };

  struct monero_account_tag : public serializable_struct {
    boost::optional<std::string> m_tag;
    boost::optional<std::string> m_label;
    std::vector<uint32_t> m_account_indices;
 
    monero_account_tag() { }
    monero_account_tag(const std::string& tag, const std::string& label): m_tag(tag), m_label(label) { }
    monero_account_tag(const std::string& tag, const std::string& label, const std::vector<uint32_t>& account_indices): m_tag(tag), m_label(label), m_account_indices(account_indices) { }
 
    rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override;
 
    static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr<monero_account_tag>& account_tag);
    static std::shared_ptr<monero_account_tag> deserialize(const std::string& json);
  };
 
}